create-mern-omar 1.0.0 → 1.1.0

package/templates/node_modules/mongoose/lib/helpers/schema/getKeysInSchemaOrder.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const get = require('../get');
+
+module.exports = function getKeysInSchemaOrder(schema, val, path) {
+  const schemaKeys = path != null ? Object.keys(get(schema.tree, path, {})) : Object.keys(schema.tree);
+  const valKeys = new Set(Object.keys(val));
+
+  let keys;
+  if (valKeys.size > 1) {
+    keys = new Set();
+    for (const key of schemaKeys) {
+      if (valKeys.has(key)) {
+        keys.add(key);
+      }
+    }
+    for (const key of valKeys) {
+      if (!keys.has(key)) {
+        keys.add(key);
+      }
+    }
+    keys = Array.from(keys);
+  } else {
+    keys = Array.from(valKeys);
+  }
+
+  return keys;
+};

package/templates/node_modules/mongoose/lib/helpers/schema/getPath.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const numberRE = /^\d+$/;
+
+/**
+ * Behaves like `Schema#path()`, except for it also digs into arrays without
+ * needing to put `.0.`, so `getPath(schema, 'docArr.elProp')` works.
+ * @api private
+ */
+
+module.exports = function getPath(schema, path, discriminatorValueMap) {
+  let schematype = schema.path(path);
+  if (schematype != null) {
+    return schematype;
+  }
+  const pieces = path.split('.');
+  let cur = '';
+  let isArray = false;
+
+  for (const piece of pieces) {
+    if (isArray && numberRE.test(piece)) {
+      continue;
+    }
+    cur = cur.length === 0 ? piece : cur + '.' + piece;
+
+    schematype = schema.path(cur);
+    if (schematype?.schema) {
+      schema = schematype.schema;
+      if (!isArray && schematype.$isMongooseDocumentArray) {
+        isArray = true;
+      }
+      if (discriminatorValueMap && discriminatorValueMap[cur]) {
+        schema = schema.discriminators[discriminatorValueMap[cur]] ?? schema;
+      }
+      cur = '';
+    } else if (schematype?.instance === 'Mixed') {
+      // If we found a mixed path, no point in digging further, the end result is always Mixed
+      break;
+    }
+  }
+
+  return schematype;
+};

package/templates/node_modules/mongoose/lib/helpers/schema/getSubdocumentStrictValue.js

@@ -0,0 +1,32 @@
+'use strict';
+
+/**
+ * Find the `strict` mode setting for the deepest subdocument along a given path
+ * to ensure we have the correct default value for `strict`. When setting values
+ * underneath a subdocument, we should use the subdocument's `strict` setting by
+ * default, not the top-level document's.
+ *
+ * @param {Schema} schema
+ * @param {String[]} parts
+ * @returns {boolean | 'throw' | undefined}
+ */
+
+module.exports = function getSubdocumentStrictValue(schema, parts) {
+  if (parts.length === 1) {
+    return undefined;
+  }
+  let cur = parts[0];
+  let strict = undefined;
+  for (let i = 0; i < parts.length - 1; ++i) {
+    const curSchemaType = schema.path(cur);
+    if (curSchemaType && curSchemaType.schema) {
+      strict = curSchemaType.schema.options.strict;
+      schema = curSchemaType.schema;
+      cur = curSchemaType.$isMongooseDocumentArray && !isNaN(parts[i + 1]) ? '' : parts[i + 1];
+    } else {
+      cur += cur.length ? ('.' + parts[i + 1]) : parts[i + 1];
+    }
+  }
+
+  return strict;
+};

package/templates/node_modules/mongoose/lib/helpers/schema/handleIdOption.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const addAutoId = require('./addAutoId');
+
+module.exports = function handleIdOption(schema, options) {
+  if (options == null || options._id == null) {
+    return schema;
+  }
+
+  schema = schema.clone();
+  if (!options._id) {
+    schema.remove('_id');
+    schema.options._id = false;
+  } else if (!schema.paths['_id']) {
+    addAutoId(schema);
+    schema.options._id = true;
+  }
+
+  return schema;
+};

package/templates/node_modules/mongoose/lib/helpers/schema/handleTimestampOption.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = handleTimestampOption;
+
+/*!
+ * ignore
+ */
+
+function handleTimestampOption(arg, prop) {
+  if (arg == null) {
+    return null;
+  }
+
+  if (typeof arg === 'boolean') {
+    return prop;
+  }
+  if (typeof arg[prop] === 'boolean') {
+    return arg[prop] ? prop : null;
+  }
+  if (!(prop in arg)) {
+    return prop;
+  }
+  return arg[prop];
+}

