@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongoose/lib/helpers/populate/setPopulatedVirtualValue.js

@@ -3,11 +3,11 @@
 /**
  * Set a populated virtual value on a document's `$$populatedVirtuals` value
  *
- * @param {*} populatedVirtuals A document's `$$populatedVirtuals`
- * @param {*} name The virtual name
- * @param {*} v The result of the populate query
- * @param {*} options The populate options. This function handles `justOne` and `count` options.
- * @returns {Array<Document>|Document|Object|Array<Object>} the populated virtual value that was set
+ * @param {object} populatedVirtuals A document's `$$populatedVirtuals`
+ * @param {string} name The virtual name
+ * @param {any} v The result of the populate query
+ * @param {object} options The populate options. This function handles `justOne` and `count` options.
+ * @returns {Document[]|Document|object|object[]} the populated virtual value that was set
  */
 
 module.exports = function setPopulatedVirtualValue(populatedVirtuals, name, v, options) {

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

@@ -11,7 +11,7 @@ if (typeof jest !== 'undefined' && !process.env.SUPPRESS_JEST_WARNINGS) {
       'to hide this warning.');
   }
 
-  if (setTimeout.clock != null && typeof setTimeout.clock.Date === 'function') {
+  if (typeof setTimeout.clock?.Date === 'function') {
     utils.warn('Mongoose: looks like you\'re trying to test a Mongoose app ' +
       'with Jest\'s mock timers enabled. Please make sure you read ' +
       'Mongoose\'s docs on configuring Jest to test Node.js apps: ' +

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

@@ -31,7 +31,7 @@ function resolveOptsConflicts(pref, opts) {
 }
 
 function setsIndexOptions(opts) {
-  const configIdx = opts.config && opts.config.autoIndex;
+  const configIdx = opts.config?.autoIndex;
   const { autoCreate, autoIndex } = opts;
   return !!(configIdx || autoCreate || autoIndex);
 }

package/.output/server/node_modules/mongoose/lib/helpers/projection/hasIncludedChildren.js

@@ -12,7 +12,7 @@
  *     res['a.b.c']; // 1
  *     res['a.c']; // undefined
  *
- * @param {Object} fields
+ * @param {object} fields
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/projection/isPathExcluded.js

@@ -5,9 +5,9 @@ const isDefiningProjection = require('./isDefiningProjection');
 /**
  * Determines if `path` is excluded by `projection`
  *
- * @param {Object} projection
- * @param {String} path
- * @return {Boolean}
+ * @param {object} projection
+ * @param {string} path
+ * @return {boolean}
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/projection/isSubpath.js

@@ -5,7 +5,7 @@
  *
  * @param {string} path1
  * @param {string} path2
- * @return {Boolean}
+ * @return {boolean}
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/projection/parseProjection.js

@@ -1,8 +1,13 @@
 'use strict';
 
 /**
- * Convert a string or array into a projection object, retaining all
- * `-` and `+` paths.
+ * Convert a string or array into a projection object. Treats `-foo` as
+ * equivalent to `foo: 0` depending on `retainMinusPaths`. If `retainMinusPaths`
+ * is true, then `-foo` will be included in the projection as `'-foo': 0`.
+ *
+ * @param {object|string|string[]} v
+ * @param {boolean} [retainMinusPaths]
+ * @return {object}
  */
 
 module.exports = function parseProjection(v, retainMinusPaths) {
@@ -22,9 +27,9 @@ module.exports = function parseProjection(v, retainMinusPaths) {
     if (!field) {
       continue;
     }
-    const include = '-' == field[0] ? 0 : 1;
+    const include = field.charAt(0) === '-' ? 0 : 1;
     if (!retainMinusPaths && include === 0) {
-      field = field.substring(1);
+      field = field.slice(1);
     }
     ret[field] = include;
   }

package/.output/server/node_modules/mongoose/lib/helpers/query/cast$expr.js

@@ -146,7 +146,7 @@ function castNumberOperator(val) {
 
   try {
     return castNumber(val);
-  } catch (err) {
+  } catch {
     throw new CastError('Number', val);
   }
 }
@@ -174,7 +174,7 @@ function castIn(val, schema, strictQuery) {
   }
 
   return [
-    schematype.$isMongooseDocumentArray ? schematype.$embeddedSchemaType.cast(search) : schematype.caster.cast(search),
+    schematype.embeddedSchemaType.cast(search),
     path
   ];
 }
@@ -187,7 +187,7 @@ function castArithmetic(val) {
     }
     try {
       return castNumber(val);
-    } catch (err) {
+    } catch {
       throw new CastError('Number', val);
     }
   }
@@ -198,7 +198,7 @@ function castArithmetic(val) {
     }
     try {
       return castNumber(v);
-    } catch (err) {
+    } catch {
       throw new CastError('Number', v);
     }
   });
