@depup/mongoose 9.1.3-depup.0

package/lib/stateMachine.js

@@ -0,0 +1,232 @@
+
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const utils = require('./utils'); // eslint-disable-line no-unused-vars
+
+/**
+ * StateMachine represents a minimal `interface` for the
+ * constructors it builds via StateMachine.ctor(...).
+ *
+ * @api private
+ */
+
+const StateMachine = module.exports = exports = function StateMachine() {
+};
+
+/**
+ * StateMachine.ctor('state1', 'state2', ...)
+ * A factory method for subclassing StateMachine.
+ * The arguments are a list of states. For each state,
+ * the constructor's prototype gets state transition
+ * methods named after each state. These transition methods
+ * place their path argument into the given state.
+ *
+ * @param {String} state
+ * @param {String} [state]
+ * @return {Function} subclass constructor
+ * @api private
+ */
+
+StateMachine.ctor = function() {
+  const states = [...arguments];
+
+  const ctor = function() {
+    StateMachine.apply(this, arguments);
+    this.paths = {};
+    this.states = {};
+  };
+
+  ctor.prototype = new StateMachine();
+  ctor.prototype.constructor = ctor;
+
+  ctor.prototype.stateNames = states;
+
+  states.forEach(function(state) {
+    // Changes the `path`'s state to `state`.
+    ctor.prototype[state] = function(path) {
+      this._changeState(path, state);
+    };
+  });
+
+  return ctor;
+};
+
+/**
+ * This function is wrapped by the state change functions:
+ *
+ * - `require(path)`
+ * - `modify(path)`
+ * - `init(path)`
+ *
+ * @api private
+ */
+
+StateMachine.prototype._changeState = function _changeState(path, nextState) {
+  const prevState = this.paths[path];
+  if (prevState === nextState) {
+    return;
+  }
+  const prevBucket = this.states[prevState];
+  if (prevBucket) delete prevBucket[path];
+
+  this.paths[path] = nextState;
+  this.states[nextState] = this.states[nextState] || {};
+  this.states[nextState][path] = true;
+};
+
+/*!
+ * ignore
+ */
+
+StateMachine.prototype.clear = function clear(state) {
+  if (this.states[state] == null) {
+    return;
+  }
+  const keys = Object.keys(this.states[state]);
+  let i = keys.length;
+  let path;
+
+  while (i--) {
+    path = keys[i];
+    delete this.states[state][path];
+    delete this.paths[path];
+  }
+};
+
+/*!
+ * ignore
+ */
+
+StateMachine.prototype.clearPath = function clearPath(path) {
+  const state = this.paths[path];
+  if (!state) {
+    return;
+  }
+  delete this.paths[path];
+  delete this.states[state][path];
+};
+
+/**
+ * Gets the paths for the given state, or empty object `{}` if none.
+ * @api private
+ */
+
+StateMachine.prototype.getStatePaths = function getStatePaths(state) {
+  if (this.states[state] != null) {
+    return this.states[state];
+  }
+  return {};
+};
+
+/**
+ * Checks to see if at least one path is in the states passed in via `arguments`
+ * e.g., this.some('required', 'inited')
+ *
+ * @param {String} state that we want to check for.
+ * @api private
+ */
+
+StateMachine.prototype.some = function some() {
+  const _this = this;
+  const what = arguments.length ? arguments : this.stateNames;
+  return Array.prototype.some.call(what, function(state) {
+    if (_this.states[state] == null) {
+      return false;
+    }
+    return Object.keys(_this.states[state]).length;
+  });
+};
+
+/**
+ * This function builds the functions that get assigned to `forEach` and `map`,
+ * since both of those methods share a lot of the same logic.
+ *
+ * @param {String} iterMethod is either 'forEach' or 'map'
+ * @return {Function}
+ * @api private
+ */
+
+StateMachine.prototype._iter = function _iter(iterMethod) {
+  return function() {
+    let states = [...arguments];
+    const callback = states.pop();
+
+    if (!states.length) states = this.stateNames;
+
+    const _this = this;
+
+    const paths = states.reduce(function(paths, state) {
+      if (_this.states[state] == null) {
+        return paths;
+      }
+      return paths.concat(Object.keys(_this.states[state]));
+    }, []);
+
+    return paths[iterMethod](function(path, i, paths) {
+      return callback(path, i, paths);
+    });
+  };
+};
+
+/**
+ * Iterates over the paths that belong to one of the parameter states.
+ *
+ * The function profile can look like:
+ * this.forEach(state1, fn);         // iterates over all paths in state1
+ * this.forEach(state1, state2, fn); // iterates over all paths in state1 or state2
+ * this.forEach(fn);                 // iterates over all paths in all states
+ *
+ * @param {String} [state]
+ * @param {String} [state]
+ * @param {Function} callback
+ * @api private
+ */
+
+StateMachine.prototype.forEach = function forEach() {
+  this.forEach = this._iter('forEach');
+  return this.forEach.apply(this, arguments);
+};
+
+/**
+ * Maps over the paths that belong to one of the parameter states.
+ *
+ * The function profile can look like:
+ * this.forEach(state1, fn);         // iterates over all paths in state1
+ * this.forEach(state1, state2, fn); // iterates over all paths in state1 or state2
+ * this.forEach(fn);                 // iterates over all paths in all states
+ *
+ * @param {String} [state]
+ * @param {String} [state]
+ * @param {Function} callback
+ * @return {Array}
+ * @api private
+ */
+
+StateMachine.prototype.map = function map() {
+  this.map = this._iter('map');
+  return this.map.apply(this, arguments);
+};
+
+/**
+ * Returns a copy of this state machine
+ *
+ * @param {Function} callback
+ * @return {StateMachine}
+ * @api private
+ */
+
+StateMachine.prototype.clone = function clone() {
+  const result = new this.constructor();
+  result.paths = { ...this.paths };
+  for (const state of this.stateNames) {
+    if (!(state in this.states)) {
+      continue;
+    }
+    result.states[state] = this.states[state] == null ? this.states[state] : { ...this.states[state] };
+  }
+  return result;
+};

