create-mern-omar 1.1.0 → 1.2.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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