create-mern-omar 1.0.0 → 1.1.0

package/templates/node_modules/mongoose/lib/helpers/query/getEmbeddedDiscriminatorPath.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const cleanPositionalOperators = require('../schema/cleanPositionalOperators');
+const get = require('../get');
+const getDiscriminatorByValue = require('../discriminator/getDiscriminatorByValue');
+const updatedPathsByArrayFilter = require('../update/updatedPathsByArrayFilter');
+
+/**
+ * Like `schema.path()`, except with a document, because impossible to
+ * determine path type without knowing the embedded discriminator key.
+ * @param {Schema} schema
+ * @param {Object} [update]
+ * @param {Object} [filter]
+ * @param {String} path
+ * @param {Object} [options]
+ * @api private
+ */
+
+module.exports = function getEmbeddedDiscriminatorPath(schema, update, filter, path, options) {
+  const parts = path.indexOf('.') === -1 ? [path] : path.split('.');
+  let schematype = null;
+  let type = 'adhocOrUndefined';
+
+  filter = filter || {};
+  update = update || {};
+  const arrayFilters = options != null && Array.isArray(options.arrayFilters) ?
+    options.arrayFilters : [];
+  const updatedPathsByFilter = updatedPathsByArrayFilter(update);
+  let startIndex = 0;
+
+  for (let i = 0; i < parts.length; ++i) {
+    const originalSubpath = parts.slice(startIndex, i + 1).join('.');
+    const subpath = cleanPositionalOperators(originalSubpath);
+    schematype = schema.path(subpath);
+    if (schematype == null) {
+      continue;
+    }
+
+    type = schema.pathType(subpath);
+    if ((schematype.$isSingleNested || schematype.$isMongooseDocumentArrayElement) &&
+        schematype.schema.discriminators != null) {
+      const key = get(schematype, 'schema.options.discriminatorKey');
+      const discriminatorValuePath = subpath + '.' + key;
+      const discriminatorFilterPath =
+        discriminatorValuePath.replace(/\.\d+\./, '.');
+      let discriminatorKey = null;
+
+      if (discriminatorValuePath in filter) {
+        discriminatorKey = filter[discriminatorValuePath];
+      }
+      if (discriminatorFilterPath in filter) {
+        discriminatorKey = filter[discriminatorFilterPath];
+      }
+
+      const wrapperPath = subpath.replace(/\.\d+$/, '');
+      if (schematype.$isMongooseDocumentArrayElement &&
+          get(filter[wrapperPath], '$elemMatch.' + key) != null) {
+        discriminatorKey = filter[wrapperPath].$elemMatch[key];
+      }
+
+      const discriminatorKeyUpdatePath = originalSubpath + '.' + key;
+      if (discriminatorKeyUpdatePath in update) {
+        discriminatorKey = update[discriminatorKeyUpdatePath];
+      }
+
+      if (discriminatorValuePath in update) {
+        discriminatorKey = update[discriminatorValuePath];
+      }
+
+      for (const filterKey of Object.keys(updatedPathsByFilter)) {
+        const schemaKey = updatedPathsByFilter[filterKey] + '.' + key;
+        const arrayFilterKey = filterKey + '.' + key;
+        if (schemaKey === discriminatorFilterPath) {
+          const filter = arrayFilters.find(filter => Object.hasOwn(filter, arrayFilterKey));
+          if (filter != null) {
+            discriminatorKey = filter[arrayFilterKey];
+          }
+        }
+      }
+
+      if (discriminatorKey == null) {
+        continue;
+      }
+
+      const discriminator = getDiscriminatorByValue(schematype.Constructor.discriminators, discriminatorKey);
+      const discriminatorSchema = discriminator && discriminator.schema;
+      if (discriminatorSchema == null) {
+        continue;
+      }
+
+      const rest = parts.slice(i + 1).join('.');
+      schematype = discriminatorSchema.path(rest);
+      schema = discriminatorSchema;
+      startIndex = i + 1;
+      if (schematype != null) {
+        type = discriminatorSchema._getPathType(rest);
+        break;
+      }
+    }
+  }
+
+  return { type: type, schematype: schematype };
+};

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

