@nullix/zod-mongoose-studio 0.0.1

package/.output/server/node_modules/mongoose/lib/helpers/model/discriminator.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const Mixed = require('../../schema/mixed');
+const applyBuiltinPlugins = require('../schema/applyBuiltinPlugins');
+const clone = require('../clone');
+const defineKey = require('../document/compile').defineKey;
+const get = require('../get');
+const utils = require('../../utils');
+const mergeDiscriminatorSchema = require('../../helpers/discriminator/mergeDiscriminatorSchema');
+
+const CUSTOMIZABLE_DISCRIMINATOR_OPTIONS = {
+  toJSON: true,
+  toObject: true,
+  _id: true,
+  id: true,
+  virtuals: true,
+  methods: true,
+  statics: true
+};
+
+/**
+ * Validate fields declared on the child schema when either schema is configured for encryption.  Specifically, this function ensures that:
+ *
+ * - any encrypted fields are declared on exactly one of the schemas (not both)
+ * - encrypted fields cannot be declared on either the parent or child schema, where the other schema declares the same field without encryption.
+ *
+ * @param {Schema} parentSchema
+ * @param {Schema} childSchema
+ */
+function validateDiscriminatorSchemasForEncryption(parentSchema, childSchema) {
+  if (parentSchema.encryptionType() == null && childSchema.encryptionType() == null) return;
+
+  const allSharedNestedPaths = setIntersection(
+    allNestedPaths(parentSchema),
+    allNestedPaths(childSchema)
+  );
+
+  for (const path of allSharedNestedPaths) {
+    if (parentSchema._hasEncryptedField(path) && childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot be declared on both the base schema and the child schema in a discriminator. path=${path}`);
+    }
+
+    if (parentSchema._hasEncryptedField(path) || childSchema._hasEncryptedField(path)) {
+      throw new Error(`encrypted fields cannot have the same path as a non-encrypted field for discriminators. path=${path}`);
+    }
+  }
+
+  function allNestedPaths(schema) {
+    return [...Object.keys(schema.paths), ...Object.keys(schema.singleNestedPaths)];
+  }
+
+  /**
+   * @param {Iterable<string>} i1
+   * @param {Iterable<string>} i2
+   */
+  function* setIntersection(i1, i2) {
+    const s1 = new Set(i1);
+    for (const item of i2) {
+      if (s1.has(item)) {
+        yield item;
+      }
+    }
+  }
+}
+
+/*!
+ * ignore
+ */
+
+module.exports = function discriminator(model, name, schema, tiedValue, applyPlugins, mergeHooks, overwriteExisting) {
+  if (!(schema && schema.instanceOfSchema)) {
+    throw new Error('You must pass a valid discriminator Schema');
+  }
+
+  mergeHooks = mergeHooks == null ? true : mergeHooks;
+
+  if (model.schema.discriminatorMapping &&
+      !model.schema.discriminatorMapping.isRoot) {
+    throw new Error('Discriminator "' + name +
+        '" can only be a discriminator of the root model');
+  }
+
+  if (applyPlugins) {
+    const applyPluginsToDiscriminators = get(model.base,
+      'options.applyPluginsToDiscriminators', false) || !mergeHooks;
+    // Even if `applyPluginsToDiscriminators` isn't set, we should still apply
+    // global plugins to schemas embedded in the discriminator schema (gh-7370)
+    model.base._applyPlugins(schema, {
+      skipTopLevel: !applyPluginsToDiscriminators
+    });
+  } else if (!mergeHooks) {
+    applyBuiltinPlugins(schema);
+  }
+
+  const key = model.schema.options.discriminatorKey;
+
+  const existingPath = model.schema.path(key);
+  if (existingPath != null) {
+    if (!utils.hasUserDefinedProperty(existingPath.options, 'select')) {
+      existingPath.options.select = true;
+    }
+    existingPath.options.$skipDiscriminatorCheck = true;
+  } else {
+    const baseSchemaAddition = {};
+    baseSchemaAddition[key] = {
+      default: void 0,
+      select: true,
+      $skipDiscriminatorCheck: true
+    };
+    baseSchemaAddition[key][model.schema.options.typeKey] = String;
+    model.schema.add(baseSchemaAddition);
+    defineKey({
+      prop: key,
+      prototype: model.prototype,
+      options: model.schema.options
+    });
+  }
+
+  if (schema.path(key) && schema.path(key).options.$skipDiscriminatorCheck !== true) {
+    throw new Error('Discriminator "' + name +
+        '" cannot have field with name "' + key + '"');
+  }
+
+  let value = name;
+  if ((typeof tiedValue === 'string' && tiedValue.length) || tiedValue != null) {
+    value = tiedValue;
+  }
+
+  validateDiscriminatorSchemasForEncryption(model.schema, schema);
+
+  function merge(schema, baseSchema) {
+    // Retain original schema before merging base schema
+    schema._baseSchema = baseSchema;
+    if (baseSchema.paths._id &&
+        baseSchema.paths._id.options &&
+        !baseSchema.paths._id.options.auto) {
+      schema.remove('_id');
+    }
+
+    // Find conflicting paths: if something is a path in the base schema
+    // and a nested path in the child schema, overwrite the base schema path.
+    // See gh-6076
+    const baseSchemaPaths = Object.keys(baseSchema.paths);
+    const conflictingPaths = [];
+
+    for (const path of baseSchemaPaths) {
+      if (schema.nested[path]) {
+        conflictingPaths.push(path);
+        continue;
+      }
+
+      if (path.indexOf('.') === -1) {
+        continue;
+      }
+      const sp = path.split('.').slice(0, -1);
+      let cur = '';
+      for (const piece of sp) {
+        cur += (cur.length ? '.' : '') + piece;
+        if (schema.paths[cur] instanceof Mixed ||
+            schema.singleNestedPaths[cur] instanceof Mixed) {
+          conflictingPaths.push(path);
+        }
+      }
+    }
+
+    // Shallow clone `obj` so we can add additional properties without modifying original
+    // schema. `Schema.prototype.clone()` copies `obj` by reference, no cloning.
+    schema.obj = { ...schema.obj };
+    mergeDiscriminatorSchema(schema, baseSchema);
+    schema._gatherChildSchemas();
+
+    // Clean up conflicting paths _after_ merging re: gh-6076
+    for (const conflictingPath of conflictingPaths) {
+      delete schema.paths[conflictingPath];
+    }
+
+    // Rebuild schema models because schemas may have been merged re: #7884
+    schema.childSchemas.forEach(obj => {
+      obj.model.prototype.$__setSchema(obj.schema);
+    });
+
+    const obj = {};
+    obj[key] = {
+      default: value,
+      select: true,
+      set: function(newName) {
+        if (newName === value || (Array.isArray(value) && utils.deepEqual(newName, value))) {
+          return value;
+        }
+        throw new Error('Can\'t set discriminator key "' + key + '"');
+      },
+      $skipDiscriminatorCheck: true
+    };
+    obj[key][schema.options.typeKey] = existingPath ? existingPath.options[schema.options.typeKey] : String;
+    schema.add(obj);
+
+    schema.discriminatorMapping = { key: key, value: value, isRoot: false };
+
+    if (baseSchema.options.collection) {
+      schema.options.collection = baseSchema.options.collection;
+    }
+    const toJSON = schema.options.toJSON;
+    const toObject = schema.options.toObject;
+    const _id = schema.options._id;
+    const id = schema.options.id;
+
+    const keys = Object.keys(schema.options);
+    schema.options.discriminatorKey = baseSchema.options.discriminatorKey;
+    const userProvidedOptions = schema._userProvidedOptions;
+    for (const _key of keys) {
+      if (!CUSTOMIZABLE_DISCRIMINATOR_OPTIONS[_key]) {
+        // Use `schema.options` in `deepEqual()` because of `discriminatorKey`
+        // set above. We don't allow customizing discriminator key, always
+        // overwrite. See gh-9238
+        if (_key in userProvidedOptions && !utils.deepEqual(schema.options[_key], baseSchema.options[_key])) {
+          throw new Error('Can\'t customize discriminator option ' + _key +
+            ' (can only modify ' +
+            Object.keys(CUSTOMIZABLE_DISCRIMINATOR_OPTIONS).join(', ') +
+            ')');
+        }
+      }
+    }
+    schema.options = clone(baseSchema.options);
+
+    for (const _key of Object.keys(userProvidedOptions)) {
+      schema.options[_key] = userProvidedOptions[_key];
+    }
+    if (toJSON) schema.options.toJSON = toJSON;
+    if (toObject) schema.options.toObject = toObject;
+    if (typeof _id !== 'undefined') {
+      schema.options._id = _id;
+    }
+    schema.options.id = id;
+    if (mergeHooks) {
+      schema.s.hooks = model.schema.s.hooks.merge(schema.s.hooks);
+    }
+    if (applyPlugins) {
+      schema.plugins = Array.prototype.slice.call(baseSchema.plugins);
+    }
+    schema.callQueue = baseSchema.callQueue.concat(schema.callQueue);
+    delete schema._requiredpaths; // reset just in case Schema#requiredPaths() was called on either schema
+  }
+
+  // merges base schema into new discriminator schema and sets new type field.
+  merge(schema, model.schema);
+
+  if (!model.discriminators) {
+    model.discriminators = {};
+  }
+
+  if (!model.schema.discriminatorMapping) {
+    model.schema.discriminatorMapping = { key: key, value: null, isRoot: true };
+  }
+  if (!model.schema.discriminators) {
+    model.schema.discriminators = {};
+  }
+
+  model.schema.discriminators[name] = schema;
+
+  if (model.discriminators[name] && !schema.options.overwriteModels && !overwriteExisting) {
+    throw new Error('Discriminator with name "' + name + '" already exists');
+  }
+
+  return schema;
+};

package/.output/server/node_modules/mongoose/lib/helpers/model/pushNestedArrayPaths.js

@@ -0,0 +1,15 @@
+'use strict';
+
+module.exports = function pushNestedArrayPaths(paths, nestedArray, path) {
+  if (nestedArray == null) {
+    return;
+  }
+
+  for (let i = 0; i < nestedArray.length; ++i) {
+    if (Array.isArray(nestedArray[i])) {
+      pushNestedArrayPaths(paths, nestedArray[i], path + '.' + i);
+    } else {
+      paths.push(path + '.' + i);
+    }
+  }
+};

package/.output/server/node_modules/mongoose/lib/helpers/omitUndefined.js

@@ -0,0 +1,20 @@
+'use strict';
+
+module.exports = function omitUndefined(val) {
+  if (val == null || typeof val !== 'object') {
+    return val;
+  }
+  if (Array.isArray(val)) {
+    for (let i = val.length - 1; i >= 0; --i) {
+      if (val[i] === undefined) {
+        val.splice(i, 1);
+      }
+    }
+  }
+  for (const key of Object.keys(val)) {
+    if (val[key] === void 0) {
+      delete val[key];
+    }
+  }
+  return val;
+};

package/.output/server/node_modules/mongoose/lib/helpers/parallelLimit.js

@@ -0,0 +1,55 @@
+'use strict';
+
+module.exports = parallelLimit;
+
+/*!
+ * ignore
+ */
+
+function parallelLimit(fns, limit, callback) {
+  let numInProgress = 0;
+  let numFinished = 0;
+  let error = null;
+
+  if (limit <= 0) {
+    throw new Error('Limit must be positive');
+  }
+
+  if (fns.length === 0) {
+    return callback(null, []);
+  }
+
+  for (let i = 0; i < fns.length && i < limit; ++i) {
+    _start();
+  }
+
+  function _start() {
+    fns[numFinished + numInProgress](_done(numFinished + numInProgress));
+    ++numInProgress;
+  }
+
+  const results = [];
+
+  function _done(index) {
+    return (err, res) => {
+      --numInProgress;
+      ++numFinished;
+
+      if (error != null) {
+        return;
+      }
+      if (err != null) {
+        error = err;
+        return callback(error);
+      }
+
+      results[index] = res;
+
+      if (numFinished === fns.length) {
+        return callback(null, results);
+      } else if (numFinished + numInProgress < fns.length) {
+        _start();
+      }
+    };
+  }
+}

package/.output/server/node_modules/mongoose/lib/helpers/path/parentPaths.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const dotRE = /\./g;
+module.exports = function parentPaths(path) {
+  if (path.indexOf('.') === -1) {
+    return [path];
+  }
+  const pieces = path.split(dotRE);
+  const len = pieces.length;
+  const ret = new Array(len);
+  let cur = '';
+  for (let i = 0; i < len; ++i) {
+    cur += (cur.length !== 0) ? '.' + pieces[i] : pieces[i];
+    ret[i] = cur;
+  }
+
+  return ret;
+};

package/.output/server/node_modules/mongoose/lib/helpers/path/setDottedPath.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const specialProperties = require('../specialProperties');
+
+
+module.exports = function setDottedPath(obj, path, val) {
+  if (path.indexOf('.') === -1) {
+    if (specialProperties.has(path)) {
+      return;
+    }
+
+    obj[path] = val;
+    return;
+  }
+  const parts = path.split('.');
+
+  const last = parts.pop();
+  let cur = obj;
+  for (const part of parts) {
+    if (specialProperties.has(part)) {
+      continue;
+    }
+    if (cur[part] == null) {
+      cur[part] = {};
+    }
+
+    cur = cur[part];
+  }
+
+  if (!specialProperties.has(last)) {
+    cur[last] = val;
+  }
+};

package/.output/server/node_modules/mongoose/lib/helpers/pluralize.js

@@ -0,0 +1,95 @@
+'use strict';
+
+module.exports = pluralize;
+
+/**
+ * Pluralization rules.
+ */
+
+exports.pluralization = [
+  [/human$/gi, 'humans'],
+  [/(m)an$/gi, '$1en'],
+  [/(pe)rson$/gi, '$1ople'],
+  [/(child)$/gi, '$1ren'],
+  [/^(ox)$/gi, '$1en'],
+  [/(ax|test)is$/gi, '$1es'],
+  [/(octop|vir)us$/gi, '$1i'],
+  [/(alias|status)$/gi, '$1es'],
+  [/(bu)s$/gi, '$1ses'],
+  [/(buffal|tomat|potat)o$/gi, '$1oes'],
+  [/([ti])um$/gi, '$1a'],
+  [/sis$/gi, 'ses'],
+  [/(?:([^f])fe|([lr])f)$/gi, '$1$2ves'],
+  [/(hive)$/gi, '$1s'],
+  [/([^aeiouy]|qu)y$/gi, '$1ies'],
+  [/(x|ch|ss|sh)$/gi, '$1es'],
+  [/(matr|vert|ind)ix|ex$/gi, '$1ices'],
+  [/([m|l])ouse$/gi, '$1ice'],
+  [/(kn|w|l)ife$/gi, '$1ives'],
+  [/(quiz)$/gi, '$1zes'],
+  [/^goose$/i, 'geese'],
+  [/s$/gi, 's'],
+  [/([^a-z])$/, '$1'],
+  [/$/gi, 's']
+];
+const rules = exports.pluralization;
+
+/**
+ * Uncountable words.
+ *
+ * These words are applied while processing the argument to `toCollectionName`.
+ * @api public
+ */
+
+exports.uncountables = [
+  'advice',
+  'energy',
+  'excretion',
+  'digestion',
+  'cooperation',
+  'health',
+  'justice',
+  'labour',
+  'machinery',
+  'equipment',
+  'information',
+  'pollution',
+  'sewage',
+  'paper',
+  'money',
+  'species',
+  'series',
+  'rain',
+  'rice',
+  'fish',
+  'sheep',
+  'moose',
+  'deer',
+  'news',
+  'expertise',
+  'status',
+  'media'
+];
+const uncountables = exports.uncountables;
+
+/**
+ * Pluralize function.
+ *
+ * @author TJ Holowaychuk (extracted from _ext.js_)
+ * @param {String} string to pluralize
+ * @api private
+ */
+
+function pluralize(str) {
+  let found;
+  str = str.toLowerCase();
+  if (!~uncountables.indexOf(str)) {
+    found = rules.filter(function(rule) {
+      return str.match(rule[0]);
+    });
+    if (found[0]) {
+      return str.replace(found[0][0], found[0][1]);
+    }
+  }
+  return str;
+}

package/.output/server/node_modules/mongoose/lib/helpers/populate/assignRawDocsToIdStructure.js

@@ -0,0 +1,136 @@
+'use strict';
+
+const clone = require('../../helpers/clone');
+const leanPopulateMap = require('./leanPopulateMap');
+const modelSymbol = require('../symbols').modelSymbol;
+const utils = require('../../utils');
+
+module.exports = assignRawDocsToIdStructure;
+
+const kHasArray = Symbol('mongoose#assignRawDocsToIdStructure#hasArray');
+
+/**
+ * Assign `vals` returned by mongo query to the `rawIds`
+ * structure returned from utils.getVals() honoring
+ * query sort order if specified by user.
+ *
+ * This can be optimized.
+ *
+ * Rules:
+ *
+ *   if the value of the path is not an array, use findOne rules, else find.
+ *   for findOne the results are assigned directly to doc path (including null results).
+ *   for find, if user specified sort order, results are assigned directly
+ *   else documents are put back in original order of array if found in results
+ *
+ * @param {Array} rawIds
+ * @param {Array} resultDocs
+ * @param {Array} resultOrder
+ * @param {Object} options
+ * @param {Boolean} recursed
+ * @api private
+ */
+
+function assignRawDocsToIdStructure(rawIds, resultDocs, resultOrder, options, recursed) {
+  // honor user specified sort order, unless we're populating a single
+  // virtual underneath an array (e.g. populating `employees.mostRecentShift` where
+  // `mostRecentShift` is a virtual with `justOne`)
+  const newOrder = [];
+  const sorting = options.isVirtual && options.justOne && rawIds.length > 1
+    ? false :
+    options.sort && rawIds.length > 1;
+  const nullIfNotFound = options.$nullIfNotFound;
+  let doc;
+  let sid;
+  let id;
+
+  if (utils.isMongooseArray(rawIds)) {
+    rawIds = rawIds.__array;
+  }
+
+  let i = 0;
+  const len = rawIds.length;
+
+  if (sorting && recursed && options[kHasArray] === undefined) {
+    options[kHasArray] = false;
+    for (const key in resultOrder) {
+      if (Array.isArray(resultOrder[key])) {
+        options[kHasArray] = true;
+        break;
+      }
+    }
+  }
+
+  for (i = 0; i < len; ++i) {
+    id = rawIds[i];
+
+    if (Array.isArray(id)) {
+      // handle [ [id0, id2], [id3] ]
+      assignRawDocsToIdStructure(id, resultDocs, resultOrder, options, true);
+      newOrder.push(id);
+      continue;
+    }
+
+    if (id === null && sorting === false) {
+      // keep nulls for findOne unless sorting, which always
+      // removes them (backward compat)
+      newOrder.push(id);
+      continue;
+    }
+
+    if (id?.constructor?.name === 'Binary' && id.sub_type === 4 && typeof id.toUUID === 'function') {
+      // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
+      sid = String(id.toUUID());
+    } else if (id?.constructor?.name === 'Buffer' && id._subtype === 4 && typeof id.toUUID === 'function') {
+      sid = String(id.toUUID());
+    } else {
+      sid = String(id);
+    }
+    doc = resultDocs[sid];
+    // If user wants separate copies of same doc, use this option
+    if (options.clone && doc != null) {
+      if (options.lean) {
+        const _model = leanPopulateMap.get(doc);
+        doc = clone(doc);
+        leanPopulateMap.set(doc, _model);
+      } else {
+        doc = doc.constructor.hydrate(doc._doc);
+      }
+    }
+
+    if (recursed) {
+      if (doc) {
+        if (sorting) {
+          const _resultOrder = resultOrder[sid];
+          if (options[kHasArray]) {
+            // If result arrays, rely on the MongoDB server response for ordering
+            newOrder.push(doc);
+          } else {
+            newOrder[_resultOrder] = doc;
+          }
+        } else {
+          newOrder.push(doc);
+        }
+      } else if (id != null && id[modelSymbol] != null) {
+        newOrder.push(id);
+      } else {
+        newOrder.push(options.retainNullValues || nullIfNotFound ? null : id);
+      }
+    } else {
+      // apply findOne behavior - if document in results, assign, else assign null
+      newOrder[i] = doc || null;
+    }
+  }
+
+  rawIds.length = 0;
+  if (newOrder.length) {
+    // reassign the documents based on corrected order
+
+    // forEach skips over sparse entries in arrays so we
+    // can safely use this to our advantage dealing with sorted
+    // result sets too.
+    newOrder.forEach(function(doc, i) {
+      rawIds[i] = doc;
+    });
+  }
+}