custom validation on embedded documents

[Malusia]

Hi,

I wrote a custom validation on a embedded document e.g.

var sub = new Schema({
 content: String
});

sub.path('content').validate(function (value) {
 // do something
});

var schema  = new  Schema({
 title: String,
 body: String,
 subDoc: [sub]
});

var myModel = new Model('MyModel', schema);

In the validation callback I can access this. If I validate like example no. 1 this will be the document itself. If I validate like example no. 2 this will be the embedded document.

Example 1

var doc = new myModel({
 title: 'hello',
 body: 'world',
 subDoc: [{
  content: 'hey!'
 }]
});

doc.validate(function () {});

Example 2

var doc = new myModel({
 title: 'hello',
 body: 'world',
 subDoc: [{
  content: 'hey!'
 }]
});

doc.subDoc[0].validate(function () {});

I found in lib/document.js in the validate (master, 3.8.x) method executen of the valdators.

process.nextTick(function(){
    var p = self.schema.path(path);
    if (!p) return --total || complete();

    var val = self.getValue(path);
    p.doValidate(val, function (err) {
        if (err) {
            self.invalidate(path, err, undefined, true);
        }
        --total || complete();
    }, self);
});

I forked the repository, modified the code and run the tests.

process.nextTick(function(){
    var p = self.schema.path(path);
    if (!p) return --total || complete();

    var val = self.getValue(path);
    var parts = path.split('.');
    parts.pop();
    p.doValidate(val, function (err) {
        if (err) {
            self.invalidate(
                path
                , err
                , undefined
                , true // embedded docs
            );
        }
        --total || complete();
    }, parts.length ? self.getValue(parts.join('.')) : self);
});
}

Now this in the validation callback is everytime the embedded document, but I don't know if the current behavior is intended. I can make a pull request, but I want to ask before.

(Sorry for my bad english 😄)

[vkarpov15]

This is intended behavior atm. I'm open to arguments as to why it should be otherwise. Right now in validators, this always refers to the top-level doc being validated (except for update validators, where it refers to global)

[Malusia]

I think it would be nice to have capsulated unit like a person schema or a user schema and I can reuse it in different other top-level documents.

I want to build a validation type extension like a unique validation. In a top-level document the validation will check the database for other documents with the key and value. In a sub document array the unique validation checks the other elements in the array for the path like this example.

/**
 * Adds a singular validator to this schematype.
 *
 * ####Example:
 *
 *     var s = new Schema({ born: { type: String, singular: true })
 *
 *     // or with custom error message
 *
 *     var s = new Schema({ born: { type: String, singular: '{PATH} is singular!' })
 *
 *     // or through the path API
 *
 *     Schema.path('name').singular(true);
 *
 *     // with custom error messaging
 *
 *     Schema.path('name').singular(true, 'grrr :( ');
 *
 *
 * @param {Boolean} singular enable/disable the validator
 * @param {String} [message] optional custom error message
 * @return {SchemaType} this
 * @api public
 */
SchemaType.prototype.singular = function (singular, message) {
    // do singular validation stuff
    if (false === singular) {
        this.validators = this.validators.filter(function (v) {
            return v[0] !== this.singularValidator;
        }, this);

        this.isSingular = false;
        return this;
    }

    var self = this;
    this.isSingular = true;

    this.singularValidator = function (v, respond) {
        // in here, `this` refers to the validating document.
        // no validation when this path wasn't selected in the query.
        if ('isSelected' in this &&
            !this.isSelected(self.path) &&
            !this.isModified(self.path)) return respond(respond);

        var model = this;

        // if the element is part of a embedded document
        if (this.constructor.name === 'EmbeddedDocument') {
            // 1. check the current doc before searching in database

            // 2. get the root document and check for isNew. if new skip step 3
            // 3. if nothing found in step 1 check the database

            model = this.ownerDocument();
        }

        // build a query
        var query; = queryBuilder(this, self.path, v, this._id);

        model.constructor.findOne(query, function (err, document) {
            respond(!document);
        });
    };

    if ('string' === typeof singular) {
        message = singular;
        singular = undefined;
    }

    var msg = message || errorMessages.general.singular;
    this.validators.push([this.singularValidator, msg, 'singular']);

    return this;
};

