create-mern-omar 1.1.0 → 1.2.0

package/templates/node_modules/mongoose/lib/helpers/indexes/isIndexEqual.js

@@ -1,95 +0,0 @@
-'use strict';
-
-const get = require('../get');
-const utils = require('../../utils');
-/**
- * Given a Mongoose index definition (key + options objects) and a MongoDB server
- * index definition, determine if the two indexes are equal.
- *
- * @param {Object} schemaIndexKeysObject the Mongoose index spec
- * @param {Object} options the Mongoose index definition's options
- * @param {Object} dbIndex the index in MongoDB as returned by `listIndexes()`
- * @api private
- */
-
-module.exports = function isIndexEqual(schemaIndexKeysObject, options, dbIndex) {
-  // Special case: text indexes have a special format in the db. For example,
-  // `{ name: 'text' }` becomes:
-  // {
-  //   v: 2,
-  //   key: { _fts: 'text', _ftsx: 1 },
-  //   name: 'name_text',
-  //   ns: 'test.tests',
-  //   weights: { name: 1 },
-  //   default_language: 'english',
-  //   language_override: 'language',
-  //   textIndexVersion: 3
-  // }
-  if (dbIndex.textIndexVersion != null) {
-    delete dbIndex.key._fts;
-    delete dbIndex.key._ftsx;
-    const weights = { ...dbIndex.weights, ...dbIndex.key };
-    if (Object.keys(weights).length !== Object.keys(schemaIndexKeysObject).length) {
-      return false;
-    }
-    for (const prop of Object.keys(weights)) {
-      if (!(prop in schemaIndexKeysObject)) {
-        return false;
-      }
-      const weight = weights[prop];
-      if (weight !== get(options, 'weights.' + prop) && !(weight === 1 && get(options, 'weights.' + prop) == null)) {
-        return false;
-      }
-    }
-
-    if (options['default_language'] !== dbIndex['default_language']) {
-      return dbIndex['default_language'] === 'english' && options['default_language'] == null;
-    }
-
-    return true;
-  }
-
-  const optionKeys = [
-    'unique',
-    'partialFilterExpression',
-    'sparse',
-    'expireAfterSeconds',
-    'collation'
-  ];
-  for (const key of optionKeys) {
-    if (!(key in options) && !(key in dbIndex)) {
-      continue;
-    }
-    if (key === 'collation') {
-      if (options[key] == null || dbIndex[key] == null) {
-        return options[key] == null && dbIndex[key] == null;
-      }
-      const definedKeys = Object.keys(options.collation);
-      const schemaCollation = options.collation;
-      const dbCollation = dbIndex.collation;
-      for (const opt of definedKeys) {
-        if (get(schemaCollation, opt) !== get(dbCollation, opt)) {
-          return false;
-        }
-      }
-    } else if (!utils.deepEqual(options[key], dbIndex[key])) {
-      return false;
-    }
-  }
-
-  const schemaIndexKeys = Object.keys(schemaIndexKeysObject);
-  const dbIndexKeys = Object.keys(dbIndex.key);
-  if (schemaIndexKeys.length !== dbIndexKeys.length) {
-    return false;
-  }
-  for (let i = 0; i < schemaIndexKeys.length; ++i) {
-    if (schemaIndexKeys[i] !== dbIndexKeys[i]) {
-      return false;
-    }
-    if (!utils.deepEqual(schemaIndexKeysObject[schemaIndexKeys[i]], dbIndex.key[dbIndexKeys[i]])) {
-      return false;
-    }
-  }
-
-  return true;
-};

package/templates/node_modules/mongoose/lib/helpers/indexes/isIndexSpecEqual.js