@@ -0,0 +1,44 @@
+'use strict';
+
+const StrictModeError = require('../../error/strict');
+
+/**
+ * Handle immutable option for a given path when casting updates based on options
+ *
+ * @param {SchemaType} schematype the resolved schematype for this path
+ * @param {Boolean | 'throw' | null} strict whether strict mode is set for this query
+ * @param {Object} obj the object containing the value being checked so we can delete
+ * @param {String} key the key in `obj` which we are checking for immutability
+ * @param {String} fullPath the full path being checked
+ * @param {Object} options the query options
+ * @param {Query} ctx the query. Passed as `this` and first param to the `immutable` option, if `immutable` is a function
+ * @returns true if field was removed, false otherwise
+ */
+
+module.exports = function handleImmutable(schematype, strict, obj, key, fullPath, options, ctx) {
+  if (schematype == null || !schematype.options || !schematype.options.immutable) {
+    return false;
+  }
+  let immutable = schematype.options.immutable;
+
+  if (typeof immutable === 'function') {
+    immutable = immutable.call(ctx, ctx);
+  }
+  if (!immutable) {
+    return false;
+  }
+
+  if (options && options.overwriteImmutable) {
+    return false;
+  }
+  if (strict === false) {
+    return false;
+  }
+  if (strict === 'throw') {
+    throw new StrictModeError(null,
+      `Field ${fullPath} is immutable and strict = 'throw'`);
+  }
+
+  delete obj[key];
+  return true;
+};

package/templates/node_modules/mongoose/lib/helpers/query/handleReadPreferenceAliases.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = function handleReadPreferenceAliases(pref) {
+  switch (pref) {
+    case 'p':
+      pref = 'primary';
+      break;
+    case 'pp':
+      pref = 'primaryPreferred';
+      break;
+    case 's':
+      pref = 'secondary';
+      break;
+    case 'sp':
+      pref = 'secondaryPreferred';
+      break;
+    case 'n':
+      pref = 'nearest';
+      break;
+  }
+
+  return pref;
+};

package/templates/node_modules/mongoose/lib/helpers/query/hasDollarKeys.js

@@ -0,0 +1,23 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+module.exports = function hasDollarKeys(obj) {
+
+  if (typeof obj !== 'object' || obj === null) {
+    return false;
+  }
+
+  const keys = Object.keys(obj);
+  const len = keys.length;
+
+  for (let i = 0; i < len; ++i) {
+    if (keys[i][0] === '$') {
+      return true;
+    }
+  }
+
+  return false;
+};

package/templates/node_modules/mongoose/lib/helpers/query/isOperator.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const specialKeys = new Set([
+  '$ref',
+  '$id',
+  '$db'
+]);
+
+module.exports = function isOperator(path) {
+  return (
+    path[0] === '$' &&
+    !specialKeys.has(path)
+  );
+};

package/templates/node_modules/mongoose/lib/helpers/query/sanitizeFilter.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const hasDollarKeys = require('./hasDollarKeys');
+const { trustedSymbol } = require('./trusted');
+
+module.exports = function sanitizeFilter(filter) {
+  if (filter == null || typeof filter !== 'object') {
+    return filter;
+  }
+  if (Array.isArray(filter)) {
+    for (const subfilter of filter) {
+      sanitizeFilter(subfilter);
+    }
+    return filter;
+  }
+
+  const filterKeys = Object.keys(filter);
+  for (const key of filterKeys) {
+    const value = filter[key];
+    if (value != null && value[trustedSymbol]) {
+      continue;
+    }
+    if (key === '$and' || key === '$or') {
+      sanitizeFilter(value);
+      continue;
+    }
+
+    if (hasDollarKeys(value)) {
+      const keys = Object.keys(value);
+      if (keys.length === 1 && keys[0] === '$eq') {
+        continue;
+      }
+      filter[key] = { $eq: filter[key] };
+    }
+  }
+
+  return filter;
+};

package/templates/node_modules/mongoose/lib/helpers/query/sanitizeProjection.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = function sanitizeProjection(projection) {
+  if (projection == null) {
+    return;
+  }
+
+  const keys = Object.keys(projection);
+  for (let i = 0; i < keys.length; ++i) {
+    if (typeof projection[keys[i]] === 'string') {
+      projection[keys[i]] = 1;
+    }
+  }
+};

