@nullix/zod-mongoose-studio 0.0.1

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

@@ -0,0 +1,150 @@
+'use strict';
+
+const symbols = require('../../schema/symbols');
+const promiseOrCallback = require('../promiseOrCallback');
+
+/*!
+ * ignore
+ */
+
+module.exports = applyHooks;
+
+/*!
+ * ignore
+ */
+
+applyHooks.middlewareFunctions = [
+  'deleteOne',
+  'save',
+  'validate',
+  'remove',
+  'updateOne',
+  '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)) {
+    const type = schema.paths[key];
+    let childModel = null;
+    if (type.$isSingleNested) {
+      childModel = type.caster;
+    } else if (type.$isMongooseDocumentArray) {
+      childModel = type.Constructor;
+    } else {
+      continue;
+    }
+
+    if (childModel.$appliedHooks) {
+      continue;
+    }
+
+    applyHooks(childModel, type.schema, { ...options, 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.s.hooks.
+    filter(hook => {
+      if (hook.name === 'updateOne' || hook.name === 'deleteOne') {
+        return !!hook['document'];
+      }
+      if (hook.name === 'remove' || hook.name === 'init') {
+        return hook['document'] == null || !!hook['document'];
+      }
+      if (hook.query != null || hook.document != null) {
+        return hook.document !== false;
+      }
+      return true;
+    }).
+    filter(hook => {
+      // If user has overwritten the method, don't apply built-in middleware
+      if (schema.methods[hook.name]) {
+        return !hook.fn[symbols.builtInMiddleware];
+      }
+
+      return true;
+    });
+
+  model._middleware = middleware;
+
+  objToDecorate.$__originalValidate = objToDecorate.$__originalValidate || objToDecorate.$__validate;
+
+  const internalMethodsToWrap = options && options.isChildSchema ? ['save', 'validate', 'deleteOne'] : ['save', 'validate'];
+  for (const method of internalMethodsToWrap) {
+    const toWrap = method === 'validate' ? '$__originalValidate' : `$__${method}`;
+    const wrapped = middleware.
+      createWrapper(method, objToDecorate[toWrap], null, kareemOptions);
+    objToDecorate[`$__${method}`] = wrapped;
+  }
+  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] = function() {
+      const args = Array.prototype.slice.call(arguments);
+      const cb = args.slice(-1).pop();
+      const argsWithoutCallback = typeof cb === 'function' ?
+        args.slice(0, args.length - 1) : args;
+      return promiseOrCallback(cb, callback => {
+        return this[`$__${method}`].apply(this,
+          argsWithoutCallback.concat([callback]));
+      }, model.events);
+    };
+    objToDecorate[`$__${method}`] = middleware.
+      createWrapper(method, originalMethod, null, customMethodOptions);
+  }
+}

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

@@ -0,0 +1,70 @@
+'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.caster.$appliedMethods) {
+      applyMethods(type.caster, type.schema);
+    }
+    if (type.$isMongooseDocumentArray && !type.Constructor.$appliedMethods) {
+      applyMethods(type.Constructor, type.schema);
+    }
+  }
+};

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

@@ -0,0 +1,80 @@
+'use strict';
+
+const promiseOrCallback = require('../promiseOrCallback');
+const { queryMiddlewareFunctions, aggregateMiddlewareFunctions, modelMiddlewareFunctions, documentMiddlewareFunctions } = require('../../constants');
+
+const middlewareFunctions = Array.from(
+  new Set([
+    ...queryMiddlewareFunctions,
+    ...aggregateMiddlewareFunctions,
+    ...modelMiddlewareFunctions,
+    ...documentMiddlewareFunctions
+  ])
+);
+
+module.exports = function applyStaticHooks(model, hooks, statics) {
+  const kareemOptions = {
+    useErrorHandlers: true,
+    numCallbackParams: 1
+  };
+
+  model.$__insertMany = hooks.createWrapper('insertMany',
+    model.$__insertMany, model, kareemOptions);
+
+  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] = function() {
+        const numArgs = arguments.length;
+        const lastArg = numArgs > 0 ? arguments[numArgs - 1] : null;
+        const cb = typeof lastArg === 'function' ? lastArg : null;
+        const args = Array.prototype.slice.
+          call(arguments, 0, cb == null ? numArgs : numArgs - 1);
+        // Special case: can't use `Kareem#wrap()` because it doesn't currently
+        // support wrapped functions that return a promise.
+        return promiseOrCallback(cb, callback => {
+          hooks.execPre(key, model, args, function(err) {
+            if (err != null) {
+              return callback(err);
+            }
+
+            let postCalled = 0;
+            const ret = original.apply(model, args.concat(post));
+            if (ret != null && typeof ret.then === 'function') {
+              ret.then(res => post(null, res), err => post(err));
+            }
+
+            function post(error, res) {
+              if (postCalled++ > 0) {
+                return;
+              }
+
+              if (error != null) {
+                return callback(error);
+              }
+
+              hooks.execPost(key, model, [res], function(error) {
+                if (error != null) {
+                  return callback(error);
+                }
+                callback(null, res);
+              });
+            }
+          });
+        }, model.events);
+      };
+    }
+  }
+};

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

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

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

