@depup/mongoose 9.1.3-depup.0

package/lib/helpers/discriminator/areDiscriminatorValuesEqual.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const isBsonType = require('../isBsonType');
+
+module.exports = function areDiscriminatorValuesEqual(a, b) {
+  if (typeof a === 'string' && typeof b === 'string') {
+    return a === b;
+  }
+  if (typeof a === 'number' && typeof b === 'number') {
+    return a === b;
+  }
+  if (isBsonType(a, 'ObjectId') && isBsonType(b, 'ObjectId')) {
+    return a.toString() === b.toString();
+  }
+  return false;
+};

package/lib/helpers/discriminator/checkEmbeddedDiscriminatorKeyProjection.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = function checkEmbeddedDiscriminatorKeyProjection(userProjection, path, schema, selected, addedPaths) {
+  const userProjectedInPath = Object.keys(userProjection).
+    reduce((cur, key) => cur || key.startsWith(path + '.'), false);
+  const _discriminatorKey = path + '.' + schema.options.discriminatorKey;
+  if (!userProjectedInPath &&
+      addedPaths.length === 1 &&
+      addedPaths[0] === _discriminatorKey) {
+    selected.splice(selected.indexOf(_discriminatorKey), 1);
+  }
+};

package/lib/helpers/discriminator/getConstructor.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const getDiscriminatorByValue = require('./getDiscriminatorByValue');
+
+/**
+ * Find the correct constructor, taking into account discriminators
+ * @api private
+ */
+
+module.exports = function getConstructor(Constructor, value, defaultDiscriminatorValue) {
+  const discriminatorKey = Constructor.schema.options.discriminatorKey;
+  let discriminatorValue = value?.[discriminatorKey];
+  if (discriminatorValue == null) {
+    discriminatorValue = defaultDiscriminatorValue;
+  }
+  if (Constructor.discriminators &&
+      discriminatorValue != null) {
+    if (Constructor.discriminators[discriminatorValue]) {
+      Constructor = Constructor.discriminators[discriminatorValue];
+    } else {
+      const constructorByValue = getDiscriminatorByValue(Constructor.discriminators, discriminatorValue);
+      if (constructorByValue) {
+        Constructor = constructorByValue;
+      }
+    }
+  }
+
+  return Constructor;
+};

package/lib/helpers/discriminator/getDiscriminatorByValue.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const areDiscriminatorValuesEqual = require('./areDiscriminatorValuesEqual');
+
+/**
+ * returns discriminator by discriminatorMapping.value
+ *
+ * @param {Object} discriminators
+ * @param {string} value
+ * @api private
+ */
+
+module.exports = function getDiscriminatorByValue(discriminators, value) {
+  if (discriminators == null) {
+    return null;
+  }
+  for (const name of Object.keys(discriminators)) {
+    const it = discriminators[name];
+    if (
+      it.schema &&
+      it.schema.discriminatorMapping &&
+      areDiscriminatorValuesEqual(it.schema.discriminatorMapping.value, value)
+    ) {
+      return it;
+    }
+  }
+  return null;
+};

package/lib/helpers/discriminator/getSchemaDiscriminatorByValue.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const areDiscriminatorValuesEqual = require('./areDiscriminatorValuesEqual');
+
+/**
+ * returns discriminator by discriminatorMapping.value
+ *
+ * @param {Schema} schema
+ * @param {string} value
+ * @api private
+ */
+
+module.exports = function getSchemaDiscriminatorByValue(schema, value) {
+  if (schema?.discriminators == null) {
+    return null;
+  }
+  for (const key of Object.keys(schema.discriminators)) {
+    const discriminatorSchema = schema.discriminators[key];
+    if (discriminatorSchema.discriminatorMapping == null) {
+      continue;
+    }
+    if (areDiscriminatorValuesEqual(discriminatorSchema.discriminatorMapping.value, value)) {
+      return discriminatorSchema;
+    }
+  }
+  return null;
+};

package/lib/helpers/discriminator/mergeDiscriminatorSchema.js

