@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongoose/lib/cast/boolean.js

@@ -6,9 +6,9 @@ const CastError = require('../error/cast');
  * Given a value, cast it to a boolean, or throw a `CastError` if the value
  * cannot be casted. `null` and `undefined` are considered valid.
  *
- * @param {Any} value
- * @param {String} [path] optional the path to set on the CastError
- * @return {Boolean|null|undefined}
+ * @param {any} value
+ * @param {string} [path] optional the path to set on the CastError
+ * @return {boolean|null|undefined}
  * @throws {CastError} if `value` is not one of the allowed values
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/cast/double.js

@@ -1,15 +1,15 @@
 'use strict';
 
 const assert = require('assert');
-const BSON = require('bson');
+const BSON = require('mongodb/lib/bson');
 const isBsonType = require('../helpers/isBsonType');
 
 /**
  * Given a value, cast it to a IEEE 754-2008 floating point, or throw an `Error` if the value
  * cannot be casted. `null`, `undefined`, and `NaN` are considered valid inputs.
  *
- * @param {Any} value
- * @return {Number}
+ * @param {any} value
+ * @return {number}
  * @throws {Error} if `value` does not represent a IEEE 754-2008 floating point. If casting from a string, see [BSON Double.fromString API documentation](https://mongodb.github.io/node-mongodb-native/Next/classes/BSON.Double.html#fromString)
  * @api private
  */
