@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongoose/lib/queryHelpers.js

@@ -19,7 +19,7 @@ const isPathSelectedInclusive = require('./helpers/projection/isPathSelectedIncl
  * version
  *
  * @param {Query} query
- * @param {Object} options
+ * @param {object} options
  * @return {Array}
  */
 
@@ -30,11 +30,11 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
   // lean options should trickle through all queries
   if (options.lean != null) {
     pop
-      .filter(p => (p && p.options && p.options.lean) == null)
+      .filter(p => p?.options?.lean == null)
       .forEach(makeLean(options.lean));
   }
 
-  const session = query && query.options && query.options.session || null;
+  const session = query?.options?.session || null;
   if (session != null) {
     pop.forEach(path => {
       if (path.options == null) {
@@ -69,8 +69,8 @@ exports.preparePopulationOptionsMQ = function preparePopulationOptionsMQ(query,
  * it returns an instance of the given model.
  *
  * @param {Model}  model
- * @param {Object} doc
- * @param {Object} fields
+ * @param {object} doc
+ * @param {object} fields
  *
  * @return {Document}
  */
@@ -80,32 +80,33 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
     model.schema.discriminatorMapping :
     null;
 
-  const key = discriminatorMapping && discriminatorMapping.isRoot ?
+  const key = discriminatorMapping?.isRoot ?
     discriminatorMapping.key :
     null;
 
+  const _opts = {
+    skipId: true,
+    isNew: false,
+    willInit: true
+  };
+  if (options?.defaults != null) {
+    _opts.defaults = options.defaults;
+  }
+  if (options?.strict != null) {
+    _opts.strict = options.strict;
+  }
+
   const value = doc[key];
   if (key && value && model.discriminators) {
     const discriminator = model.discriminators[value] || getDiscriminatorByValue(model.discriminators, value);
     if (discriminator) {
       const _fields = clone(userProvidedFields);
       exports.applyPaths(_fields, discriminator.schema);
-      const _opts = { strict: options?.strict };
+
       return new discriminator(undefined, _fields, _opts);
     }
   }
 
-  const _opts = {
-    skipId: true,
-    isNew: false,
-    willInit: true
-  };
-  if (options != null && 'defaults' in options) {
-    _opts.defaults = options.defaults;
-  }
-  if (options != null && 'strict' in options) {
-    _opts.strict = options.strict;
-  }
   return new model(undefined, fields, _opts);
 };
 
@@ -114,9 +115,13 @@ exports.createModel = function createModel(model, doc, fields, userProvidedField
  */
 
 exports.createModelAndInit = function createModelAndInit(model, doc, fields, userProvidedFields, options, populatedIds, callback) {
-  const initOpts = populatedIds ?
-    { populated: populatedIds } :
-    undefined;
+  const initOpts = {};
+  if (populatedIds) {
+    initOpts.populated = populatedIds;
+  }
+  if (options?.middleware != null) {
+    initOpts.middleware = options.middleware;
+  }
 
   const casted = exports.createModel(model, doc, fields, userProvidedFields, options);
   try {
@@ -183,10 +188,10 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
       // inclusive, minus path is treated as equivalent to `key: 0`.
       // But we also allow using `-name` to remove `name` from an inclusive
       // projection if `name` has schema-level `select: true`.
-      if ((!type || !type.selected) || exclude !== false) {
+      if (!type?.selected || exclude !== false) {
         fields[path] = 0;
         exclude = true;
-      } else if (type && type.selected && exclude === false) {
+      } else if (type?.selected && exclude === false) {
         // Make a note of minus paths that are overwriting paths that are
         // included by default.
         minusPathsToSkip.add(path);
@@ -208,10 +213,7 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
       }
       break;
     case false:
-      if (schema &&
-          schema.paths['_id'] &&
-          schema.paths['_id'].options &&
-          schema.paths['_id'].options.select === false) {
+      if (schema?.paths['_id']?.options?.select === false) {
         fields._id = 0;
       }
 
@@ -264,7 +266,7 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
       if (type.$isSchemaMap || path.endsWith('.$*')) {
         const plusPath = '+' + path;
         const hasPlusPath = fields && plusPath in fields;
-        if (type.options && type.options.select === false && !hasPlusPath) {
+        if (type.options?.select === false && !hasPlusPath) {
           excluded.push(path);
         }
         return;
@@ -272,7 +274,7 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
       let addedPath = analyzePath(path, type);
       // arrays
       if (addedPath == null && !Array.isArray(type) && type.$isMongooseArray && !type.$isMongooseDocumentArray) {
-        addedPath = analyzePath(path, type.caster);
+        addedPath = analyzePath(path, type.embeddedSchemaType);
       }
       if (addedPath != null) {
         addedPaths.push(addedPath);
@@ -356,7 +358,7 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
     // Special case: if user has included a parent path of a discriminator key,
     // don't explicitly project in the discriminator key because that will
     // project out everything else under the parent path
-    if (!exclude && (type && type.options && type.options.$skipDiscriminatorCheck || false)) {
+    if (!exclude && (type?.options?.$skipDiscriminatorCheck || false)) {
       let cur = '';
       for (let i = 0; i < pieces.length; ++i) {
         cur += (cur.length === 0 ? '' : '.') + pieces[i];
@@ -375,14 +377,14 @@ exports.applyPaths = function applyPaths(fields, schema, sanitizeProjection) {
 /**
  * Set each path query option to lean
  *
- * @param {Object} option
+ * @param {object} option
  */
 
 function makeLean(val) {
   return function(option) {
     option.options || (option.options = {});
 
-    if (val != null && Array.isArray(val.virtuals)) {
+    if (Array.isArray(val?.virtuals)) {
       val = Object.assign({}, val);
       val.virtuals = val.virtuals.
         filter(path => typeof path === 'string' && path.startsWith(option.path + '.')).

package/.output/server/node_modules/mongoose/lib/schema/array.js

@@ -21,23 +21,21 @@ const isOperator = require('../helpers/query/isOperator');
 const util = require('util');
 const utils = require('../utils');
 const castToNumber = require('./operators/helpers').castToNumber;
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const geospatial = require('./operators/geospatial');
 const getDiscriminatorByValue = require('../helpers/discriminator/getDiscriminatorByValue');
 
 let MongooseArray;
 let EmbeddedDoc;
 
-const isNestedArraySymbol = Symbol('mongoose#isNestedArray');
 const emptyOpts = Object.freeze({});
 
 /**
  * Array SchemaType constructor
  *
- * @param {String} key
+ * @param {string} key
  * @param {SchemaType} cast
- * @param {Object} options
- * @param {Object} schemaOptions
+ * @param {object} options
+ * @param {object} schemaOptions
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
@@ -48,7 +46,7 @@ function SchemaArray(key, cast, options, schemaOptions, parentSchema) {
   EmbeddedDoc || (EmbeddedDoc = require('../types').Embedded);
 
   let typeKey = 'type';
-  if (schemaOptions && schemaOptions.typeKey) {
+  if (schemaOptions?.typeKey) {
     typeKey = schemaOptions.typeKey;
   }
   this.schemaOptions = schemaOptions;
@@ -67,7 +65,7 @@ function SchemaArray(key, cast, options, schemaOptions, parentSchema) {
       }
     }
 
-    if (options != null && options.ref != null && castOptions.ref == null) {
+    if (options?.ref != null && castOptions.ref == null) {
       castOptions.ref = options.ref;
     }
 
@@ -81,31 +79,21 @@ function SchemaArray(key, cast, options, schemaOptions, parentSchema) {
       : utils.getFunctionName(cast);
 
     const Types = require('./index.js');
-    const caster = Object.hasOwn(Types, name) ? Types[name] : cast;
+    const schemaTypeDefinition = Object.hasOwn(Types, name) ? Types[name] : cast;
 
-    this.casterConstructor = caster;
-
-    if (this.casterConstructor instanceof SchemaArray) {
-      this.casterConstructor[isNestedArraySymbol] = true;
-    }
-
-    if (typeof caster === 'function' &&
-        !caster.$isArraySubdocument &&
-        !caster.$isSchemaMap) {
-      const path = this.caster instanceof EmbeddedDoc ? null : key;
-      if (caster === SchemaArray) {
-        this.caster = new caster(path, castOptions, schemaOptions, null, parentSchema);
+    if (typeof schemaTypeDefinition === 'function') {
+      if (schemaTypeDefinition === SchemaArray) {
+        this.embeddedSchemaType = new schemaTypeDefinition(key, castOptions, schemaOptions, null, parentSchema);
       } else {
-        this.caster = new caster(path, castOptions, schemaOptions, parentSchema);
+        this.embeddedSchemaType = new schemaTypeDefinition(key, castOptions, schemaOptions, parentSchema);
       }
-    } else {
-      this.caster = caster;
-      if (!(this.caster instanceof EmbeddedDoc)) {
-        this.caster.path = key;
+    } else if (schemaTypeDefinition instanceof SchemaType) {
+      this.embeddedSchemaType = schemaTypeDefinition;
+      if (!(this.embeddedSchemaType instanceof EmbeddedDoc)) {
+        this.embeddedSchemaType.path = key;
       }
     }
 
-    this.$embeddedSchemaType = this.caster;
   }
 
   this.$isMongooseArray = true;
@@ -166,13 +154,13 @@ SchemaArray.defaultOptions = {};
  * #### Example:
  *
  *     // Make all Array instances have `required` of true by default.
- *     mongoose.Schema.Array.set('required', true);
+ *     mongoose.Schema.Types.Array.set('required', true);
  *
  *     const User = mongoose.model('User', new Schema({ test: Array }));
  *     new User({ }).validateSync().errors.test.message; // Path `test` is required.
  *
- * @param {String} option The option you'd like to set the value for
- * @param {Any} value value for option
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
  * @return {undefined}
  * @function set
  * @api public
@@ -235,9 +223,9 @@ SchemaArray.prototype.virtuals = null;
 /**
  * Check if the given value satisfies the `required` validator.
  *
- * @param {Any} value
+ * @param {any} value
  * @param {Document} doc
- * @return {Boolean}
+ * @return {boolean}
  * @api public
  */
 
@@ -259,18 +247,16 @@ SchemaArray.prototype.checkRequired = function checkRequired(value, doc) {
  * Adds an enum validator if this is an array of strings or numbers. Equivalent to
  * `SchemaString.prototype.enum()` or `SchemaNumber.prototype.enum()`
  *
- * @param {...String|Object} [args] enumeration values
+ * @param {...string|object} [args] enumeration values
  * @return {SchemaArray} this
  */
 
 SchemaArray.prototype.enum = function() {
   let arr = this;
   while (true) {
-    const instance = arr &&
-    arr.caster &&
-    arr.caster.instance;
+    const instance = arr?.embeddedSchemaType?.instance;
     if (instance === 'Array') {
-      arr = arr.caster;
+      arr = arr.embeddedSchemaType;
       continue;
     }
     if (instance !== 'String' && instance !== 'Number') {
@@ -285,20 +271,20 @@ SchemaArray.prototype.enum = function() {
     enumArray = utils.object.vals(enumArray);
   }
 
-  arr.caster.enum.apply(arr.caster, enumArray);
+  arr.embeddedSchemaType.enum.apply(arr.embeddedSchemaType, enumArray);
   return this;
 };
 
 /**
  * Overrides the getters application for the population special-case
  *
- * @param {Object} value
- * @param {Object} scope
+ * @param {object} value
+ * @param {object} scope
  * @api private
  */
 
 SchemaArray.prototype.applyGetters = function(value, scope) {
-  if (scope != null && scope.$__ != null && scope.$populated(this.path)) {
+  if (scope?.$__ != null && scope.$populated(this.path)) {
     // means the object id was populated
     return value;
   }
@@ -308,9 +294,8 @@ SchemaArray.prototype.applyGetters = function(value, scope) {
 };
 
 SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
-  if (this.casterConstructor.$isMongooseArray &&
-      SchemaArray.options.castNonArrays &&
-      !this[isNestedArraySymbol]) {
+  if (this.embeddedSchemaType.$isMongooseArray &&
+      SchemaArray.options.castNonArrays) {
     // Check nesting levels and wrap in array if necessary
     let depth = 0;
     let arr = this;
@@ -318,7 +303,7 @@ SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
       arr.$isMongooseArray &&
       !arr.$isMongooseDocumentArray) {
       ++depth;
-      arr = arr.casterConstructor;
+      arr = arr.embeddedSchemaType;
     }
 
     // No need to wrap empty arrays
@@ -338,9 +323,9 @@ SchemaArray.prototype._applySetters = function(value, scope, init, priorVal) {
 /**
  * Casts values for set().
  *
- * @param {Object} value
+ * @param {object} value
  * @param {Document} doc document that triggers the casting
- * @param {Boolean} init whether this is an initialization cast
+ * @param {boolean} init whether this is an initialization cast
  * @api private
  */
 
@@ -388,13 +373,13 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
     value = MongooseArray(rawValue, path, doc, this);
     rawValue = value.__array;
 
-    if (init && doc != null && doc.$__ != null && doc.$populated(this.path)) {
+    if (init && doc?.$__ != null && doc.$populated(this.path)) {
       return value;
     }
 
-    const caster = this.caster;
+    const caster = this.embeddedSchemaType;
     const isMongooseArray = caster.$isMongooseArray;
-    if (caster && this.casterConstructor !== Mixed) {
+    if (caster && this.embeddedSchemaType.constructor !== Mixed) {
       try {
         const len = rawValue.length;
         for (i = 0; i < len; i++) {
@@ -412,6 +397,9 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
           if (options.hydratedPopulatedDocs) {
             opts.hydratedPopulatedDocs = options.hydratedPopulatedDocs;
           }
+          if (options.virtuals) {
+            opts.virtuals = options.virtuals;
+          }
           rawValue[i] = caster.applySetters(rawValue[i], doc, init, void 0, opts);
         }
       } catch (e) {
@@ -423,11 +411,11 @@ SchemaArray.prototype.cast = function(value, doc, init, prev, options) {
     return value;
   }
 
-  const castNonArraysOption = this.options.castNonArrays != null ? this.options.castNonArrays : SchemaArray.options.castNonArrays;
+  const castNonArraysOption = this.options.castNonArrays ?? SchemaArray.options.castNonArrays;
   if (init || castNonArraysOption) {
     // gh-2442: if we're loading this from the db and its not an array, mark
     // the whole array as modified.
-    if (!!doc && !!init) {
+    if (doc && init) {
       doc.markModified(this.path);
     }
     return this.cast([value], doc, init);
@@ -449,19 +437,18 @@ SchemaArray.prototype._castForPopulate = function _castForPopulate(value, doc) {
     const rawValue = value.__array ? value.__array : value;
     const len = rawValue.length;
 
-    const caster = this.caster;
-    if (caster && this.casterConstructor !== Mixed) {
+    if (this.embeddedSchemaType && this.embeddedSchemaType.constructor !== Mixed) {
       try {
         for (i = 0; i < len; i++) {
           const opts = {};
           // Perf: creating `arrayPath` is expensive for large arrays.
           // We only need `arrayPath` if this is a nested array, so
           // skip if possible.
-          if (caster.$isMongooseArray && caster._arrayParentPath != null) {
+          if (this.embeddedSchemaType.$isMongooseArray && this.embeddedSchemaType._arrayParentPath != null) {
             opts.arrayPathIndex = i;
           }
 
-          rawValue[i] = caster.cast(rawValue[i], doc, false, void 0, opts);
+          rawValue[i] = this.embeddedSchemaType.cast(rawValue[i], doc, false, void 0, opts);
         }
       } catch (e) {
         // rethrow
@@ -484,11 +471,10 @@ SchemaArray.prototype.$toObject = SchemaArray.prototype.toObject;
 SchemaArray.prototype.discriminator = function(...args) {
   let arr = this;
   while (arr.$isMongooseArray && !arr.$isMongooseDocumentArray) {
-    arr = arr.casterConstructor;
-    if (arr == null || typeof arr === 'function') {
-      throw new MongooseError('You can only add an embedded discriminator on ' +
-        'a document array, ' + this.path + ' is a plain array');
-    }
+    arr = arr.embeddedSchemaType;
+  }
+  if (!arr.$isMongooseDocumentArray) {
+    throw new MongooseError('You can only add an embedded discriminator on a document array, ' + this.path + ' is a plain array');
   }
   return arr.discriminator(...args);
 };
@@ -499,7 +485,7 @@ SchemaArray.prototype.discriminator = function(...args) {
 
 SchemaArray.prototype.clone = function() {
   const options = Object.assign({}, this.options);
-  const schematype = new this.constructor(this.path, this.caster, options, this.schemaOptions, this.parentSchema);
+  const schematype = new this.constructor(this.path, this.embeddedSchemaType, options, this.schemaOptions, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;
@@ -508,30 +494,21 @@ SchemaArray.prototype.clone = function() {
 };
 
 SchemaArray.prototype._castForQuery = function(val, context) {
-  let Constructor = this.casterConstructor;
-
-  if (val &&
-      Constructor.discriminators &&
-      Constructor.schema &&
-      Constructor.schema.options &&
-      Constructor.schema.options.discriminatorKey) {
-    if (typeof val[Constructor.schema.options.discriminatorKey] === 'string' &&
-        Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]]) {
-      Constructor = Constructor.discriminators[val[Constructor.schema.options.discriminatorKey]];
+  let embeddedSchemaType = this.embeddedSchemaType;
+  const discriminatorKey = embeddedSchemaType?.schema?.options?.discriminatorKey;
+  const discriminators = embeddedSchemaType?.discriminators;
+
+  if (val && discriminators && typeof discriminatorKey === 'string') {
+    if (discriminators[val[discriminatorKey]]) {
+      embeddedSchemaType = discriminators[val[discriminatorKey]];
     } else {
-      const constructorByValue = getDiscriminatorByValue(Constructor.discriminators, val[Constructor.schema.options.discriminatorKey]);
+      const constructorByValue = getDiscriminatorByValue(discriminators, val[discriminatorKey]);
       if (constructorByValue) {
-        Constructor = constructorByValue;
+        embeddedSchemaType = constructorByValue;
       }
     }
   }
 
-  const proto = this.casterConstructor.prototype;
-  const protoCastForQuery = proto && proto.castForQuery;
-  const protoCast = proto && proto.cast;
-  const constructorCastForQuery = Constructor.castForQuery;
-  const caster = this.caster;
-
   if (Array.isArray(val)) {
     this.setters.reverse().forEach(setter => {
       val = setter.call(this, val, this);
@@ -540,30 +517,10 @@ SchemaArray.prototype._castForQuery = function(val, context) {
       if (utils.isObject(v) && v.$elemMatch) {
         return v;
       }
-      if (protoCastForQuery) {
-        v = protoCastForQuery.call(caster, null, v, context);
-        return v;
-      } else if (protoCast) {
-        v = protoCast.call(caster, v);
-        return v;
-      } else if (constructorCastForQuery) {
-        v = constructorCastForQuery.call(caster, null, v, context);
-        return v;
-      }
-      if (v != null) {
-        v = new Constructor(v);
-        return v;
-      }
-      return v;
+      return embeddedSchemaType.castForQuery(null, v, context);
     });
-  } else if (protoCastForQuery) {
-    val = protoCastForQuery.call(caster, null, val, context);
-  } else if (protoCast) {
-    val = protoCast.call(caster, val);
-  } else if (constructorCastForQuery) {
-    val = constructorCastForQuery.call(caster, null, val, context);
-  } else if (val != null) {
-    val = new Constructor(val);
+  } else {
+    val = embeddedSchemaType.castForQuery(null, val, context);
   }
 
   return val;
@@ -572,7 +529,7 @@ SchemaArray.prototype._castForQuery = function(val, context) {
 /**
  * Casts values for queries.
  *
- * @param {String} $conditional
+ * @param {string} $conditional
  * @param {any} [value]
  * @api private
  */
@@ -596,8 +553,8 @@ SchemaArray.prototype.castForQuery = function($conditional, val, context) {
 /**
  * Add a virtual to this array. Specifically to this array, not the individual elements.
  *
- * @param {String} name
- * @param {Object} [options]
+ * @param {string} name
+ * @param {object} [options]
  * @api private
  */
 
@@ -629,12 +586,12 @@ function cast$all(val, context) {
       return v;
     }
     if (v.$elemMatch != null) {
-      return { $elemMatch: cast(this.casterConstructor.schema, v.$elemMatch, null, this && this.$$context) };
+      return { $elemMatch: cast(this.embeddedSchemaType.schema, v.$elemMatch, null, this?.$$context) };
     }
 
     const o = {};
     o[this.path] = v;
-    return cast(this.casterConstructor.schema, o, null, this && this.$$context)[this.path];
+    return cast(this.embeddedSchemaType.schema, o, null, this?.$$context)[this.path];
   }, this);
 
   return this.castForQuery(null, val, context);
@@ -682,7 +639,7 @@ function createLogicalQueryOperatorHandler(op) {
 
     const ret = [];
     for (const obj of val) {
-      ret.push(cast(this.casterConstructor.schema ?? context.schema, obj, null, this && this.$$context));
+      ret.push(cast(this.embeddedSchemaType.schema ?? context.schema, obj, null, this?.$$context));
     }
 
     return ret;
@@ -719,16 +676,15 @@ handle.$in = SchemaType.prototype.$conditionalHandlers.$in;
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaArray.prototype.toJSONSchema = function toJSONSchema(options) {
   const embeddedSchemaType = this.getEmbeddedSchemaType();
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
   return {
-    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    ...this._createJSONSchemaTypeDefinition('array', 'array', options),
     items: embeddedSchemaType.toJSONSchema(options)
   };
 };