@depup/mongoose 9.3.3-depup.0 → 9.8.0-depup.0

package/lib/schemaType.js

@@ -181,6 +181,40 @@ SchemaType.prototype.toJSON = function toJSON() {
   return res;
 };
 
+/**
+ * Helper for creating `{ type: 'object' }` vs `{ bsonType: 'object' }` vs nullable variants.
+ *
+ * @param {string} type
+ * @param {string} bsonType
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false]
+ * @param {boolean} [options._defaultRequired=false]
+ * @param {boolean} [options._overrideRequired]
+ * @returns {object}
+ * @api private
+ */
+
+SchemaType.prototype._createJSONSchemaTypeDefinition = function _createJSONSchemaTypeDefinition(type, bsonType, options) {
+  const useBsonType = options?.useBsonType;
+  const isRequired = options?._overrideRequired ??
+    (this.options.required == null ?
+      (options?._defaultRequired === true || this.path === '_id') :
+      this.options.required && typeof this.options.required !== 'function');
+  const allowNull = this.options.allowNull !== false;
+
+  if (useBsonType) {
+    if (isRequired || !allowNull) {
+      return { bsonType };
+    }
+    return { bsonType: [bsonType, 'null'] };
+  }
+
+  if (isRequired || !allowNull) {
+    return { type };
+  }
+  return { type: [type, 'null'] };
+};
+
 /**
  * The validators that Mongoose should run to validate properties at this SchemaType's path.
  *
@@ -380,10 +414,10 @@ SchemaType.get = function(getter) {
  * #### Example:
  *
  *     // values are cast:
- *     const schema = new Schema({ aNumber: { type: Number, default: 4.815162342 }})
+ *     const schema = new Schema({ num: { type: Number, default: 4.815162342 }})
  *     const M = db.model('M', schema)
  *     const m = new M;
- *     console.log(m.aNumber) // 4.815162342
+ *     console.log(m.num) // 4.815162342
  *
  *     // default unique objects for Mixed types:
  *     const schema = new Schema({ mixed: Schema.Types.Mixed });
@@ -786,7 +820,7 @@ SchemaType.prototype.set = function(fn) {
  *     // defining within the schema
  *     const s = new Schema({ born: { type: Date, get: dob })
  *
- *     // or by retreiving its SchemaType
+ *     // or by retrieving its SchemaType
  *     const s = new Schema({ born: Date })
  *     s.path('born').get(dob)
  *
@@ -936,7 +970,7 @@ SchemaType.prototype.validateAll = function(validators) {
  *       }
  *     });
  *
- * You might use asynchronous validators to retreive other documents from the database to validate against or to meet other I/O bound validation needs.
+ * You might use asynchronous validators to retrieve other documents from the database to validate against or to meet other I/O bound validation needs.
  *
  * Validation occurs `pre('save')` or whenever you manually execute [document#validate](https://mongoosejs.com/docs/api/document.html#Document.prototype.validate()).
  *
@@ -1109,6 +1143,12 @@ SchemaType.prototype.required = function(required, message) {
 
   const _this = this;
   this.isRequired = true;
+  this.originalRequiredValue = required;
+
+  if (typeof this.originalRequiredValue !== 'function' &&
+      (utils.hasUserDefinedProperty(this.options, 'allowNull') || this.allowNullValidator != null)) {
+    throw new MongooseError('Path "' + this.path + '" may not have `allowNull` specified when `required` is true');
+  }
 
   this.requiredValidator = function(v) {
     const cachedRequired = this?.$__?.cachedRequired;
@@ -1133,8 +1173,6 @@ SchemaType.prototype.required = function(required, message) {
 
     return _this.checkRequired(v, this);
   };
-  this.originalRequiredValue = required;
-
   if (typeof required === 'string') {
     message = required;
     required = undefined;
@@ -1150,6 +1188,54 @@ SchemaType.prototype.required = function(required, message) {
   return this;
 };
 
+/**
+ * Adds a validator that disallows `null` for this path without making the path
+ * required. `undefined` values still pass validation.
+ *
+ * #### Example:
+ *
+ *     const schema = new Schema({
+ *       name: { type: String, allowNull: false }
+ *     });
+ *
+ *     new Model({}).validateSync(); // OK
+ *     new Model({ name: undefined }).validateSync(); // OK, Mongoose strips out `name` when its value is `undefined`
+ *     new Model({ name: null }).validateSync(); // ValidationError
+ *
+ * @param {boolean} allowNull
+ * @return {SchemaType} this
+ * @api public
+ */
+
+SchemaType.prototype.allowNull = function(allowNull) {
+  if (arguments.length > 0 && this.isRequired && typeof this.originalRequiredValue !== 'function') {
+    throw new MongooseError('Path "' + this.path + '" may not have `allowNull` specified when `required` is true');
+  }
+
+  this.validators = this.validators.filter(function(v) {
+    return v.validator !== this.allowNullValidator;
+  }, this);
+
+  if (allowNull !== false) {
+    delete this.options.allowNull;
+    delete this.allowNullValidator;
+    return this;
+  }
+
+  this.options.allowNull = false;
+  this.allowNullValidator = function(v) {
+    return v !== null;
+  };
+
+  this.validators.push({
+    validator: this.allowNullValidator,
+    message: MongooseError.messages.general.allowNull,
+    type: 'allowNull'
+  });
+
+  return this;
+};
+
 /**
  * Set the model that this path refers to. This is the option that [populate](https://mongoosejs.com/docs/populate.html)
  * looks at to determine the foreign collection it should query.
@@ -1371,9 +1457,6 @@ SchemaType.prototype.doValidate = async function doValidate(value, scope, option
     validatorProperties.value = value;
     if (typeof value === 'string') {
       validatorProperties.length = value.length;
-      if (validatorProperties.value.length > 30) {
-        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
-      }
     }
 
     if (value === undefined && validator !== this.requiredValidator) {
@@ -1497,9 +1580,6 @@ SchemaType.prototype.doValidateSync = function(value, scope, options) {
     validatorProperties.value = value;
     if (typeof value === 'string') {
       validatorProperties.length = value.length;
-      if (validatorProperties.value.length > 30) {
-        validatorProperties.value = validatorProperties.value.slice(0, 30) + '...';
-      }
     }
     let ok = false;
 
@@ -1769,6 +1849,7 @@ SchemaType.prototype.clone = function() {
   const schematype = new this.constructor(this.path, options, this.instance, this.parentSchema);
   schematype.validators = this.validators.slice();
   if (this.requiredValidator !== undefined) schematype.requiredValidator = this.requiredValidator;
+  if (this.allowNullValidator !== undefined) schematype.allowNullValidator = this.allowNullValidator;
   if (this.defaultValue !== undefined) schematype.defaultValue = this.defaultValue;
   if (this.$immutable !== undefined && this.options.immutable === undefined) {
     schematype.$immutable = this.$immutable;

package/lib/standardSchema/convertErrorToIssues.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const ValidationError = require('../error/validation');
+
+module.exports = function convertErrorToIssues(error) {
+  if (error instanceof ValidationError) {
+    return Object.keys(error.errors).map(path => {
+      const err = error.errors[path];
+      return {
+        message: err.message,
+        path: path.split('.').map(part => {
+          const num = +part;
+          return Number.isInteger(num) && String(num) === part ? num : part;
+        })
+      };
+    });
+  }
+
+  return [{ message: error.message }];
+};

package/lib/stateMachine.js

@@ -69,8 +69,10 @@ StateMachine.prototype._changeState = function _changeState(path, nextState) {
   if (prevState === nextState) {
     return;
   }
-  const prevBucket = this.states[prevState];
-  if (prevBucket) delete prevBucket[path];
+  if (prevState !== undefined) {
+    const prevBucket = this.states[prevState];
+    if (prevBucket) delete prevBucket[path];
+  }
 
   this.paths[path] = nextState;
   this.states[nextState] = this.states[nextState] || {};
@@ -86,13 +88,16 @@ StateMachine.prototype.clear = function clear(state) {
     return;
   }
   const keys = Object.keys(this.states[state]);
+  if (keys.length === 0) {
+    return;
+  }
+  // Replace the bucket rather than deleting each key: repeated `delete` puts
+  // the object in dictionary mode, which is significantly slower.
+  this.states[state] = {};
   let i = keys.length;
-  let path;
 
   while (i--) {
-    path = keys[i];
-    delete this.states[state][path];
-    delete this.paths[path];
+    delete this.paths[keys[i]];
   }
 };
 

package/lib/tracing.js

@@ -0,0 +1,38 @@
+'use strict';
+
+let dc;
+try {
+  dc = (typeof process !== 'undefined' && 'getBuiltinModule' in process)
+    ? process.getBuiltinModule('node:diagnostics_channel')
+    : require('node:diagnostics_channel');
+} catch {
+  // diagnostics_channel not available
+}
+
+const hasTracingChannel = !!dc && typeof dc.tracingChannel === 'function';
+
+function shouldTrace(channel) {
+  // Node 18 and Bun don't expose hasSubscribers on TracingChannel
+  // so undefined means it may or may not have subscribers, so we'll trace anyway
+  return !!channel && channel.hasSubscribers !== false;
+}
+
+function createTracedChannel(name) {
+  const ch = hasTracingChannel ? dc.tracingChannel(name) : undefined;
+
+  function trace(fn, contextFactory) {
+    if (!shouldTrace(ch)) {
+      return fn();
+    }
+
+    const traced = ch.tracePromise(fn, contextFactory());
+    return traced;
+  }
+
+  return { channel: ch, trace };
+}
+
+module.exports = {
+  createTracedChannel,
+  cursorNextChannel: createTracedChannel('mongoose:cursor:next')
+};

package/lib/types/array/methods/index.js

@@ -572,7 +572,7 @@ const methods = {
    *
    * #### Note:
    *
-   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it._
+   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwriting any changes that happen between when you retrieved the object and when you save it._
    *
    * @param {...any} [args]
    * @api public
@@ -830,7 +830,7 @@ const methods = {
    *
    * #### Note:
    *
-   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it._
+   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwriting any changes that happen between when you retrieved the object and when you save it._
    *
    * @api public
    * @method shift
@@ -850,7 +850,7 @@ const methods = {
    *
    * #### Note:
    *
-   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it._
+   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwriting any changes that happen between when you retrieved the object and when you save it._
    *
    * @api public
    * @method sort
@@ -870,7 +870,7 @@ const methods = {
    *
    * #### Note:
    *
-   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwritting any changes that happen between when you retrieved the object and when you save it._
+   * _marks the entire array as modified, which if saved, will store it as a `$set` operation, potentially overwriting any changes that happen between when you retrieved the object and when you save it._
    *
    * @api public
    * @method splice

package/lib/types/documentArray/methods/index.js

@@ -12,6 +12,7 @@ const arrayPathSymbol = require('../../../helpers/symbols').arrayPathSymbol;
 const arraySchemaSymbol = require('../../../helpers/symbols').arraySchemaSymbol;
 const documentArrayParent = require('../../../helpers/symbols').documentArrayParent;
 
+const _baseReverse = Array.prototype.reverse;
 const _baseToString = Array.prototype.toString;
 
 const methods = {
@@ -211,7 +212,7 @@ const methods = {
   },
 
   /**
-   * Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
+   * Wraps [`Array#push`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
    *
    * @param {...object} [args]
    * @api public
@@ -220,8 +221,37 @@ const methods = {
    */
 
   push() {
+    const shouldReindex = _shouldReindexAfterPush(arguments);
     const ret = ArrayMethods.push.apply(this, arguments);
 
+    if (shouldReindex) {
+      _updateSubdocIndexes(this);
+    }
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#pop`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) with proper change tracking.
+   * @api private
+   */
+
+  pop() {
+    const ret = ArrayMethods.pop.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /*!
+   * ignore
+   */
+
+  $pop() {
+    const ret = ArrayMethods.$pop.apply(this, arguments);
+
     _updateParentPopulated(this);
 
     return ret;
@@ -239,32 +269,96 @@ const methods = {
   pull() {
     const ret = ArrayMethods.pull.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
   },
 
   /**
-   * Wraps [`Array#shift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking.
+   * Wraps [`Array#shift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) with proper change tracking.
    * @api private
    */
 
   shift() {
     const ret = ArrayMethods.shift.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /*!
+   * ignore
+   */
+
+  $shift() {
+    const ret = ArrayMethods.$shift.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
   },
 
   /**
-   * Wraps [`Array#splice`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
+   * Wraps [`Array#splice`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
    * @api private
    */
 
   splice() {
     const ret = ArrayMethods.splice.apply(this, arguments);
 
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#reverse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)
+   * with proper change tracking.
+   * @api private
+   */
+
+  reverse() {
+    _baseReverse.call(this.__array);
+    this._registerAtomic('$set', this);
+
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return this;
+  },
+
+  /**
+   * Wraps [`Array#sort`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)
+   * with proper change tracking.
+   *
+   * @param {Function} [compareFunction]
+   * @api private
+   */
+
+  sort() {
+    const ret = ArrayMethods.sort.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#unshift`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)
+   * with proper change tracking.
+   * @api private
+   */
+
+  unshift() {
+    const ret = ArrayMethods.unshift.apply(this, arguments);
+
+    _updateSubdocIndexes(this);
     _updateParentPopulated(this);
 
     return ret;
@@ -389,6 +483,26 @@ const methods = {
 
 module.exports = methods;
 
+/*!
+ * ignore
+ */
+
+function _updateSubdocIndexes(arr) {
+  const rawArray = utils.isMongooseArray(arr) ? arr.__array : arr;
+
+  for (let i = 0; i < rawArray.length; ++i) {
+    if (typeof rawArray[i]?.$setIndex === 'function') {
+      rawArray[i].$setIndex(i);
+    }
+  }
+}
+
+function _shouldReindexAfterPush(args) {
+  return args[0] != null &&
+    utils.hasUserDefinedProperty(args[0], '$each') &&
+    args[0].$position != null;
+}
+
 /**
  * If this is a document array, each element may contain single
  * populated paths, so we need to modify the top-level document's

package/lib/types/subdocument.js

@@ -403,7 +403,9 @@ if (util.inspect.custom) {
 
 /**
  * Override `$toObject()` to handle minimizing the whole path. Should not minimize if schematype-level minimize
- * is set to false re: gh-11247, gh-14058, gh-14151
+ * is set to false re: gh-11247, gh-14058, gh-14151. Should not minimize document array elements: an array
+ * element cannot be removed without shifting the array, so minimizing it to `undefined` makes the BSON
+ * serializer store `null` re: gh-7322.
  */
 
 Subdocument.prototype.$toObject = function $toObject(options, json) {
@@ -413,7 +415,7 @@ Subdocument.prototype.$toObject = function $toObject(options, json) {
   // If minimize is set, then we can minimize out the whole object.
   if (utils.hasOwnKeys(ret) === false && options?._calledWithOptions != null) {
     const minimize = options._calledWithOptions?.minimize ?? this?.$__schemaTypeOptions?.minimize ?? options.minimize;
-    if (minimize && !this.constructor.$__required) {
+    if (minimize && !this.constructor.$__required && !this.$isDocumentArrayElement) {
       return undefined;
     }
   }

package/lib/utils.js

@@ -119,6 +119,16 @@ exports.deepEqual = function deepEqual(a, b) {
       deepEqual(Array.from(a.values()), Array.from(b.values()));
   }
 
+  if (a instanceof Set || b instanceof Set) {
+    if (!(a instanceof Set) || !(b instanceof Set)) {
+      return false;
+    }
+    if (a.size !== b.size) {
+      return false;
+    }
+    return deepEqual(Array.from(a.values()), Array.from(b.values()));
+  }
+
   // Handle MongooseNumbers
   if (a instanceof Number && b instanceof Number) {
     return a.valueOf() === b.valueOf();
@@ -313,8 +323,8 @@ exports.merge = function merge(to, from, options, path) {
         // 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 (options.isDiscriminatorSchemaMerge &&
-            (from[key].$isSingleNested && to[key].$isMongooseDocumentArray) ||
-            (from[key].$isMongooseDocumentArray && to[key].$isSingleNested)) {
+            ((from[key].$isSingleNested && to[key].$isMongooseDocumentArray) ||
+            (from[key].$isMongooseDocumentArray && to[key].$isSingleNested))) {
           continue;
         } else if (from[key].instanceOfSchema) {
           if (to[key].instanceOfSchema) {

package/lib/validOptions.js

@@ -32,6 +32,7 @@ const VALID_OPTIONS = Object.freeze([
   'strict',
   'strictPopulate',
   'strictQuery',
+  'strictRead',
   'timestamps.createdAt.immutable',
   'toJSON',
   'toObject',