This is probably overkill, but I wonder if it's worth defining an `optional` wrapper:

```javascript
function optional (fn) {
  return function (value) {
    if (typeof value === 'undefined' || value === null) return;
    return fn.call(this, value);
  }
}
```

Then, above, when defining the model:

```javascript
...
email: optional(function (email) {
  this.check(email).isEmail();
}),
webhook: optional(function (url) {
  this.check(url).isUrl();
}),
...
```

I suppose we could take this to the extreme, and just say:

```javascript
function optional (fn) {
  if (typeof fn === 'string') {
    var validator = fn;
    var args = Array.prototype.slice.call(arguments, 1);
    fn = function (value) {
      var checker = this.check(value);
      checker[validator].apply(checker, args);
    }
  }
  return function (value) {
    if (typeof value === 'undefined' || value === null) return;
    return fn.call(this, value);
  }
}
```
```javascript
...
email: optional('isEmail'),
webhook: optional('isUrl'),
...
```

Which then makes me wonder if it's worth a `required`:

```javascript
function required (fn) {
  if (typeof fn === 'string') {
    var validator = fn;
    var args = Array.prototype.slice.call(arguments, 1);
    fn = function (value) {
      var checker = this.check(value);
      checker[validator].apply(checker, args);
    }
  }
  return function (value) {
    return fn.call(this, value);
  }
}
```

Kind of seems a bit redundant, but does allow us to define our models like:

```javascript
{
  id: optional('isInt'),
  slug: required('len', 1, 50),
  email: optional('isEmail'),
  imageId: optional('isInt'),
  webhook: optional('isUrl')
}
```

---

*Possibly my longest and most round-about comment on GitHub, but I got there in the end.*