@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongoose/lib/helpers/setDefaultsOnInsert.js

@@ -4,28 +4,27 @@ const get = require('./get');
 /**
  * Applies defaults to update and findOneAndUpdate operations.
  *
- * @param {Object} filter
+ * @param {object} filter
  * @param {Schema} schema
- * @param {Object} castedDoc
- * @param {Object} options
+ * @param {object} castedDoc
+ * @param {object} options
+ * @param {object} queryMongooseOptions
+ * @param {object | null} [context] the context to pass to default functions as `this`
  * @method setDefaultsOnInsert
  * @api private
  */
 
-module.exports = function(filter, schema, castedDoc, options) {
-  options = options || {};
-
-  const shouldSetDefaultsOnInsert =
-    options.setDefaultsOnInsert != null ?
-      options.setDefaultsOnInsert :
-      schema.base.options.setDefaultsOnInsert;
+module.exports = function(filter, schema, castedDoc, options, queryMongooseOptions, context) {
+  const shouldSetDefaultsOnInsert = options?.setDefaultsOnInsert ??
+    queryMongooseOptions?.setDefaultsOnInsert ??
+    schema.base.options.setDefaultsOnInsert;
 
   if (!options.upsert || shouldSetDefaultsOnInsert === false) {
     return castedDoc;
   }
 
   const keys = Object.keys(castedDoc || {});
-  const updatedKeys = {};
+  const updatedKeys = Object.create(null);
   const updatedValues = {};
   const numKeys = keys.length;
 
@@ -58,9 +57,23 @@ module.exports = function(filter, schema, castedDoc, options) {
       }
     }
     updatedKeys[path] = true;
+    if (path.indexOf('.') === -1) {
+      continue;
+    }
+    // Also mark all parent prefixes so child-path lookups are O(1).
+    // e.g. 'extraProps.location' also marks 'extraProps'
+    const pieces = schema.paths[path] ?
+      // If the SchemaType already split for us, use that to avoid the extra overhead
+      schema.paths[path].splitPath() :
+      path.split('.');
+    let cur = pieces[0];
+    for (let j = 1; j < pieces.length; ++j) {
+      updatedKeys[cur] = true;
+      cur += '.' + pieces[j];
+    }
   }
 