@@ -0,0 +1,91 @@
+'use strict';
+const schemaMerge = require('../schema/merge');
+const specialProperties = require('../../helpers/specialProperties');
+const isBsonType = require('../../helpers/isBsonType');
+const ObjectId = require('../../types/objectid');
+const SchemaType = require('../../schemaType');
+const isObject = require('../../helpers/isObject');
+/**
+ * Merges `from` into `to` without overwriting existing properties.
+ *
+ * @param {Object} to
+ * @param {Object} from
+ * @param {String} [path]
+ * @api private
+ */
+
+module.exports = function mergeDiscriminatorSchema(to, from, path, seen) {
+  const keys = Object.keys(from);
+  let i = 0;
+  const len = keys.length;
+  let key;
+
+  path = path || '';
+  seen = seen || new WeakSet();
+
+  if (seen.has(from)) {
+    return;
+  }
+  seen.add(from);
+
+  while (i < len) {
+    key = keys[i++];
+    if (!path) {
+      if (key === 'discriminators' ||
+        key === 'base' ||
+        key === '_applyDiscriminators' ||
+        key === '_userProvidedOptions' ||
+        key === 'options' ||
+        key === 'tree') {
+        continue;
+      }
+    }
+    if (path === 'tree' && from?.instanceOfSchema) {
+      continue;
+    }
+    if (specialProperties.has(key)) {
+      continue;
+    }
+    if (to[key] == null) {
+      to[key] = from[key];
+    } else if (isObject(from[key])) {
+      if (!isObject(to[key])) {
+        to[key] = {};
+      }
+      if (from[key] != null) {
+        // Skip merging schemas if we're creating a discriminator schema and
+        // base schema has a given path as a single nested but discriminator schema
+        // has the path as a document array, or vice versa (gh-9534)
+        if ((from[key].$isSingleNested && to[key].$isMongooseDocumentArray) ||
+              (from[key].$isMongooseDocumentArray && to[key].$isSingleNested) ||
+              (from[key].$isMongooseDocumentArrayElement && to[key].$isMongooseDocumentArrayElement)) {
+          continue;
+        } else if (from[key].instanceOfSchema) {
+          if (to[key].instanceOfSchema) {
+            schemaMerge(to[key], from[key].clone(), true);
+          } else {
+            to[key] = from[key].clone();
+          }
+          continue;
+        } else if (isBsonType(from[key], 'ObjectId')) {
+          to[key] = new ObjectId(from[key]);
+          continue;
+        } else if (from[key] instanceof SchemaType) {
+          if (to[key] == null) {
+            to[key] = from[key].clone();
+          }
+          // For container types with nested schemas, we need to continue to the
+          // recursive merge below to properly merge the nested schemas
+          if (!from[key].$isMongooseDocumentArray && !from[key].$isSingleNested) {
+            continue;
+          }
+        }
+      }
+      mergeDiscriminatorSchema(to[key], from[key], path ? path + '.' + key : key, seen);
+    }
+  }
+
+  if (from?.instanceOfSchema) {
+    to.tree = Object.assign({}, from.tree, to.tree);
+  }
+};

package/lib/helpers/document/applyDefaults.js