package/templates/node_modules/mongoose/lib/helpers/schema/idGetter.js

@@ -0,0 +1,34 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function addIdGetter(schema) {
+  // ensure the documents receive an id getter unless disabled
+  const autoIdGetter = !schema.paths['id'] &&
+    schema.paths['_id'] &&
+    schema.options.id;
+  if (!autoIdGetter) {
+    return schema;
+  }
+  if (schema.aliases && schema.aliases.id) {
+    return schema;
+  }
+  schema.virtual('id').get(idGetter);
+
+  return schema;
+};
+
+/**
+ * Returns this documents _id cast to a string.
+ * @api private
+ */
+
+function idGetter() {
+  if (this._id != null) {
+    return this._id.toString();
+  }
+
+  return null;
+}

package/templates/node_modules/mongoose/lib/helpers/schema/merge.js

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports = function merge(s1, s2, skipConflictingPaths) {
+  const paths = Object.keys(s2.tree);
+  const pathsToAdd = {};
+  for (const key of paths) {
+    if (skipConflictingPaths && (s1.paths[key] || s1.nested[key] || s1.singleNestedPaths[key])) {
+      continue;
+    }
+    pathsToAdd[key] = s2.tree[key];
+  }
+  s1.options._isMerging = true;
+  s1.add(pathsToAdd, null);
+  delete s1.options._isMerging;
+
+  s1.callQueue = s1.callQueue.concat(s2.callQueue);
+  s1.method(s2.methods);
+  s1.static(s2.statics);
+
+  for (const [option, value] of Object.entries(s2._userProvidedOptions)) {
+    if (!(option in s1._userProvidedOptions)) {
+      s1.set(option, value);
+    }
+  }
+
+  for (const query in s2.query) {
+    s1.query[query] = s2.query[query];
+  }
+
+  for (const virtual in s2.virtuals) {
+    s1.virtuals[virtual] = s2.virtuals[virtual].clone();
+  }
+
+  s1._indexes = s1._indexes.concat(s2._indexes || []);
+  s1.s.hooks.merge(s2.s.hooks, false);
+};

package/templates/node_modules/mongoose/lib/helpers/schematype/handleImmutable.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const StrictModeError = require('../../error/strict');
+
+/*!
+ * ignore
+ */
+
+module.exports = function(schematype) {
+  if (schematype.$immutable) {
+    schematype.$immutableSetter = createImmutableSetter(schematype.path,
+      schematype.options.immutable);
+    schematype.set(schematype.$immutableSetter);
+  } else if (schematype.$immutableSetter) {
+    schematype.setters = schematype.setters.
+      filter(fn => fn !== schematype.$immutableSetter);
+    delete schematype.$immutableSetter;
+  }
+};
+
+function createImmutableSetter(path, immutable) {
+  return function immutableSetter(v, _priorVal, _doc, options) {
+    if (this == null || this.$__ == null) {
+      return v;
+    }
+    if (this.isNew) {
+      return v;
+    }
+    if (options && options.overwriteImmutable) {
+      return v;
+    }
+
+    const _immutable = typeof immutable === 'function' ?
+      immutable.call(this, this) :
+      immutable;
+    if (!_immutable) {
+      return v;
+    }
+
+    const _value = this.$__.priorDoc != null ?
+      this.$__.priorDoc.$__getValue(path) :
+      this.$__getValue(path);
+    if (this.$__.strictMode === 'throw' && v !== _value) {
+      throw new StrictModeError(path, 'Path `' + path + '` is immutable ' +
+        'and strict mode is set to throw.', true);
+    }
+
+    return _value;
+  };
+}

package/templates/node_modules/mongoose/lib/helpers/setDefaultsOnInsert.js