@@ -1,32 +0,0 @@
-'use strict';
-
-/**
- * Compares two index specifications to determine if they are equal.
- *
- * #### Example:
- *     isIndexSpecEqual({ a: 1, b: 1 }, { a: 1, b: 1 }); // true
- *     isIndexSpecEqual({ a: 1, b: 1 }, { b: 1, a: 1 }); // false
- *     isIndexSpecEqual({ a: 1, b: -1 }, { a: 1, b: 1 }); // false
- *
- * @param {Object} spec1 The first index specification to compare.
- * @param {Object} spec2 The second index specification to compare.
- * @returns {Boolean} Returns true if the index specifications are equal, otherwise returns false.
- */
-
-module.exports = function isIndexSpecEqual(spec1, spec2) {
-  const spec1Keys = Object.keys(spec1);
-  const spec2Keys = Object.keys(spec2);
-
-  if (spec1Keys.length !== spec2Keys.length) {
-    return false;
-  }
-
-  for (let i = 0; i < spec1Keys.length; i++) {
-    const key = spec1Keys[i];
-    if (key !== spec2Keys[i] || spec1[key] !== spec2[key]) {
-      return false;
-    }
-  }
-
-  return true;
-};

package/templates/node_modules/mongoose/lib/helpers/indexes/isTextIndex.js

@@ -1,16 +0,0 @@
-'use strict';
-
-/**
- * Returns `true` if the given index options have a `text` option.
- */
-
-module.exports = function isTextIndex(indexKeys) {
-  let isTextIndex = false;
-  for (const key of Object.keys(indexKeys)) {
-    if (indexKeys[key] === 'text') {
-      isTextIndex = true;
-    }
-  }
-
-  return isTextIndex;
-};

package/templates/node_modules/mongoose/lib/helpers/indexes/isTimeseriesIndex.js

@@ -1,16 +0,0 @@
-'use strict';
-
-/**
- * Returns `true` if the given index matches the schema's `timestamps` options
- */
-
-module.exports = function isTimeseriesIndex(dbIndex, schemaOptions) {
-  if (schemaOptions.timeseries == null) {
-    return false;
-  }
-  const { timeField, metaField } = schemaOptions.timeseries;
-  if (typeof timeField !== 'string' || typeof metaField !== 'string') {
-    return false;
-  }
-  return Object.keys(dbIndex.key).length === 2 && dbIndex.key[timeField] === 1 && dbIndex.key[metaField] === 1;
-};

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

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = function isAsyncFunction(v) {
-  return (
-    typeof v === 'function' &&
-    v.constructor &&
-    v.constructor.name === 'AsyncFunction'
-  );
-};

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

@@ -1,15 +0,0 @@
-'use strict';
-
-/**
- * Get the bson type, if it exists
- * @api private
- */
-
-function isBsonType(obj, typename) {
-  return (
-    obj != null &&
-    obj._bsontype === typename
-  );
-}
-
-module.exports = isBsonType;

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

@@ -1,22 +0,0 @@
-'use strict';
-
-const isMongooseArray = require('../types/array/isMongooseArray').isMongooseArray;
-/**
- * Returns if `v` is a mongoose object that has a `toObject()` method we can use.
- *
- * This is for compatibility with libs like Date.js which do foolish things to Natives.
- *
- * @param {Any} v
- * @api private
- */
-
-module.exports = function(v) {
-  return (
-    v != null && (
-      isMongooseArray(v) || // Array or Document Array
-      v.$__ != null || // Document
-      v.isMongooseBuffer || // Buffer
-      v.$isMongooseMap // Map
-    )
-  );
-};

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

@@ -1,16 +0,0 @@
-'use strict';
-
-/**
- * Determines if `arg` is an object.
- *
- * @param {Object|Array|String|Function|RegExp|any} arg
- * @api private
- * @return {Boolean}
- */
-
-module.exports = function(arg) {
-  return (
-    Buffer.isBuffer(arg) ||
-    Object.prototype.toString.call(arg) === '[object Object]'
-  );
-};

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

@@ -1,12 +0,0 @@
-'use strict';
-
-module.exports = function isPOJO(arg) {
-  if (arg == null || typeof arg !== 'object') {
-    return false;
-  }
-  const proto = Object.getPrototypeOf(arg);
-  // Prototype may be null if you used `Object.create(null)`
-  // Checking `proto`'s constructor is safe because `getPrototypeOf()`
-  // explicitly crosses the boundary from object data to object metadata
-  return !proto || proto.constructor.name === 'Object';
-};

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