@@ -0,0 +1,132 @@
+'use strict';
+
+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?.skipParentChangeTracking;
+
+  for (let i = 0; i < plen; ++i) {
+    let def;
+    let curPath = '';
+    const p = paths[i];
+
+    if (p === '_id' && doc.$__.skipId) {
+      continue;
+    }
+
+    const type = doc.$__schema.paths[p];
+    const path = type.splitPath();
+    const len = path.length;
+    if (path[len - 1] === '$*') {
+      continue;
+    }
+    let included = false;
+    let doc_ = doc._doc;
+    for (let j = 0; j < len; ++j) {
+      if (doc_ == null) {
+        break;
+      }
+
+      const piece = path[j];
+      curPath += (!curPath.length ? '' : '.') + piece;
+
+      if (exclude === true) {
+        if (curPath in fields) {
+          break;
+        }
+      } else if (exclude === false && fields && !included) {
+        const hasSubpaths = type.$isSingleNested || type.$isMongooseDocumentArray;
+        if ((curPath in fields && !isNestedProjection(fields[curPath])) || (j === len - 1 && hasSubpaths && hasIncludedChildren != null && hasIncludedChildren[curPath])) {
+          included = true;
+        } else if (hasIncludedChildren != null && !hasIncludedChildren[curPath]) {
+          break;
+        }
+      }
+
+      if (j === len - 1) {
+        if (doc_[piece] !== void 0) {
+          break;
+        }
+
+        if (isBeforeSetters != null) {
+          if (typeof type.defaultValue === 'function') {
+            if (!type.defaultValue.$runBeforeSetters && isBeforeSetters) {
+              break;
+            }
+            if (type.defaultValue.$runBeforeSetters && !isBeforeSetters) {
+              break;
+            }
+          } else if (!isBeforeSetters) {
+            // Non-function defaults should always run **before** setters
+            continue;
+          }
+        }
+
+        if (pathsToSkip && pathsToSkip[curPath]) {
+          break;
+        }
+
+        if (fields && exclude !== null) {
+          if (exclude === true) {
+            // apply defaults to all non-excluded fields
+            if (p in fields) {
+              continue;
+            }
+
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              applyChangeTracking(doc, p, skipParentChangeTracking);
+            }
+          } else if (included) {
+            // selected field
+            try {
+              def = type.getDefault(doc, false);
+            } catch (err) {
+              doc.invalidate(p, err);
+              break;
+            }
+
+            if (typeof def !== 'undefined') {
+              doc_[piece] = def;
+              applyChangeTracking(doc, p, skipParentChangeTracking);
+            }
+          }
+        } else {
+          try {
+            def = type.getDefault(doc, false);
+          } catch (err) {
+            doc.invalidate(p, err);
+            break;
+          }
+
+          if (typeof def !== 'undefined') {
+            doc_[piece] = def;
+            applyChangeTracking(doc, p, skipParentChangeTracking);
+          }
+        }
+      } else {
+        doc_ = doc_[piece];
+      }
+    }
+  }
+};
+
+/*!
+ * ignore
+ */
+
+function applyChangeTracking(doc, fullPath, skipParentChangeTracking) {
+  doc.$__.activePaths.default(fullPath);
+  if (!skipParentChangeTracking && doc.$isSubdocument && doc.$isSingleNested && doc.$parent() != null) {
+    doc.$parent().$__.activePaths.default(doc.$__pathRelativeToParent(fullPath));
+  }
+}