@@ -0,0 +1,161 @@
+'use strict';
+const get = require('./get');
+
+/**
+ * Applies defaults to update and findOneAndUpdate operations.
+ *
+ * @param {Object} filter
+ * @param {Schema} schema
+ * @param {Object} castedDoc
+ * @param {Object} options
+ * @method setDefaultsOnInsert
+ * @api private
+ */
+
+module.exports = function(filter, schema, castedDoc, options) {
+  options = options || {};
+
+  const shouldSetDefaultsOnInsert =
+    options.setDefaultsOnInsert != null ?
+      options.setDefaultsOnInsert :
+      schema.base.options.setDefaultsOnInsert;
+
+  if (!options.upsert || shouldSetDefaultsOnInsert === false) {
+    return castedDoc;
+  }
+
+  const keys = Object.keys(castedDoc || {});
+  const updatedKeys = {};
+  const updatedValues = {};
+  const numKeys = keys.length;
+
+  let hasDollarUpdate = false;
+
+  for (let i = 0; i < numKeys; ++i) {
+    if (keys[i].charAt(0) === '$') {
+      hasDollarUpdate = true;
+      break;
+    }
+  }
+
+  const paths = Object.keys(filter);
+  const numPaths = paths.length;
+  for (let i = 0; i < numPaths; ++i) {
+    const path = paths[i];
+    const condition = filter[path];
+    if (condition && typeof condition === 'object') {
+      const conditionKeys = Object.keys(condition);
+      const numConditionKeys = conditionKeys.length;
+      let hasDollarKey = false;
+      for (let j = 0; j < numConditionKeys; ++j) {
+        if (conditionKeys[j].charAt(0) === '$') {
+          hasDollarKey = true;
+          break;
+        }
+      }
+      if (hasDollarKey) {
+        continue;
+      }
+    }
+    updatedKeys[path] = true;
+  }
+
+  if (options && options.overwrite && !hasDollarUpdate) {
+    // Defaults will be set later, since we're overwriting we'll cast
+    // the whole update to a document
+    return castedDoc;
+  }
+
+  schema.eachPath(function(path, schemaType) {
+    // Skip single nested paths if underneath a map
+    if (schemaType.path === '_id' && schemaType.options.auto) {
+      return;
+    }
+    const def = schemaType.getDefault(null, true);
+    if (typeof def === 'undefined') {
+      return;
+    }
+    const pathPieces = schemaType.splitPath();
+    if (pathPieces.includes('$*')) {
+      // Skip defaults underneath maps. We should never do `$setOnInsert` on a path with `$*`
+      return;
+    }
+    if (isModified(castedDoc, updatedKeys, path, pathPieces, hasDollarUpdate)) {
+      return;
+    }
+
+    castedDoc = castedDoc || {};
+    castedDoc.$setOnInsert = castedDoc.$setOnInsert || {};
+    if (get(castedDoc, path) == null) {
+      castedDoc.$setOnInsert[path] = def;
+    }
+    updatedValues[path] = def;
+  });
+
+  return castedDoc;
+};
+
+function isModified(castedDoc, updatedKeys, path, pathPieces, hasDollarUpdate) {
+  // Check if path is in filter (updatedKeys)
+  if (updatedKeys[path]) {
+    return true;
+  }
+
+  // Check if any parent path is in filter
+  let cur = pathPieces[0];
+  for (let i = 1; i < pathPieces.length; ++i) {
+    if (updatedKeys[cur]) {
+      return true;
+    }
+    cur += '.' + pathPieces[i];
+  }
+
+  // Check if path is modified in the update
+  if (hasDollarUpdate) {
+    // Check each update operator
+    for (const key in castedDoc) {
+      if (key.charAt(0) === '$') {
+        if (pathExistsInUpdate(castedDoc[key], path, pathPieces)) {
+          return true;
+        }
+      }
+    }
+  } else {
+    // No dollar operators, check the castedDoc directly
+    if (pathExistsInUpdate(castedDoc, path, pathPieces)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function pathExistsInUpdate(update, targetPath, pathPieces) {
+  if (update == null || typeof update !== 'object') {
+    return false;
+  }
+
+  // Check exact match
+  if (Object.hasOwn(update, targetPath)) {
+    return true;
+  }
+
+  // Check if any parent path exists
+  let cur = pathPieces[0];
+  for (let i = 1; i < pathPieces.length; ++i) {
+    if (Object.hasOwn(update, cur)) {
+      return true;
+    }
+    cur += '.' + pathPieces[i];
+  }
+
+  // Check if any child path exists (e.g., path is "a" and update has "a.b")
+  const prefix = targetPath + '.';
+  for (const key in update) {
+    if (key.startsWith(prefix)) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/templates/node_modules/mongoose/lib/helpers/specialProperties.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = new Set(['__proto__', 'constructor', 'prototype']);

package/templates/node_modules/mongoose/lib/helpers/symbols.js

@@ -0,0 +1,20 @@
+'use strict';
+
+exports.arrayAtomicsBackupSymbol = Symbol('mongoose#Array#atomicsBackup');
+exports.arrayAtomicsSymbol = Symbol('mongoose#Array#_atomics');
+exports.arrayParentSymbol = Symbol('mongoose#Array#_parent');
+exports.arrayPathSymbol = Symbol('mongoose#Array#_path');
+exports.arraySchemaSymbol = Symbol('mongoose#Array#_schema');
+exports.documentArrayParent = Symbol('mongoose#documentArrayParent');
+exports.documentIsSelected = Symbol('mongoose#Document#isSelected');
+exports.documentIsModified = Symbol('mongoose#Document#isModified');
+exports.documentModifiedPaths = Symbol('mongoose#Document#modifiedPaths');
+exports.documentSchemaSymbol = Symbol('mongoose#Document#schema');
+exports.getSymbol = Symbol('mongoose#Document#get');
+exports.modelSymbol = Symbol('mongoose#Model');
+exports.objectIdSymbol = Symbol('mongoose#ObjectId');
+exports.populateModelSymbol = Symbol('mongoose#PopulateOptions#Model');
+exports.schemaTypeSymbol = Symbol('mongoose#schemaType');
+exports.sessionNewDocuments = Symbol('mongoose#ClientSession#newDocuments');
+exports.scopeSymbol = Symbol('mongoose#Document#scope');
+exports.validatorErrorSymbol = Symbol('mongoose#validatorError');

package/templates/node_modules/mongoose/lib/helpers/timers.js

@@ -0,0 +1,3 @@
+'use strict';
+
+exports.setTimeout = setTimeout;

package/templates/node_modules/mongoose/lib/helpers/timestamps/setDocumentTimestamps.js

@@ -0,0 +1,26 @@
+'use strict';
+
+module.exports = function setDocumentTimestamps(doc, timestampOption, currentTime, createdAt, updatedAt) {
+  const skipUpdatedAt = timestampOption != null && timestampOption.updatedAt === false;
+  const skipCreatedAt = timestampOption != null && timestampOption.createdAt === false;
+
+  const defaultTimestamp = currentTime != null ?
+    currentTime() :
+    doc.ownerDocument().constructor.base.now();
+
+  if (!skipCreatedAt &&
+      (doc.isNew || doc.$isSubdocument) &&
+      createdAt &&
+      !doc.$__getValue(createdAt) &&
+      doc.$__isSelected(createdAt)) {
+    doc.$set(createdAt, defaultTimestamp, undefined, { overwriteImmutable: true });
+  }
+
+  if (!skipUpdatedAt && updatedAt && (doc.isNew || doc.$isModified())) {
+    let ts = defaultTimestamp;
+    if (doc.isNew && createdAt != null) {
+      ts = doc.$__getValue(createdAt);
+    }
+    doc.$set(updatedAt, ts);
+  }
+};

package/templates/node_modules/mongoose/lib/helpers/timestamps/setupTimestamps.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const applyTimestampsToChildren = require('../update/applyTimestampsToChildren');
+const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
+const get = require('../get');
+const handleTimestampOption = require('../schema/handleTimestampOption');
+const setDocumentTimestamps = require('./setDocumentTimestamps');
+const symbols = require('../../schema/symbols');
+
+const replaceOps = new Set([
+  'replaceOne',
+  'findOneAndReplace'
+]);
+
+module.exports = function setupTimestamps(schema, timestamps) {
+  const childHasTimestamp = schema.childSchemas.find(withTimestamp);
+  function withTimestamp(s) {
+    const ts = s.schema.options.timestamps;
+    return !!ts;
+  }
+  if (!timestamps && !childHasTimestamp) {
+    return;
+  }
+  const createdAt = handleTimestampOption(timestamps, 'createdAt');
+  const updatedAt = handleTimestampOption(timestamps, 'updatedAt');
+  const currentTime = timestamps != null && Object.hasOwn(timestamps, 'currentTime') ?
+    timestamps.currentTime :
+    null;
+  const schemaAdditions = {};
+
+  schema.$timestamps = { createdAt: createdAt, updatedAt: updatedAt };
+
+  if (createdAt && !schema.paths[createdAt]) {
+    const baseImmutableCreatedAt = schema.base != null ? schema.base.get('timestamps.createdAt.immutable') : null;
+    const immutable = baseImmutableCreatedAt != null ? baseImmutableCreatedAt : true;
+    schemaAdditions[createdAt] = { [schema.options.typeKey || 'type']: Date, immutable };
+  }
+
+  if (updatedAt && !schema.paths[updatedAt]) {
+    schemaAdditions[updatedAt] = Date;
+  }
+
+  schema.add(schemaAdditions);
+
+  schema.pre('save', function timestampsPreSave() {
+    const timestampOption = get(this, '$__.saveOptions.timestamps');
+    if (timestampOption === false) {
+      return;
+    }
+
+    setDocumentTimestamps(this, timestampOption, currentTime, createdAt, updatedAt);
+  });
+
+  schema.methods.initializeTimestamps = function() {
+    const ts = currentTime != null ?
+      currentTime() : this.constructor.base.now();
+
+
+    if (createdAt && !this.get(createdAt)) {
+      this.$set(createdAt, ts);
+    }
+    if (updatedAt && !this.get(updatedAt)) {
+      this.$set(updatedAt, ts);
+    }
+    if (this.$isSubdocument) {
+      return this;
+    }
+
+    const subdocs = this.$getAllSubdocs();
+    for (const subdoc of subdocs) {
+      if (subdoc.initializeTimestamps) {
+        subdoc.initializeTimestamps();
+      }
+    }
+
+    return this;
+  };
+
+  _setTimestampsOnUpdate[symbols.builtInMiddleware] = true;
+
+  const opts = { query: true, model: false };
+  schema.pre('findOneAndReplace', opts, _setTimestampsOnUpdate);
+  schema.pre('findOneAndUpdate', opts, _setTimestampsOnUpdate);
+  schema.pre('replaceOne', opts, _setTimestampsOnUpdate);
+  schema.pre('update', opts, _setTimestampsOnUpdate);
+  schema.pre('updateOne', opts, _setTimestampsOnUpdate);
+  schema.pre('updateMany', opts, _setTimestampsOnUpdate);
+
+  function _setTimestampsOnUpdate() {
+    const now = currentTime != null ?
+      currentTime() :
+      this.model.base.now();
+    // Replacing with null update should still trigger timestamps
+    if (replaceOps.has(this.op) && this.getUpdate() == null) {
+      this.setUpdate({});
+    }
+    applyTimestampsToUpdate(
+      now,
+      createdAt,
+      updatedAt,
+      this.getUpdate(),
+      this._mongooseOptions,
+      replaceOps.has(this.op)
+    );
+    applyTimestampsToChildren(now, this.getUpdate(), this.model.schema);
+  }
+};

package/templates/node_modules/mongoose/lib/helpers/topology/allServersUnknown.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const getConstructorName = require('../getConstructorName');
+
+module.exports = function allServersUnknown(topologyDescription) {
+  if (getConstructorName(topologyDescription) !== 'TopologyDescription') {
+    return false;
+  }
+
+  const servers = Array.from(topologyDescription.servers.values());
+  return servers.length > 0 && servers.every(server => server.type === 'Unknown');
+};

package/templates/node_modules/mongoose/lib/helpers/topology/isAtlas.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const getConstructorName = require('../getConstructorName');
+
+/**
+ * @typedef { import('mongodb').TopologyDescription } TopologyDescription
+ */
+
+/**
+ * Checks if topologyDescription contains servers connected to an atlas instance
+ *
+ * @param  {TopologyDescription} topologyDescription
+ * @returns {boolean}
+ */
+module.exports = function isAtlas(topologyDescription) {
+  if (getConstructorName(topologyDescription) !== 'TopologyDescription') {
+    return false;
+  }
+
+  if (topologyDescription.servers.size === 0) {
+    return false;
+  }
+
+  for (const server of topologyDescription.servers.values()) {
+    if (server.host.endsWith('.mongodb.net') === false || server.port !== 27017) {
+      return false;
+    }
+  }
+
+  return true;
+};

package/templates/node_modules/mongoose/lib/helpers/topology/isSSLError.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const getConstructorName = require('../getConstructorName');
+
+const nonSSLMessage = 'Client network socket disconnected before secure TLS ' +
+  'connection was established';
+
+module.exports = function isSSLError(topologyDescription) {
+  if (getConstructorName(topologyDescription) !== 'TopologyDescription') {
+    return false;
+  }
+
+  const descriptions = Array.from(topologyDescription.servers.values());
+  return descriptions.length > 0 &&
+    descriptions.every(descr => descr.error && descr.error.message.indexOf(nonSSLMessage) !== -1);
+};