package/templates/node_modules/mongoose/lib/helpers/query/selectPopulatedFields.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const isExclusive = require('../projection/isExclusive');
+const isInclusive = require('../projection/isInclusive');
+
+/*!
+ * ignore
+ */
+
+module.exports = function selectPopulatedFields(fields, userProvidedFields, populateOptions) {
+  if (populateOptions == null) {
+    return;
+  }
+
+  const paths = Object.keys(populateOptions);
+  userProvidedFields = userProvidedFields || {};
+  if (isInclusive(fields)) {
+    for (const path of paths) {
+      if (!isPathInFields(userProvidedFields, path)) {
+        fields[path] = 1;
+      } else if (userProvidedFields[path] === 0) {
+        delete fields[path];
+      }
+
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string') {
+        if (!isPathInFields(userProvidedFields, refPath)) {
+          fields[refPath] = 1;
+        } else if (userProvidedFields[refPath] === 0) {
+          delete fields[refPath];
+        }
+      }
+    }
+  } else if (isExclusive(fields)) {
+    for (const path of paths) {
+      if (userProvidedFields[path] == null) {
+        delete fields[path];
+      }
+      const refPath = populateOptions[path]?.refPath;
+      if (typeof refPath === 'string' && userProvidedFields[refPath] == null) {
+        delete fields[refPath];
+      }
+    }
+  }
+};
+
+/*!
+ * ignore
+ */
+
+function isPathInFields(userProvidedFields, path) {
+  const pieces = path.split('.');
+  const len = pieces.length;
+  let cur = pieces[0];
+  for (let i = 1; i < len; ++i) {
+    if (userProvidedFields[cur] != null || userProvidedFields[cur + '.$'] != null) {
+      return true;
+    }
+    cur += '.' + pieces[i];
+  }
+  return userProvidedFields[cur] != null || userProvidedFields[cur + '.$'] != null;
+}

package/templates/node_modules/mongoose/lib/helpers/query/trusted.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const trustedSymbol = Symbol('mongoose#trustedSymbol');
+
+exports.trustedSymbol = trustedSymbol;
+
+exports.trusted = function trusted(obj) {
+  if (obj == null || typeof obj !== 'object') {
+    return obj;
+  }
+  obj[trustedSymbol] = true;
+  return obj;
+};

package/templates/node_modules/mongoose/lib/helpers/query/validOps.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('../../constants').queryMiddlewareFunctions;

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

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = function addAutoId(schema) {
+  const _obj = { _id: { auto: true } };
+  _obj._id[schema.options.typeKey] = 'ObjectId';
+  schema.add(_obj);
+};

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const builtinPlugins = require('../../plugins');
+
+module.exports = function applyBuiltinPlugins(schema) {
+  for (const plugin of Object.values(builtinPlugins)) {
+    plugin(schema, { deduplicate: true });
+  }
+  schema.plugins = Object.values(builtinPlugins).
+    map(fn => ({ fn, opts: { deduplicate: true } })).
+    concat(schema.plugins);
+};

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

@@ -0,0 +1,55 @@
+'use strict';
+
+module.exports = function applyPlugins(schema, plugins, options, cacheKey) {
+  if (schema[cacheKey]) {
+    return;
+  }
+  schema[cacheKey] = true;
+
+  if (!options || !options.skipTopLevel) {
+    let pluginTags = null;
+    for (const plugin of plugins) {
+      const tags = plugin[1] == null ? null : plugin[1].tags;
+      if (!Array.isArray(tags)) {
+        schema.plugin(plugin[0], plugin[1]);
+        continue;
+      }
+
+      pluginTags = pluginTags || new Set(schema.options.pluginTags || []);
+      if (!tags.find(tag => pluginTags.has(tag))) {
+        continue;
+      }
+      schema.plugin(plugin[0], plugin[1]);
+    }
+  }
+
+  options = Object.assign({}, options);
+  delete options.skipTopLevel;
+
+  if (options.applyPluginsToChildSchemas !== false) {
+    for (const path of Object.keys(schema.paths)) {
+      const type = schema.paths[path];
+      if (type.schema != null) {
+        applyPlugins(type.schema, plugins, options, cacheKey);
+
+        // Recompile schema because plugins may have changed it, see gh-7572
+        type.Constructor.prototype.$__setSchema(type.schema);
+      }
+    }
+  }
+
+  const discriminators = schema.discriminators;
+  if (discriminators == null) {
+    return;
+  }
+
+  const applyPluginsToDiscriminators = options.applyPluginsToDiscriminators;
+
+  const keys = Object.keys(discriminators);
+  for (const discriminatorKey of keys) {
+    const discriminatorSchema = discriminators[discriminatorKey];
+
+    applyPlugins(discriminatorSchema, plugins,
+      { skipTopLevel: !applyPluginsToDiscriminators }, cacheKey);
+  }
+};

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