package/lib/helpers/document/applyTimestamps.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const handleTimestampOption = require('../schema/handleTimestampOption');
+const mpath = require('mpath');
+const utils = require('../../utils');
+
+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 {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
+ */
+
+function applyTimestamps(schema, obj, options) {
+  if (obj == null) {
+    return obj;
+  }
+
+  applyTimestampsToChildren(schema, obj, options);
+  return applyTimestampsToDoc(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 {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
+ */
+
+function applyTimestampsToChildren(schema, res, options) {
+  for (const childSchema of schema.childSchemas) {
+    const _path = childSchema.model.path;
+    const _schema = childSchema.schema;
+    if (!_path) {
+      continue;
+    }
+    const _obj = mpath.get(_path, res);
+    if (_obj == null || (Array.isArray(_obj) && _obj.flat(Infinity).length === 0)) {
+      continue;
+    }
+
+    applyTimestamps(_schema, _obj, 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 {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
+ */
+
+function applyTimestampsToDoc(schema, obj, options) {
+  if (obj == null || typeof obj !== 'object') {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (const el of obj) {
+      applyTimestampsToDoc(schema, el, options);
+    }
+    return;
+  }
+
+  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;
+      const value = discriminator.discriminatorMapping.value;
+      if (obj[key] == value) {
+        schema = discriminator;
+        break;
+      }
+    }
+  }
+
+  const createdAt = handleTimestampOption(schema.options.timestamps, 'createdAt');
+  const updatedAt = handleTimestampOption(schema.options.timestamps, 'updatedAt');
+  const currentTime = options?.currentTime;
+
+  let ts = null;
+  if (currentTime != null) {
+    ts = currentTime();
+  } else if (schema.base?.now) {
+    ts = schema.base.now();
+  } else {
+    ts = new Date();
+  }
+
+  if (createdAt && obj[createdAt] == null && !options?.isUpdate) {
+    obj[createdAt] = ts;
+  }
+  if (updatedAt) {
+    obj[updatedAt] = ts;
+  }
+}

package/lib/helpers/document/applyVirtuals.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const mpath = require('mpath');
+const utils = require('../../utils');
+
+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
+ * @returns
+ */
+
+function applyVirtuals(schema, obj, virtuals) {
+  if (obj == null) {
+    return obj;
+  }
+
+  let virtualsForChildren = virtuals;
+  let toApply = null;
+
+  if (Array.isArray(virtuals)) {
+    virtualsForChildren = [];
+    toApply = [];
+    for (const virtual of virtuals) {
+      if (virtual.length === 1) {
+        toApply.push(virtual[0]);
+      } else {
+        virtualsForChildren.push(virtual);
+      }
+    }
+  }
+
+  applyVirtualsToChildren(schema, obj, virtualsForChildren);
+  return applyVirtualsToDoc(schema, obj, toApply);
+}
+
+/**
+ * Apply virtuals to any subdocuments
+ *
+ * @param {Schema} schema subdocument schema
+ * @param {Object} res subdocument
+ * @param {Array<String>} [virtuals] optional whitelist of virtuals to apply
+ */
+
+function applyVirtualsToChildren(schema, res, virtuals) {
+  let attachedVirtuals = false;
+  for (const childSchema of schema.childSchemas) {
+    const _path = childSchema.model.path;
+    const _schema = childSchema.schema;
+    if (!_path) {
+      continue;
+    }
+    const _obj = mpath.get(_path, res);
+    if (_obj == null || (Array.isArray(_obj) && _obj.flat(Infinity).length === 0)) {
+      continue;
+    }
+
+    let virtualsForChild = null;
+    if (Array.isArray(virtuals)) {
+      virtualsForChild = [];
+      for (const virtual of virtuals) {
+        if (virtual[0] == _path) {
+          virtualsForChild.push(virtual.slice(1));
+        }
+      }
+
+      if (virtualsForChild.length === 0) {
+        continue;
+      }
+    }
+
+    applyVirtuals(_schema, _obj, virtualsForChild);
+    attachedVirtuals = true;
+  }
+
+  if (virtuals?.length && !attachedVirtuals) {
+    applyVirtualsToDoc(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
+ * @returns
+ */
+
+function applyVirtualsToDoc(schema, obj, virtuals) {
+  if (obj == null || typeof obj !== 'object') {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (const el of obj) {
+      applyVirtualsToDoc(schema, el, virtuals);
+    }
+    return;
+  }
+
+  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;
+      const value = discriminator.discriminatorMapping.value;
+      if (obj[key] == value) {
+        schema = discriminator;
+        break;
+      }
+    }
+  }
+
+  if (virtuals == null) {
+    virtuals = Object.keys(schema.virtuals);
+  }
+  for (const virtual of virtuals) {
+    if (schema.virtuals[virtual] == null) {
+      continue;
+    }
+    const virtualType = schema.virtuals[virtual];
+    const sp = Array.isArray(virtual)
+      ? virtual
+      : virtual.indexOf('.') === -1
+        ? [virtual]
+        : virtual.split('.');
+    let cur = obj;
+    for (let i = 0; i < sp.length - 1; ++i) {
+      cur[sp[i]] = sp[i] in cur ? cur[sp[i]] : {};
+      cur = cur[sp[i]];
+    }
+    let val = virtualType.applyGetters(cur[sp[sp.length - 1]], obj);
+    const isPopulateVirtual =
+      virtualType.options?.ref || virtualType.options?.refPath;
+    if (isPopulateVirtual && val === undefined) {
+      if (virtualType.options.justOne) {
+        val = null;
+      } else {
+        val = [];
+      }
+    }
+    cur[sp[sp.length - 1]] = val;
+  }
+}

package/lib/helpers/document/cleanModifiedSubpaths.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function cleanModifiedSubpaths(doc, path, options) {
+  options = options || {};
+  const skipDocArrays = options.skipDocArrays;
+
+  let deleted = 0;
+  if (!doc) {
+    return deleted;
+  }
+
+  for (const modifiedPath of Object.keys(doc.$__.activePaths.getStatePaths('modify'))) {
+    if (skipDocArrays) {
+      const schemaType = doc.$__schema.path(modifiedPath);
+      if (schemaType?.$isMongooseDocumentArray) {
+        continue;
+      }
+    }
+    if (modifiedPath.startsWith(path + '.')) {
+      doc.$__.activePaths.clearPath(modifiedPath);
+      ++deleted;
+
+      if (doc.$isSubdocument) {
+        cleanParent(doc, modifiedPath);
+      }
+    }
+  }
+  return deleted;
+};
+
+function cleanParent(doc, path, seen = new Set()) {
+  if (seen.has(doc)) {
+    throw new Error('Infinite subdocument loop: subdoc with _id ' + doc._id + ' is a parent of itself');
+  }
+  const parent = doc.$parent();
+  const newPath = doc.$__pathRelativeToParent(void 0, false) + '.' + path;
+  parent.$__.activePaths.clearPath(newPath);
+  if (parent.$isSubdocument) {
+    cleanParent(parent, newPath, seen);
+  }
+}