@depup/mongoose 9.1.3-depup.0

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

@@ -0,0 +1,415 @@
+'use strict';
+
+const ArrayMethods = require('../../array/methods');
+const Document = require('../../../document');
+const getDiscriminatorByValue = require('../../../helpers/discriminator/getDiscriminatorByValue');
+const internalToObjectOptions = require('../../../options').internalToObjectOptions;
+const utils = require('../../../utils');
+const isBsonType = require('../../../helpers/isBsonType');
+
+const arrayParentSymbol = require('../../../helpers/symbols').arrayParentSymbol;
+const arrayPathSymbol = require('../../../helpers/symbols').arrayPathSymbol;
+const arraySchemaSymbol = require('../../../helpers/symbols').arraySchemaSymbol;
+const documentArrayParent = require('../../../helpers/symbols').documentArrayParent;
+
+const _baseToString = Array.prototype.toString;
+
+const methods = {
+  /*!
+   * ignore
+   */
+
+  toBSON() {
+    return this.toObject(internalToObjectOptions);
+  },
+
+  toString() {
+    return _baseToString.call(this.__array.map(subdoc => {
+      if (subdoc?.$__ != null) {
+        return subdoc.toString();
+      }
+      return subdoc;
+    }));
+  },
+
+  /*!
+   * ignore
+   */
+
+  getArrayParent() {
+    return this[arrayParentSymbol];
+  },
+
+  /*!
+   * ignore
+   */
+  $schemaType() {
+    return this[arraySchemaSymbol];
+  },
+
+  /**
+   * Overrides MongooseArray#cast
+   *
+   * @method _cast
+   * @api private
+   * @memberOf MongooseDocumentArray
+   */
+
+  _cast(value, index, options) {
+    if (this[arraySchemaSymbol] == null) {
+      return value;
+    }
+    let Constructor = this[arraySchemaSymbol].Constructor;
+    const isInstance = Constructor.$isMongooseDocumentArray ?
+      utils.isMongooseDocumentArray(value) :
+      value instanceof Constructor;
+    if (isInstance ||
+        // Hack re: #5001, see #5005
+        value?.constructor?.baseCasterConstructor === Constructor) {
+      if (!(value[documentArrayParent] && value.__parentArray)) {
+        // value may have been created using array.create()
+        value[documentArrayParent] = this[arrayParentSymbol];
+        value.__parentArray = this;
+      }
+      value.$setIndex(index);
+      return value;
+    }
+
+    if (value == null) {
+      return null;
+    }
+
+    // handle cast('string') or cast(ObjectId) etc.
+    // only objects are permitted so we can safely assume that
+    // non-objects are to be interpreted as _id
+    if (Buffer.isBuffer(value) ||
+        isBsonType(value, 'ObjectId') || !utils.isObject(value)) {
+      value = { _id: value };
+    }
+
+    if (value &&
+        Constructor.discriminators &&
+        Constructor.schema &&
+        Constructor.schema.options &&
+        Constructor.schema.options.discriminatorKey) {
+      if (typeof value[Constructor.schema.options.discriminatorKey] === 'string' &&
+          Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]]) {
+        Constructor = Constructor.discriminators[value[Constructor.schema.options.discriminatorKey]];
+      } else {
+        const constructorByValue = getDiscriminatorByValue(Constructor.discriminators, value[Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
+    }
+
+    if (Constructor.$isMongooseDocumentArray) {
+      return Constructor.cast(value, this, undefined, undefined, index);
+    }
+    const ret = new Constructor(value, this, options, undefined, index);
+    ret.isNew = true;
+    return ret;
+  },
+
+  /**
+   * Searches array items for the first document with a matching _id.
+   *
+   * #### Example:
+   *
+   *     const embeddedDoc = m.array.id(some_id);
+   *
+   * @return {EmbeddedDocument|null} the subdocument or null if not found.
+   * @param {ObjectId|String|Number|Buffer} id
+   * @method id
+   * @api public
+   * @memberOf MongooseDocumentArray
+   */
+
+  id(id) {
+    if (id == null) {
+      return null;
+    }
+
+    const schemaType = this[arraySchemaSymbol];
+    let idSchemaType = null;
+
+    if (schemaType?.schema) {
+      idSchemaType = schemaType.schema.path('_id');
+    } else if (schemaType?.casterConstructor?.schema) {
+      idSchemaType = schemaType.casterConstructor.schema.path('_id');
+    }
+
+    let castedId = null;
+    if (idSchemaType) {
+      try {
+        castedId = idSchemaType.cast(id);
+      } catch {
+        // ignore error
+      }
+    }
+
+    let _id;
+
+    for (const val of this) {
+      if (!val) {
+        continue;
+      }
+
+      _id = val.get('_id');
+
+      if (_id == null) {
+        continue;
+      } else if (_id instanceof Document) {
+        _id = _id.get('_id');
+        if (castedId != null && utils.deepEqual(castedId, _id)) {
+          return val;
+        } else if (castedId == null && (id == _id || utils.deepEqual(id, _id))) {
+          // Backwards compat: compare user-specified param to _id using loose equality
+          return val;
+        }
+      } else if (castedId != null && utils.deepEqual(castedId, _id)) {
+        return val;
+      } else if (castedId == null && (_id == id || utils.deepEqual(id, _id))) {
+        // Backwards compat: compare user-specified param to _id using loose equality
+        return val;
+      }
+    }
+
+    return null;
+  },
+
+  /**
+   * Returns a native js Array of plain js objects
+   *
+   * #### Note:
+   *
+   * _Each sub-document is converted to a plain object by calling its `#toObject` method._
+   *
+   * @param {Object} [options] optional options to pass to each documents `toObject` method call during conversion
+   * @return {Array}
+   * @method toObject
+   * @api public
+   * @memberOf MongooseDocumentArray
+   */
+
+  toObject(options) {
+    // `[].concat` coerces the return value into a vanilla JS array, rather
+    // than a Mongoose array.
+    return [].concat(this.map(function(doc) {
+      if (doc == null) {
+        return null;
+      }
+      if (typeof doc.toObject !== 'function') {
+        return doc;
+      }
+      return doc.toObject(options);
+    }));
+  },
+
+  $toObject() {
+    return this.constructor.prototype.toObject.apply(this, arguments);
+  },
+
+  /**
+   * Wraps [`Array#push`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/push) with proper change tracking.
+   *
+   * @param {...Object} [args]
+   * @api public
+   * @method push
+   * @memberOf MongooseDocumentArray
+   */
+
+  push() {
+    const ret = ArrayMethods.push.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Pulls items from the array atomically.
+   *
+   * @param {...Object} [args]
+   * @api public
+   * @method pull
+   * @memberOf MongooseDocumentArray
+   */
+
+  pull() {
+    const ret = ArrayMethods.pull.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#shift`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/unshift) with proper change tracking.
+   * @api private
+   */
+
+  shift() {
+    const ret = ArrayMethods.shift.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Wraps [`Array#splice`](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice) with proper change tracking and casting.
+   * @api private
+   */
+
+  splice() {
+    const ret = ArrayMethods.splice.apply(this, arguments);
+
+    _updateParentPopulated(this);
+
+    return ret;
+  },
+
+  /**
+   * Helper for console.log
+   *
+   * @method inspect
+   * @api public
+   * @memberOf MongooseDocumentArray
+   */
+
+  inspect() {
+    return this.toObject();
+  },
+
+  /**
+   * Creates a subdocument casted to this schema.
+   *
+   * This is the same subdocument constructor used for casting.
+   *
+   * @param {Object} obj the value to cast to this arrays SubDocument schema
+   * @method create
+   * @api public
+   * @memberOf MongooseDocumentArray
+   */
+
+  create(obj) {
+    let Constructor = this[arraySchemaSymbol].Constructor;
+    if (obj &&
+        Constructor.discriminators &&
+        Constructor.schema &&
+        Constructor.schema.options &&
+        Constructor.schema.options.discriminatorKey) {
+      if (typeof obj[Constructor.schema.options.discriminatorKey] === 'string' &&
+          Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]]) {
+        Constructor = Constructor.discriminators[obj[Constructor.schema.options.discriminatorKey]];
+      } else {
+        const constructorByValue = getDiscriminatorByValue(Constructor.discriminators, obj[Constructor.schema.options.discriminatorKey]);
+        if (constructorByValue) {
+          Constructor = constructorByValue;
+        }
+      }
+    }
+
+    return new Constructor(obj, this);
+  },
+
+  /*!
+   * ignore
+   */
+
+  notify(event) {
+    const _this = this;
+    return function notify(val, _arr) {
+      _arr = _arr || _this;
+      let i = _arr.length;
+      while (i--) {
+        if (_arr[i] == null) {
+          continue;
+        }
+        switch (event) {
+          // only swap for save event for now, we may change this to all event types later
+          case 'save':
+            val = _this[i];
+            break;
+          default:
+            // NO-OP
+            break;
+        }
+
+        if (utils.isMongooseArray(_arr[i])) {
+          notify(val, _arr[i]);
+        } else if (_arr[i]) {
+          _arr[i].emit(event, val);
+        }
+      }
+    };
+  },
+
+  set(i, val, skipModified) {
+    const arr = this.__array;
+    if (skipModified) {
+      arr[i] = val;
+      return this;
+    }
+    const value = methods._cast.call(this, val, i);
+    methods._markModified.call(this, i);
+    arr[i] = value;
+    return this;
+  },
+
+  _markModified(elem, embeddedPath) {
+    const parent = this[arrayParentSymbol];
+    let dirtyPath;
+
+    if (parent) {
+      dirtyPath = this[arrayPathSymbol];
+
+      if (arguments.length) {
+        if (embeddedPath != null) {
+          // an embedded doc bubbled up the change
+          const index = elem.__index;
+          dirtyPath = dirtyPath + '.' + index + '.' + embeddedPath;
+        } else {
+          // directly set an index
+          dirtyPath = dirtyPath + '.' + elem;
+        }
+      }
+
+      if (dirtyPath != null && dirtyPath.endsWith('.$')) {
+        return this;
+      }
+
+      parent.markModified(dirtyPath, arguments.length !== 0 ? elem : parent);
+    }
+
+    return this;
+  }
+};
+
+module.exports = methods;
+
+/**
+ * If this is a document array, each element may contain single
+ * populated paths, so we need to modify the top-level document's
+ * populated cache. See gh-8247, gh-8265.
+ * @param {Array} arr
+ * @api private
+ */
+
+function _updateParentPopulated(arr) {
+  const parent = arr[arrayParentSymbol];
+  if (!parent || parent.$__.populated == null) return;
+
+  const populatedPaths = Object.keys(parent.$__.populated).
+    filter(p => p.startsWith(arr[arrayPathSymbol] + '.'));
+
+  for (const path of populatedPaths) {
+    const remnant = path.slice((arr[arrayPathSymbol] + '.').length);
+    if (!Array.isArray(parent.$__.populated[path].value)) {
+      continue;
+    }
+
+    parent.$__.populated[path].value = arr.map(val => val.$populated(remnant));
+  }
+}

package/lib/types/double.js

@@ -0,0 +1,13 @@
+/**
+ * Double type constructor
+ *
+ * #### Example:
+ *
+ *     const pi = new mongoose.Types.Double(3.1415);
+ *
+ * @constructor Double
+ */
+
+'use strict';
+
+module.exports = require('mongodb/lib/bson').Double;

package/lib/types/index.js

@@ -0,0 +1,23 @@
+
+/*!
+ * Module exports.
+ */
+
+'use strict';
+
+exports.Array = require('./array');
+exports.Buffer = require('./buffer');
+
+exports.Document = // @deprecate
+exports.Embedded = require('./arraySubdocument');
+
+exports.DocumentArray = require('./documentArray');
+exports.Double = require('./double');
+exports.Decimal128 = require('./decimal128');
+exports.ObjectId = require('./objectid');
+
+exports.Map = require('./map');
+
+exports.Subdocument = require('./subdocument');
+
+exports.UUID = require('./uuid');