So I can use the validation type like this:

var userSchema = new Schema({
 username: {
  type: String,
  trim: true,
  required: true,
  lowercase: true,
  singular: true
 }
});

var customerSchema = new Schema({
 name: String,
 key: {
  type: String,
  trim: true,
  required: true,
  lowercase: true,
  singular: true
 },
 users: [userSchema]
});

var Customer = new Model('Customer', customerSchema);

If I want to save or validate a Customer, the validation is executed for the path users.0.username, but this refers to the top-level document and not the document it self. In this case I can not find the right user and I don't know I am a user sub document because the path in the validation is only username and this refers to the top-level document.

It is possible that this is the wrong approach, but I don't want to create the validation every time for every field and I wan't to create my own ValidationError-types for later usage.

[vkarpov15]

Why not just use a unique index? The approach you specified suffers from a race condition - two calls at almost the same time could very well make it so that you have two identical ids in db.

[Malusia]

I thought that does not work with embedded documents. I'll try it. Thanks for your help!

[Malusia]

Hm, it does not work for me, can you give me an example.

[vkarpov15]

Unique index doesn't enforce uniqueness in an array within a single document, but I would recommend you use $addToSet for that, or an application-level search. It does enforce uniqueness across documents though. Just use index: 'unique' in your schema and wait for Model.on('index') event should work. Can you provide me an example of what you're trying to do with unique indexes?

[Malusia]

Yes, this is a good solution to use $addToSet but not to do an application-level search because uniqueness is part of the validation and the validation is part of the model. In this case the user must be part of the customer.
The example is simple. I have a customer model and this model contains users.

Example:

var userSchema = new Schema({
 username: String, // should unique
 email: String, // should unique
 // ...
});

var customerSchema = new Schema({
 name: String,
 // ...
 users: [userSchema]
});

// ... create model

But lets talk about the main problem. I think it is important to have the same enviroment in a validation method every time. this should always the document itself and not sometimes the top-level document.

In a unit test case I discovered that only on update an existing embedded document (with the save or validate method) this is the top-level document and in all other cases this is the embedded docuemnt. This behavior can not be right because I can never interact with enviroment e.g. to use this.isNew.

In addition, the behavior takes the opportunity to consider embedded documents as a unit.

[Malusia]

I made an other example without unique validation.

var userSchema = new Schema({
    username: String,
    // because we don't want to save the clear text password in database
    hashedPassword: String
    // ...
});

userSchema
    .virtual('password')
    .set(function (password) {
        this._password = password;
        this.salt = this.makeSalt();
        this.hashedPassword = this.encryptPassword(password);
    })
    .get(function () {
        return this._password;
    });

userSchema
    .path('hashedPassword')
    .validate(function () {
        // In the update-case I can not interact with `this._password` because `this` is the top-level document
        // and there is no way to get the current embedded document

        // min. 6 chars, 1 number, 1 uppercase char, 1 lowercase char
        return this._password.match(/^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{6,}$/) ? true : false;
    }, '...');

var customerSchema = new Schema({
    name: String,
    // ...
    users: [userSchema]
});

// ... create model

The password validation will never work for updates because of the current behavior.

[vkarpov15]

That's a neat way of storing passwords, I've never thought of doing it that way before. Very clever. However, it wouldn't work right because _password would not get persisted to the database, so user validation would succeed initially but would never succeed again unless you set this._password every time.

I'll put this up as a discussion for 5.0. I've seen similar feature requests before - won't make it in to 4.0 because we're already in 4.0.0-rc3.