@@ -0,0 +1,20 @@
+'use strict';
+
+module.exports = function applyReadConcern(schema, options) {
+  if (options.readConcern !== undefined) {
+    return;
+  }
+
+  // Don't apply default read concern to operations in transactions,
+  // because you shouldn't set read concern on individual operations
+  // within a transaction.
+  // See: https://www.mongodb.com/docs/manual/reference/read-concern/
+  if (options && options.session && options.session.transaction) {
+    return;
+  }
+
+  const level = schema.options?.readConcern?.level;
+  if (level != null) {
+    options.readConcern = { level };
+  }
+};

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

@@ -0,0 +1,37 @@
+'use strict';
+
+module.exports = function applyWriteConcern(schema, options) {
+  if (options.writeConcern != null) {
+    return;
+  }
+  // Don't apply default write concern to operations in transactions,
+  // because setting write concern on an operation in a transaction is an error
+  // See: https://www.mongodb.com/docs/manual/reference/write-concern/
+  if (options && options.session && options.session.transaction) {
+    return;
+  }
+  const writeConcern = schema.options.writeConcern ?? {};
+  if (Object.keys(writeConcern).length != 0) {
+    options.writeConcern = {};
+    if (!('w' in options) && writeConcern.w != null) {
+      options.writeConcern.w = writeConcern.w;
+    }
+    if (!('j' in options) && writeConcern.j != null) {
+      options.writeConcern.j = writeConcern.j;
+    }
+    if (!('wtimeout' in options) && writeConcern.wtimeout != null) {
+      options.writeConcern.wtimeout = writeConcern.wtimeout;
+    }
+  }
+  else {
+    if (!('w' in options) && writeConcern.w != null) {
+      options.w = writeConcern.w;
+    }
+    if (!('j' in options) && writeConcern.j != null) {
+      options.j = writeConcern.j;
+    }
+    if (!('wtimeout' in options) && writeConcern.wtimeout != null) {
+      options.wtimeout = writeConcern.wtimeout;
+    }
+  }
+};

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

@@ -0,0 +1,12 @@
+'use strict';
+
+/**
+ * For consistency's sake, we replace positional operator `$` and array filters
+ * `$[]` and `$[foo]` with `0` when looking up schema paths.
+ */
+
+module.exports = function cleanPositionalOperators(path) {
+  return path.
+    replace(/\.\$(\[[^\]]*\])?(?=\.)/g, '.0').
+    replace(/\.\$(\[[^\]]*\])?$/g, '.0');
+};

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

