针对 Mongoose 模式验证对象而不保存为新文档

Question

我正在尝试验证一些将被插入到新文档中的数据，但不是在许多其他事情需要发生之前。所以我打算在静态方法中添加一个函数，希望能根据模型模式验证数组中的对象。

这是目前为止的代码：

module.exports = Mongoose => {
    const Schema = Mongoose.Schema

    const peopleSchema = new Schema({
        name: {
            type: Schema.Types.String,
            required: true,
            minlength: 3,
            maxlength: 25
        },
        age: Schema.Types.Number
    })

    /**
     * Validate the settings of an array of people
     *
     * @param   {array}     people  Array of people (objects)
     * @return  {boolean}
     */
    peopleSchema.statics.validatePeople = function( people ) {
        return _.every(people, p => {
            /**
             * How can I validate the object `p` against the peopleSchema
             */
        })
    }

    return Mongoose.model( 'People', peopleSchema )
}

所以peopleSchema.statics.validatePeople 是我尝试进行验证的地方。我已通读 mongooses validation 文档，但没有说明如何在不保存数据的情况下验证模型。

这可能吗？

更新

这里的一个答案向我指出了正确的验证方法，这似乎有效，但现在它抛出了Unhandled rejection ValidationError。

这是用于验证数据的静态方法（无需插入）

peopleSchema.statics.testValidate = function( person ) {
    return new Promise( ( res, rej ) => {
        const personObj = new this( person )

        // FYI - Wrapping the personObj.validate() in a try/catch does NOT suppress the error
        personObj.validate( err => {
            if ( err ) return rej( err )

            res( 'SUCCESS' )
        } )
    })
}

然后我来测试一下：

People.testValidate( { /* Data */ } )
    .then(data => {
        console.log('OK!', data)
    })
    .catch( err => {
        console.error('FAILED:',err)
    })
    .finally(() => Mongoose.connection.close())

使用不遵循架构规则的数据对其进行测试会抛出错误，正如您所看到的，我尝试捕捉它，但它似乎不起作用。

P.S.我使用 Bluebird 来兑现我的承诺

Answer 1

通过Custom validators 有一种方法可以做到这一点。验证失败时，无法将文档保存到数据库中。

var peopleSchema = new mongoose.Schema({
        name: String,
        age: Number
    });
var People = mongoose.model('People', peopleSchema);

peopleSchema.path('name').validate(function(n) {
    return !!n && n.length >= 3 && n.length < 25;
}, 'Invalid Name');

function savePeople() {
    var p = new People({
        name: 'you',
        age: 3
    });

    p.save(function(err){
        if (err) {
             console.log(err);           
         }
        else
            console.log('save people successfully.');
    });
}

或通过validate() 使用与您定义的相同架构来实现此目的的另一种方式。

var p = new People({
    name: 'you',
    age: 3
});

p.validate(function(err) {
    if (err)
        console.log(err);
    else
        console.log('pass validate');
});

Answer 2

正如猫鼬文档 https://mongoosejs.com/docs/validation.html 中所述，您可以使用 doc.validate(callback) 或 doc.validateSync() 来检查验证。

不同之处在于您不必像其名称所暗示的那样将await 用于validateSync()。如果验证失败，则返回错误，否则返回undefined。 例如：

const model = new Model({somedata:somedata})

const validatedModel = model.validateSync()
if(!!validatedModel) throw validatedModel

Answer 3

我编写了以下函数，它根本不需要模型，你只需传递一个对象和 Mongoose 模式，无论它是作为文档还是子文档。子文档也被递归检查：

const validateObjectAgainstMongooseSchema = ({checkObject, mongooseSchema, currentPath = "object"} = {}) => {
    const errors = [];

    for (const key of Object.keys(checkObject)) {
        const checkObjectType = Array.isArray(checkObject[key]) ? "array" : typeof checkObject[key];
        const mongooseType = mongooseSchema.path(key).instance.toLowerCase();
        const valid = mongooseType === checkObjectType;

        if (checkObjectType === "object") {
            errors.push(
                ...validateObjectAgainstMongooseSchema({
                    checkObject: checkObject[key],
                    mongooseSchema: mongooseSchema.path(key).schema,
                    currentPath: `${currentPath}.${key}`
                })
            );
        } else if (!valid) {
            errors.push(`${currentPath}.${key} should be of type ${mongooseType} but got ${checkObjectType}`);
        }
    }

    return errors;
};

使用以下架构时：

const schema = new mongoose.Schema({
        stringType: {
            type: String
        },
        numberType: {
            type: Number
        },
        dateType: {
            type: Date
        },
        boolType: {
            type: Boolean
        },
        arrayType: {
            type: Array
        },
        schemaType: {
            type: new mongoose.Schema({
                embeddedDate: {
                    type: Date
                },
                embeddedBool: {
                    type: Boolean
                }
            })
        }
    });

以下产生一个空数组

const errors = schemaUtils.helpers.validateObjectAgainstMongooseSchema({
            checkObject: {
                stringType: "test",
                numberType: 2,
                dateType: new Date("2020-01-01"),
                boolType: true,
                arrayType: ["test", "it"],
                schemaType: {embeddedDate: new Date("2020-01-02"), embeddedBool: true}
            },
            mongooseSchema: schema
        });

还有这个

const errors = schemaUtils.helpers.validateObjectAgainstMongooseSchema({
            checkObject: {
                stringType: 1,
                numberType: "1",
                dateType: 1,
                boolType: 1,
                arrayType: 1,
                schemaType: {embeddedDate: 1, embeddedBool: 1}
            },
            mongooseSchema: schema
        });

产量：

[
      'object.stringType should be of type string but got number',
      'object.numberType should be of type number but got string',
      'object.dateType should be of type date but got number',
      'object.boolType should be of type boolean but got number',
      'object.arrayType should be of type array but got number',
      'object.schemaType.embeddedDate should be of type date but got number',
      'object.schemaType.embeddedBool should be of type boolean but got number'
    ]