@@ -1,6 +0,0 @@
-'use strict';
-function isPromise(val) {
-  return !!val && (typeof val === 'object' || typeof val === 'function') && typeof val.then === 'function';
-}
-
-module.exports = isPromise;

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

@@ -1,22 +0,0 @@
-'use strict';
-
-/**
- * Determines if `arg` is a flat object.
- *
- * @param {Object|Array|String|Function|RegExp|any} arg
- * @api private
- * @return {Boolean}
- */
-
-module.exports = function isSimpleValidator(obj) {
-  const keys = Object.keys(obj);
-  let result = true;
-  for (let i = 0, len = keys.length; i < len; ++i) {
-    if (typeof obj[keys[i]] === 'object' && obj[keys[i]] !== null) {
-      result = false;
-      break;
-    }
-  }
-
-  return result;
-};

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

@@ -1,41 +0,0 @@
-'use strict';
-
-const { isPOJO } = require('../utils');
-
-module.exports = minimize;
-
-/**
- * Minimizes an object, removing undefined values and empty objects
- *
- * @param {Object} object to minimize
- * @return {Object|undefined}
- * @api private
- */
-
-function minimize(obj) {
-  const keys = Object.keys(obj);
-  let i = keys.length;
-  let hasKeys;
-  let key;
-  let val;
-
-  while (i--) {
-    key = keys[i];
-    val = obj[key];
-
-    if (isPOJO(val)) {
-      obj[key] = minimize(val);
-    }
-
-    if (undefined === obj[key]) {
-      delete obj[key];
-      continue;
-    }
-
-    hasKeys = true;
-  }
-
-  return hasKeys
-    ? obj
-    : undefined;
-}

package/templates/node_modules/mongoose/lib/helpers/model/applyDefaultsToPOJO.js

@@ -1,52 +0,0 @@
-'use strict';
-
-module.exports = function applyDefaultsToPOJO(doc, schema) {
-  const paths = Object.keys(schema.paths);
-  const plen = paths.length;
-
-  for (let i = 0; i < plen; ++i) {
-    let curPath = '';
-    const p = paths[i];
-
-    const type = schema.paths[p];
-    const path = type.splitPath();
-    const len = path.length;
-    let doc_ = doc;
-    for (let j = 0; j < len; ++j) {
-      if (doc_ == null) {
-        break;
-      }
-
-      const piece = path[j];
-      curPath += (!curPath.length ? '' : '.') + piece;
-
-      if (j === len - 1) {
-        if (typeof doc_[piece] !== 'undefined') {
-          if (type.$isSingleNested) {
-            applyDefaultsToPOJO(doc_[piece], type.schema);
-          } else if (type.$isMongooseDocumentArray && Array.isArray(doc_[piece])) {
-            doc_[piece].forEach(el => applyDefaultsToPOJO(el, type.schema));
-          }
-
-          break;
-        }
-
-        const def = type.getDefault(doc, false, { skipCast: true });
-        if (typeof def !== 'undefined') {
-          doc_[piece] = def;
-
-          if (type.$isSingleNested) {
-            applyDefaultsToPOJO(def, type.schema);
-          } else if (type.$isMongooseDocumentArray && Array.isArray(def)) {
-            def.forEach(el => applyDefaultsToPOJO(el, type.schema));
-          }
-        }
-      } else {
-        if (doc_[piece] == null) {
-          doc_[piece] = {};
-        }
-        doc_ = doc_[piece];
-      }
-    }
-  }
-};

package/templates/node_modules/mongoose/lib/helpers/model/applyHooks.js