@@ -0,0 +1,171 @@
+'use strict';
+
+const get = require('../get');
+const helperIsObject = require('../isObject');
+const decorateDiscriminatorIndexOptions = require('../indexes/decorateDiscriminatorIndexOptions');
+
+/**
+ * Gather all indexes defined in the schema, including single nested,
+ * document arrays, and embedded discriminators.
+ * @param {Schema} schema
+ * @api private
+ */
+
+module.exports = function getIndexes(schema) {
+  let indexes = [];
+  const schemaStack = new WeakMap();
+  const indexTypes = schema.constructor.indexTypes;
+  const indexByName = new Map();
+
+  collectIndexes(schema);
+  return indexes;
+
+  function collectIndexes(schema, prefix, baseSchema) {
+    // Ignore infinitely nested schemas, if we've already seen this schema
+    // along this path there must be a cycle
+    if (schemaStack.has(schema)) {
+      return;
+    }
+    schemaStack.set(schema, true);
+
+    prefix = prefix || '';
+    const keys = Object.keys(schema.paths);
+
+    for (const key of keys) {
+      const path = schema.paths[key];
+      if (baseSchema != null && baseSchema.paths[key]) {
+        // If looking at an embedded discriminator schema, don't look at paths
+        // that the
+        continue;
+      }
+
+      if (path._duplicateKeyErrorMessage != null) {
+        schema._duplicateKeyErrorMessagesByPath = schema._duplicateKeyErrorMessagesByPath || {};
+        schema._duplicateKeyErrorMessagesByPath[key] = path._duplicateKeyErrorMessage;
+      }
+
+      if (path.$isMongooseDocumentArray || path.$isSingleNested) {
+        if (get(path, 'options.excludeIndexes') !== true &&
+            get(path, 'schemaOptions.excludeIndexes') !== true &&
+            get(path, 'schema.options.excludeIndexes') !== true) {
+          collectIndexes(path.schema, prefix + key + '.');
+        }
+
+        if (path.schema.discriminators != null) {
+          const discriminators = path.schema.discriminators;
+          const discriminatorKeys = Object.keys(discriminators);
+          for (const discriminatorKey of discriminatorKeys) {
+            collectIndexes(discriminators[discriminatorKey],
+              prefix + key + '.', path.schema);
+          }
+        }
+
+        // Retained to minimize risk of backwards breaking changes due to
+        // gh-6113
+        if (path.$isMongooseDocumentArray) {
+          continue;
+        }
+      }
+
+      const index = path._index || (path.embeddedSchemaType && path.embeddedSchemaType._index);
+
+      if (index !== false && index !== null && index !== undefined) {
+        const field = {};
+        const isObject = helperIsObject(index);
+        const options = isObject ? { ...index } : {};
+        const type = typeof index === 'string' ? index :
+          isObject ? index.type :
+            false;
+
+        if (type && indexTypes.indexOf(type) !== -1) {
+          field[prefix + key] = type;
+        } else if (options.text) {
+          field[prefix + key] = 'text';
+          delete options.text;
+        } else {
+          let isDescendingIndex = false;
+          if (index === 'descending' || index === 'desc') {
+            isDescendingIndex = true;
+          } else if (index === 'ascending' || index === 'asc') {
+            isDescendingIndex = false;
+          } else {
+            isDescendingIndex = Number(index) === -1;
+          }
+
+          field[prefix + key] = isDescendingIndex ? -1 : 1;
+        }
+
+        delete options.type;
+        if (schema.options.autoIndex != null) {
+          options._autoIndex = schema.options.autoIndex;
+        }
+
+        const indexName = options && options.name;
+
+        if (typeof indexName === 'string') {
+          if (indexByName.has(indexName)) {
+            Object.assign(indexByName.get(indexName), field);
+          } else {
+            indexes.push([field, options]);
+            indexByName.set(indexName, field);
+          }
+        } else {
+          indexes.push([field, options]);
+          indexByName.set(indexName, field);
+        }
+      }
+    }
+
+    schemaStack.delete(schema);
+
+    if (prefix) {
+      fixSubIndexPaths(schema, prefix);
+    } else {
+      schema._indexes.forEach(function(index) {
+        const options = index[1];
+        decorateDiscriminatorIndexOptions(schema, options);
+      });
+      indexes = indexes.concat(schema._indexes);
+    }
+  }
+
+  /**
+   * Checks for indexes added to subdocs using Schema.index().
+   * These indexes need their paths prefixed properly.
+   *
+   * schema._indexes = [ [indexObj, options], [indexObj, options] ..]
+   * @param {Schema} schema
+   * @param {String} prefix
+   * @api private
+   */
+
+  function fixSubIndexPaths(schema, prefix) {
+    const subindexes = schema._indexes;
+    const len = subindexes.length;
+    for (let i = 0; i < len; ++i) {
+      const indexObj = subindexes[i][0];
+      const indexOptions = subindexes[i][1];
+      const keys = Object.keys(indexObj);
+      const klen = keys.length;
+      const newindex = {};
+
+      // use forward iteration, order matters
+      for (let j = 0; j < klen; ++j) {
+        const key = keys[j];
+        newindex[prefix + key] = indexObj[key];
+      }
+
+      const newIndexOptions = Object.assign({}, indexOptions);
+      if (indexOptions != null && indexOptions.partialFilterExpression != null) {
+        newIndexOptions.partialFilterExpression = {};
+        const partialFilterExpression = indexOptions.partialFilterExpression;
+        for (const key of Object.keys(partialFilterExpression)) {
+          newIndexOptions.partialFilterExpression[prefix + key] =
+            partialFilterExpression[key];
+        }
+      }
+
+      indexes.push([newindex, newIndexOptions]);
+    }
+  }
+};