@@ -0,0 +1,326 @@
+'use strict';
+
+const MongooseError = require('../../error/mongooseError');
+const getDiscriminatorByValue = require('../../helpers/discriminator/getDiscriminatorByValue');
+const applyTimestampsToChildren = require('../update/applyTimestampsToChildren');
+const applyTimestampsToUpdate = require('../update/applyTimestampsToUpdate');
+const cast = require('../../cast');
+const castUpdate = require('../query/castUpdate');
+const clone = require('../clone');
+const decorateUpdateWithVersionKey = require('../update/decorateUpdateWithVersionKey');
+const { inspect } = require('util');
+const setDefaultsOnInsert = require('../setDefaultsOnInsert');
+
+/**
+ * Given a model and a bulkWrite op, return a thunk that handles casting and
+ * validating the individual op.
+ * @param {Model} originalModel
+ * @param {Object} op
+ * @param {Object} [options]
+ * @api private
+ */
+
+module.exports = function castBulkWrite(originalModel, op, options) {
+  let now;
+  const timestampOpts = originalModel.schema.get('timestamps');
+  if (typeof timestampOpts?.currentTime === 'function') {
+    now = timestampOpts.currentTime();
+  } else {
+    now = originalModel.base.now();
+  }
+
+  if (op['insertOne']) {
+    return callback => module.exports.castInsertOne(originalModel, op['insertOne'], options).then(() => callback(null), err => callback(err));
+  } else if (op['updateOne']) {
+    return (callback) => {
+      try {
+        module.exports.castUpdateOne(originalModel, op['updateOne'], options, now);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['updateMany']) {
+    return (callback) => {
+      try {
+        module.exports.castUpdateMany(originalModel, op['updateMany'], options, now);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['replaceOne']) {
+    return (callback) => {
+      module.exports.castReplaceOne(originalModel, op['replaceOne'], options).then(() => callback(null), err => callback(err));
+    };
+  } else if (op['deleteOne']) {
+    return (callback) => {
+      try {
+        module.exports.castDeleteOne(originalModel, op['deleteOne']);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else if (op['deleteMany']) {
+    return (callback) => {
+      try {
+        module.exports.castDeleteMany(originalModel, op['deleteMany']);
+        callback(null);
+      } catch (err) {
+        callback(err);
+      }
+    };
+  } else {
+    return (callback) => {
+      const error = new MongooseError(`Invalid op passed to \`bulkWrite()\`: ${inspect(op)}`);
+      callback(error, null);
+    };
+  }
+};
+
+module.exports.castInsertOne = async function castInsertOne(originalModel, insertOne, options) {
+  const model = decideModelByObject(originalModel, insertOne['document']);
+
+  const doc = new model(insertOne['document']);
+  if (model.schema.options.timestamps && getTimestampsOpt(insertOne, options)) {
+    doc.initializeTimestamps();
+  }
+  if (options.session != null) {
+    doc.$session(options.session);
+  }
+  const versionKey = model?.schema?.options?.versionKey;
+  if (versionKey && doc[versionKey] == null) {
+    doc[versionKey] = 0;
+  }
+  insertOne['document'] = doc;
+
+  if (options.skipValidation || insertOne.skipValidation) {
+    return insertOne;
+  }
+
+  await insertOne['document'].$validate();
+  return insertOne;
+};
+
+module.exports.castUpdateOne = function castUpdateOne(originalModel, updateOne, options, now) {
+  if (!updateOne['filter']) {
+    throw new Error('Must provide a filter object.');
+  }
+  if (!updateOne['update']) {
+    throw new Error('Must provide an update object.');
+  }
+
+  const model = decideModelByObject(originalModel, updateOne['filter']);
+  const schema = model.schema;
+  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+
+  const update = clone(updateOne['update']);
+
+  _addDiscriminatorToObject(schema, updateOne['filter']);
+
+  const doInitTimestamps = getTimestampsOpt(updateOne, options);
+
+  if (model.schema.$timestamps != null && doInitTimestamps) {
+    const createdAt = model.schema.$timestamps.createdAt;
+    const updatedAt = model.schema.$timestamps.updatedAt;
+    applyTimestampsToUpdate(now, createdAt, updatedAt, update, {
+      timestamps: updateOne.timestamps,
+      overwriteImmutable: updateOne.overwriteImmutable
+    });
+  }
+
+  if (doInitTimestamps) {
+    applyTimestampsToChildren(now, update, model.schema);
+  }
+
+  const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateOne.setDefaultsOnInsert == null ?
+    globalSetDefaultsOnInsert :
+    updateOne.setDefaultsOnInsert;
+  if (shouldSetDefaultsOnInsert !== false) {
+    setDefaultsOnInsert(updateOne['filter'], model.schema, update, {
+      setDefaultsOnInsert: true,
+      upsert: updateOne.upsert
+    });
+  }
+
+  decorateUpdateWithVersionKey(
+    update,
+    updateOne,
+    model.schema.options.versionKey
+  );
+
+  updateOne['filter'] = cast(model.schema, updateOne['filter'], {
+    strict: strict,
+    upsert: updateOne.upsert
+  });
+  updateOne['update'] = castUpdate(model.schema, update, {
+    strict: strict,
+    upsert: updateOne.upsert,
+    arrayFilters: updateOne.arrayFilters,
+    overwriteDiscriminatorKey: updateOne.overwriteDiscriminatorKey,
+    overwriteImmutable: updateOne.overwriteImmutable
+  }, model, updateOne['filter']);
+
+  return updateOne;
+};
+
+module.exports.castUpdateMany = function castUpdateMany(originalModel, updateMany, options, now) {
+  if (!updateMany['filter']) {
+    throw new Error('Must provide a filter object.');
+  }
+  if (!updateMany['update']) {
+    throw new Error('Must provide an update object.');
+  }
+
+  const model = decideModelByObject(originalModel, updateMany['filter']);
+  const schema = model.schema;
+  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+
+  const globalSetDefaultsOnInsert = originalModel.base.options.setDefaultsOnInsert;
+  const shouldSetDefaultsOnInsert = updateMany.setDefaultsOnInsert == null ?
+    globalSetDefaultsOnInsert :
+    updateMany.setDefaultsOnInsert;
+
+  if (shouldSetDefaultsOnInsert !== false) {
+    setDefaultsOnInsert(updateMany['filter'], model.schema, updateMany['update'], {
+      setDefaultsOnInsert: true,
+      upsert: updateMany.upsert
+    });
+  }
+
+  const doInitTimestamps = getTimestampsOpt(updateMany, options);
+
+  if (model.schema.$timestamps != null && doInitTimestamps) {
+    const createdAt = model.schema.$timestamps.createdAt;
+    const updatedAt = model.schema.$timestamps.updatedAt;
+    applyTimestampsToUpdate(now, createdAt, updatedAt, updateMany['update'], {
+      timestamps: updateMany.timestamps,
+      overwriteImmutable: updateMany.overwriteImmutable
+    });
+  }
+  if (doInitTimestamps) {
+    applyTimestampsToChildren(now, updateMany['update'], model.schema);
+  }
+
+  _addDiscriminatorToObject(schema, updateMany['filter']);
+
+  decorateUpdateWithVersionKey(
+    updateMany['update'],
+    updateMany,
+    model.schema.options.versionKey
+  );
+
+  updateMany['filter'] = cast(model.schema, updateMany['filter'], {
+    strict: strict,
+    upsert: updateMany.upsert
+  });
+
+  updateMany['update'] = castUpdate(model.schema, updateMany['update'], {
+    strict: strict,
+    upsert: updateMany.upsert,
+    arrayFilters: updateMany.arrayFilters,
+    overwriteDiscriminatorKey: updateMany.overwriteDiscriminatorKey,
+    overwriteImmutable: updateMany.overwriteImmutable
+  }, model, updateMany['filter']);
+};
+
+module.exports.castReplaceOne = async function castReplaceOne(originalModel, replaceOne, options) {
+  const model = decideModelByObject(originalModel, replaceOne['filter']);
+  const schema = model.schema;
+  const strict = options.strict != null ? options.strict : model.schema.options.strict;
+
+  _addDiscriminatorToObject(schema, replaceOne['filter']);
+  replaceOne['filter'] = cast(model.schema, replaceOne['filter'], {
+    strict: strict,
+    upsert: replaceOne.upsert
+  });
+
+  // set `skipId`, otherwise we get "_id field cannot be changed"
+  const doc = new model(replaceOne['replacement'], strict, true);
+  if (model.schema.options.timestamps && getTimestampsOpt(replaceOne, options)) {
+    doc.initializeTimestamps();
+  }
+  if (options.session != null) {
+    doc.$session(options.session);
+  }
+  const versionKey = model?.schema?.options?.versionKey;
+  if (versionKey && doc[versionKey] == null) {
+    doc[versionKey] = 0;
+  }
+  replaceOne['replacement'] = doc;
+
+  if (options.skipValidation || replaceOne.skipValidation) {
+    replaceOne['replacement'] = replaceOne['replacement'].toBSON();
+    return;
+  }
+
+  await replaceOne['replacement'].$validate();
+  replaceOne['replacement'] = replaceOne['replacement'].toBSON();
+};
+
+module.exports.castDeleteOne = function castDeleteOne(originalModel, deleteOne) {
+  const model = decideModelByObject(originalModel, deleteOne['filter']);
+  const schema = model.schema;
+
+  _addDiscriminatorToObject(schema, deleteOne['filter']);
+
+  deleteOne['filter'] = cast(model.schema, deleteOne['filter']);
+};
+
+module.exports.castDeleteMany = function castDeleteMany(originalModel, deleteMany) {
+  const model = decideModelByObject(originalModel, deleteMany['filter']);
+  const schema = model.schema;
+
+  _addDiscriminatorToObject(schema, deleteMany['filter']);
+
+  deleteMany['filter'] = cast(model.schema, deleteMany['filter']);
+};
+
+module.exports.cast = {
+  insertOne: module.exports.castInsertOne,
+  updateOne: module.exports.castUpdateOne,
+  updateMany: module.exports.castUpdateMany,
+  replaceOne: module.exports.castReplaceOne,
+  deleteOne: module.exports.castDeleteOne,
+  deleteMany: module.exports.castDeleteMany
+};
+
+function _addDiscriminatorToObject(schema, obj) {
+  if (schema == null) {
+    return;
+  }
+  if (schema.discriminatorMapping && !schema.discriminatorMapping.isRoot) {
+    obj[schema.discriminatorMapping.key] = schema.discriminatorMapping.value;
+  }
+}
+
+/**
+ * gets discriminator model if discriminator key is present in object
+ * @api private
+ */
+
+function decideModelByObject(model, object) {
+  const discriminatorKey = model.schema.options.discriminatorKey;
+  if (object != null && Object.hasOwn(object, discriminatorKey)) {
+    model = getDiscriminatorByValue(model.discriminators, object[discriminatorKey]) || model;
+  }
+  return model;
+}
+
+/**
+ * gets timestamps option for a given operation. If the option is set within an individual operation, use it. Otherwise, use the global timestamps option configured in the `bulkWrite` options. Overall default is `true`.
+ * @api private
+ */
+
+function getTimestampsOpt(opCommand, options) {
+  const opLevelOpt = opCommand.timestamps;
+  const bulkLevelOpt = options.timestamps;
+  if (opLevelOpt != null) {
+    return opLevelOpt;
+  } else if (bulkLevelOpt != null) {
+    return bulkLevelOpt;
+  }
+  return true;
+}

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

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports = function decorateBulkWriteResult(resultOrError, validationErrors, results) {
+  resultOrError.mongoose = resultOrError.mongoose || {};
+  resultOrError.mongoose.validationErrors = validationErrors;
+  resultOrError.mongoose.results = results;
+  return resultOrError;
+};