merge validators from schemaType.prototype.validate definition and schemaType.set

[chumager]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the feature has not already been requested

🚀 Feature Proposal

Hi, As validate attribute in a schemaType could be Function|Array|Object, and you can set it via schemaType.set I'll be nice to merge both definitions.

Motivation

I want to add a validation set for the schemaType Array (I need this for several types with different validations), to check min and max elements. but if I add other validator in the schemaType definition, it get overwritten.

For now my only choice is to create a plugin who searches in all paths and check if there is a min or max option in an "Array" instance and add a pre or post validate hook to the schema or merge the default validators with the ones declared in Schema, either way Schema.prototype.validate ain't accepts arrays

Example

import db from "mongoose";
await db.connect("mongodb://127.0.0.1/test");
//SchemaType.prototype.validate() can't get an array to set several validators but Schema.Types.set("validate", ...) can
//Comment this plugin to check the problem.
db.plugin(schema => {
  schema.eachPath((path, schemaType) => {
    if (schemaType.validators !== schemaType.constructor.defaultOptions.validate) {
      const validators = [
        ...new Set([].concat(schemaType.constructor.defaultOptions.validate ?? [], schemaType.validators ?? []))
      ];
      schemaType.validators = validators;
    }
  });
});
//custom validators for type Array
db.Schema.Types.Array.set("validate", [
  {
    validator(val, rest) {
      const {options} = this.constructor.schema.path(rest.path);
      if (options.min) {
        if (val.length < options.min) throw `El campo ${rest.path} debe tener al menos ${options.min} elementos`;
      }
      return true;
    },
    propsParameter: true
  },
  {
    validator(val, rest) {
      const {options} = this.constructor.schema.path(rest.path);
      if (options.max) {
        if (val.length > options.max) throw `El campo ${rest.path} debe tener a lo más ${options.max} elementos`;
      }
      return true;
    },
    propsParameter: true
  }
]);
const Schema = new db.Schema({
  a: {
    type: [String],
    min: 2,
    max: 3,
    validate: {
      validator(v) {
        return v.includes("test3");
      },
      message: "el campo {PATH} no incluye 'test3'"
    }
  }
});
const model = db.model("model", Schema);
//console.log("validators", Schema.path("a").validators);                                                                              
let doc;                                                                                                                               
const a = [];                                                                                                                          
for (let i = 1; i <= 5; i++) {                                                                                                         
  a.push("test" + i);                                                                                                                  
  doc = new model({a});                                                                                                                
  console.log(doc);                                                                                                                    
  const error = doc.validateSync();                                                                                                    
  console.log(error?.errors?.a?.reason ?? error?.errors?.a?.message ?? "Sin errores");                                                 
}                                                                                                                                      
db.disconnect();                                                                                                                       

[vkarpov15]

Does the following? It outputs the same result. Types.Array.set() is meant to set a default option, so overwriting is expected behavior.

import db from "mongoose";
await db.connect("mongodb://127.0.0.1/test");

const defaultValidators = [
  {
    validator(val, rest) {
      const {options} = this.constructor.schema.path(rest.path);
      if (options.min) {
        if (val.length < options.min) throw `El campo ${rest.path} debe tener al menos ${options.min} elementos`;
      }
      return true;
    },
    propsParameter: true
  },
  {
    validator(val, rest) {
      const {options} = this.constructor.schema.path(rest.path);
      if (options.max) {
        if (val.length > options.max) throw `El campo ${rest.path} debe tener a lo más ${options.max} elementos`;
      }
      return true;
    },
    propsParameter: true
  }
];

db.plugin(schema => {
  schema.eachPath((path, schemaType) => {
    defaultValidators.forEach(v => schemaType.validate(v));
  });
});

const Schema = new db.Schema({
  a: {
    type: [String],
    min: 2,
    max: 3,
    validate: {
      validator(v) {
        return v.includes("test3");
      },
      message: "el campo {PATH} no incluye 'test3'"
    }
  }
});
const model = db.model("model", Schema);
//console.log("validators", Schema.path("a").validators);                                                                              
let doc;                                                                                 
const a = [];                                                                            
for (let i = 1; i <= 5; i++) {                                                           
  a.push("test" + i);                                                                    
  doc = new model({a});                                                                  
  console.log(doc);                                                                      
  const error = doc.validateSync();                                                      
  console.log(error?.errors?.a?.reason ?? error?.errors?.a?.message ?? "Sin errores");   
}                                                                                        
db.disconnect();

Output:

$ node gh-14070.mjs 
{ a: [ 'test1' ], _id: new ObjectId('6553cad536df2a1c876da746') }
el campo a no incluye 'test3'
{
  a: [ 'test1', 'test2' ],
  _id: new ObjectId('6553cad536df2a1c876da747')
}
el campo a no incluye 'test3'
{
  a: [ 'test1', 'test2', 'test3' ],
  _id: new ObjectId('6553cad536df2a1c876da748')
}
Sin errores
{
  a: [ 'test1', 'test2', 'test3', 'test4' ],
  _id: new ObjectId('6553cad536df2a1c876da749')
}
El campo a debe tener a lo más 3 elementos
{
  a: [ 'test1', 'test2', 'test3', 'test4', 'test5' ],
  _id: new ObjectId('6553cad536df2a1c876da74a')
}
El campo a debe tener a lo más 3 elementos

[chumager]

Hi, I know the set is to set a default option, but I think this is a special, case... if the Schema definition sets all the default options like a merge, then the strings, booleans, and functions will use the "last" definition, and objects and arrays will be merged.

Maybe I'm too used to "vue mixin way" to define defaults.

Regards.

[github-actions]

This issue is stale because it has been open 14 days with no activity. Remove stale label or comment or this will be closed in 5 days