@depup/mongoose 9.1.3-depup.0

package/lib/helpers/model/castBulkWrite.js

@@ -0,0 +1,316 @@
+'use strict';
+
+const MongooseError = require('../../error/mongooseError');
+const getDiscriminatorByValue = require('../../helpers/discriminator/getDiscriminatorByValue');
+const applyTimestampsToChildren = require('../update/applyTimestampsToChildren');
+const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
+const cast = require('../../cast');
+const castUpdate = require('../query/castUpdate');
+const clone = require('../clone');
+const decorateUpdateWithVersionKey = require('../update/decorateUpdateWithVersionKey');
+const { inspect } = require('util');
+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]
+ * @api private
+ */
+
+module.exports = function castBulkWrite(originalModel, op, options) {
+  const now = originalModel.base.now();
+
+  if (op['insertOne']) {
+    return callback => module.exports.castInsertOne(originalModel, op['insertOne'], options).then(() => callback(null), err => callback(err));
+  } else if (op['updateOne']) {
+    return (callback) => {
+      try {
+        module.exports.castUpdateOne(originalModel, op['updateOne'], options, now);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['updateMany']) {
+    return (callback) => {
+      try {
+        module.exports.castUpdateMany(originalModel, op['updateMany'], options, now);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['replaceOne']) {
+    return (callback) => {
+      module.exports.castReplaceOne(originalModel, op['replaceOne'], options).then(() => callback(null), err => callback(err));
+    };
+  } else if (op['deleteOne']) {
+    return (callback) => {
+      try {
+        module.exports.castDeleteOne(originalModel, op['deleteOne']);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['deleteMany']) {
+    return (callback) => {
+      try {
+        module.exports.castDeleteMany(originalModel, op['deleteMany']);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else {
+    return (callback) => {
+      const error = new MongooseError(`Invalid op passed to \`bulkWrite()\`: ${inspect(op)}`);
+      callback(error, null);
+    };
+  }
+};
+
+module.exports.castInsertOne = async function castInsertOne(originalModel, insertOne, options) {
+  const model = decideModelByObject(originalModel, insertOne['document']);
+
+  const doc = new model(insertOne['document']);
+  if (model.schema.options.timestamps && getTimestampsOpt(insertOne, options)) {
+    doc.initializeTimestamps();
+  }
+  if (options.session != null) {
+    doc.$session(options.session);
+  }
+  const versionKey = model?.schema?.options?.versionKey;
+  if (versionKey && doc[versionKey] == null) {
+    doc[versionKey] = 0;
+  }
+  insertOne['document'] = doc;
+
+  if (options.skipValidation || insertOne.skipValidation) {
+    return insertOne;
+  }
+
+  await insertOne['document'].$validate();
+  return insertOne;
+};
+
+module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne, options, now) {
+  if (!updateOne['filter']) {
+    throw new Error('Must provide a filter object.');
+  }
+  if (!updateOne['update']) {
+    throw new Error('Must provide an update object.');
+  }
+
+  const model = decideModelByObject(originalModel, updateOne['filter']);
+  const schema = model.schema;
+  const strict = options.strict ?? model.schema.options.strict;
+
+  const update = clone(updateOne['update']);
+
+  _addDiscriminatorToObject(schema, updateOne['filter']);
+
+  const doInitTimestamps = getTimestampsOpt(updateOne, options);
+
+  if (model.schema.$timestamps != null && doInitTimestamps) {
+    const createdAt = model.schema.$timestamps.createdAt;
+    const updatedAt = model.schema.$timestamps.updatedAt;
+    applyTimestampsToUpdate(now, createdAt, updatedAt, update, {
+      timestamps: updateOne.timestamps,
+      overwriteImmutable: updateOne.overwriteImmutable
+    });
+  }
+
+  if (doInitTimestamps) {
+    applyTimestampsToChildren(now, update, model.schema);
+  }
+
+  const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateOne.setDefaultsOnInsert ?? globalSetDefaultsOnInsert;
+  if (shouldSetDefaultsOnInsert !== false) {
+    setDefaultsOnInsert(updateOne['filter'], model.schema, update, {
+      setDefaultsOnInsert: true,
+      upsert: updateOne.upsert
+    });
+  }
+
+  decorateUpdateWithVersionKey(
+    update,
+    updateOne,
+    model.schema.options.versionKey
+  );
+
+  updateOne['filter'] = cast(model.schema, updateOne['filter'], {
+    strict: strict,
+    upsert: updateOne.upsert
+  });
+  updateOne['update'] = castUpdate(model.schema, update, {
+    strict: strict,
+    upsert: updateOne.upsert,
+    arrayFilters: updateOne.arrayFilters,
+    overwriteDiscriminatorKey: updateOne.overwriteDiscriminatorKey,
+    overwriteImmutable: updateOne.overwriteImmutable
+  }, model, updateOne['filter']);
+
+  return updateOne;
+};
+
+module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMany, options, now) {
+  if (!updateMany['filter']) {
+    throw new Error('Must provide a filter object.');
+  }
+  if (!updateMany['update']) {
+    throw new Error('Must provide an update object.');
+  }
+
+  const model = decideModelByObject(originalModel, updateMany['filter']);
+  const schema = model.schema;
+  const strict = options.strict ?? model.schema.options.strict;
+
+  const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateMany.setDefaultsOnInsert ?? globalSetDefaultsOnInsert;
+
+  if (shouldSetDefaultsOnInsert !== false) {
+    setDefaultsOnInsert(updateMany['filter'], model.schema, updateMany['update'], {
+      setDefaultsOnInsert: true,
+      upsert: updateMany.upsert
+    });
+  }
+
+  const doInitTimestamps = getTimestampsOpt(updateMany, options);
+
+  if (model.schema.$timestamps != null && doInitTimestamps) {
+    const createdAt = model.schema.$timestamps.createdAt;
+    const updatedAt = model.schema.$timestamps.updatedAt;
+    applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {
+      timestamps: updateMany.timestamps,
+      overwriteImmutable: updateMany.overwriteImmutable
+    });
+  }
+  if (doInitTimestamps) {
+    applyTimestampsToChildren(now, updateMany['update'], model.schema);
+  }
+
+  _addDiscriminatorToObject(schema, updateMany['filter']);
+
+  decorateUpdateWithVersionKey(
+    updateMany['update'],
+    updateMany,
+    model.schema.options.versionKey
+  );
+
+  updateMany['filter'] = cast(model.schema, updateMany['filter'], {
+    strict: strict,
+    upsert: updateMany.upsert
+  });
+
+  updateMany['update'] = castUpdate(model.schema, updateMany['update'], {
+    strict: strict,
+    upsert: updateMany.upsert,
+    arrayFilters: updateMany.arrayFilters,
+    overwriteDiscriminatorKey: updateMany.overwriteDiscriminatorKey,
+    overwriteImmutable: updateMany.overwriteImmutable
+  }, model, updateMany['filter']);
+};
+
+module.exports.castReplaceOne = async function castReplaceOne(originalModel, replaceOne, options) {
+  const model = decideModelByObject(originalModel, replaceOne['filter']);
+  const schema = model.schema;
+  const strict = options.strict ?? model.schema.options.strict;
+
+  _addDiscriminatorToObject(schema, replaceOne['filter']);
+  replaceOne['filter'] = cast(model.schema, replaceOne['filter'], {
+    strict: strict,
+    upsert: replaceOne.upsert
+  });
+
+  // set `skipId`, otherwise we get "_id field cannot be changed"
+  const doc = new model(replaceOne['replacement'], strict, { skipId: true });
+  if (model.schema.options.timestamps && getTimestampsOpt(replaceOne, options)) {
+    doc.initializeTimestamps();
+  }
+  if (options.session != null) {
+    doc.$session(options.session);
+  }
+  const versionKey = model?.schema?.options?.versionKey;
+  if (versionKey && doc[versionKey] == null) {
+    doc[versionKey] = 0;
+  }
+  replaceOne['replacement'] = doc;
+
+  if (options.skipValidation || replaceOne.skipValidation) {
+    replaceOne['replacement'] = replaceOne['replacement'].toBSON();
+    return;
+  }
+
+  await replaceOne['replacement'].$validate();
+  replaceOne['replacement'] = replaceOne['replacement'].toBSON();
+};
+
+module.exports.castDeleteOne = function castDeleteOne(originalModel, deleteOne) {
+  const model = decideModelByObject(originalModel, deleteOne['filter']);
+  const schema = model.schema;
+
+  _addDiscriminatorToObject(schema, deleteOne['filter']);
+
+  deleteOne['filter'] = cast(model.schema, deleteOne['filter']);
+};
+
+module.exports.castDeleteMany = function castDeleteMany(originalModel, deleteMany) {
+  const model = decideModelByObject(originalModel, deleteMany['filter']);
+  const schema = model.schema;
+
+  _addDiscriminatorToObject(schema, deleteMany['filter']);
+
+  deleteMany['filter'] = cast(model.schema, deleteMany['filter']);
+};
+
+module.exports.cast = {
+  insertOne: module.exports.castInsertOne,
+  updateOne: module.exports.castUpdateOne,
+  updateMany: module.exports.castUpdateMany,
+  replaceOne: module.exports.castReplaceOne,
+  deleteOne: module.exports.castDeleteOne,
+  deleteMany: module.exports.castDeleteMany
+};
+
+function _addDiscriminatorToObject(schema, obj) {
+  if (schema == null) {
+    return;
+  }
+  if (schema.discriminatorMapping && !schema.discriminatorMapping.isRoot) {
+    obj[schema.discriminatorMapping.key] = schema.discriminatorMapping.value;
+  }
+}
+
+/**
+ * gets discriminator model if discriminator key is present in object
+ * @api private
+ */
+
+function decideModelByObject(model, object) {
+  const discriminatorKey = model.schema.options.discriminatorKey;
+  if (object != null && Object.hasOwn(object, discriminatorKey)) {
+    model = getDiscriminatorByValue(model.discriminators, object[discriminatorKey]) || model;
+  }
+  return model;
+}
+
+/**
+ * gets timestamps option for a given operation. If the option is set within an individual operation, use it. Otherwise, use the global timestamps option configured in the `bulkWrite` options. Overall default is `true`.
+ * @api private
+ */
+
+function getTimestampsOpt(opCommand, options) {
+  const opLevelOpt = opCommand.timestamps;
+  const bulkLevelOpt = options.timestamps;
+  if (opLevelOpt != null) {
+    return opLevelOpt;
+  } else if (bulkLevelOpt != null) {
+    return bulkLevelOpt;
+  }
+  return true;
+}

package/lib/helpers/model/decorateBulkWriteResult.js

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function decorateBulkWriteResult(resultOrError, validationErrors, results) {
+  resultOrError.mongoose = resultOrError.mongoose || {};
+  resultOrError.mongoose.validationErrors = validationErrors;
+  resultOrError.mongoose.results = results;
+  return resultOrError;
+};

package/lib/helpers/model/discriminator.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const Mixed = require('../../schema/mixed');
+const applyBuiltinPlugins = require('../schema/applyBuiltinPlugins');
+const clone = require('../clone');
+const defineKey = require('../document/compile').defineKey;
+const get = require('../get');
+const utils = require('../../utils');
+const mergeDiscriminatorSchema = require('../../helpers/discriminator/mergeDiscriminatorSchema');
+
+const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
+  toJSON: true,
+  toObject: true,
+  _id: true,
+  id: true,
+  virtuals: true,
+  methods: true,
+  statics: true
+};
+
+/**
+ * Validate fields declared on the child schema when either schema is configured for encryption.  Specifically, this function ensures that:
+ *
+ * - any encrypted fields are declared on exactly one of the schemas (not both)
+ * - encrypted fields cannot be declared on either the parent or child schema, where the other schema declares the same field without encryption.
+ *
+ * @param {Schema} parentSchema
+ * @param {Schema} childSchema
+ */
+function validateDiscriminatorSchemasForEncryption(parentSchema, childSchema) {
+  if (parentSchema.encryptionType() == null && childSchema.encryptionType() == null) return;
+
+  const allSharedNestedPaths = setIntersection(
+    allNestedPaths(parentSchema),
+    allNestedPaths(childSchema)
+  );
+
+  for (const path of allSharedNestedPaths) {
+    if (parentSchema._hasEncryptedField(path) && childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot be declared on both the base schema and the child schema in a discriminator. path=${path}`);
+    }
+
+    if (parentSchema._hasEncryptedField(path) || childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot have the same path as a non-encrypted field for discriminators. path=${path}`);
+    }
+  }
+
+  function allNestedPaths(schema) {
+    return [...Object.keys(schema.paths), ...Object.keys(schema.singleNestedPaths)];
+  }
+
+  /**
+   * @param {Iterable<string>} i1
+   * @param {Iterable<string>} i2
+   */
+  function* setIntersection(i1, i2) {
+    const s1 = new Set(i1);
+    for (const item of i2) {
+      if (s1.has(item)) {
+        yield item;
+      }
+    }
+  }
+}
+
+/*!
+ * ignore
+ */
+
+module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks, overwriteExisting) {
+  if (!schema?.instanceOfSchema) {
+    throw new Error('You must pass a valid discriminator Schema');
+  }
+
+  mergeHooks = mergeHooks == null ? true : mergeHooks;
+
+  if (model.schema.discriminatorMapping &&
+      !model.schema.discriminatorMapping.isRoot) {
+    throw new Error('Discriminator "' + name +
+        '" can only be a discriminator of the root model');
+  }
+
+  if (applyPlugins) {
+    const applyPluginsToDiscriminators = get(model.base,
+      'options.applyPluginsToDiscriminators', false) || !mergeHooks;
+    // Even if `applyPluginsToDiscriminators` isn't set, we should still apply
+    // global plugins to schemas embedded in the discriminator schema (gh-7370)
+    model.base._applyPlugins(schema, {
+      skipTopLevel: !applyPluginsToDiscriminators
+    });
+  } else if (!mergeHooks) {
+    applyBuiltinPlugins(schema);
+  }
+
+  const key = model.schema.options.discriminatorKey;
+
+  const existingPath = model.schema.path(key);
+  if (existingPath != null) {
+    if (!utils.hasUserDefinedProperty(existingPath.options, 'select')) {
+      existingPath.options.select = true;
+    }
+    existingPath.options.$skipDiscriminatorCheck = true;
+  } else {
+    const baseSchemaAddition = {};
+    baseSchemaAddition[key] = {
+      default: void 0,
+      select: true,
+      $skipDiscriminatorCheck: true
+    };
+    baseSchemaAddition[key][model.schema.options.typeKey] = String;
+    model.schema.add(baseSchemaAddition);
+    defineKey({
+      prop: key,
+      prototype: model.prototype,
+      options: model.schema.options
+    });
+  }
+
+  if (schema.path(key) && schema.path(key).options.$skipDiscriminatorCheck !== true) {
+    throw new Error('Discriminator "' + name +
+        '" cannot have field with name "' + key + '"');
+  }
+
+  let value = name;
+  if ((typeof tiedValue === 'string' && tiedValue.length) || tiedValue != null) {
+    value = tiedValue;
+  }
+
+  validateDiscriminatorSchemasForEncryption(model.schema, schema);
+
+  function merge(schema, baseSchema) {
+    // Retain original schema before merging base schema
+    schema._baseSchema = baseSchema;
+    if (baseSchema.paths._id &&
+        baseSchema.paths._id.options &&
+        !baseSchema.paths._id.options.auto) {
+      schema.remove('_id');
+    }
+
+    // Find conflicting paths: if something is a path in the base schema
+    // and a nested path in the child schema, overwrite the base schema path.
+    // See gh-6076
+    const baseSchemaPaths = Object.keys(baseSchema.paths);
+    const conflictingPaths = [];
+
+    for (const path of baseSchemaPaths) {
+      if (schema.nested[path]) {
+        conflictingPaths.push(path);
+        continue;
+      }
+
+      if (path.indexOf('.') === -1) {
+        continue;
+      }
+      const sp = path.split('.').slice(0, -1);
+      let cur = '';
+      for (const piece of sp) {
+        cur += (cur.length ? '.' : '') + piece;
+        if (schema.paths[cur] instanceof Mixed ||
+            schema.singleNestedPaths[cur] instanceof Mixed) {
+          conflictingPaths.push(path);
+        }
+      }
+    }
+
+    // Shallow clone `obj` so we can add additional properties without modifying original
+    // schema. `Schema.prototype.clone()` copies `obj` by reference, no cloning.
+    schema.obj = { ...schema.obj };
+    mergeDiscriminatorSchema(schema, baseSchema);
+    schema._gatherChildSchemas();
+
+    // Clean up conflicting paths _after_ merging re: gh-6076
+    for (const conflictingPath of conflictingPaths) {
+      delete schema.paths[conflictingPath];
+    }
+
+    // Rebuild schema models because schemas may have been merged re: #7884
+    schema.childSchemas.forEach(obj => {
+      obj.model.prototype.$__setSchema(obj.schema);
+    });
+
+    const obj = {};
+    obj[key] = {
+      default: value,
+      select: true,
+      set: function(newName) {
+        if (newName === value || (Array.isArray(value) && utils.deepEqual(newName, value))) {
+          return value;
+        }
+        throw new Error('Can\'t set discriminator key "' + key + '"');
+      },
+      $skipDiscriminatorCheck: true
+    };
+    obj[key][schema.options.typeKey] = existingPath ? existingPath.options[schema.options.typeKey] : String;
+    schema.add(obj);
+
+    schema.discriminatorMapping = { key: key, value: value, isRoot: false };
+
+    if (baseSchema.options.collection) {
+      schema.options.collection = baseSchema.options.collection;
+    }
+    const toJSON = schema.options.toJSON;
+    const toObject = schema.options.toObject;
+    const _id = schema.options._id;
+    const id = schema.options.id;
+
+    const keys = Object.keys(schema.options);
+    schema.options.discriminatorKey = baseSchema.options.discriminatorKey;
+    const userProvidedOptions = schema._userProvidedOptions;
+    for (const _key of keys) {
+      if (!CUSTOMIZABLE_DISCRIMINATOR_OPTIONS[_key]) {
+        // Use `schema.options` in `deepEqual()` because of `discriminatorKey`
+        // set above. We don't allow customizing discriminator key, always
+        // overwrite. See gh-9238
+        if (_key in userProvidedOptions && !utils.deepEqual(schema.options[_key], baseSchema.options[_key])) {
+          throw new Error('Can\'t customize discriminator option ' + _key +
+            ' (can only modify ' +
+            Object.keys(CUSTOMIZABLE_DISCRIMINATOR_OPTIONS).join(', ') +
+            ')');
+        }
+      }
+    }
+    schema.options = clone(baseSchema.options);
+
+    for (const _key of Object.keys(userProvidedOptions)) {
+      schema.options[_key] = userProvidedOptions[_key];
+    }
+    if (toJSON) schema.options.toJSON = toJSON;
+    if (toObject) schema.options.toObject = toObject;
+    if (typeof _id !== 'undefined') {
+      schema.options._id = _id;
+    }
+    schema.options.id = id;
+    if (mergeHooks) {
+      schema.s.hooks = model.schema.s.hooks.merge(schema.s.hooks);
+    }
+    if (applyPlugins) {
+      schema.plugins = Array.prototype.slice.call(baseSchema.plugins);
+    }
+    schema.callQueue = baseSchema.callQueue.concat(schema.callQueue);
+    delete schema._requiredpaths; // reset just in case Schema#requiredPaths() was called on either schema
+  }
+
+  // merges base schema into new discriminator schema and sets new type field.
+  merge(schema, model.schema);
+
+  if (!model.discriminators) {
+    model.discriminators = {};
+  }
+
+  if (!model.schema.discriminatorMapping) {
+    model.schema.discriminatorMapping = { key: key, value: null, isRoot: true };
+  }
+  if (!model.schema.discriminators) {
+    model.schema.discriminators = {};
+  }
+
+  model.schema.discriminators[name] = schema;
+
+  if (model.discriminators[name] && !schema.options.overwriteModels && !overwriteExisting) {
+    throw new Error('Discriminator with name "' + name + '" already exists');
+  }
+
+  return schema;
+};

package/lib/helpers/model/pushNestedArrayPaths.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function pushNestedArrayPaths(paths, nestedArray, path) {
+  if (nestedArray == null) {
+    return;
+  }
+
+  for (let i = 0; i < nestedArray.length; ++i) {
+    if (Array.isArray(nestedArray[i])) {
+      pushNestedArrayPaths(paths, nestedArray[i], path + '.' + i);
+    } else {
+      paths.push(path + '.' + i);
+    }
+  }
+};

package/lib/helpers/omitUndefined.js

@@ -0,0 +1,20 @@
+'use strict';
+
+module.exports = function omitUndefined(val) {
+  if (val == null || typeof val !== 'object') {
+    return val;
+  }
+  if (Array.isArray(val)) {
+    for (let i = val.length - 1; i >= 0; --i) {
+      if (val[i] === undefined) {
+        val.splice(i, 1);
+      }
+    }
+  }
+  for (const key of Object.keys(val)) {
+    if (val[key] === void 0) {
+      delete val[key];
+    }
+  }
+  return val;
+};

package/lib/helpers/once.js

@@ -0,0 +1,12 @@
+'use strict';
+
+module.exports = function once(fn) {
+  let called = false;
+  return function() {
+    if (called) {
+      return;
+    }
+    called = true;
+    return fn.apply(null, arguments);
+  };
+};

package/lib/helpers/parallelLimit.js

@@ -0,0 +1,37 @@
+'use strict';
+
+module.exports = parallelLimit;
+
+/*!
+ * ignore
+ */
+
+async function parallelLimit(params, fn, limit) {
+  if (limit <= 0) {
+    throw new Error('Limit must be positive');
+  }
+
+  if (params.length === 0) {
+    return [];
+  }
+
+  const results = [];
+  const executing = new Set();
+
+  for (let index = 0; index < params.length; index++) {
+    const param = params[index];
+    const p = fn(param, index);
+    results.push(p);
+
+    executing.add(p);
+
+    const clean = () => executing.delete(p);
+    p.then(clean).catch(clean);
+
+    if (executing.size >= limit) {
+      await Promise.race(executing);
+    }
+  }
+
+  return Promise.all(results);
+}

package/lib/helpers/path/parentPaths.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const dotRE = /\./g;
+module.exports = function parentPaths(path) {
+  if (path.indexOf('.') === -1) {
+    return [path];
+  }
+  const pieces = path.split(dotRE);
+  const len = pieces.length;
+  const ret = new Array(len);
+  let cur = '';
+  for (let i = 0; i < len; ++i) {
+    cur += (cur.length !== 0) ? '.' + pieces[i] : pieces[i];
+    ret[i] = cur;
+  }
+
+  return ret;
+};