@@ -229,10 +229,8 @@ function castComparison(val, schema, strictQuery) {
           path = lhs[key].slice(1) + '.' + key;
           schematype = schema.path(lhs[key].slice(1));
           if (schematype != null) {
-            if (schematype.$isMongooseDocumentArray) {
-              schematype = schematype.$embeddedSchemaType;
-            } else if (schematype.$isMongooseArray) {
-              schematype = schematype.caster;
+            if (schematype.$isMongooseArray) {
+              schematype = schematype.embeddedSchemaType;
             }
           }
         }
@@ -250,13 +248,13 @@ function castComparison(val, schema, strictQuery) {
       if (is$literal) {
         try {
           val[1] = { $literal: caster(val[1].$literal) };
-        } catch (err) {
+        } catch {
           throw new CastError(caster.name.replace(/^cast/, ''), val[1], path + '.$literal');
         }
       } else {
         try {
           val[1] = caster(val[1]);
-        } catch (err) {
+        } catch {
           throw new CastError(caster.name.replace(/^cast/, ''), val[1], path);
         }
       }

package/.output/server/node_modules/mongoose/lib/helpers/query/castFilterPath.js

@@ -22,7 +22,7 @@ module.exports = function castFilterPath(ctx, schematype, val) {
     const nested = val[$cond];
 
     if ($cond === '$not') {
-      if (nested && schematype && !schematype.caster) {
+      if (nested && schematype && !schematype.embeddedSchemaType && !schematype.Constructor) {
         const _keys = Object.keys(nested);
         if (_keys.length && isOperator(_keys[0])) {
           for (const key of Object.keys(nested)) {

package/.output/server/node_modules/mongoose/lib/helpers/query/castUpdate.js

@@ -39,11 +39,11 @@ const mongodbUpdateOperators = new Set([
  * Casts an update op based on the given schema
  *
  * @param {Schema} schema
- * @param {Object} obj
- * @param {Object} [options]
- * @param {Boolean|String} [options.strict] defaults to true
+ * @param {object} obj
+ * @param {object} [options]
+ * @param {boolean|'throw'} [options.strict] defaults to true
  * @param {Query} context passed to setters
- * @return {Boolean} true iff the update is non-empty
+ * @return {boolean} true iff the update is non-empty
  * @api private
  */
 module.exports = function castUpdate(schema, obj, options, context, filter) {
@@ -71,7 +71,7 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     const discriminatorValue = filter[schema.options.discriminatorKey];
     const byValue = getDiscriminatorByValue(context.model.discriminators, discriminatorValue);
     schema = schema.discriminators[discriminatorValue] ||
-      (byValue && byValue.schema) ||
+      byValue?.schema ||
       schema;
   } else if (schema != null &&
       options.overwriteDiscriminatorKey &&
@@ -80,7 +80,7 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     const discriminatorValue = obj[schema.options.discriminatorKey];
     const byValue = getDiscriminatorByValue(context.model.discriminators, discriminatorValue);
     schema = schema.discriminators[discriminatorValue] ||
-      (byValue && byValue.schema) ||
+      byValue?.schema ||
       schema;
   } else if (schema != null &&
       options.overwriteDiscriminatorKey &&
@@ -90,7 +90,7 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     const discriminatorValue = obj.$set[schema.options.discriminatorKey];
     const byValue = getDiscriminatorByValue(context.model.discriminators, discriminatorValue);
     schema = schema.discriminators[discriminatorValue] ||
-      (byValue && byValue.schema) ||
+      byValue?.schema ||
       schema;
   }
 
@@ -98,6 +98,10 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     moveImmutableProperties(schema, obj, context);
   }
 
+  if (obj?.$__ && typeof obj.toObject === 'function') {
+    obj = obj.toObject(internalToObjectOptions);
+  }
+
   const ops = Object.keys(obj);
   let i = ops.length;
   const ret = {};
@@ -133,7 +137,7 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     const op = ops[i];
     val = ret[op];
     hasDollarKey = hasDollarKey || op.startsWith('$');
-    if (val != null && val.$__) {
+    if (val?.$__) {
       val = val.toObject(internalToObjectOptions);
       ret[op] = val;
     }
@@ -153,9 +157,9 @@ module.exports = function castUpdate(schema, obj, options, context, filter) {
     }
   }
 
-  if (Object.keys(ret).length === 0 &&
+  if (utils.hasOwnKeys(ret) === false &&
       options.upsert &&
-      Object.keys(filter).length > 0) {
+      utils.hasOwnKeys(filter)) {
     // Trick the driver into allowing empty upserts to work around
     // https://github.com/mongodb/node-mongodb-native/pull/2490
     // Shallow clone to avoid passing defaults in re: gh-13962
@@ -202,13 +206,13 @@ function castPipelineOperator(op, val) {
  * according to its schema.
  *
  * @param {Schema} schema
- * @param {Object} obj part of a query
- * @param {String} op the atomic operator ($pull, $set, etc)
- * @param {Object} [options]
- * @param {Boolean|String} [options.strict]
+ * @param {object} obj part of a query
+ * @param {string} op the atomic operator ($pull, $set, etc)
+ * @param {object} [options]
+ * @param {boolean|'throw'} [options.strict]
  * @param {Query} context
- * @param {Object} filter
- * @param {String} pref path prefix (internal only)
+ * @param {object} filter
+ * @param {string} pref path prefix (internal only)
  * @return {Bool} true if this path has keys to update
  * @api private
  */
@@ -225,7 +229,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
 
   let aggregatedError = null;
 
-  const strictMode = strict != null ? strict : schema.options.strict;
+  const strictMode = strict ?? schema.options.strict;
 
   while (i--) {
     key = keys[i];
@@ -241,7 +245,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
           schematype = _res.schematype;
         }
       }
-      if (schematype != null && schematype.schema != null) {
+      if (schematype?.schema != null) {
         obj[key] = cast(schematype.schema, obj[key], options, context);
         hasKeys = true;
         continue;
@@ -281,7 +285,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
         continue;
       }
 
-      if (schematype && schematype.caster && op in castOps) {
+      if (schematype && (schematype.embeddedSchemaType || schematype.Constructor) && op in castOps) {
         // embedded doc schema
         if ('$each' in val) {
           hasKeys = true;
@@ -305,7 +309,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
             obj[key].$position = castNumber(val.$position);
           }
         } else {
-          if (schematype != null && schematype.$isSingleNested) {
+          if (schematype?.$isSingleNested) {
             const _strict = strict == null ? schematype.schema.options.strict : strict;
             try {
               obj[key] = schematype.castForQuery(null, val, context, { strict: _strict });
@@ -359,7 +363,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
         const pathToCheck = (prefix + key);
         const v = schema._getPathType(pathToCheck);
         let _strict = strict;
-        if (v && v.schema && _strict == null) {
+        if (v?.schema && _strict == null) {
           _strict = v.schema.options.strict;
         }
 
@@ -376,7 +380,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
         // we should be able to set a schema-less field
         // to an empty object literal
         hasKeys |= walkUpdatePath(schema, val, op, options, context, filter, prefix + key) ||
-          (utils.isObject(val) && Object.keys(val).length === 0);
+          (utils.isObject(val) && utils.hasOwnKeys(val) === false);
       }
     } else {
       const isModifier = (key === '$each' || key === '$or' || key === '$and' || key === '$in');
@@ -407,7 +411,7 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
       }
 
       let isStrict = strict;
-      if (pathDetails && pathDetails.schema && strict == null) {
+      if (pathDetails?.schema && strict == null) {
         isStrict = pathDetails.schema.options.strict;
       }
 
@@ -449,9 +453,9 @@ function walkUpdatePath(schema, obj, op, options, context, filter, prefix) {
 
         if (Array.isArray(obj[key]) && (op === '$addToSet' || op === '$push') && key !== '$each') {
           if (schematype &&
-              schematype.caster &&
-              !schematype.caster.$isMongooseArray &&
-              !schematype.caster[schemaMixedSymbol]) {
+              schematype.embeddedSchemaType &&
+              !schematype.embeddedSchemaType.$isMongooseArray &&
+              !schematype.embeddedSchemaType[schemaMixedSymbol]) {
             obj[key] = { $each: obj[key] };
           }
         }
@@ -532,11 +536,11 @@ const overwriteOps = {
  * Casts `val` according to `schema` and atomic `op`.
  *
  * @param {SchemaType} schema
- * @param {Object} val
- * @param {String} op the atomic operator ($pull, $set, etc)
- * @param {String} $conditional
+ * @param {object} val
+ * @param {string} op the atomic operator ($pull, $set, etc)
+ * @param {string} $conditional
  * @param {Query} context
- * @param {String} path
+ * @param {string} path
  * @api private
  */
 
@@ -546,17 +550,16 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     if (op in numberOps) {
       try {
         return castNumber(val);
-      } catch (err) {
+      } catch {
         throw new CastError('number', val, path);
       }
     }
     return val;
   }
 
-  // console.log('CastUpdateVal', path, op, val, schema);
-
-  const cond = schema.caster && op in castOps &&
-      (utils.isObject(val) || Array.isArray(val));
+  const cond = schema.$isMongooseArray
+    && op in castOps
+    && (utils.isObject(val) || Array.isArray(val));
   if (cond && !overwriteOps[op]) {
     // Cast values for ops that add data to MongoDB.
     // Ensures embedded documents get ObjectIds etc.
@@ -564,7 +567,7 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     let cur = schema;
     while (cur.$isMongooseArray) {
       ++schemaArrayDepth;
-      cur = cur.caster;
+      cur = cur.embeddedSchemaType;
     }
     let arrayDepth = 0;
     let _val = val;
@@ -605,7 +608,7 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
     }
     try {
       return castNumber(val);
-    } catch (error) {
+    } catch {
       throw new CastError('number', val, schema.path);
     }
   }
@@ -625,7 +628,10 @@ function castUpdateVal(schema, val, op, $conditional, context, path) {
   }
 
   if (overwriteOps[op]) {
-    const skipQueryCastForUpdate = val != null && schema.$isMongooseArray && schema.$fullPath != null && !schema.$fullPath.match(/\d+$/);
+    const skipQueryCastForUpdate = val != null
+      && schema.$isMongooseArray
+      && schema.$fullPath != null
+      && !schema.$fullPath.match(/\d+$/);
     const applySetters = schema[schemaMixedSymbol] != null;
     if (skipQueryCastForUpdate || applySetters) {
       return schema.applySetters(val, context);

package/.output/server/node_modules/mongoose/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -9,10 +9,10 @@ const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter')
  * Like `schema.path()`, except with a document, because impossible to
  * determine path type without knowing the embedded discriminator key.
  * @param {Schema} schema
- * @param {Object} [update]
- * @param {Object} [filter]
- * @param {String} path
- * @param {Object} [options]
+ * @param {object} [update]
+ * @param {object} [filter]
+ * @param {string} path
+ * @param {object} [options]
  * @api private
  */
 
@@ -23,7 +23,7 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
 
   filter = filter || {};
   update = update || {};
-  const arrayFilters = options != null && Array.isArray(options.arrayFilters) ?
+  const arrayFilters = Array.isArray(options?.arrayFilters) ?
     options.arrayFilters : [];
   const updatedPathsByFilter = updatedPathsByArrayFilter(update);
   let startIndex = 0;
@@ -82,14 +82,14 @@ module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, p
         continue;
       }
 
-      const discriminator = getDiscriminatorByValue(schematype.caster.discriminators, discriminatorKey);
-      const discriminatorSchema = discriminator && discriminator.schema;
+      const discriminator = getDiscriminatorByValue(schematype.Constructor.discriminators, discriminatorKey);
+      const discriminatorSchema = discriminator?.schema;
       if (discriminatorSchema == null) {
         continue;
       }
 
       const rest = parts.slice(i + 1).join('.');
-      schematype = discriminatorSchema.path(rest);
+      schematype = discriminatorSchema._getSchema(rest);
       schema = discriminatorSchema;
       startIndex = i + 1;
       if (schematype != null) {

package/.output/server/node_modules/mongoose/lib/helpers/query/handleImmutable.js

@@ -6,17 +6,17 @@ const StrictModeError = require('../../error/strict');
  * Handle immutable option for a given path when casting updates based on options
  *
  * @param {SchemaType} schematype the resolved schematype for this path
- * @param {Boolean | 'throw' | null} strict whether strict mode is set for this query
- * @param {Object} obj the object containing the value being checked so we can delete
- * @param {String} key the key in `obj` which we are checking for immutability
- * @param {String} fullPath the full path being checked
- * @param {Object} options the query options
+ * @param {boolean | 'throw' | null} strict whether strict mode is set for this query
+ * @param {object} obj the object containing the value being checked so we can delete
+ * @param {string} key the key in `obj` which we are checking for immutability
+ * @param {string} fullPath the full path being checked
+ * @param {object} options the query options
  * @param {Query} ctx the query. Passed as `this` and first param to the `immutable` option, if `immutable` is a function
- * @returns true if field was removed, false otherwise
+ * @returns {boolean} true if field was removed, false otherwise
  */
 
 module.exports = function handleImmutable(schematype, strict, obj, key, fullPath, options, ctx) {
-  if (schematype == null || !schematype.options || !schematype.options.immutable) {
+  if (!schematype?.options?.immutable) {
     return false;
   }
   let immutable = schematype.options.immutable;
@@ -28,7 +28,7 @@ module.exports = function handleImmutable(schematype, strict, obj, key, fullPath
     return false;
   }
 
-  if (options && options.overwriteImmutable) {
+  if (options?.overwriteImmutable) {
     return false;
   }
   if (strict === false) {

package/.output/server/node_modules/mongoose/lib/helpers/schema/applyPlugins.js

@@ -6,7 +6,7 @@ module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
   }
   schema[cacheKey] = true;
 
-  if (!options || !options.skipTopLevel) {
+  if (!options?.skipTopLevel) {
     let pluginTags = null;
     for (const plugin of plugins) {
       const tags = plugin[1] == null ? null : plugin[1].tags;
@@ -33,7 +33,7 @@ module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
         applyPlugins(type.schema, plugins, options, cacheKey);
 
         // Recompile schema because plugins may have changed it, see gh-7572
-        type.caster.prototype.$__setSchema(type.schema);
+        type.Constructor.prototype.$__setSchema(type.schema);
       }
     }
   }

package/.output/server/node_modules/mongoose/lib/helpers/schema/applyReadConcern.js

@@ -9,7 +9,7 @@ module.exports = function applyReadConcern(schema, options) {
   // because you shouldn't set read concern on individual operations
   // within a transaction.
   // See: https://www.mongodb.com/docs/manual/reference/read-concern/
-  if (options && options.session && options.session.transaction) {
+  if (options?.session?.transaction) {
     return;
   }
 

package/.output/server/node_modules/mongoose/lib/helpers/schema/applyWriteConcern.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const utils = require('../../utils');
+
 module.exports = function applyWriteConcern(schema, options) {
   if (options.writeConcern != null) {
     return;
@@ -7,11 +9,11 @@ module.exports = function applyWriteConcern(schema, options) {
   // Don't apply default write concern to operations in transactions,
   // because setting write concern on an operation in a transaction is an error
   // See: https://www.mongodb.com/docs/manual/reference/write-concern/
-  if (options && options.session && options.session.transaction) {
+  if (options?.session?.transaction) {
     return;
   }
   const writeConcern = schema.options.writeConcern ?? {};
-  if (Object.keys(writeConcern).length != 0) {
+  if (utils.hasOwnKeys(writeConcern)) {
     options.writeConcern = {};
     if (!('w' in options) && writeConcern.w != null) {
       options.writeConcern.w = writeConcern.w;

package/.output/server/node_modules/mongoose/lib/helpers/schema/getIndexes.js

@@ -67,9 +67,9 @@ module.exports = function getIndexes(schema) {
         }
       }
 
-      const index = path._index || (path.caster && path.caster._index);
+      const index = path._index || (path.embeddedSchemaType && path.embeddedSchemaType._index);
 
-      if (index !== false && index !== null && index !== undefined) {
+      if (index !== false && index != null) {
         const field = {};
         const isObject = helperIsObject(index);
         const options = isObject ? { ...index } : {};
@@ -96,14 +96,11 @@ module.exports = function getIndexes(schema) {
         }
 
         delete options.type;
-        if (!('background' in options)) {
-          options.background = true;
-        }
         if (schema.options.autoIndex != null) {
           options._autoIndex = schema.options.autoIndex;
         }
 
-        const indexName = options && options.name;
+        const indexName = options?.name;
 
         if (typeof indexName === 'string') {
           if (indexByName.has(indexName)) {
@@ -126,9 +123,6 @@ module.exports = function getIndexes(schema) {
     } else {
       schema._indexes.forEach(function(index) {
         const options = index[1];
-        if (!('background' in options)) {
-          options.background = true;
-        }
         decorateDiscriminatorIndexOptions(schema, options);
       });
       indexes = indexes.concat(schema._indexes);
@@ -141,7 +135,7 @@ module.exports = function getIndexes(schema) {
    *
    * schema._indexes = [ [indexObj, options], [indexObj, options] ..]
    * @param {Schema} schema
-   * @param {String} prefix
+   * @param {string} prefix
    * @api private
    */
 
@@ -162,7 +156,7 @@ module.exports = function getIndexes(schema) {
       }
 
       const newIndexOptions = Object.assign({}, indexOptions);
-      if (indexOptions != null && indexOptions.partialFilterExpression != null) {
+      if (indexOptions?.partialFilterExpression != null) {
         newIndexOptions.partialFilterExpression = {};
         const partialFilterExpression = indexOptions.partialFilterExpression;
         for (const key of Object.keys(partialFilterExpression)) {

package/.output/server/node_modules/mongoose/lib/helpers/schema/getSubdocumentStrictValue.js

@@ -7,7 +7,7 @@
  * default, not the top-level document's.
  *
  * @param {Schema} schema
- * @param {String[]} parts
+ * @param {string[]} parts
  * @returns {boolean | 'throw' | undefined}
  */
 
@@ -19,7 +19,7 @@ module.exports = function getSubdocumentStrictValue(schema, parts) {
   let strict = undefined;
   for (let i = 0; i < parts.length - 1; ++i) {
     const curSchemaType = schema.path(cur);
-    if (curSchemaType && curSchemaType.schema) {
+    if (curSchemaType?.schema) {
       strict = curSchemaType.schema.options.strict;
       schema = curSchemaType.schema;
       cur = curSchemaType.$isMongooseDocumentArray && !isNaN(parts[i + 1]) ? '' : parts[i + 1];

package/.output/server/node_modules/mongoose/lib/helpers/schema/handleIdOption.js

@@ -3,7 +3,7 @@
 const addAutoId = require('./addAutoId');
 
 module.exports = function handleIdOption(schema, options) {
-  if (options == null || options._id == null) {
+  if (options?._id == null) {
     return schema;
   }
 

package/.output/server/node_modules/mongoose/lib/helpers/schema/idGetter.js

@@ -12,7 +12,7 @@ module.exports = function addIdGetter(schema) {
   if (!autoIdGetter) {
     return schema;
   }
-  if (schema.aliases && schema.aliases.id) {
+  if (schema.aliases?.id) {
     return schema;
   }
   schema.virtual('id').get(idGetter);

package/.output/server/node_modules/mongoose/lib/helpers/schematype/handleImmutable.js

@@ -26,7 +26,7 @@ function createImmutableSetter(path, immutable) {
     if (this.isNew) {
       return v;
     }
-    if (options && options.overwriteImmutable) {
+    if (options?.overwriteImmutable) {
       return v;
     }