package/lib/types/array/index.js

@@ -0,0 +1,119 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const mongooseArrayMethods = require('./methods');
+
+const arrayAtomicsSymbol = require('../../helpers/symbols').arrayAtomicsSymbol;
+const arrayAtomicsBackupSymbol = require('../../helpers/symbols').arrayAtomicsBackupSymbol;
+const arrayParentSymbol = require('../../helpers/symbols').arrayParentSymbol;
+const arrayPathSymbol = require('../../helpers/symbols').arrayPathSymbol;
+const arraySchemaSymbol = require('../../helpers/symbols').arraySchemaSymbol;
+
+/**
+ * Mongoose Array constructor.
+ *
+ * #### Note:
+ *
+ * _Values always have to be passed to the constructor to initialize, otherwise `MongooseArray#push` will mark the array as modified._
+ *
+ * @param {Array} values
+ * @param {String} path
+ * @param {Document} doc parent document
+ * @api private
+ * @inherits Array https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+ * @see https://bit.ly/f6CnZU
+ */
+const _basePush = Array.prototype.push;
+const numberRE = /^\d+$/;
+
+function MongooseArray(values, path, doc, schematype) {
+  let __array;
+
+  if (Array.isArray(values)) {
+    const len = values.length;
+
+    // Perf optimizations for small arrays: much faster to use `...` than `for` + `push`,
+    // but large arrays may cause stack overflows. And for arrays of length 0/1, just
+    // modifying the array is faster. Seems small, but adds up when you have a document
+    // with thousands of nested arrays.
+    if (len === 0) {
+      __array = new Array();
+    } else if (len === 1) {
+      __array = new Array(1);
+      __array[0] = values[0];
+    } else if (len < 10000) {
+      __array = new Array();
+      _basePush.apply(__array, values);
+    } else {
+      __array = new Array();
+      for (let i = 0; i < len; ++i) {
+        _basePush.call(__array, values[i]);
+      }
+    }
+  } else {
+    __array = [];
+  }
+
+  const internals = {
+    [arrayAtomicsSymbol]: {},
+    [arrayAtomicsBackupSymbol]: void 0,
+    [arrayPathSymbol]: path,
+    [arraySchemaSymbol]: schematype,
+    [arrayParentSymbol]: void 0,
+    isMongooseArray: true,
+    isMongooseArrayProxy: true,
+    __array: __array
+  };
+
+  if (values && values[arrayAtomicsSymbol] != null) {
+    internals[arrayAtomicsSymbol] = values[arrayAtomicsSymbol];
+  }
+
+  if (doc?.$__) {
+    internals[arrayParentSymbol] = doc;
+    internals[arraySchemaSymbol] = schematype || doc.schema.path(path);
+  }
+
+  const proxy = new Proxy(__array, {
+    get: function(target, prop) {
+      if (Object.hasOwn(internals, prop)) {
+        return internals[prop];
+      }
+      if (Object.hasOwn(mongooseArrayMethods, prop)) {
+        return mongooseArrayMethods[prop];
+      }
+      if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
+        return schematype.virtuals[prop].applyGetters(undefined, target);
+      }
+      if (typeof prop === 'string' && numberRE.test(prop) && schematype?.embeddedSchemaType != null) {
+        return schematype.embeddedSchemaType.applyGetters(__array[prop], doc);
+      }
+
+      return __array[prop];
+    },
+    set: function(target, prop, value) {
+      if (typeof prop === 'string' && numberRE.test(prop)) {
+        mongooseArrayMethods.set.call(proxy, prop, value, false);
+      } else if (Object.hasOwn(internals, prop)) {
+        internals[prop] = value;
+      } else if (schematype?.virtuals && Object.hasOwn(schematype.virtuals, prop)) {
+        schematype.virtuals[prop].applySetters(value, target);
+      } else {
+        __array[prop] = value;
+      }
+
+      return true;
+    }
+  });
+
+  return proxy;
+}
+
+/*!
+ * Module exports.
+ */
+
+module.exports = exports = MongooseArray;

package/lib/types/array/isMongooseArray.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.isMongooseArray = function(mongooseArray) {
+  return Array.isArray(mongooseArray) && mongooseArray.isMongooseArray;
+};