@@ -1,140 +0,0 @@
-'use strict';
-
-/*!
- * ignore
- */
-
-module.exports = applyHooks;
-
-/*!
- * ignore
- */
-
-applyHooks.middlewareFunctions = [
-  'deleteOne',
-  'remove',
-  'save',
-  'updateOne',
-  'validate',
-  'init'
-];
-
-/*!
- * ignore
- */
-
-const alreadyHookedFunctions = new Set(applyHooks.middlewareFunctions.flatMap(fn => ([fn, `$__${fn}`])));
-
-/**
- * Register hooks for this model
- *
- * @param {Model} model
- * @param {Schema} schema
- * @param {Object} options
- * @api private
- */
-
-function applyHooks(model, schema, options) {
-  options = options || {};
-
-  const kareemOptions = {
-    useErrorHandlers: true,
-    numCallbackParams: 1,
-    nullResultByDefault: true,
-    contextParameter: true
-  };
-  const objToDecorate = options.decorateDoc ? model : model.prototype;
-  model.$appliedHooks = true;
-  for (const key of Object.keys(schema.paths)) {
-    let type = schema.paths[key];
-    let childModel = null;
-
-    const result = findChildModel(type);
-    if (result) {
-      childModel = result.childModel;
-      type = result.type;
-    } else {
-      continue;
-    }
-
-    if (childModel.$appliedHooks) {
-      continue;
-    }
-
-    applyHooks(childModel, type.schema, {
-      ...options,
-      decorateDoc: false,
-      isChildSchema: true
-    });
-    if (childModel.discriminators != null) {
-      const keys = Object.keys(childModel.discriminators);
-      for (const key of keys) {
-        applyHooks(childModel.discriminators[key],
-          childModel.discriminators[key].schema, options);
-      }
-    }
-  }
-
-  // Built-in hooks rely on hooking internal functions in order to support
-  // promises and make it so that `doc.save.toString()` provides meaningful
-  // information.
-
-  const middleware = schema._getDocumentMiddleware();
-
-  model._middleware = middleware;
-
-  objToDecorate.$__init = middleware.
-    createWrapperSync('init', objToDecorate.$__init, null, kareemOptions);
-
-  // Support hooks for custom methods
-  const customMethods = Object.keys(schema.methods);
-  const customMethodOptions = Object.assign({}, kareemOptions, {
-    // Only use `checkForPromise` for custom methods, because mongoose
-    // query thunks are not as consistent as I would like about returning
-    // a nullish value rather than the query. If a query thunk returns
-    // a query, `checkForPromise` causes infinite recursion
-    checkForPromise: true
-  });
-  for (const method of customMethods) {
-    if (alreadyHookedFunctions.has(method)) {
-      continue;
-    }
-    if (!middleware.hasHooks(method)) {
-      // Don't wrap if there are no hooks for the custom method to avoid
-      // surprises. Also, `createWrapper()` enforces consistent async,
-      // so wrapping a sync method would break it.
-      continue;
-    }
-    const originalMethod = objToDecorate[method];
-    objToDecorate[`$__${method}`] = objToDecorate[method];
-    objToDecorate[method] = middleware.
-      createWrapper(method, originalMethod, null, customMethodOptions);
-  }
-}
-
-/**
- * Check if there is an embedded schematype in the given schematype. Handles drilling down into primitive
- * arrays and maps in case of array of array of subdocs or map of subdocs.
- *
- * @param {SchemaType} curType
- * @returns {{ childModel: Model | typeof Subdocument, curType: SchemaType } | null}
- */
-
-function findChildModel(curType) {
-  if (curType.$isSingleNested || curType.$isMongooseDocumentArray) {
-    return { childModel: curType.Constructor, type: curType };
-  }
-  if (curType.instance === 'Array') {
-    const embedded = curType.getEmbeddedSchemaType();
-    if (embedded) {
-      return findChildModel(embedded);
-    }
-  }
-  if (curType.instance === 'Map') {
-    const mapType = curType.getEmbeddedSchemaType();
-    if (mapType) {
-      return findChildModel(mapType);
-    }
-  }
-  return null;
-}

package/templates/node_modules/mongoose/lib/helpers/model/applyMethods.js

