@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

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

@@ -6,9 +6,9 @@
  * document.
  *
  * @param {Document} doc
- * @param {String[]} parts
+ * @param {string[]} parts
  * @param {Schema} schema
- * @returns Document
+ * @returns {Document}
  */
 
 module.exports = function getDeepestSubdocumentForPath(doc, parts, schema) {
@@ -17,7 +17,7 @@ module.exports = function getDeepestSubdocumentForPath(doc, parts, schema) {
   let subdoc = doc;
   for (let i = 0; i < parts.length - 1; ++i) {
     const curSchemaType = curSchema.path(curPath);
-    if (curSchemaType && curSchemaType.schema) {
+    if (curSchemaType?.schema) {
       let newSubdoc = subdoc.get(curPath);
       curSchema = curSchemaType.schema;
       curPath = parts[i + 1];

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

@@ -8,8 +8,8 @@ const getSchemaDiscriminatorByValue = require('../discriminator/getSchemaDiscrim
  * determine path type without knowing the embedded discriminator key.
  *
  * @param {Document} doc
- * @param {String|String[]} path
- * @param {Object} [options]
+ * @param {string|string[]} path
+ * @param {object} [options]
  * @api private
  */
 

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

@@ -0,0 +1,24 @@
+'use strict';
+
+/**
+ * Returns true if `path` is included by the `pathsToSave` filter.
+ * Matches exact paths and child paths (e.g. 'metadata.views' is included by 'metadata').
+ *
+ * @param {string} path
+ * @param {Set<string>} pathsToSaveSet - pre-built Set of pathsToSave for O(1) exact lookup
+ * @param {string[]} pathsToSave - original array, used for prefix matching
+ * @returns {boolean}
+ */
+module.exports = function isInPathsToSave(path, pathsToSaveSet, pathsToSave) {
+  if (pathsToSaveSet.has(path)) {
+    return true;
+  }
+
+  for (const pathToSave of pathsToSave) {
+    if (path.slice(0, pathToSave.length) === pathToSave && path.charAt(pathToSave.length) === '.') {
+      return true;
+    }
+  }
+
+  return false;
+};

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

@@ -47,7 +47,7 @@ module.exports = function get(obj, path, def) {
     cur = getProperty(cur, part);
 
     if (!isPathArray) {
-      rest = rest.substr(part.length + 1);
+      rest = rest.substring(part.length + 1);
     }
   }
 

package/.output/server/node_modules/mongoose/lib/helpers/indexes/decorateDiscriminatorIndexOptions.js

@@ -4,7 +4,7 @@ module.exports = function decorateDiscriminatorIndexOptions(schema, indexOptions
   // If the model is a discriminator and has an index, add a
   // partialFilterExpression by default so the index will only apply
   // to that discriminator.
-  const discriminatorName = schema.discriminatorMapping && schema.discriminatorMapping.value;
+  const discriminatorName = schema.discriminatorMapping?.value;
   if (discriminatorName && !('sparse' in indexOptions)) {
     const discriminatorKey = schema.options.discriminatorKey;
     indexOptions.partialFilterExpression = indexOptions.partialFilterExpression || {};

package/.output/server/node_modules/mongoose/lib/helpers/indexes/getRelatedIndexes.js

@@ -31,8 +31,8 @@ function getRelatedIndexes({
   indexes,
   indexesType
 }) {
-  const discriminatorKey = discriminatorMapping && discriminatorMapping.key;
-  const discriminatorValue = discriminatorMapping && discriminatorMapping.value;
+  const discriminatorKey = discriminatorMapping?.key;
+  const discriminatorValue = discriminatorMapping?.value;
 
   if (!discriminatorKey) {
     return indexes;
@@ -57,7 +57,7 @@ function getRelatedIndexes({
 function getPartialFilterExpression(index, indexesType) {
   if (indexesType === 'schema') {
     const options = index[1];
-    return options && options.partialFilterExpression;
+    return options?.partialFilterExpression;
   }
   return index.partialFilterExpression;
 }

package/.output/server/node_modules/mongoose/lib/helpers/indexes/isIndexEqual.js

@@ -6,9 +6,9 @@ const utils = require('../../utils');
  * Given a Mongoose index definition (key + options objects) and a MongoDB server
  * index definition, determine if the two indexes are equal.
  *
- * @param {Object} schemaIndexKeysObject the Mongoose index spec
- * @param {Object} options the Mongoose index definition's options
- * @param {Object} dbIndex the index in MongoDB as returned by `listIndexes()`
+ * @param {object} schemaIndexKeysObject the Mongoose index spec
+ * @param {object} options the Mongoose index definition's options
+ * @param {object} dbIndex the index in MongoDB as returned by `listIndexes()`
  * @api private
  */
 
@@ -20,7 +20,6 @@ module.exports = function isIndexEqual(schemaIndexKeysObject, options, dbIndex)
   //   key: { _fts: 'text', _ftsx: 1 },
   //   name: 'name_text',
   //   ns: 'test.tests',
-  //   background: true,
   //   weights: { name: 1 },
   //   default_language: 'english',
   //   language_override: 'language',

package/.output/server/node_modules/mongoose/lib/helpers/indexes/isIndexSpecEqual.js

@@ -8,9 +8,9 @@
  *     isIndexSpecEqual({ a: 1, b: 1 }, { b: 1, a: 1 }); // false
  *     isIndexSpecEqual({ a: 1, b: -1 }, { a: 1, b: 1 }); // false
  *
- * @param {Object} spec1 The first index specification to compare.
- * @param {Object} spec2 The second index specification to compare.
- * @returns {Boolean} Returns true if the index specifications are equal, otherwise returns false.
+ * @param {object} spec1 The first index specification to compare.
+ * @param {object} spec2 The second index specification to compare.
+ * @returns {boolean} Returns true if the index specifications are equal, otherwise returns false.
  */
 
 module.exports = function isIndexSpecEqual(spec1, spec2) {

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

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * Get the bson type, if it exists
+ * Determines if `obj` has the given BSON type.
  * @api private
  */
 

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

@@ -6,7 +6,7 @@ const isMongooseArray = require('../types/array/isMongooseArray').isMongooseArra
  *
  * This is for compatibility with libs like Date.js which do foolish things to Natives.
  *
- * @param {Any} v
+ * @param {any} v
  * @api private
  */
 

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

@@ -3,9 +3,9 @@
 /**
  * Determines if `arg` is an object.
  *
- * @param {Object|Array|String|Function|RegExp|any} arg
+ * @param {object|Array|string|Function|RegExp|any} arg
  * @api private
- * @return {Boolean}
+ * @return {boolean}
  */
 
 module.exports = function(arg) {

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

@@ -3,9 +3,9 @@
 /**
  * Determines if `arg` is a flat object.
  *
- * @param {Object|Array|String|Function|RegExp|any} arg
+ * @param {object|Array|string|Function|RegExp|any} arg
  * @api private
- * @return {Boolean}
+ * @return {boolean}
  */
 
 module.exports = function isSimpleValidator(obj) {

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

@@ -7,8 +7,8 @@ module.exports = minimize;
 /**
  * Minimizes an object, removing undefined values and empty objects
  *
- * @param {Object} object to minimize
- * @return {Object|undefined}
+ * @param {object} object to minimize
+ * @return {object|undefined}
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/helpers/model/applyDefaultsToPOJO.js

@@ -23,7 +23,7 @@ module.exports = function applyDefaultsToPOJO(doc, schema) {
       if (j === len - 1) {
         if (typeof doc_[piece] !== 'undefined') {
           if (type.$isSingleNested) {
-            applyDefaultsToPOJO(doc_[piece], type.caster.schema);
+            applyDefaultsToPOJO(doc_[piece], type.schema);
           } else if (type.$isMongooseDocumentArray && Array.isArray(doc_[piece])) {
             doc_[piece].forEach(el => applyDefaultsToPOJO(el, type.schema));
           }
@@ -36,7 +36,7 @@ module.exports = function applyDefaultsToPOJO(doc, schema) {
           doc_[piece] = def;
 
           if (type.$isSingleNested) {
-            applyDefaultsToPOJO(def, type.caster.schema);
+            applyDefaultsToPOJO(def, type.schema);
           } else if (type.$isMongooseDocumentArray && Array.isArray(def)) {
             def.forEach(el => applyDefaultsToPOJO(el, type.schema));
           }

package/.output/server/node_modules/mongoose/lib/helpers/model/applyHooks.js

@@ -1,7 +1,6 @@
 'use strict';
 
-const symbols = require('../../schema/symbols');
-const promiseOrCallback = require('../promiseOrCallback');
+const { buildMiddlewareFilter } = require('../buildMiddlewareFilter');
 
 /*!
  * ignore
@@ -15,10 +14,10 @@ module.exports = applyHooks;
 
 applyHooks.middlewareFunctions = [
   'deleteOne',
-  'save',
-  'validate',
   'remove',
+  'save',
   'updateOne',
+  'validate',
   'init'
 ];
 
@@ -33,7 +32,7 @@ const alreadyHookedFunctions = new Set(applyHooks.middlewareFunctions.flatMap(fn
  *
  * @param {Model} model
  * @param {Schema} schema
- * @param {Object} options
+ * @param {object} options
  * @api private
  */
 
@@ -47,15 +46,15 @@ function applyHooks(model, schema, options) {
     contextParameter: true
   };
   const objToDecorate = options.decorateDoc ? model : model.prototype;
-
   model.$appliedHooks = true;
   for (const key of Object.keys(schema.paths)) {
-    const type = schema.paths[key];
+    let type = schema.paths[key];
     let childModel = null;
-    if (type.$isSingleNested) {
-      childModel = type.caster;
-    } else if (type.$isMongooseDocumentArray) {
-      childModel = type.Constructor;
+
+    const result = findChildModel(type);
+    if (result) {
+      childModel = result.childModel;
+      type = result.type;
     } else {
       continue;
     }
@@ -64,7 +63,11 @@ function applyHooks(model, schema, options) {
       continue;
     }
 
-    applyHooks(childModel, type.schema, { ...options, isChildSchema: true });
+    applyHooks(childModel, type.schema, {
+      ...options,
+      decorateDoc: false,
+      isChildSchema: true
+    });
     if (childModel.discriminators != null) {
       const keys = Object.keys(childModel.discriminators);
       for (const key of keys) {
@@ -78,41 +81,21 @@ function applyHooks(model, schema, options) {
   // promises and make it so that `doc.save.toString()` provides meaningful
   // information.
 
-  const middleware = schema.s.hooks.
-    filter(hook => {
-      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
-        return !!hook['document'];
-      }
-      if (hook.name === 'remove' || hook.name === 'init') {
-        return hook['document'] == null || !!hook['document'];
-      }
-      if (hook.query != null || hook.document != null) {
-        return hook.document !== false;
-      }
-      return true;
-    }).
-    filter(hook => {
-      // If user has overwritten the method, don't apply built-in middleware
-      if (schema.methods[hook.name]) {
-        return !hook.fn[symbols.builtInMiddleware];
-      }
-
-      return true;
-    });
+  const middleware = schema._getDocumentMiddleware();
 
   model._middleware = middleware;
 
-  objToDecorate.$__originalValidate = objToDecorate.$__originalValidate || objToDecorate.$__validate;
-
-  const internalMethodsToWrap = options && options.isChildSchema ? ['save', 'validate', 'deleteOne'] : ['save', 'validate'];
-  for (const method of internalMethodsToWrap) {
-    const toWrap = method === 'validate' ? '$__originalValidate' : `$__${method}`;
-    const wrapped = middleware.
-      createWrapper(method, objToDecorate[toWrap], null, kareemOptions);
-    objToDecorate[`$__${method}`] = wrapped;
-  }
   objToDecorate.$__init = middleware.
-    createWrapperSync('init', objToDecorate.$__init, null, kareemOptions);
+    createWrapperSync('init', objToDecorate.$__init, null, {
+      ...kareemOptions,
+      getOptions: (args) => {
+        const opts = args[1];
+        return {
+          pre: { filter: buildMiddlewareFilter(opts, 'pre') },
+          post: { filter: buildMiddlewareFilter(opts, 'post') }
+        };
+      }
+    });
 
   // Support hooks for custom methods
   const customMethods = Object.keys(schema.methods);
@@ -134,17 +117,35 @@ function applyHooks(model, schema, options) {
       continue;
     }
     const originalMethod = objToDecorate[method];
-    objToDecorate[method] = function() {
-      const args = Array.prototype.slice.call(arguments);
-      const cb = args.slice(-1).pop();
-      const argsWithoutCallback = typeof cb === 'function' ?
-        args.slice(0, args.length - 1) : args;
-      return promiseOrCallback(cb, callback => {
-        return this[`$__${method}`].apply(this,
-          argsWithoutCallback.concat([callback]));
-      }, model.events);
-    };
-    objToDecorate[`$__${method}`] = middleware.
+    objToDecorate[`$__${method}`] = objToDecorate[method];
+    objToDecorate[method] = middleware.
       createWrapper(method, originalMethod, null, customMethodOptions);
   }
 }
+
+/**
+ * Check if there is an embedded schematype in the given schematype. Handles drilling down into primitive
+ * arrays and maps in case of array of array of subdocs or map of subdocs.
+ *
+ * @param {SchemaType} curType
+ * @returns {{ childModel: Model | typeof Subdocument, curType: SchemaType } | null}
+ */
+
+function findChildModel(curType) {
+  if (curType.$isSingleNested || curType.$isMongooseDocumentArray) {
+    return { childModel: curType.Constructor, type: curType };
+  }
+  if (curType.instance === 'Array') {
+    const embedded = curType.getEmbeddedSchemaType();
+    if (embedded) {
+      return findChildModel(embedded);
+    }
+  }
+  if (curType.instance === 'Map') {
+    const mapType = curType.getEmbeddedSchemaType();
+    if (mapType) {
+      return findChildModel(mapType);
+    }
+  }
+  return null;
+}

package/.output/server/node_modules/mongoose/lib/helpers/model/applyMethods.js

@@ -60,8 +60,8 @@ module.exports = function applyMethods(model, schema) {
   model.$appliedMethods = true;
   for (const key of Object.keys(schema.paths)) {
     const type = schema.paths[key];
-    if (type.$isSingleNested && !type.caster.$appliedMethods) {
-      applyMethods(type.caster, type.schema);
+    if (type.$isSingleNested && !type.Constructor.$appliedMethods) {
+      applyMethods(type.Constructor, type.schema);
     }
     if (type.$isMongooseDocumentArray && !type.Constructor.$appliedMethods) {
       applyMethods(type.Constructor, type.schema);

package/.output/server/node_modules/mongoose/lib/helpers/model/applyStaticHooks.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const promiseOrCallback = require('../promiseOrCallback');
 const { queryMiddlewareFunctions, aggregateMiddlewareFunctions, modelMiddlewareFunctions, documentMiddlewareFunctions } = require('../../constants');
 
 const middlewareFunctions = Array.from(
@@ -13,14 +12,6 @@ const middlewareFunctions = Array.from(
 );
 
 module.exports = function applyStaticHooks(model, hooks, statics) {
-  const kareemOptions = {
-    useErrorHandlers: true,
-    numCallbackParams: 1
-  };
-
-  model.$__insertMany = hooks.createWrapper('insertMany',
-    model.$__insertMany, model, kareemOptions);
-
   hooks = hooks.filter(hook => {
     // If the custom static overwrites an existing middleware, don't apply
     // middleware to it by default. This avoids a potential backwards breaking
@@ -36,45 +27,7 @@ module.exports = function applyStaticHooks(model, hooks, statics) {
     if (hooks.hasHooks(key)) {
       const original = model[key];
 
-      model[key] = function() {
-        const numArgs = arguments.length;
-        const lastArg = numArgs > 0 ? arguments[numArgs - 1] : null;
-        const cb = typeof lastArg === 'function' ? lastArg : null;
-        const args = Array.prototype.slice.
-          call(arguments, 0, cb == null ? numArgs : numArgs - 1);
-        // Special case: can't use `Kareem#wrap()` because it doesn't currently
-        // support wrapped functions that return a promise.
-        return promiseOrCallback(cb, callback => {
-          hooks.execPre(key, model, args, function(err) {
-            if (err != null) {
-              return callback(err);
-            }
-
-            let postCalled = 0;
-            const ret = original.apply(model, args.concat(post));
-            if (ret != null && typeof ret.then === 'function') {
-              ret.then(res => post(null, res), err => post(err));
-            }
-
-            function post(error, res) {
-              if (postCalled++ > 0) {
-                return;
-              }
-
-              if (error != null) {
-                return callback(error);
-              }
-
-              hooks.execPost(key, model, [res], function(error) {
-                if (error != null) {
-                  return callback(error);
-                }
-                callback(null, res);
-              });
-            }
-          });
-        }, model.events);
-      };
+      model[key] = hooks.createWrapper(key, original);
     }
   }
 };

package/.output/server/node_modules/mongoose/lib/helpers/model/castBulkWrite.js

@@ -15,8 +15,8 @@ const setDefaultsOnInsert = require('../setDefaultsOnInsert');
  * Given a model and a bulkWrite op, return a thunk that handles casting and
  * validating the individual op.
  * @param {Model} originalModel
- * @param {Object} op
- * @param {Object} [options]
+ * @param {object} op
+ * @param {object} [options]
  * @api private
  */
 
@@ -113,7 +113,7 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
 
   const model = decideModelByObject(originalModel, updateOne['filter']);
   const schema = model.schema;
-  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+  const strict = options.strict ?? model.schema.options.strict;
 
   const update = clone(updateOne['update']);
 
@@ -135,9 +135,7 @@ module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne,
   }
 
   const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
-  const shouldSetDefaultsOnInsert = updateOne.setDefaultsOnInsert == null ?
-    globalSetDefaultsOnInsert :
-    updateOne.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateOne.setDefaultsOnInsert ?? globalSetDefaultsOnInsert;
   if (shouldSetDefaultsOnInsert !== false) {
     setDefaultsOnInsert(updateOne['filter'], model.schema, update, {
       setDefaultsOnInsert: true,
@@ -176,12 +174,10 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
 
   const model = decideModelByObject(originalModel, updateMany['filter']);
   const schema = model.schema;
-  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+  const strict = options.strict ?? model.schema.options.strict;
 
   const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
-  const shouldSetDefaultsOnInsert = updateMany.setDefaultsOnInsert == null ?
-    globalSetDefaultsOnInsert :
-    updateMany.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateMany.setDefaultsOnInsert ?? globalSetDefaultsOnInsert;
 
   if (shouldSetDefaultsOnInsert !== false) {
     setDefaultsOnInsert(updateMany['filter'], model.schema, updateMany['update'], {
@@ -229,7 +225,7 @@ module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMan
 module.exports.castReplaceOne = async function castReplaceOne(originalModel, replaceOne, options) {
   const model = decideModelByObject(originalModel, replaceOne['filter']);
   const schema = model.schema;
-  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+  const strict = options.strict ?? model.schema.options.strict;
 
   _addDiscriminatorToObject(schema, replaceOne['filter']);
   replaceOne['filter'] = cast(model.schema, replaceOne['filter'], {
@@ -238,7 +234,7 @@ module.exports.castReplaceOne = async function castReplaceOne(originalModel, rep
   });
 
   // set `skipId`, otherwise we get "_id field cannot be changed"
-  const doc = new model(replaceOne['replacement'], strict, true);
+  const doc = new model(replaceOne['replacement'], strict, { skipId: true });
   if (model.schema.options.timestamps && getTimestampsOpt(replaceOne, options)) {
     doc.initializeTimestamps();
   }

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

@@ -68,7 +68,7 @@ function validateDiscriminatorSchemasForEncryption(parentSchema, childSchema) {
  */
 
 module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks, overwriteExisting) {
-  if (!(schema && schema.instanceOfSchema)) {
+  if (!schema?.instanceOfSchema) {
     throw new Error('You must pass a valid discriminator Schema');
   }
 

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

@@ -6,50 +6,32 @@ module.exports = parallelLimit;
  * ignore
  */
 
-function parallelLimit(fns, limit, callback) {
-  let numInProgress = 0;
-  let numFinished = 0;
-  let error = null;
-
+async function parallelLimit(params, fn, limit) {
   if (limit <= 0) {
     throw new Error('Limit must be positive');
   }
 
-  if (fns.length === 0) {
-    return callback(null, []);
+  if (params.length === 0) {
+    return [];
   }
 
-  for (let i = 0; i < fns.length && i < limit; ++i) {
-    _start();
-  }
+  const results = [];
+  const executing = new Set();
 
-  function _start() {
-    fns[numFinished + numInProgress](_done(numFinished + numInProgress));
-    ++numInProgress;
-  }
+  for (let index = 0; index < params.length; index++) {
+    const param = params[index];
+    const p = fn(param, index);
+    results.push(p);
 
-  const results = [];
+    executing.add(p);
+
+    const clean = () => executing.delete(p);
+    p.then(clean).catch(clean);
 
-  function _done(index) {
-    return (err, res) => {
-      --numInProgress;
-      ++numFinished;
-
-      if (error != null) {
-        return;
-      }
-      if (err != null) {
-        error = err;
-        return callback(error);
-      }
-
-      results[index] = res;
-
-      if (numFinished === fns.length) {
-        return callback(null, results);
-      } else if (numFinished + numInProgress < fns.length) {
-        _start();
-      }
-    };
+    if (executing.size >= limit) {
+      await Promise.race(executing);
+    }
   }
+
+  return Promise.all(results);
 }

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

@@ -8,13 +8,13 @@ module.exports = pluralize;
 
 exports.pluralization = [
   [/human$/gi, 'humans'],
-  [/(m)an$/gi, '$1en'],
+  [/(m|wom)an$/gi, '$1en'],
   [/(pe)rson$/gi, '$1ople'],
   [/(child)$/gi, '$1ren'],
   [/^(ox)$/gi, '$1en'],
   [/(ax|test)is$/gi, '$1es'],
-  [/(octop|vir)us$/gi, '$1i'],
-  [/(alias|status)$/gi, '$1es'],
+  [/(octop|cact|foc|fung|nucle)us$/gi, '$1i'],
+  [/(alias|status|virus)$/gi, '$1es'],
   [/(bu)s$/gi, '$1ses'],
   [/(buffal|tomat|potat)o$/gi, '$1oes'],
   [/([ti])um$/gi, '$1a'],
@@ -76,7 +76,7 @@ const uncountables = exports.uncountables;
  * Pluralize function.
  *
  * @author TJ Holowaychuk (extracted from _ext.js_)
- * @param {String} string to pluralize
+ * @param {string} string to pluralize
  * @api private
  */
 

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

@@ -26,8 +26,8 @@ const kHasArray = Symbol('mongoose#assignRawDocsToIdStructure#hasArray');
  * @param {Array} rawIds
  * @param {Array} resultDocs
  * @param {Array} resultOrder
- * @param {Object} options
- * @param {Boolean} recursed
+ * @param {object} options
+ * @param {boolean} recursed
  * @api private
  */
 
@@ -78,14 +78,7 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
       continue;
     }
 
-    if (id?.constructor?.name === 'Binary' && id.sub_type === 4 && typeof id.toUUID === 'function') {
-      // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-      sid = String(id.toUUID());
-    } else if (id?.constructor?.name === 'Buffer' && id._subtype === 4 && typeof id.toUUID === 'function') {
-      sid = String(id.toUUID());
-    } else {
-      sid = String(id);
-    }
+    sid = String(id);
     doc = resultDocs[sid];
     // If user wants separate copies of same doc, use this option
     if (options.clone && doc != null) {
@@ -111,7 +104,7 @@ function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, re
         } else {
           newOrder.push(doc);
         }
-      } else if (id != null && id[modelSymbol] != null) {
+      } else if (id?.[modelSymbol] != null) {
         newOrder.push(id);
       } else {
         newOrder.push(options.retainNullValues || nullIfNotFound ? null : id);