@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongoose/lib/error/missingSchema.js

@@ -9,7 +9,7 @@ const MongooseError = require('./mongooseError');
 
 /**
  * MissingSchema Error constructor.
- * @param {String} name
+ * @param {string} name
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/error/objectParameter.js

@@ -10,17 +10,16 @@ const MongooseError = require('./mongooseError');
  * Constructor for errors that happen when a parameter that's expected to be
  * an object isn't an object
  *
- * @param {Any} value
- * @param {String} paramName
- * @param {String} fnName
+ * @param {any} value
+ * @param {string} paramName
+ * @param {string} fnName
  * @api private
  */
 
 class ObjectParameterError extends MongooseError {
-
   constructor(value, paramName, fnName) {
     super('Parameter "' + paramName + '" to ' + fnName +
-      '() must be an object, got "' + (value?.toString() ?? (value + '')) + '" (type ' + typeof value + ')');
+      '() must be an object, got "' + (value == null ? value : value.toString()) + '" (type ' + typeof value + ')');
   }
 }
 

package/.output/server/node_modules/mongoose/lib/error/overwriteModel.js

@@ -9,7 +9,7 @@ const MongooseError = require('./mongooseError');
 
 /**
  * OverwriteModel Error constructor.
- * @param {String} name
+ * @param {string} name
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/error/setOptionError.js

@@ -40,8 +40,8 @@ class SetOptionError extends MongooseError {
 
   /**
   * add message
-  * @param {String} key
-  * @param {String|Error} error
+  * @param {string} key
+  * @param {string|Error} error
   * @api private
   */
   addError(key, error) {
@@ -87,7 +87,7 @@ Object.defineProperty(SetOptionError.prototype, 'name', {
 class SetOptionInnerError extends MongooseError {
   /**
    * Error for the "errors" array in "SetOptionError" with consistent message
-   * @param {String} key
+   * @param {string} key
    */
   constructor(key) {
     super(`"${key}" is not a valid option to set`);

package/.output/server/node_modules/mongoose/lib/error/strict.js

@@ -9,9 +9,9 @@ const MongooseError = require('./mongooseError');
 /**
  * Strict mode error constructor
  *
- * @param {String} path
- * @param {String} [msg]
- * @param {Boolean} [immutable]
+ * @param {string} path
+ * @param {string} [msg]
+ * @param {boolean} [immutable]
  * @inherits MongooseError
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/error/strictPopulate.js

@@ -9,8 +9,8 @@ const MongooseError = require('./mongooseError');
 /**
  * Strict mode error constructor
  *
- * @param {String} path
- * @param {String} [msg]
+ * @param {string} path
+ * @param {string} [msg]
  * @inherits MongooseError
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/error/syncIndexes.js

@@ -9,8 +9,8 @@ const MongooseError = require('./mongooseError');
 /**
  * SyncIndexes Error constructor.
  *
- * @param {String} message
- * @param {String} errorsMap
+ * @param {string} message
+ * @param {string} errorsMap
  * @inherits MongooseError
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/error/validation.js

@@ -44,18 +44,10 @@ class ValidationError extends MongooseError {
     return this.name + ': ' + combinePathErrors(this);
   }
 
-  /**
-   * inspect helper
-   * @api private
-   */
-  inspect() {
-    return Object.assign(new Error(this.message), this);
-  }
-
   /**
   * add message
-  * @param {String} path
-  * @param {String|Error} error
+  * @param {string} path
+  * @param {string|Error} error
   * @api private
   */
   addError(path, error) {

package/.output/server/node_modules/mongoose/lib/error/validator.js

@@ -9,7 +9,7 @@ const MongooseError = require('./mongooseError');
 /**
  * Schema validator error
  *
- * @param {Object} properties
+ * @param {object} properties
  * @param {Document} doc
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/error/version.js

@@ -10,8 +10,8 @@ const MongooseError = require('./mongooseError');
  * Version Error constructor.
  *
  * @param {Document} doc
- * @param {Number} currentVersion
- * @param {Array<String>} modifiedPaths
+ * @param {number} currentVersion
+ * @param {string[]} modifiedPaths
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/aggregate/prepareDiscriminatorPipeline.js

@@ -1,7 +1,7 @@
 'use strict';
 
 module.exports = function prepareDiscriminatorPipeline(pipeline, schema, prefix) {
-  const discriminatorMapping = schema && schema.discriminatorMapping;
+  const discriminatorMapping = schema?.discriminatorMapping;
   prefix = prefix || '';
 
   if (discriminatorMapping && !discriminatorMapping.isRoot) {
@@ -18,12 +18,12 @@ module.exports = function prepareDiscriminatorPipeline(pipeline, schema, prefix)
       originalPipeline[0].$match[filterKey] = discriminatorValue;
       // `originalPipeline` is a ref, so there's no need for
       // aggregate._pipeline = originalPipeline
-    } else if (originalPipeline[0] != null && originalPipeline[0].$geoNear) {
+    } else if (originalPipeline[0]?.$geoNear) {
       originalPipeline[0].$geoNear.query =
           originalPipeline[0].$geoNear.query || {};
       originalPipeline[0].$geoNear.query[filterKey] = discriminatorValue;
-    } else if (originalPipeline[0] != null && originalPipeline[0].$search) {
-      if (originalPipeline[1] && originalPipeline[1].$match != null) {
+    } else if (originalPipeline[0]?.$search) {
+      if (originalPipeline[1]?.$match != null) {
         originalPipeline[1].$match[filterKey] = originalPipeline[1].$match[filterKey] || discriminatorValue;
       } else {
         const match = {};

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

@@ -0,0 +1,24 @@
+'use strict';
+
+const symbols = require('../schema/symbols');
+
+/**
+ * Filter predicate that returns true for built-in middleware (marked with `builtInMiddleware` symbol).
+ */
+const isBuiltInMiddleware = hook => hook.fn[symbols.builtInMiddleware];
+
+/**
+ * Builds a filter for kareem's execPre/execPost based on middleware options.
+ *
+ * @param {object} options - Options object that may contain `middleware` setting
+ * @param {string} phase - Either 'pre' or 'post'
+ * @returns {Function|null} - null runs all middleware, isBuiltInMiddleware skips user middleware
+ */
+function buildMiddlewareFilter(options, phase) {
+  const shouldRun = options?.middleware?.[phase] ?? options?.middleware ?? true;
+  return shouldRun ? null : isBuiltInMiddleware;
+}
+
+module.exports = {
+  buildMiddlewareFilter
+};

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

@@ -11,10 +11,10 @@ const isObject = require('./isObject');
 const isPOJO = require('./isPOJO');
 const symbols = require('./symbols');
 const trustedSymbol = require('./query/trusted').trustedSymbol;
-const BSON = require('bson');
+const BSON = require('mongodb/lib/bson');
+const UUID = BSON.UUID;
 
 const Binary = BSON.Binary;
-const UUID = BSON.UUID;
 
 /**
  * Object clone with Mongoose natives support.
@@ -23,10 +23,10 @@ const UUID = BSON.UUID;
  *
  * Functions and primitives are never cloned.
  *
- * @param {Object} obj the object to clone
- * @param {Object} options
- * @param {Boolean} isArrayChild true if cloning immediately underneath an array. Special case for minimize.
- * @return {Object} the cloned object
+ * @param {object} obj the object to clone
+ * @param {object} options
+ * @param {boolean} isArrayChild true if cloning immediately underneath an array. Special case for minimize.
+ * @return {object} the cloned object
  * @api private
  */
 
@@ -83,7 +83,7 @@ function clone(obj, options, isArrayChild) {
     }
 
     let ret;
-    if (options && options.json && typeof obj.toJSON === 'function') {
+    if (options?.json && typeof obj.toJSON === 'function') {
       ret = obj.toJSON(options);
     } else {
       ret = obj.toObject(options);
@@ -109,14 +109,14 @@ function clone(obj, options, isArrayChild) {
   }
 
   if (isBsonType(obj, 'ObjectId')) {
-    if (options && options.flattenObjectIds) {
+    if (options?.flattenObjectIds) {
       return obj.toJSON();
     }
     return new ObjectId(obj.id);
   }
 
   if (isBsonType(obj, 'Decimal128')) {
-    if (options && options.flattenDecimals) {
+    if (options?.flattenDecimals) {
       return obj.toJSON();
     }
     return Decimal.fromString(obj.toString());
@@ -141,7 +141,7 @@ function clone(obj, options, isArrayChild) {
   // If we're cloning this object to go into a MongoDB command,
   // and there's a `toBSON()` function, assume this object will be
   // stored as a primitive in MongoDB and doesn't need to be cloned.
-  if (options && options.bson && typeof obj.toBSON === 'function') {
+  if (options?.bson && typeof obj.toBSON === 'function') {
     return obj;
   }
 
@@ -158,9 +158,9 @@ module.exports = clone;
  */
 
 function cloneObject(obj, options, isArrayChild) {
-  const minimize = options && options.minimize;
-  const omitUndefined = options && options.omitUndefined;
-  const seen = options && options._seen;
+  const minimize = options?.minimize;
+  const omitUndefined = options?.omitUndefined;
+  const seen = options?._seen;
   const ret = {};
   let hasKeys;
 
@@ -202,10 +202,15 @@ function cloneArray(arr, options) {
 
   let ret = null;
   if (options?.retainDocuments) {
+    // Use the cloned parent doc (options.parentDoc) when available so the new
+    // array is wired up to the clone, not the source. Falling back to the
+    // source's parent preserves the previous behavior for callers that don't
+    // pass parentDoc.
+    const newParent = options.parentDoc ?? (arr.isMongooseArray ? arr.$parent() : undefined);
     if (arr.isMongooseDocumentArray) {
-      ret = new (arr.$schemaType().schema.base.Types.DocumentArray)([], arr.$path(), arr.$parent(), arr.$schemaType());
+      ret = new (arr.$schemaType().schema.base.Types.DocumentArray)([], arr.$path(), newParent, arr.$schemaType());
     } else if (arr.isMongooseArray) {
-      ret = new (arr.$parent().schema.base.Types.Array)([], arr.$path(), arr.$parent(), arr.$schemaType());
+      ret = new (arr.$parent().schema.base.Types.Array)([], arr.$path(), newParent, arr.$schemaType());
     } else {
       ret = new Array(len);
     }
@@ -218,9 +223,21 @@ function cloneArray(arr, options) {
     // Create new options object to avoid mutating the shared options.
     // Subdocs need parentArray to point to their own cloned array.
     options = { ...options, parentArray: ret };
-  }
-  for (i = 0; i < len; ++i) {
-    ret[i] = clone(arr[i], options, true);
+    // Skip change-tracking while populating the freshly cloned array: every
+    // index assignment would otherwise call markModified on the cloned parent
+    // doc and (before this guard) on the source parent doc.
+    for (i = 0; i < len; ++i) {
+      const doc = clone(arr[i], options, true);
+      // Document arrays can contain null entries, so only restamp actual subdocs.
+      if (typeof doc?.$setIndex === 'function') {
+        doc.$setIndex(i);
+      }
+      ret.set(i, doc, true);
+    }
+  } else {
+    for (i = 0; i < len; ++i) {
+      ret[i] = clone(arr[i], options, true);
+    }
   }
 
   return ret;

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

@@ -4,7 +4,7 @@
  * Module dependencies.
  */
 
-const Binary = require('bson').Binary;
+const Binary = require('mongodb/lib/bson').Binary;
 const isBsonType = require('./isBsonType');
 const isMongooseObject = require('./isMongooseObject');
 const MongooseError = require('../error');
@@ -35,12 +35,12 @@ function flatten(update, path, options, schema) {
     result[path + key] = val;
 
     // Avoid going into mixed paths if schema is specified
-    const keySchema = schema && schema.path && schema.path(path + key);
-    const isNested = schema && schema.nested && schema.nested[path + key];
-    if (keySchema && keySchema.instance === 'Mixed') continue;
+    const keySchema = schema?.path?.(path + key);
+    const isNested = schema?.nested?.[path + key];
+    if (keySchema?.instance === 'Mixed') continue;
 
     if (shouldFlatten(val)) {
-      if (options && options.skipArrays && Array.isArray(val)) {
+      if (options?.skipArrays && Array.isArray(val)) {
         continue;
       }
       const flat = flatten(val, path + key, options, schema);

package/.output/server/node_modules/mongoose/lib/helpers/cursor/eachAsync.js

@@ -14,9 +14,9 @@ const immediate = require('../immediate');
  *
  * @param {Function} next the thunk to call to get the next document
  * @param {Function} fn
- * @param {Object} options
- * @param {Number} [options.batchSize=null] if set, Mongoose will call `fn` with an array of at most `batchSize` documents, instead of a single document
- * @param {Number} [options.parallel=1] maximum number of `fn` calls that Mongoose will run in parallel
+ * @param {object} options
+ * @param {number} [options.batchSize=null] if set, Mongoose will call `fn` with an array of at most `batchSize` documents, instead of a single document
+ * @param {number} [options.parallel=1] maximum number of `fn` calls that Mongoose will run in parallel
  * @param {AbortSignal} [options.signal] allow cancelling this eachAsync(). Once the abort signal is fired, `eachAsync()` will immediately fulfill the returned promise (or call the callback) and not fetch any more documents.
  * @return {Promise}
  * @api public
@@ -174,7 +174,7 @@ module.exports = async function eachAsync(next, fn, options) {
     } catch (err) {
       return callback(err);
     }
-    if (maybePromise && typeof maybePromise.then === 'function') {
+    if (typeof maybePromise?.then === 'function') {
       maybePromise.then(
         function() { callback(null); },
         function(error) {

package/.output/server/node_modules/mongoose/lib/helpers/discriminator/getConstructor.js

@@ -9,7 +9,7 @@ const getDiscriminatorByValue = require('./getDiscriminatorByValue');
 
 module.exports = function getConstructor(Constructor, value, defaultDiscriminatorValue) {
   const discriminatorKey = Constructor.schema.options.discriminatorKey;
-  let discriminatorValue = (value != null && value[discriminatorKey]);
+  let discriminatorValue = value?.[discriminatorKey];
   if (discriminatorValue == null) {
     discriminatorValue = defaultDiscriminatorValue;
   }

package/.output/server/node_modules/mongoose/lib/helpers/discriminator/getDiscriminatorByValue.js

@@ -5,7 +5,7 @@ const areDiscriminatorValuesEqual = require('./areDiscriminatorValuesEqual');
 /**
  * returns discriminator by discriminatorMapping.value
  *
- * @param {Object} discriminators
+ * @param {object} discriminators
  * @param {string} value
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/helpers/discriminator/getSchemaDiscriminatorByValue.js

@@ -11,7 +11,7 @@ const areDiscriminatorValuesEqual = require('./areDiscriminatorValuesEqual');
  */
 
 module.exports = function getSchemaDiscriminatorByValue(schema, value) {
-  if (schema == null || schema.discriminators == null) {
+  if (schema?.discriminators == null) {
     return null;
   }
   for (const key of Object.keys(schema.discriminators)) {

package/.output/server/node_modules/mongoose/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -8,9 +8,9 @@ const isObject = require('../../helpers/isObject');
 /**
  * Merges `from` into `to` without overwriting existing properties.
  *
- * @param {Object} to
- * @param {Object} from
- * @param {String} [path]
+ * @param {object} to
+ * @param {object} from
+ * @param {string} [path]
  * @api private
  */
 
@@ -40,12 +40,17 @@ module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
         continue;
       }
     }
-    if (path === 'tree' && from != null && from.instanceOfSchema) {
+    if (path === 'tree' && from?.instanceOfSchema) {
       continue;
     }
     if (specialProperties.has(key)) {
       continue;
     }
+    if (key === 'parentSchema') {
+      // Skip parentSchema to avoid merging parent schema multiple times
+      // through child paths' back-references (gh-15966)
+      continue;
+    }
     if (to[key] == null) {
       to[key] = from[key];
     } else if (isObject(from[key])) {
@@ -85,7 +90,7 @@ module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
     }
   }
 
-  if (from != null && from.instanceOfSchema) {
+  if (from?.instanceOfSchema) {
     to.tree = Object.assign({}, from.tree, to.tree);
   }
 };

package/.output/server/node_modules/mongoose/lib/helpers/document/applyDefaults.js

@@ -5,7 +5,7 @@ const isNestedProjection = require('../projection/isNestedProjection');
 module.exports = function applyDefaults(doc, fields, exclude, hasIncludedChildren, isBeforeSetters, pathsToSkip, options) {
   const paths = Object.keys(doc.$__schema.paths);
   const plen = paths.length;
-  const skipParentChangeTracking = options && options.skipParentChangeTracking;
+  const skipParentChangeTracking = options?.skipParentChangeTracking;
 
   for (let i = 0; i < plen; ++i) {
     let def;

package/.output/server/node_modules/mongoose/lib/helpers/document/applyTimestamps.js

@@ -2,6 +2,7 @@
 
 const handleTimestampOption = require('../schema/handleTimestampOption');
 const mpath = require('mpath');
+const utils = require('../../utils');
 
 module.exports = applyTimestamps;
 
@@ -9,9 +10,9 @@ module.exports = applyTimestamps;
  * Apply a given schema's timestamps to the given POJO
  *
  * @param {Schema} schema
- * @param {Object} obj
- * @param {Object} [options]
- * @param {Boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
+ * @param {object} obj
+ * @param {object} [options]
+ * @param {boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
  * @param {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
  */
 
@@ -28,9 +29,9 @@ function applyTimestamps(schema, obj, options) {
  * Apply timestamps to any subdocuments
  *
  * @param {Schema} schema subdocument schema
- * @param {Object} res subdocument
- * @param {Object} [options]
- * @param {Boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
+ * @param {object} res subdocument
+ * @param {object} [options]
+ * @param {boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
  * @param {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
  */
 
@@ -54,9 +55,9 @@ function applyTimestampsToChildren(schema, res, options) {
  * Apply timestamps to a given document. Does not apply timestamps to subdocuments: use `applyTimestampsToChildren` instead
  *
  * @param {Schema} schema
- * @param {Object} obj
- * @param {Object} [options]
- * @param {Boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
+ * @param {object} obj
+ * @param {object} [options]
+ * @param {boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
  * @param {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
  */
 
@@ -71,7 +72,7 @@ function applyTimestampsToDoc(schema, obj, options) {
     return;
   }
 
-  if (schema.discriminators && Object.keys(schema.discriminators).length > 0) {
+  if (schema.discriminators && utils.hasOwnKeys(schema.discriminators)) {
     for (const discriminatorKey of Object.keys(schema.discriminators)) {
       const discriminator = schema.discriminators[discriminatorKey];
       const key = discriminator.discriminatorMapping.key;

package/.output/server/node_modules/mongoose/lib/helpers/document/applyVirtuals.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const mpath = require('mpath');
+const utils = require('../../utils');
 
 module.exports = applyVirtuals;
 
@@ -8,8 +9,8 @@ module.exports = applyVirtuals;
  * Apply a given schema's virtuals to a given POJO
  *
  * @param {Schema} schema
- * @param {Object} obj
- * @param {Array<string>} [virtuals] optional whitelist of virtuals to apply
+ * @param {object} obj
+ * @param {string[]} [virtuals] optional whitelist of virtuals to apply
  * @returns
  */
 
@@ -41,8 +42,8 @@ function applyVirtuals(schema, obj, virtuals) {
  * Apply virtuals to any subdocuments
  *
  * @param {Schema} schema subdocument schema
- * @param {Object} res subdocument
- * @param {Array<String>} [virtuals] optional whitelist of virtuals to apply
+ * @param {object} res subdocument
+ * @param {string[]} [virtuals] optional whitelist of virtuals to apply
  */
 
 function applyVirtualsToChildren(schema, res, virtuals) {
@@ -76,7 +77,7 @@ function applyVirtualsToChildren(schema, res, virtuals) {
     attachedVirtuals = true;
   }
 
-  if (virtuals && virtuals.length && !attachedVirtuals) {
+  if (virtuals?.length && !attachedVirtuals) {
     applyVirtualsToDoc(schema, res, virtuals);
   }
 }
@@ -85,8 +86,8 @@ function applyVirtualsToChildren(schema, res, virtuals) {
  * Apply virtuals to a given document. Does not apply virtuals to subdocuments: use `applyVirtualsToChildren` instead
  *
  * @param {Schema} schema
- * @param {Object} doc
- * @param {Array<String>} [virtuals] optional whitelist of virtuals to apply
+ * @param {object} doc
+ * @param {string[]} [virtuals] optional whitelist of virtuals to apply
  * @returns
  */
 
@@ -101,7 +102,7 @@ function applyVirtualsToDoc(schema, obj, virtuals) {
     return;
   }
 
-  if (schema.discriminators && Object.keys(schema.discriminators).length > 0) {
+  if (schema.discriminators && utils.hasOwnKeys(schema.discriminators)) {
     for (const discriminatorKey of Object.keys(schema.discriminators)) {
       const discriminator = schema.discriminators[discriminatorKey];
       const key = discriminator.discriminatorMapping.key;
@@ -133,7 +134,7 @@ function applyVirtualsToDoc(schema, obj, virtuals) {
     }
     let val = virtualType.applyGetters(cur[sp[sp.length - 1]], obj);
     const isPopulateVirtual =
-      virtualType.options && (virtualType.options.ref || virtualType.options.refPath);
+      virtualType.options?.ref || virtualType.options?.refPath;
     if (isPopulateVirtual && val === undefined) {
       if (virtualType.options.justOne) {
         val = null;

package/.output/server/node_modules/mongoose/lib/helpers/document/cleanModifiedSubpaths.js

@@ -16,7 +16,7 @@ module.exports = function cleanModifiedSubpaths(doc, path, options) {
   for (const modifiedPath of Object.keys(doc.$__.activePaths.getStatePaths('modify'))) {
     if (skipDocArrays) {
       const schemaType = doc.$__schema.path(modifiedPath);
-      if (schemaType && schemaType.$isMongooseDocumentArray) {
+      if (schemaType?.$isMongooseDocumentArray) {
         continue;
       }
     }

package/.output/server/node_modules/mongoose/lib/helpers/document/compile.js

@@ -31,10 +31,10 @@ const noDottedPathGetOptions = Object.freeze({
 
 /**
  * Compiles schemas.
- * @param {Object} tree
- * @param {Any} proto
- * @param {String} prefix
- * @param {Object} options
+ * @param {object} tree
+ * @param {any} proto
+ * @param {string} prefix
+ * @param {object} options
  * @api private
  */
 
@@ -46,7 +46,7 @@ function compile(tree, proto, prefix, options) {
     const limb = tree[key];
 
     const hasSubprops = isPOJO(limb) &&
-      Object.keys(limb).length > 0 &&
+      utils.hasOwnKeys(limb) &&
       (!limb[typeKey] || (typeKey === 'type' && isPOJO(limb.type) && limb.type.type));
     const subprops = hasSubprops ? limb : null;
 
@@ -56,12 +56,12 @@ function compile(tree, proto, prefix, options) {
 
 /**
  * Defines the accessor named prop on the incoming prototype.
- * @param {Object} options
- * @param {String} options.prop
- * @param {Boolean} options.subprops
- * @param {Any} options.prototype
- * @param {String} [options.prefix]
- * @param {Object} options.options
+ * @param {object} options
+ * @param {string} options.prop
+ * @param {boolean} options.subprops
+ * @param {any} options.prototype
+ * @param {string} [options.prefix]
+ * @param {object} options.options
  * @api private
  */
 
@@ -76,6 +76,9 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
       enumerable: true,
       configurable: true,
       get: function() {
+        if (!this.$__) {
+          return undefined;
+        }
         const _this = this;
         if (!this.$__.getters) {
           this.$__.getters = {};
@@ -132,7 +135,7 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             writable: false,
             value: function() {
               return _this.get(path, null, {
-                virtuals: this && this.schema && this.schema.options && this.schema.options.toObject && this.schema.options.toObject.virtuals || null
+                virtuals: this?.schema?.options?.toObject?.virtuals || null
               });
             }
           });
@@ -143,7 +146,7 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
             writable: false,
             value: function() {
               return _this.get(path, null, {
-                virtuals: this && this.schema && this.schema.options && this.schema.options.toJSON && this.schema.options.toJSON.virtuals || null
+                virtuals: this?.schema?.options?.toJSON?.virtuals || null
               });
             }
           });
@@ -178,7 +181,7 @@ function defineKey({ prop, subprops, prototype, prefix, options }) {
         return this.$__.getters[path];
       },
       set: function(v) {
-        if (v != null && v.$__isNested) {
+        if (v?.$__isNested) {
           // Convert top-level to POJO, but leave subdocs hydrated so `$set`
           // can handle them. See gh-9293.
           v = v.$__get();