@@ -1,70 +0,0 @@
-'use strict';
-
-const get = require('../get');
-const utils = require('../../utils');
-
-/**
- * Register methods for this model
- *
- * @param {Model} model
- * @param {Schema} schema
- * @api private
- */
-
-module.exports = function applyMethods(model, schema) {
-  const Model = require('../../model');
-
-  function apply(method, schema) {
-    Object.defineProperty(model.prototype, method, {
-      get: function() {
-        const h = {};
-        for (const k in schema.methods[method]) {
-          h[k] = schema.methods[method][k].bind(this);
-        }
-        return h;
-      },
-      configurable: true
-    });
-  }
-  for (const method of Object.keys(schema.methods)) {
-    const fn = schema.methods[method];
-    if (Object.hasOwn(schema.tree, method)) {
-      throw new Error('You have a method and a property in your schema both ' +
-        'named "' + method + '"');
-    }
-
-    // Avoid making custom methods if user sets a method to itself, e.g.
-    // `schema.method(save, Document.prototype.save)`. Can happen when
-    // calling `loadClass()` with a class that `extends Document`. See gh-12254
-    if (typeof fn === 'function' &&
-        Model.prototype[method] === fn) {
-      delete schema.methods[method];
-      continue;
-    }
-
-    if (schema.reserved[method] &&
-        !get(schema, `methodOptions.${method}.suppressWarning`, false)) {
-      utils.warn(`mongoose: the method name "${method}" is used by mongoose ` +
-        'internally, overwriting it may cause bugs. If you\'re sure you know ' +
-        'what you\'re doing, you can suppress this error by using ' +
-        `\`schema.method('${method}', fn, { suppressWarning: true })\`.`);
-    }
-    if (typeof fn === 'function') {
-      model.prototype[method] = fn;
-    } else {
-      apply(method, schema);
-    }
-  }
-
-  // Recursively call `applyMethods()` on child schemas
-  model.$appliedMethods = true;
-  for (const key of Object.keys(schema.paths)) {
-    const type = schema.paths[key];
-    if (type.$isSingleNested && !type.Constructor.$appliedMethods) {
-      applyMethods(type.Constructor, type.schema);
-    }
-    if (type.$isMongooseDocumentArray && !type.Constructor.$appliedMethods) {
-      applyMethods(type.Constructor, type.schema);
-    }
-  }
-};

package/templates/node_modules/mongoose/lib/helpers/model/applyStaticHooks.js

@@ -1,33 +0,0 @@
-'use strict';
-
-const { queryMiddlewareFunctions, aggregateMiddlewareFunctions, modelMiddlewareFunctions, documentMiddlewareFunctions } = require('../../constants');
-
-const middlewareFunctions = Array.from(
-  new Set([
-    ...queryMiddlewareFunctions,
-    ...aggregateMiddlewareFunctions,
-    ...modelMiddlewareFunctions,
-    ...documentMiddlewareFunctions
-  ])
-);
-
-module.exports = function applyStaticHooks(model, hooks, statics) {
-  hooks = hooks.filter(hook => {
-    // If the custom static overwrites an existing middleware, don't apply
-    // middleware to it by default. This avoids a potential backwards breaking
-    // change with plugins like `mongoose-delete` that use statics to overwrite
-    // built-in Mongoose functions.
-    if (middlewareFunctions.indexOf(hook.name) !== -1) {
-      return !!hook.model;
-    }
-    return hook.model !== false;
-  });
-
-  for (const key of Object.keys(statics)) {
-    if (hooks.hasHooks(key)) {
-      const original = model[key];
-
-      model[key] = hooks.createWrapper(key, original);
-    }
-  }
-};

package/templates/node_modules/mongoose/lib/helpers/model/applyStatics.js

@@ -1,13 +0,0 @@
-'use strict';
-
-/**
- * Register statics for this model
- * @param {Model} model
- * @param {Schema} schema
- * @api private
- */
-module.exports = function applyStatics(model, schema) {
-  for (const i in schema.statics) {
-    model[i] = schema.statics[i];
-  }
-};