@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongoose/lib/types/map.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const Mixed = require('../schema/mixed');
 const MongooseError = require('../error/mongooseError');
 const clone = require('../helpers/clone');
 const deepEqual = require('../utils').deepEqual;
@@ -17,30 +18,14 @@ const populateModelSymbol = require('../helpers/symbols').populateModelSymbol;
  */
 
 class MongooseMap extends Map {
-  constructor(v, path, doc, schemaType, options) {
+  constructor(v, path, doc, schemaType) {
     if (getConstructorName(v) === 'Object') {
       v = Object.keys(v).reduce((arr, key) => arr.concat([[key, v[key]]]), []);
     }
     super(v);
-    this.$__parent = doc != null && doc.$__ != null ? doc : null;
-
-    // Calculate the full path from the root document
-    // Priority: parent.$basePath (from subdoc) > options.path (from parent map/structure) > path (schema path)
-    // Subdocuments have the most up-to-date path info, so prefer that over options.path
-    if (this.$__parent?.$isSingleNested && this.$__parent.$basePath) {
-      this.$__path = this.$__parent.$basePath + '.' + path;
-      // Performance optimization: store path relative to parent subdocument
-      // to avoid string operations in set() hot path
-      this.$__pathRelativeToParent = path;
-    } else if (options?.path) {
-      this.$__path = options.path;
-      this.$__pathRelativeToParent = null;
-    } else {
-      this.$__path = path;
-      this.$__pathRelativeToParent = null;
-    }
-
-    this.$__schemaType = schemaType;
+    this.$__parent = doc?.$__ != null ? doc : null;
+    this.$__path = path;
+    this.$__schemaType = schemaType == null ? new Mixed(path) : schemaType;
 
     this.$__runDeferred();
   }
@@ -50,16 +35,8 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    if (value != null && value.$isSingleNested) {
+    if (value?.$isSingleNested) {
       value.$basePath = this.$__path + '.' + key;
-      // Store the path relative to parent subdoc for efficient markModified()
-      if (this.$__pathRelativeToParent != null) {
-        // Map's parent is a subdocument, store path relative to that subdoc
-        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Map's parent is root document, store the full path
-        value.$pathRelativeToParent = this.$__path + '.' + key;
-      }
     }
   }
 
@@ -129,7 +106,7 @@ class MongooseMap extends Map {
 
     let _fullPath;
     const parent = this.$__parent;
-    const populated = parent != null && parent.$__ && parent.$__.populated ?
+    const populated = parent?.$__?.populated ?
       parent.$populated(fullPath.call(this), true) || parent.$populated(this.$__path, true) :
       null;
     const priorVal = this.get(key);
@@ -159,16 +136,9 @@ class MongooseMap extends Map {
       }
     } else {
       try {
-        let options = null;
-        if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap) {
-          options = { path: fullPath.call(this) };
-          // For subdocuments, also pass the relative path to avoid string operations
-          if (this.$__schemaType.$isSingleNested) {
-            options.pathRelativeToParent = this.$__pathRelativeToParent != null ?
-              this.$__pathRelativeToParent + '.' + key :
-              this.$__path + '.' + key;
-          }
-        }
+        const options = this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested || this.$__schemaType.$isMongooseArray || this.$__schemaType.$isSchemaMap ?
+          { path: fullPath.call(this) } :
+          null;
         value = this.$__schemaType.applySetters(
           value,
           this.$__parent,
@@ -177,7 +147,7 @@ class MongooseMap extends Map {
           options
         );
       } catch (error) {
-        if (this.$__parent != null && this.$__parent.$__ != null) {
+        if (this.$__parent?.$__ != null) {
           this.$__parent.invalidate(fullPath.call(this), error);
           return;
         }
@@ -187,34 +157,13 @@ class MongooseMap extends Map {
 
     super.set(key, value);
 
-    // Set relative path on subdocuments to avoid string operations in markModified()
-    // The path should be relative to the parent subdocument (if any), not just the key
-    if (value != null && value.$isSingleNested) {
-      if (this.$__pathRelativeToParent != null) {
-        // Map's parent is a subdocument, store path relative to that subdoc (e.g., 'items.i2')
-        value.$pathRelativeToParent = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Map's parent is root document, store just the full path
-        value.$pathRelativeToParent = this.$__path + '.' + key;
-      }
-    }
-
-    if (parent != null && parent.$__ != null && !deepEqual(value, priorVal)) {
-      // Optimization: if parent is a subdocument, use precalculated relative path
-      // to avoid building a full path just to strip the parent's prefix
-      let pathToMark;
-      if (this.$__pathRelativeToParent != null) {
-        // Parent is a subdocument - use precalculated relative path (e.g., 'items.i1')
-        pathToMark = this.$__pathRelativeToParent + '.' + key;
-      } else {
-        // Parent is root document or map - use full path
-        pathToMark = fullPath.call(this);
-      }
-      parent.markModified(pathToMark);
+    if (parent?.$__ != null && !deepEqual(value, priorVal)) {
+      const path = fullPath.call(this);
+      parent.markModified(path);
       // If overwriting the full document array or subdoc, make sure to clean up any paths that were modified
       // before re: #15108
       if (this.$__schemaType.$isMongooseDocumentArray || this.$__schemaType.$isSingleNested) {
-        cleanModifiedSubpaths(parent, pathToMark);
+        cleanModifiedSubpaths(parent, path);
       }
     }
 
@@ -275,7 +224,7 @@ class MongooseMap extends Map {
   }
 
   toObject(options) {
-    if (options && options.flattenMaps) {
+    if (options?.flattenMaps) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {
@@ -302,13 +251,13 @@ class MongooseMap extends Map {
    *
    * @api public
    * @method toJSON
-   * @param {Object} [options]
-   * @param {Boolean} [options.flattenMaps=false] set to `true` to convert the map to a POJO rather than a native JavaScript map
+   * @param {object} [options]
+   * @param {boolean} [options.flattenMaps=false] set to `true` to convert the map to a POJO rather than a native JavaScript map
    * @memberOf Map
    */
 
   toJSON(options) {
-    if (typeof (options && options.flattenMaps) === 'boolean' ? options.flattenMaps : true) {
+    if (typeof options?.flattenMaps === 'boolean' ? options.flattenMaps : true) {
       const ret = {};
       const keys = this.keys();
       for (const key of keys) {
@@ -396,7 +345,7 @@ Object.defineProperty(MongooseMap.prototype, '$__deferredCalls', {
 /**
  * Since maps are stored as objects under the hood, keys must be strings
  * and can't contain any invalid characters
- * @param {String} key
+ * @param {string} key
  * @api private
  */
 

package/.output/server/node_modules/mongoose/lib/types/objectid.js

@@ -10,7 +10,7 @@
 
 'use strict';
 
-const ObjectId = require('bson').ObjectId;
+const ObjectId = require('mongodb/lib/bson').ObjectId;
 const objectIdSymbol = require('../helpers/symbols').objectIdSymbol;
 
 /**

package/.output/server/node_modules/mongoose/lib/types/subdocument.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const Document = require('../document');
-const immediate = require('../helpers/immediate');
 const internalToObjectOptions = require('../options').internalToObjectOptions;
 const util = require('util');
 const utils = require('../utils');
@@ -15,11 +14,7 @@ module.exports = Subdocument;
  * @api private
  */
 
-function Subdocument(value, fields, parent, skipId, options) {
-  if (typeof skipId === 'object' && skipId != null && options == null) {
-    options = skipId;
-    skipId = undefined;
-  }
+function Subdocument(value, fields, parent, options) {
   if (parent != null) {
     // If setting a nested path, should copy isNew from parent re: gh-7048
     const parentOptions = { isNew: parent.isNew };
@@ -28,24 +23,10 @@ function Subdocument(value, fields, parent, skipId, options) {
     }
     options = Object.assign(parentOptions, options);
   }
-  if (options != null && options.path != null) {
+  if (options?.path != null) {
     this.$basePath = options.path;
   }
-  if (options != null && options.pathRelativeToParent != null) {
-    this.$pathRelativeToParent = options.pathRelativeToParent;
-  }
-
-  // Don't pass `path` to Document constructor: path is used for storing the
-  // absolute path to this schematype relative to the top-level document, but
-  // subdocuments use relative paths (relative to the parent document) to track changes.
-  // This avoids the subdocument's fields receiving the subdocument's path as options.path.
-  let documentOptions = options;
-  if (options != null && options.path != null) {
-    documentOptions = Object.assign({}, options);
-    delete documentOptions.path;
-  }
-
-  Document.call(this, value, fields, skipId, documentOptions);
+  Document.call(this, value, fields, options);
 
   delete this.$__.priorDoc;
 }
@@ -79,7 +60,11 @@ Subdocument.prototype.toBSON = function() {
  *
  * _This is a no-op. Does not actually save the doc to the db._
  *
- * @param {Function} [fn]
+ * @param {object} [options]
+ * @param {boolean} [options.suppressWarning=false] If `true`, suppress the warning about calling `save()` on a subdoc.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @return {Promise} resolved Promise
  * @api private
  */
@@ -94,24 +79,17 @@ Subdocument.prototype.save = async function save(options) {
       'if you\'re sure this behavior is right for your app.');
   }
 
-  return new Promise((resolve, reject) => {
-    this.$__save((err) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve(this);
-    });
-  });
+  return await this.$__save(options);
 };
 
 /**
  * Given a path relative to this document, return the path relative
  * to the top-level document.
- * @param {String} path
+ * @param {string} path
  * @method $__fullPath
  * @memberOf Subdocument
  * @instance
- * @returns {String}
+ * @returns {string}
  * @api private
  */
 
@@ -128,8 +106,8 @@ Subdocument.prototype.$__fullPath = function(path) {
 /**
  * Given a path relative to this document, return the path relative
  * to the parent document.
- * @param {String} p
- * @returns {String}
+ * @param {string} p
+ * @returns {string}
  * @method $__pathRelativeToParent
  * @memberOf Subdocument
  * @instance
@@ -137,12 +115,6 @@ Subdocument.prototype.$__fullPath = function(path) {
  */
 
 Subdocument.prototype.$__pathRelativeToParent = function(p) {
-  // If this subdocument has a stored relative path (set by map when subdoc is created),
-  // use it directly to avoid string operations
-  if (this.$pathRelativeToParent != null) {
-    return p == null ? this.$pathRelativeToParent : this.$pathRelativeToParent + '.' + p;
-  }
-
   if (p == null) {
     return this.$basePath;
   }
@@ -164,8 +136,15 @@ Subdocument.prototype.$__pathRelativeToParent = function(p) {
  * @api private
  */
 
-Subdocument.prototype.$__save = function(fn) {
-  return immediate(() => fn(null, this));
+Subdocument.prototype.$__save = async function $__save(options) {
+  try {
+    await this._execDocumentPreHooks('save', options, [options]);
+  } catch (error) {
+    await this._execDocumentPostHooks('save', options, error);
+    return;
+  }
+
+  await this._execDocumentPostHooks('save', options);
 };
 
 /*!
@@ -188,13 +167,9 @@ Subdocument.prototype.$isValid = function(path) {
 Subdocument.prototype.markModified = function(path) {
   Document.prototype.markModified.call(this, path);
   const parent = this.$parent();
+  const fullPath = this.$__pathRelativeToParent(path);
 
-  if (parent == null) {
-    return;
-  }
-
-  const pathToMark = this.$__pathRelativeToParent(path);
-  if (pathToMark == null) {
+  if (parent == null || fullPath == null) {
     return;
   }
 
@@ -202,8 +177,7 @@ Subdocument.prototype.markModified = function(path) {
   if (parent.isDirectModified(myPath) || this.isNew) {
     return;
   }
-
-  this.$__parent.markModified(pathToMark, this);
+  this.$__parent.markModified(fullPath, this);
 };
 
 /*!
@@ -229,7 +203,7 @@ Subdocument.prototype.isModified = function(paths, options, modifiedPaths) {
 /**
  * Marks a path as valid, removing existing validation errors.
  *
- * @param {String} path the field to mark as valid
+ * @param {string} path the field to mark as valid
  * @api private
  * @method $markValid
  * @memberOf Subdocument
@@ -286,7 +260,7 @@ Subdocument.prototype.ownerDocument = function() {
     return this.$__.ownerDocument;
   }
 
-  let parent = this; // eslint-disable-line consistent-this
+  let parent = this;
   const paths = [];
   const seenDocs = new Set([parent]);
 
@@ -318,7 +292,7 @@ Subdocument.prototype.ownerDocument = function() {
  */
 
 Subdocument.prototype.$__fullPathWithIndexes = function() {
-  let parent = this; // eslint-disable-line consistent-this
+  let parent = this;
   const paths = [];
   const seenDocs = new Set([parent]);
 
@@ -371,22 +345,6 @@ Subdocument.prototype.$__setParent = function $__setParent(parent) {
   this.$__parent = parent;
 };
 
-/**
- * no-op for hooks
- * @param {Function} cb
- * @method $__deleteOne
- * @memberOf Subdocument
- * @instance
- * @api private
- */
-
-Subdocument.prototype.$__deleteOne = function(cb) {
-  if (cb == null) {
-    return;
-  }
-  return cb(null, this);
-};
-
 /**
  * ignore
  * @method $__removeFromParent
@@ -402,27 +360,20 @@ Subdocument.prototype.$__removeFromParent = function() {
 /**
  * Null-out this subdoc
  *
- * @param {Object} [options]
- * @param {Function} [callback] optional callback for compatibility with Document.prototype.remove
+ * @param {object} [options]
  */
 
-Subdocument.prototype.deleteOne = function(options, callback) {
-  if (typeof options === 'function') {
-    callback = options;
-    options = null;
-  }
+Subdocument.prototype.deleteOne = function deleteOne(options) {
   registerRemoveListener(this);
 
   // If removing entire doc, no need to remove subdoc
-  if (!options || !options.noop) {
+  if (!options?.noop) {
     this.$__removeFromParent();
 
     const owner = this.ownerDocument();
     owner.$__.removedSubdocs = owner.$__.removedSubdocs || [];
     owner.$__.removedSubdocs.push(this);
   }
-
-  return this.$__deleteOne(callback);
 };
 
 /*!
@@ -460,7 +411,7 @@ Subdocument.prototype.$toObject = function $toObject(options, json) {
 
   // If `$toObject()` was called recursively, respect the minimize option, including schematype level minimize.
   // If minimize is set, then we can minimize out the whole object.
-  if (Object.keys(ret).length === 0 && options?._calledWithOptions != null) {
+  if (utils.hasOwnKeys(ret) === false && options?._calledWithOptions != null) {
     const minimize = options._calledWithOptions?.minimize ?? this?.$__schemaTypeOptions?.minimize ?? options.minimize;
     if (minimize && !this.constructor.$__required) {
       return undefined;

package/.output/server/node_modules/mongoose/lib/types/uuid.js

@@ -10,4 +10,4 @@
 
 'use strict';
 
-module.exports = require('bson').UUID;
+module.exports = require('mongodb/lib/bson').UUID;