@@ -34,7 +34,7 @@ module.exports = function castDouble(val) {
     // ex: { a: 'im an object, valueOf: () => 'helloworld' } // throw an error
     if (typeof tempVal === 'string') {
       try {
-        coercedVal = BSON.Double.fromString(val);
+        coercedVal = BSON.Double.fromString(tempVal);
         return coercedVal;
       } catch {
         assert.ok(false);

package/.output/server/node_modules/mongoose/lib/cast/int32.js

@@ -7,8 +7,8 @@ const assert = require('assert');
  * Given a value, cast it to a Int32, or throw an `Error` if the value
  * cannot be casted. `null` and `undefined` are considered valid.
  *
- * @param {Any} value
- * @return {Number}
+ * @param {any} value
+ * @return {number}
  * @throws {Error} if `value` does not represent an integer, or is outside the bounds of an 32-bit integer.
  * @api private
  */

package/.output/server/node_modules/mongoose/lib/cast/number.js

@@ -1,13 +1,11 @@
 'use strict';
 
-const assert = require('assert');
-
 /**
  * Given a value, cast it to a number, or throw an `Error` if the value
  * cannot be casted. `null` and `undefined` are considered valid.
  *
- * @param {Any} value
- * @return {Number}
+ * @param {any} value
+ * @return {number}
  * @throws {Error} if `value` is not one of the allowed values
  * @api private
  */
@@ -24,7 +22,9 @@ module.exports = function castNumber(val) {
     val = Number(val);
   }
 
-  assert.ok(!isNaN(val));
+  if (isNaN(val)) {
+    throw new Error('Cast to Number failed: value is not a valid number');
+  }
   if (val instanceof Number) {
     return val.valueOf();
   }
@@ -38,5 +38,5 @@ module.exports = function castNumber(val) {
     return Number(val);
   }
 
-  assert.ok(false);
+  throw new Error('Cast to Number failed: value is not a valid number');
 };

package/.output/server/node_modules/mongoose/lib/cast/string.js

@@ -6,8 +6,8 @@ const CastError = require('../error/cast');
  * Given a value, cast it to a string, or throw a `CastError` if the value
  * cannot be casted. `null` and `undefined` are considered valid.
  *
- * @param {Any} value
- * @param {String} [path] optional the path to set on the CastError
+ * @param {any} value
+ * @param {string} [path] optional the path to set on the CastError
  * @return {string|null|undefined}
  * @throws {CastError}
  * @api private
@@ -20,7 +20,7 @@ module.exports = function castString(value, path) {
   }
 
   // handle documents being passed
-  if (value._id && typeof value._id === 'string') {
+  if (typeof value?._id === 'string') {
     return value._id;
   }
 

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

@@ -1,43 +1,31 @@
 'use strict';
 
-const MongooseBuffer = require('../types/buffer');
+const UUID = require('mongodb/lib/bson').UUID;
 
 const UUID_FORMAT = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i;
-const Binary = MongooseBuffer.Binary;
 
 module.exports = function castUUID(value) {
   if (value == null) {
     return value;
   }
 
-  function newBuffer(initbuff) {
-    const buff = new MongooseBuffer(initbuff);
-    buff._subtype = 4;
-    return buff;
+  if (value instanceof UUID) {
+    return value;
   }
-
   if (typeof value === 'string') {
     if (UUID_FORMAT.test(value)) {
-      return stringToBinary(value);
+      return new UUID(value);
     } else {
       throw new Error(`"${value}" is not a valid UUID string`);
     }
   }
 
-  if (Buffer.isBuffer(value)) {
-    return newBuffer(value);
-  }
-
-  if (value instanceof Binary) {
-    return newBuffer(value.value(true));
-  }
-
   // Re: gh-647 and gh-3030, we're ok with casting using `toString()`
   // **unless** its the default Object.toString, because "[object Object]"
   // doesn't really qualify as useful data
   if (value.toString && value.toString !== Object.prototype.toString) {
     if (UUID_FORMAT.test(value.toString())) {
-      return stringToBinary(value.toString());
+      return new UUID(value.toString());
     }
   }
 
@@ -45,34 +33,3 @@ module.exports = function castUUID(value) {
 };
 
 module.exports.UUID_FORMAT = UUID_FORMAT;
-
-/**
- * Helper function to convert the input hex-string to a buffer
- * @param {String} hex The hex string to convert
- * @returns {Buffer} The hex as buffer
- * @api private
- */
-
-function hex2buffer(hex) {
-  // use buffer built-in function to convert from hex-string to buffer
-  const buff = hex != null && Buffer.from(hex, 'hex');
-  return buff;
-}
-
-/**
- * Convert a String to Binary
- * @param {String} uuidStr The value to process
- * @returns {MongooseBuffer} The binary to store
- * @api private
- */
-
-function stringToBinary(uuidStr) {
-  // Protect against undefined & throwing err
-  if (typeof uuidStr !== 'string') uuidStr = '';
-  const hex = uuidStr.replace(/[{}-]/g, ''); // remove extra characters
-  const bytes = hex2buffer(hex);
-  const buff = new MongooseBuffer(bytes);
-  buff._subtype = 4;
-
-  return buff;
-}

package/.output/server/node_modules/mongoose/lib/cast.js

@@ -24,25 +24,25 @@ const ALLOWED_GEOWITHIN_GEOJSON_TYPES = ['Polygon', 'MultiPolygon'];
  * Handles internal casting for query filters.
  *
  * @param {Schema} schema
- * @param {Object} obj Object to cast
- * @param {Object} [options] the query options
- * @param {Boolean|"throw"} [options.strict] Wheter to enable all strict options
- * @param {Boolean|"throw"} [options.strictQuery] Enable strict Queries
- * @param {Boolean} [options.sanitizeFilter] avoid adding implict query selectors ($in)
- * @param {Boolean} [options.upsert]
+ * @param {object} obj Object to cast
+ * @param {object} [options] the query options
+ * @param {boolean|"throw"} [options.strict] Whether to enable all strict options
+ * @param {boolean|"throw"} [options.strictQuery] Enable strict Queries
+ * @param {boolean} [options.sanitizeFilter] avoid adding implicit query selectors ($in)
+ * @param {boolean} [options.upsert]
  * @param {Query} [context] passed to setters
  * @api private
  */
 module.exports = function cast(schema, obj, options, context) {
   if (Array.isArray(obj)) {
-    throw new Error('Query filter must be an object, got an array ', util.inspect(obj));
+    throw new Error('Query filter must be an object, got an array ' + util.inspect(obj));
   }
 
   if (obj == null) {
     return obj;
   }
 
-  if (schema != null && schema.discriminators != null && obj[schema.options.discriminatorKey] != null) {
+  if (schema?.discriminators != null && obj[schema.options.discriminatorKey] != null) {
     schema = getSchemaDiscriminatorByValue(schema, obj[schema.options.discriminatorKey]) || schema;
   }
 
@@ -79,7 +79,7 @@ module.exports = function cast(schema, obj, options, context) {
           val[k] = cast(discriminatorSchema ? discriminatorSchema : schema, val[k], options, context);
         }
 
-        if (Object.keys(val[k]).length === 0 && beforeCastKeysLength !== 0) {
+        if (utils.hasOwnKeys(val[k]) === false && beforeCastKeysLength !== 0) {
           val.splice(k, 1);
         }
       }
@@ -126,16 +126,12 @@ module.exports = function cast(schema, obj, options, context) {
           const pathFirstHalf = split.slice(0, j).join('.');
           const pathLastHalf = split.slice(j).join('.');
           const _schematype = schema.path(pathFirstHalf);
-          const discriminatorKey = _schematype &&
-            _schematype.schema &&
-            _schematype.schema.options &&
-            _schematype.schema.options.discriminatorKey;
+          const discriminatorKey = _schematype?.schema?.options?.discriminatorKey;
 
           // gh-6027: if we haven't found the schematype but this path is
           // underneath an embedded discriminator and the embedded discriminator
           // key is in the query, use the embedded discriminator schema
-          if (_schematype != null &&
-            (_schematype.schema && _schematype.schema.discriminators) != null &&
+          if (_schematype?.schema?.discriminators != null &&
             discriminatorKey != null &&
             pathLastHalf !== discriminatorKey) {
             const discriminatorVal = get(obj, pathFirstHalf + '.' + discriminatorKey);
@@ -175,12 +171,12 @@ module.exports = function cast(schema, obj, options, context) {
         // If a substring of the input path resolves to an actual real path...
         if (schematype) {
           // Apply the casting; similar code for $elemMatch in schema/array.js
-          if (schematype.caster && schematype.caster.schema) {
+          if (schematype.schema) {
             remainingConds = {};
             pathLastHalf = split.slice(j).join('.');
             remainingConds[pathLastHalf] = val;
 
-            const ret = cast(schematype.caster.schema, remainingConds, options, context)[pathLastHalf];
+            const ret = cast(schematype.schema, remainingConds, options, context)[pathLastHalf];
             if (ret === void 0) {
               delete obj[path];
             } else {
@@ -330,9 +326,9 @@ module.exports = function cast(schema, obj, options, context) {
             $cond = ks[k];
             nested = val[$cond];
             if ($cond === '$elemMatch') {
-              if (nested && schematype != null && schematype.schema != null) {
+              if (nested && schematype?.schema != null) {
                 cast(schematype.schema, nested, options, context);
-              } else if (nested && schematype != null && schematype.$isMongooseArray) {
+              } else if (nested && schematype?.$isMongooseArray) {
                 if (utils.isPOJO(nested) && nested.$not != null) {
                   cast(schema, nested, options, context);
                 } else {
@@ -430,11 +426,7 @@ function getStrictQuery(queryOptions, schemaUserProvidedOptions, schemaOptions,
   if ('strictQuery' in schemaUserProvidedOptions) {
     return schemaUserProvidedOptions.strictQuery;
   }
-  const mongooseOptions = context &&
-    context.mongooseCollection &&
-    context.mongooseCollection.conn &&
-    context.mongooseCollection.conn.base &&
-    context.mongooseCollection.conn.base.options;
+  const mongooseOptions = context?.mongooseCollection?.conn?.base?.options;
   if (mongooseOptions) {
     if ('strictQuery' in mongooseOptions) {
       return mongooseOptions.strictQuery;

package/.output/server/node_modules/mongoose/lib/collection.js

@@ -13,9 +13,9 @@ const immediate = require('./helpers/immediate');
  *
  * This is the base class that drivers inherit from and implement.
  *
- * @param {String} name name of the collection
+ * @param {string} name name of the collection
  * @param {Connection} conn A MongooseConnection instance
- * @param {Object} [opts] optional collection options
+ * @param {object} [opts] optional collection options
  * @api public
  */
 
@@ -87,7 +87,7 @@ Collection.prototype.onClose = function() {};
  * Queues a method for later execution when its
  * database connection opens.
  *
- * @param {String} name name of the method to queue
+ * @param {string} name name of the method to queue
  * @param {Array} args arguments to pass to the method when executed
  * @api private
  */
@@ -100,7 +100,7 @@ Collection.prototype.addQueue = function(name, args) {
 /**
  * Removes a queued method
  *
- * @param {String} name name of the method to queue
+ * @param {string} name name of the method to queue
  * @param {Array} args arguments to pass to the method when executed
  * @api private
  */
@@ -290,7 +290,7 @@ Collection.prototype._shouldBufferCommands = function _shouldBufferCommands() {
   if (opts.bufferCommands != null) {
     return opts.bufferCommands;
   }
-  if (opts && opts.schemaUserProvidedOptions != null && opts.schemaUserProvidedOptions.bufferCommands != null) {
+  if (opts?.schemaUserProvidedOptions?.bufferCommands != null) {
     return opts.schemaUserProvidedOptions.bufferCommands;
   }
 
@@ -308,7 +308,7 @@ Collection.prototype._getBufferTimeoutMS = function _getBufferTimeoutMS() {
   if (opts.bufferTimeoutMS != null) {
     return opts.bufferTimeoutMS;
   }
-  if (opts && opts.schemaUserProvidedOptions != null && opts.schemaUserProvidedOptions.bufferTimeoutMS != null) {
+  if (opts?.schemaUserProvidedOptions?.bufferTimeoutMS != null) {
     return opts.schemaUserProvidedOptions.bufferTimeoutMS;
   }
   return conn._getBufferTimeoutMS();