create-mern-omar 1.1.0 → 1.2.0

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

@@ -1,28 +0,0 @@
-'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

@@ -1,43 +0,0 @@
-'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

@@ -1,32 +0,0 @@
-'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

@@ -1,20 +0,0 @@
-'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

@@ -1,24 +0,0 @@
-'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

@@ -1,34 +0,0 @@
-'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

@@ -1,36 +0,0 @@
-'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

@@ -1,50 +0,0 @@
-'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

@@ -1,161 +0,0 @@
-'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

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

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

@@ -1,20 +0,0 @@
-'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

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

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

@@ -1,26 +0,0 @@
-'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

@@ -1,107 +0,0 @@
-'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

@@ -1,12 +0,0 @@
-'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

@@ -1,31 +0,0 @@
-'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

@@ -1,16 +0,0 @@
-'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);
-};