-  if (options && options.overwrite && !hasDollarUpdate) {
+  if (options?.overwrite && !hasDollarUpdate) {
     // Defaults will be set later, since we're overwriting we'll cast
     // the whole update to a document
     return castedDoc;
@@ -71,7 +84,7 @@ module.exports = function(filter, schema, castedDoc, options) {
     if (schemaType.path === '_id' && schemaType.options.auto) {
       return;
     }
-    const def = schemaType.getDefault(null, true);
+    const def = schemaType.getDefault(null, true, { context });
     if (typeof def === 'undefined') {
       return;
     }

package/.output/server/node_modules/mongoose/lib/helpers/timestamps/setDocumentTimestamps.js

@@ -1,8 +1,8 @@
 'use strict';
 
 module.exports = function setDocumentTimestamps(doc, timestampOption, currentTime, createdAt, updatedAt) {
-  const skipUpdatedAt = timestampOption != null && timestampOption.updatedAt === false;
-  const skipCreatedAt = timestampOption != null && timestampOption.createdAt === false;
+  const skipUpdatedAt = timestampOption?.updatedAt === false;
+  const skipCreatedAt = timestampOption?.createdAt === false;
 
   const defaultTimestamp = currentTime != null ?
     currentTime() :

package/.output/server/node_modules/mongoose/lib/helpers/timestamps/setupTimestamps.js

@@ -2,7 +2,6 @@
 
 const applyTimestampsToChildren = require('../update/applyTimestampsToChildren');
 const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
-const get = require('../get');
 const handleTimestampOption = require('../schema/handleTimestampOption');
 const setDocumentTimestamps = require('./setDocumentTimestamps');
 const symbols = require('../../schema/symbols');
@@ -31,8 +30,8 @@ module.exports = function setupTimestamps(schema, timestamps) {
   schema.$timestamps = { createdAt: createdAt, updatedAt: updatedAt };
 
   if (createdAt && !schema.paths[createdAt]) {
-    const baseImmutableCreatedAt = schema.base != null ? schema.base.get('timestamps.createdAt.immutable') : null;
-    const immutable = baseImmutableCreatedAt != null ? baseImmutableCreatedAt : true;
+    const baseImmutableCreatedAt = schema.base?.get('timestamps.createdAt.immutable') ?? null;
+    const immutable = baseImmutableCreatedAt ?? true;
     schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable };
   }
 
@@ -42,26 +41,26 @@ module.exports = function setupTimestamps(schema, timestamps) {
 
   schema.add(schemaAdditions);
 
-  schema.pre('save', function timestampsPreSave(next) {
-    const timestampOption = get(this, '$__.saveOptions.timestamps');
-    if (timestampOption === false) {
-      return next();
-    }
-
-    setDocumentTimestamps(this, timestampOption, currentTime, createdAt, updatedAt);
-
-    next();
-  });
+  schema.pre('save', timestampsPreSave);
 
-  schema.methods.initializeTimestamps = function() {
+  schema.methods.initializeTimestamps = function(timestampsOptions) {
+    if (timestampsOptions === false) {
+      return this;
+    }
     const ts = currentTime != null ?
       currentTime() : this.constructor.base.now();
 
+    const initTimestampsCreatedAt = timestampsOptions != null ?
+      handleTimestampOption(timestampsOptions, 'createdAt') :
+      createdAt;
+    const initTimestampsUpdatedAt = timestampsOptions != null ?
+      handleTimestampOption(timestampsOptions, 'updatedAt') :
+      updatedAt;
 
-    if (createdAt && !this.get(createdAt)) {
+    if (initTimestampsCreatedAt && !this.get(initTimestampsCreatedAt)) {
       this.$set(createdAt, ts);
     }
-    if (updatedAt && !this.get(updatedAt)) {
+    if (initTimestampsUpdatedAt && !this.get(initTimestampsUpdatedAt)) {
       this.$set(updatedAt, ts);
     }
     if (this.$isSubdocument) {
@@ -71,15 +70,13 @@ module.exports = function setupTimestamps(schema, timestamps) {
     const subdocs = this.$getAllSubdocs();
     for (const subdoc of subdocs) {
       if (subdoc.initializeTimestamps) {
-        subdoc.initializeTimestamps();
+        subdoc.initializeTimestamps(timestampsOptions);
       }
     }
 
     return this;
   };
 
-  _setTimestampsOnUpdate[symbols.builtInMiddleware] = true;
-
   const opts = { query: true, model: false };
   schema.pre('findOneAndReplace', opts, _setTimestampsOnUpdate);
   schema.pre('findOneAndUpdate', opts, _setTimestampsOnUpdate);
@@ -87,24 +84,49 @@ module.exports = function setupTimestamps(schema, timestamps) {
   schema.pre('update', opts, _setTimestampsOnUpdate);
   schema.pre('updateOne', opts, _setTimestampsOnUpdate);
   schema.pre('updateMany', opts, _setTimestampsOnUpdate);
+};
 
-  function _setTimestampsOnUpdate(next) {
-    const now = currentTime != null ?
-      currentTime() :
-      this.model.base.now();
-    // Replacing with null update should still trigger timestamps
-    if (replaceOps.has(this.op) && this.getUpdate() == null) {
-      this.setUpdate({});
-    }
-    applyTimestampsToUpdate(
-      now,
-      createdAt,
-      updatedAt,
-      this.getUpdate(),
-      this._mongooseOptions,
-      replaceOps.has(this.op)
-    );
-    applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);
-    next();
+function timestampsPreSave() {
+  const timestampOption = this.$__?.saveOptions?.timestamps;
+  if (timestampOption === false) {
+    return;
   }
-};
+
+  const schema = this.$__schema;
+  const { createdAt, updatedAt } = schema.$timestamps;
+  const timestamps = schema.options.timestamps;
+  const currentTime = timestamps != null && Object.hasOwn(timestamps, 'currentTime') ?
+    timestamps.currentTime :
+    null;
+
+  setDocumentTimestamps(this, timestampOption, currentTime, createdAt, updatedAt);
+}
+
+function _setTimestampsOnUpdate() {
+  const schema = this.model.schema;
+  const { createdAt, updatedAt } = schema.$timestamps;
+  const timestamps = schema.options.timestamps;
+  const currentTime = timestamps != null && Object.hasOwn(timestamps, 'currentTime') ?
+    timestamps.currentTime :
+    null;
+
+  const now = currentTime != null ?
+    currentTime() :
+    this.model.base.now();
+  // Replacing with null update should still trigger timestamps
+  if (replaceOps.has(this.op) && this.getUpdate() == null) {
+    this.setUpdate({});
+  }
+  applyTimestampsToUpdate(
+    now,
+    createdAt,
+    updatedAt,
+    this.getUpdate(),
+    this._mongooseOptions,
+    replaceOps.has(this.op)
+  );
+  applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);
+}
+
+timestampsPreSave[symbols.builtInMiddleware] = true;
+_setTimestampsOnUpdate[symbols.builtInMiddleware] = true;

package/.output/server/node_modules/mongoose/lib/helpers/update/applyTimestampsToUpdate.js

@@ -5,6 +5,7 @@
  */
 
 const get = require('../get');
+const utils = require('../../utils');
 
 module.exports = applyTimestampsToUpdate;
 
@@ -22,11 +23,11 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
     return currentUpdate;
   }
 
-  const skipCreatedAt = timestamps != null && timestamps.createdAt === false;
-  const skipUpdatedAt = timestamps != null && timestamps.updatedAt === false;
+  const skipCreatedAt = timestamps?.createdAt === false;
+  const skipUpdatedAt = timestamps?.updatedAt === false;
 
   if (isReplace) {
-    if (currentUpdate && currentUpdate.$set) {
+    if (currentUpdate?.$set) {
       currentUpdate = currentUpdate.$set;
       updates.$set = {};
       _updates = updates.$set;
@@ -51,7 +52,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
   }
   updates.$set = updates.$set || {};
   if (!skipUpdatedAt && updatedAt &&
-      (!currentUpdate.$currentDate || !currentUpdate.$currentDate[updatedAt])) {
+      !currentUpdate.$currentDate?.[updatedAt]) {
     let timestampSet = false;
     if (updatedAt.indexOf('.') !== -1) {
       const pieces = updatedAt.split('.');
@@ -62,7 +63,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
           currentUpdate[start][remnant] = now;
           timestampSet = true;
           break;
-        } else if (currentUpdate.$set && currentUpdate.$set[start]) {
+        } else if (currentUpdate.$set?.[start]) {
           currentUpdate.$set[start][remnant] = now;
           timestampSet = true;
           break;
@@ -81,7 +82,9 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
 
   if (!skipCreatedAt && createdAt) {
     const overwriteImmutable = get(options, 'overwriteImmutable', false);
-    const hasUserCreatedAt = currentUpdate[createdAt] != null || currentUpdate?.$set[createdAt] != null;
+    const hasUserCreatedAt = currentUpdate[createdAt] != null
+      || currentUpdate.$set?.[createdAt] != null
+      || currentUpdate.$setOnInsert?.[createdAt] != null;
 
     // If overwriteImmutable is true and user provided createdAt, keep their value
     if (overwriteImmutable && hasUserCreatedAt) {
@@ -90,12 +93,12 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
         updates.$set[createdAt] = currentUpdate[createdAt];
         delete currentUpdate[createdAt];
       }
-      // User's value is already in $set, nothing more to do
+      // User's value is already in $set or $setOnInsert, nothing more to do
     } else {
       if (currentUpdate[createdAt]) {
         delete currentUpdate[createdAt];
       }
-      if (currentUpdate.$set && currentUpdate.$set[createdAt]) {
+      if (currentUpdate.$set?.[createdAt]) {
         delete currentUpdate.$set[createdAt];
       }
       let timestampSet = false;
@@ -108,7 +111,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
             currentUpdate[start][remnant] = now;
             timestampSet = true;
             break;
-          } else if (currentUpdate.$set && currentUpdate.$set[start]) {
+          } else if (currentUpdate.$set?.[start]) {
             currentUpdate.$set[start][remnant] = now;
             timestampSet = true;
             break;
@@ -123,7 +126,7 @@ function applyTimestampsToUpdate(now, createdAt, updatedAt, currentUpdate, optio
     }
   }
 
-  if (Object.keys(updates.$set).length === 0) {
+  if (utils.hasOwnKeys(updates.$set) === false) {
     delete updates.$set;
   }
   return updates;

package/.output/server/node_modules/mongoose/lib/helpers/update/castArrayFilters.js

@@ -4,6 +4,7 @@ const castFilterPath = require('../query/castFilterPath');
 const cleanPositionalOperators = require('../schema/cleanPositionalOperators');
 const getPath = require('../schema/getPath');
 const updatedPathsByArrayFilter = require('./updatedPathsByArrayFilter');
+const utils = require('../../utils');
 
 module.exports = function castArrayFilters(query) {
   const arrayFilters = query.options.arrayFilters;
@@ -18,7 +19,7 @@ module.exports = function castArrayFilters(query) {
   if (query._mongooseOptions.strict != null) {
     strictQuery = query._mongooseOptions.strict;
   }
-  if (query.model && query.model.base.options.strictQuery != null) {
+  if (query.model?.base.options.strictQuery != null) {
     strictQuery = query.model.base.options.strictQuery;
   }
   if (schema._userProvidedOptions.strictQuery != null) {
@@ -63,8 +64,7 @@ function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilt
 
     const baseSchematype = getPath(schema, baseFilterPath, discriminatorValueMap);
     let filterBaseSchema = baseSchematype != null ? baseSchematype.schema : null;
-    if (filterBaseSchema != null &&
-        filterBaseSchema.discriminators != null &&
+    if (filterBaseSchema?.discriminators != null &&
         filter[filterWildcardPath + '.' + filterBaseSchema.options.discriminatorKey]) {
       filterBaseSchema = filterBaseSchema.discriminators[filter[filterWildcardPath + '.' + filterBaseSchema.options.discriminatorKey]] || filterBaseSchema;
       discriminatorValueMap[baseFilterPath] = filter[filterWildcardPath + '.' + filterBaseSchema.options.discriminatorKey];
@@ -74,7 +74,7 @@ function _castArrayFilters(arrayFilters, schema, strictQuery, updatedPathsByFilt
       if (updatedPathsByFilter[key] === null) {
         continue;
       }
-      if (Object.keys(updatedPathsByFilter).length === 0) {
+      if (utils.hasOwnKeys(updatedPathsByFilter) === false) {
         continue;
       }
       const dot = key.indexOf('.');

package/.output/server/node_modules/mongoose/lib/helpers/update/decorateUpdateWithVersionKey.js

@@ -6,7 +6,7 @@
  */
 
 module.exports = function decorateUpdateWithVersionKey(update, options, versionKey) {
-  if (!versionKey || !(options && options.upsert || false)) {
+  if (!versionKey || !options?.upsert) {
     return;
   }
 

package/.output/server/node_modules/mongoose/lib/helpers/update/modifiedPaths.js

@@ -10,8 +10,8 @@ const _modifiedPaths = require('../common').modifiedPaths;
  * will get wrapped in a `$set`. The Mongoose Query is responsible for wrapping
  * top-level keys in `$set`.
  *
- * @param {Object} update
- * @return {Object} modified
+ * @param {object} update
+ * @return {object} modified
  */
 
 module.exports = function modifiedPaths(update) {

package/.output/server/node_modules/mongoose/lib/helpers/update/removeUnusedArrayFilters.js

@@ -6,11 +6,16 @@
  * filters.
  */
 
-module.exports = function removeUnusedArrayFilters(update, arrayFilters) {
+module.exports = function removeUnusedArrayFilters(update, options) {
+  const arrayFilters = options?.arrayFilters;
+  if (!Array.isArray(arrayFilters)) {
+    return;
+  }
+
   const updateKeys = Object.keys(update).
     map(key => Object.keys(update[key])).
     reduce((cur, arr) => cur.concat(arr), []);
-  return arrayFilters.filter(obj => {
+  options.arrayFilters = options.arrayFilters.filter(obj => {
     return _checkSingleFilterKey(obj, updateKeys);
   });
 };

package/.output/server/node_modules/mongoose/lib/helpers/updateValidators.js

@@ -14,13 +14,13 @@ const flatten = require('./common').flatten;
  *
  * @param {Query} query
  * @param {Schema} schema
- * @param {Object} castedDoc
- * @param {Object} options
+ * @param {object} castedDoc
+ * @param {object} options
  * @method runValidatorsOnUpdate
  * @api private
  */
 
-module.exports = function(query, schema, castedDoc, options, callback) {
+module.exports = async function updateValidators(query, schema, castedDoc, options) {
   const keys = Object.keys(castedDoc || {});
   let updatedKeys = {};
   let updatedValues = {};
@@ -30,16 +30,15 @@ module.exports = function(query, schema, castedDoc, options, callback) {
   let hasDollarUpdate = false;
   let currentUpdate;
   let key;
-  let i;
 
-  for (i = 0; i < numKeys; ++i) {
+  for (let i = 0; i < numKeys; ++i) {
     if (keys[i].startsWith('$')) {
       hasDollarUpdate = true;
       if (keys[i] === '$push' || keys[i] === '$addToSet') {
         const _keys = Object.keys(castedDoc[keys[i]]);
         for (let ii = 0; ii < _keys.length; ++ii) {
           currentUpdate = castedDoc[keys[i]][_keys[ii]];
-          if (currentUpdate && currentUpdate.$each) {
+          if (currentUpdate?.$each) {
             arrayAtomicUpdates[_keys[ii]] = (arrayAtomicUpdates[_keys[ii]] || []).
               concat(currentUpdate.$each);
           } else {
@@ -85,163 +84,103 @@ module.exports = function(query, schema, castedDoc, options, callback) {
   const alreadyValidated = [];
 
   const context = query;
-  function iter(i, v) {
+  for (let i = 0; i < numUpdates; ++i) {
+    const v = updatedValues[updates[i]];
     const schemaPath = schema._getSchema(updates[i]);
     if (schemaPath == null) {
-      return;
+      continue;
     }
     if (schemaPath.instance === 'Mixed' && schemaPath.path !== updates[i]) {
-      return;
+      continue;
     }
 
     if (v && Array.isArray(v.$in)) {
       v.$in.forEach((v, i) => {
-        validatorsToExecute.push(function(callback) {
-          schemaPath.doValidate(
-            v,
-            function(err) {
-              if (err) {
-                err.path = updates[i] + '.$in.' + i;
-                validationErrors.push(err);
-              }
-              callback(null);
-            },
-            context,
-            { updateValidator: true });
-        });
+        validatorsToExecute.push(
+          schemaPath.doValidate(v, context, { updateValidator: true }).catch(err => {
+            err.path = updates[i] + '.$in.' + i;
+            validationErrors.push(err);
+          })
+        );
       });
     } else {
       if (isPull[updates[i]] &&
           schemaPath.$isMongooseArray) {
-        return;
+        continue;
       }
 
-      if (schemaPath.$isMongooseDocumentArrayElement && v != null && v.$__ != null) {
+      if (schemaPath.$isMongooseDocumentArrayElement && v?.$__ != null) {
         alreadyValidated.push(updates[i]);
-        validatorsToExecute.push(function(callback) {
-          schemaPath.doValidate(v, function(err) {
-            if (err) {
-              if (err.errors) {
-                for (const key of Object.keys(err.errors)) {
-                  const _err = err.errors[key];
-                  _err.path = updates[i] + '.' + key;
-                  validationErrors.push(_err);
-                }
-              } else {
-                err.path = updates[i];
-                validationErrors.push(err);
+        validatorsToExecute.push(
+          schemaPath.doValidate(v, context, { updateValidator: true }).catch(err => {
+            if (err.errors) {
+              for (const key of Object.keys(err.errors)) {
+                const _err = err.errors[key];
+                _err.path = updates[i] + '.' + key;
+                validationErrors.push(_err);
               }
+            } else {
+              err.path = updates[i];
+              validationErrors.push(err);
             }
-
-            return callback(null);
-          }, context, { updateValidator: true });
-        });
+          })
+        );
       } else {
-        validatorsToExecute.push(function(callback) {
-          for (const path of alreadyValidated) {
-            if (updates[i].startsWith(path + '.')) {
-              return callback(null);
-            }
-          }
-          if (schemaPath.$isSingleNested) {
-            alreadyValidated.push(updates[i]);
-          }
-
-          schemaPath.doValidate(v, function(err) {
+        const isAlreadyValidated = alreadyValidated.find(path => updates[i].startsWith(path + '.'));
+        if (isAlreadyValidated) {
+          continue;
+        }
+        if (schemaPath.$isSingleNested) {
+          alreadyValidated.push(updates[i]);
+        }
+        validatorsToExecute.push(
+          schemaPath.doValidate(v, context, { updateValidator: true }).catch(err => {
             if (schemaPath.schema != null &&
                 schemaPath.schema.options.storeSubdocValidationError === false &&
                 err instanceof ValidationError) {
-              return callback(null);
+              return;
             }
 
             if (err) {
               err.path = updates[i];
               validationErrors.push(err);
             }
-            callback(null);
-          }, context, { updateValidator: true });
-        });
+          })
+        );
       }
     }
   }
-  for (i = 0; i < numUpdates; ++i) {
-    iter(i, updatedValues[updates[i]]);
-  }
 
   const arrayUpdates = Object.keys(arrayAtomicUpdates);
   for (const arrayUpdate of arrayUpdates) {
     let schemaPath = schema._getSchema(arrayUpdate);
     if (schemaPath && schemaPath.$isMongooseDocumentArray) {
-      validatorsToExecute.push(function(callback) {
+      validatorsToExecute.push(
         schemaPath.doValidate(
           arrayAtomicUpdates[arrayUpdate],
-          getValidationCallback(arrayUpdate, validationErrors, callback),
-          options && options.context === 'query' ? query : null);
-      });
+          options?.context === 'query' ? query : null
+        ).catch(err => {
+          err.path = arrayUpdate;
+          validationErrors.push(err);
+        })
+      );
     } else {
       schemaPath = schema._getSchema(arrayUpdate + '.0');
       for (const atomicUpdate of arrayAtomicUpdates[arrayUpdate]) {
-        validatorsToExecute.push(function(callback) {
+        validatorsToExecute.push(
           schemaPath.doValidate(
             atomicUpdate,
-            getValidationCallback(arrayUpdate, validationErrors, callback),
-            options && options.context === 'query' ? query : null,
-            { updateValidator: true });
-        });
-      }
-    }
-  }
-
-  if (callback != null) {
-    let numValidators = validatorsToExecute.length;
-    if (numValidators === 0) {
-      return _done(callback);
-    }
-    for (const validator of validatorsToExecute) {
-      validator(function() {
-        if (--numValidators <= 0) {
-          _done(callback);
-        }
-      });
-    }
-
-    return;
-  }
-
-  return function(callback) {
-    let numValidators = validatorsToExecute.length;
-    if (numValidators === 0) {
-      return _done(callback);
-    }
-    for (const validator of validatorsToExecute) {
-      validator(function() {
-        if (--numValidators <= 0) {
-          _done(callback);
-        }
-      });
-    }
-  };
-
-  function _done(callback) {
-    if (validationErrors.length) {
-      const err = new ValidationError(null);
-
-      for (const validationError of validationErrors) {
-        err.addError(validationError.path, validationError);
+            options?.context === 'query' ? query : null,
+            { updateValidator: true }
+          ).catch(err => {
+            err.path = arrayUpdate;
+            validationErrors.push(err);
+          })
+        );
       }
-
-      return callback(err);
     }
-    callback(null);
   }
 
-  function getValidationCallback(arrayUpdate, validationErrors, callback) {
-    return function(err) {
-      if (err) {
-        err.path = arrayUpdate;
-        validationErrors.push(err);
-      }
-      callback(null);
-    };
-  }
+  await Promise.all(validatorsToExecute);
+  return validationErrors;
 };