@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

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

@@ -8,7 +8,6 @@ const SchemaType = require('../schemaType');
 const MongooseError = require('../error/index');
 const SchemaStringOptions = require('../options/schemaStringOptions');
 const castString = require('../cast/string');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const isBsonType = require('../helpers/isBsonType');
 
@@ -17,9 +16,9 @@ const CastError = SchemaType.CastError;
 /**
  * String SchemaType constructor.
  *
- * @param {String} key
- * @param {Object} options
- * @param {Object} schemaOptions
+ * @param {string} key
+ * @param {object} options
+ * @param {object} schemaOptions
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
@@ -111,7 +110,7 @@ SchemaString._defaultCaster = v => {
  * #### Example:
  *
  *     // Make all numbers round down
- *     mongoose.Schema.String.get(v => v.toLowerCase());
+ *     mongoose.Schema.Types.String.get(v => v.toLowerCase());
  *
  *     const Model = mongoose.model('Test', new Schema({ test: String }));
  *     new Model({ test: 'FOO' }).test; // 'foo'
@@ -131,13 +130,13 @@ SchemaString.get = SchemaType.get;
  * #### Example:
  *
  *     // Make all strings have option `trim` equal to true.
- *     mongoose.Schema.String.set('trim', true);
+ *     mongoose.Schema.Types.String.set('trim', true);
  *
  *     const User = mongoose.model('User', new Schema({ name: String }));
  *     new User({ name: '   John Doe   ' }).name; // 'John Doe'
  *
- * @param {String} option The option you'd like to set the value for
- * @param {Any} value value for option
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
  * @return {undefined}
  * @function set
  * @static
@@ -204,7 +203,7 @@ SchemaString.checkRequired = SchemaType.checkRequired;
  *     await m.save();
  *     // success
  *
- * @param {...String|Object} [args] enumeration values
+ * @param {...string|object} [args] enumeration values
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
  * @see Enums in JavaScript https://masteringjs.io/tutorials/fundamentals/enum
@@ -402,8 +401,8 @@ SchemaString.prototype.trim = function(shouldTrim) {
  *       console.log(String(err)) // ValidationError: The value of path `postalCode` (`9512`) is shorter than the minimum length (5).
  *     })
  *
- * @param {Number} value minimum string length
- * @param {String} [message] optional custom error message
+ * @param {number} value minimum string length
+ * @param {string} [message] optional custom error message
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
  * @api public
@@ -416,7 +415,7 @@ SchemaString.prototype.minlength = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.String.minlength;
     msg = msg.replace(/{MINLENGTH}/, value);
     this.validators.push({
@@ -458,8 +457,8 @@ SchemaString.prototype.minLength = SchemaString.prototype.minlength;
  *       console.log(String(err)) // ValidationError: The value of path `postalCode` (`9512512345`) exceeds the maximum allowed length (9).
  *     })
  *
- * @param {Number} value maximum string length
- * @param {String} [message] optional custom error message
+ * @param {number} value maximum string length
+ * @param {string} [message] optional custom error message
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
  * @api public
@@ -472,14 +471,16 @@ SchemaString.prototype.maxlength = function(value, message) {
     }, this);
   }
 
-  if (value !== null && value !== undefined) {
+  if (value != null) {
     let msg = message || MongooseError.messages.String.maxlength;
-    msg = msg.replace(/{MAXLENGTH}/, value);
+    if (typeof msg !== 'function') {
+      msg = msg.replace(/{MAXLENGTH}/, value);
+    }
     this.validators.push({
       validator: this.maxlengthValidator = function(v) {
         return v === null || v.length <= value;
       },
-      message: msg,
+      message: formatMaxLengthValidatorMessage(msg),
       type: 'maxlength',
       maxlength: value
     });
@@ -522,7 +523,7 @@ SchemaString.prototype.maxLength = SchemaString.prototype.maxlength;
  *     const s = new Schema({ name: { type: String, match: /^a/, required: true }})
  *
  * @param {RegExp} regExp regular expression to test against
- * @param {String} [message] optional custom error message
+ * @param {string} [message] optional custom error message
  * @return {SchemaType} this
  * @see Customized Error Messages https://mongoosejs.com/docs/api/error.html#Error.messages
  * @api public
@@ -563,9 +564,9 @@ SchemaString.prototype.match = function match(regExp, message) {
  * has positive length. The `required` validator **will** fail for empty
  * strings.
  *
- * @param {Any} value
+ * @param {any} value
  * @param {Document} doc
- * @return {Boolean}
+ * @return {boolean}
  * @api public
  */
 
@@ -605,7 +606,7 @@ SchemaString.prototype.cast = function(value, doc, init, prev, options) {
 
   try {
     return castString(value);
-  } catch (error) {
+  } catch {
     throw new CastError('string', value, this.path, null, this);
   }
 };
@@ -680,7 +681,7 @@ Object.defineProperty(SchemaString.prototype, '$conditionalHandlers', {
 /**
  * Casts contents for queries.
  *
- * @param {String} $conditional
+ * @param {string} $conditional
  * @param {any} [val]
  * @api private
  */
@@ -712,14 +713,13 @@ SchemaString.prototype.castForQuery = function($conditional, val, context) {
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaString.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'string', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'string', options);
 };
 
 SchemaString.prototype.autoEncryptionType = function autoEncryptionType() {
@@ -731,3 +731,18 @@ SchemaString.prototype.autoEncryptionType = function autoEncryptionType() {
  */
 
 module.exports = SchemaString;
+
+function formatMaxLengthValidatorMessage(msg) {
+  return function(props, doc) {
+    if (typeof msg === 'function') {
+      return MongooseError.ValidatorError.prototype.formatMessage(msg, props, doc);
+    }
+
+    if (typeof msg === 'string' && typeof props.value === 'string' && props.value.length > 30) {
+      props = Object.assign({}, props, {
+        value: props.value.slice(0, 30) + '...'
+      });
+    }
+    return MongooseError.ValidatorError.prototype.formatMessage(msg, props, doc);
+  };
+}

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

@@ -12,7 +12,6 @@ const SchemaType = require('../schemaType');
 const applyDefaults = require('../helpers/document/applyDefaults');
 const $exists = require('./operators/exists');
 const castToNumber = require('./operators/helpers').castToNumber;
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const geospatial = require('./operators/geospatial');
 const getConstructor = require('../helpers/discriminator/getConstructor');
@@ -30,8 +29,8 @@ module.exports = SchemaSubdocument;
  * Single nested subdocument SchemaType constructor.
  *
  * @param {Schema} schema
- * @param {String} path
- * @param {Object} options
+ * @param {string} path
+ * @param {object} options
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
@@ -41,8 +40,7 @@ function SchemaSubdocument(schema, path, options, parentSchema) {
   if (schema.options.timeseries) {
     throw new InvalidSchemaOptionError(path, 'timeseries');
   }
-  const schemaTypeIdOption = SchemaSubdocument.defaultOptions &&
-    SchemaSubdocument.defaultOptions._id;
+  const schemaTypeIdOption = SchemaSubdocument.defaultOptions?._id;
   if (schemaTypeIdOption != null) {
     options = options || {};
     options._id = schemaTypeIdOption;
@@ -50,9 +48,9 @@ function SchemaSubdocument(schema, path, options, parentSchema) {
 
   schema = handleIdOption(schema, options);
 
-  this.caster = _createConstructor(schema, null, options);
-  this.caster.path = path;
-  this.caster.prototype.$basePath = path;
+  this.Constructor = _createConstructor(schema, null, options);
+  this.Constructor.path = path;
+  this.Constructor.prototype.$basePath = path;
   this.schema = schema;
   this.$isSingleNested = true;
   this.base = schema.base;
@@ -87,7 +85,7 @@ function _createConstructor(schema, baseClass, options) {
 
   schema._preCompile();
 
-  const proto = baseClass != null ? baseClass.prototype : SubdocumentType.prototype;
+  const proto = baseClass?.prototype ?? SubdocumentType.prototype;
   _embedded.prototype = Object.create(proto);
   _embedded.prototype.$__setSchema(schema);
   _embedded.prototype.constructor = _embedded;
@@ -128,7 +126,7 @@ const $conditionalHandlers = { ...SchemaType.prototype.$conditionalHandlers };
  * locations for use with $geoWithin.
  * https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/
  *
- * @param {Object} val
+ * @param {object} val
  * @api private
  */
 
@@ -172,27 +170,27 @@ Object.defineProperty(SchemaSubdocument.prototype, '$conditionalHandlers', {
 /**
  * Casts contents
  *
- * @param {Object} value
+ * @param {object} value
  * @api private
  */
 
 SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
-  if (val && val.$isSingleNested && val.parent === doc) {
+  if (val?.$isSingleNested && val.parent === doc) {
     return val;
   }
 
-  if (val != null && (typeof val !== 'object' || Array.isArray(val))) {
+  if (!init && val != null && (typeof val !== 'object' || Array.isArray(val))) {
     throw new ObjectExpectedError(this.path, val);
   }
 
   const discriminatorKeyPath = this.schema.path(this.schema.options.discriminatorKey);
   const defaultDiscriminatorValue = discriminatorKeyPath == null ? null : discriminatorKeyPath.getDefault(doc);
-  const Constructor = getConstructor(this.caster, val, defaultDiscriminatorValue);
+  const Constructor = getConstructor(this.Constructor, val, defaultDiscriminatorValue);
 
   let subdoc;
 
   // Only pull relevant selected paths and pull out the base path
-  const parentSelected = doc && doc.$__ && doc.$__.selected;
+  const parentSelected = doc?.$__?.selected;
   const path = this.path;
   const selected = parentSelected == null ? null : Object.keys(parentSelected).reduce((obj, key) => {
     if (key.startsWith(path + '.')) {
@@ -202,7 +200,7 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     return obj;
   }, null);
   if (init) {
-    subdoc = new Constructor(void 0, selected, doc, false, { defaults: false });
+    subdoc = new Constructor(void 0, selected, doc, { defaults: false });
     delete subdoc.$__.defaults;
     // Don't pass `path` to $init - it's only for the subdocument itself, not its fields.
     // For change tracking, subdocuments use relative paths internally.
@@ -216,11 +214,11 @@ SchemaSubdocument.prototype.cast = function(val, doc, init, priorVal, options) {
     applyDefaults(subdoc, selected, exclude);
   } else {
     options = Object.assign({}, options, { priorDoc: priorVal });
-    if (Object.keys(val).length === 0) {
-      return new Constructor({}, selected, doc, undefined, options);
+    if (utils.hasOwnKeys(val) === false) {
+      return new Constructor({}, selected, doc, options);
     }
 
-    return new Constructor(val, selected, doc, undefined, options);
+    return new Constructor(val, selected, doc, options);
   }
 
   return subdoc;
@@ -247,7 +245,7 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
     return val;
   }
 
-  const Constructor = getConstructor(this.caster, val);
+  const Constructor = getConstructor(this.Constructor, val);
   if (val instanceof Constructor) {
     return val;
   }
@@ -256,9 +254,7 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
     val = this._applySetters(val, context);
   }
 
-  const overrideStrict = options != null && options.strict != null ?
-    options.strict :
-    void 0;
+  const overrideStrict = options?.strict ?? void 0;
 
   try {
     val = new Constructor(val, overrideStrict);
@@ -275,33 +271,27 @@ SchemaSubdocument.prototype.castForQuery = function($conditional, val, context,
 /**
  * Async validation on this single nested doc.
  *
- * @api private
+ * @api public
  */
 
-SchemaSubdocument.prototype.doValidate = function(value, fn, scope, options) {
-  const Constructor = getConstructor(this.caster, value);
+SchemaSubdocument.prototype.doValidate = async function doValidate(value, scope, options) {
+  const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
-    value = new Constructor(value, null, (scope != null && scope.$__ != null) ? scope : null);
+    value = new Constructor(value, null, scope?.$__ != null ? scope : null);
   }
 
-  if (options && options.skipSchemaValidators) {
+  if (options?.skipSchemaValidators) {
     if (!value) {
-      return fn(null);
+      return;
     }
-    return value.validate().then(() => fn(null), err => fn(err));
+    return value.validate();
   }
 
-  SchemaType.prototype.doValidate.call(this, value, function(error) {
-    if (error) {
-      return fn(error);
-    }
-    if (!value) {
-      return fn(null);
-    }
-
-    value.validate().then(() => fn(null), err => fn(err));
-  }, scope, options);
+  await SchemaType.prototype.doValidate.call(this, value, scope, options);
+  if (value != null) {
+    await value.validate();
+  }
 };
 
 /**
@@ -311,7 +301,7 @@ SchemaSubdocument.prototype.doValidate = function(value, fn, scope, options) {
  */
 
 SchemaSubdocument.prototype.doValidateSync = function(value, scope, options) {
-  if (!options || !options.skipSchemaValidators) {
+  if (!options?.skipSchemaValidators) {
     const schemaTypeError = SchemaType.prototype.doValidateSync.call(this, value, scope);
     if (schemaTypeError) {
       return schemaTypeError;
@@ -334,11 +324,11 @@ SchemaSubdocument.prototype.doValidateSync = function(value, scope, options) {
  *     const singleNestedPath = parentSchema.path('shape');
  *     singleNestedPath.discriminator('Circle', Schema({ radius: Number }));
  *
- * @param {String} name
+ * @param {string} name
  * @param {Schema} schema fields to add to the schema for instances of this sub-class
- * @param {Object|string} [options] If string, same as `options.value`.
- * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
- * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
+ * @param {object|string} [options] If string, same as `options.value`.
+ * @param {string} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @param {boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
  * @return {Function} the constructor Mongoose will use for creating instances of this discriminator model
  * @see discriminators https://mongoosejs.com/docs/discriminators.html
  * @api public
@@ -355,11 +345,11 @@ SchemaSubdocument.prototype.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this.caster, name, schema, value, null, null, options.overwriteExisting);
+  schema = discriminator(this.Constructor, name, schema, value, null, null, options.overwriteExisting);
 
-  this.caster.discriminators[name] = _createConstructor(schema, this.caster);
+  this.Constructor.discriminators[name] = _createConstructor(schema, this.Constructor);
 
-  return this.caster.discriminators[name];
+  return this.Constructor.discriminators[name];
 };
 
 /*!
@@ -373,11 +363,11 @@ SchemaSubdocument.defaultOptions = {};
  *
  * #### Example:
  *
- *     // Make all numbers have option `min` equal to 0.
- *     mongoose.Schema.Subdocument.set('required', true);
+ *     // Make all subdocuments required by default.
+ *     mongoose.Schema.Types.Subdocument.set('required', true);
  *
- * @param {String} option The option you'd like to set the value for
- * @param {Any} value value for option
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
  * @return {void}
  * @function set
  * @static
@@ -423,7 +413,7 @@ SchemaSubdocument.prototype.clone = function() {
   if (this.requiredValidator !== undefined) {
     schematype.requiredValidator = this.requiredValidator;
   }
-  schematype.caster.discriminators = Object.assign({}, this.caster.discriminators);
+  schematype.Constructor.discriminators = Object.assign({}, this.Constructor.discriminators);
   schematype._appliedDiscriminators = this._appliedDiscriminators;
   return schematype;
 };
@@ -431,15 +421,14 @@ SchemaSubdocument.prototype.clone = function() {
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaSubdocument.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
   return {
     ...this.schema.toJSONSchema(options),
-    ...createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, isRequired)
+    ...this._createJSONSchemaTypeDefinition('object', 'object', options)
   };
 };

package/.output/server/node_modules/mongoose/lib/schema/union.js

@@ -17,17 +17,18 @@ class Union extends SchemaType {
   /**
    * Create a Union schema type.
    *
-   * @param {String} key the path in the schema for this schema type
-   * @param {Object} options SchemaType-specific options (must have 'of' as array)
-   * @param {Object} schemaOptions additional options from the schema this schematype belongs to
+   * @param {string} key the path in the schema for this schema type
+   * @param {object} options SchemaType-specific options (must have 'of' as array)
+   * @param {object} schemaOptions additional options from the schema this schematype belongs to
    * @param {Schema} parentSchema the schema this schematype belongs to
    */
   constructor(key, options, schemaOptions, parentSchema) {
     super(key, options, 'Union', parentSchema);
-    if (!options || !Array.isArray(options.of) || options.of.length === 0) {
+    if (!Array.isArray(options?.of) || options.of.length === 0) {
       throw new Error('Union schema type requires an array of types');
     }
     this.schemaTypes = options.of.map(obj => parentSchema.interpretAsType(key, obj, schemaOptions));
+    this.$isSchemaUnion = true;
   }
 
   cast(val, doc, init, prev, options) {
@@ -90,12 +91,61 @@ class Union extends SchemaType {
     throw lastError;
   }
 
+  async doValidate(value, scope, options) {
+    if (options && options.skipSchemaValidators) {
+      if (value != null && typeof value.validate === 'function') {
+        return value.validate();
+      }
+      return;
+    }
+
+    await super.doValidate(value, scope, options);
+    if (value != null && typeof value.validate === 'function') {
+      await value.validate();
+    }
+  }
+
+  doValidateSync(value, scope, options) {
+    if (!options || !options.skipSchemaValidators) {
+      const schemaTypeError = super.doValidateSync(value, scope, options);
+      if (schemaTypeError) {
+        return schemaTypeError;
+      }
+    }
+    if (value != null && typeof value.validateSync === 'function') {
+      return value.validateSync();
+    }
+  }
+
   clone() {
     const schematype = super.clone();
 
     schematype.schemaTypes = this.schemaTypes.map(schemaType => schemaType.clone());
     return schematype;
   }
+
+  /**
+   * Returns this schema type's representation in a JSON schema.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+   * @returns {object} JSON schema properties
+   */
+  toJSONSchema(options) {
+    const isRequired = this.options.required && typeof this.options.required !== 'function';
+    const childOptions = { ...options, _overrideRequired: true };
+    const jsonSchemas = this.schemaTypes.map(schemaType => schemaType.toJSONSchema(childOptions));
+    if (isRequired) {
+      return { anyOf: jsonSchemas };
+    }
+
+    return {
+      anyOf: [
+        options?.useBsonType ? { bsonType: 'null' } : { type: 'null' },
+        ...jsonSchemas
+      ]
+    };
+  }
 }
 
 /**

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

@@ -4,21 +4,18 @@
 
 'use strict';
 
-const MongooseBuffer = require('../types/buffer');
 const SchemaType = require('../schemaType');
 const CastError = SchemaType.CastError;
 const castUUID = require('../cast/uuid');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const utils = require('../utils');
 const handleBitwiseOperator = require('./operators/bitwise');
 
 const UUID_FORMAT = castUUID.UUID_FORMAT;
-const Binary = MongooseBuffer.Binary;
 
 /**
  * Convert binary to a uuid string
- * @param {Buffer|Binary|String} uuidBin The value to process
- * @returns {String} The completed uuid-string
+ * @param {Buffer|Binary|string} uuidBin The value to process
+ * @returns {string} The completed uuid-string
  * @api private
  */
 function binaryToString(uuidBin) {
@@ -35,9 +32,9 @@ function binaryToString(uuidBin) {
 /**
  * UUIDv1 SchemaType constructor.
  *
- * @param {String} key
- * @param {Object} options
- * @param {Object} _schemaOptions
+ * @param {string} key
+ * @param {object} options
+ * @param {object} _schemaOptions
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
@@ -45,21 +42,6 @@ function binaryToString(uuidBin) {
 
 function SchemaUUID(key, options, _schemaOptions, parentSchema) {
   SchemaType.call(this, key, options, 'UUID', parentSchema);
-  this.getters.push(function(value) {
-    // For populated
-    if (value != null && value.$__ != null) {
-      return value;
-    }
-    if (Buffer.isBuffer(value)) {
-      return binaryToString(value);
-    } else if (value instanceof Binary) {
-      return binaryToString(value.buffer);
-    } else if (utils.isPOJO(value) && value.type === 'Buffer' && Array.isArray(value.data)) {
-      // Cloned buffers look like `{ type: 'Buffer', data: [5, 224, ...] }`
-      return binaryToString(Buffer.from(value.data));
-    }
-    return value;
-  });
 }
 
 /**
@@ -115,8 +97,8 @@ SchemaUUID.get = SchemaType.get;
  *     const User = mongoose.model('User', new Schema({ test: mongoose.UUID }));
  *     new User({ }).validateSync().errors.test.message; // Path `test` is required.
  *
- * @param {String} option The option you'd like to set the value for
- * @param {Any} value value for option
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
  * @return {undefined}
  * @function set
  * @static
@@ -183,8 +165,8 @@ SchemaUUID.checkRequired = SchemaType.checkRequired;
 /**
  * Check if the given value satisfies a required validator.
  *
- * @param {Any} value
- * @return {Boolean}
+ * @param {any} value
+ * @return {boolean}
  * @api public
  */
 
@@ -198,9 +180,9 @@ SchemaUUID.prototype.checkRequired = function checkRequired(value) {
 /**
  * Casts to UUID
  *
- * @param {Object} value
- * @param {Object} doc
- * @param {Boolean} init whether this is an initialization cast
+ * @param {object} value
+ * @param {object} doc
+ * @param {boolean} init whether this is an initialization cast
  * @api private
  */
 
@@ -251,11 +233,7 @@ const $conditionalHandlers = {
   $bitsAllSet: handleBitwiseOperator,
   $bitsAnySet: handleBitwiseOperator,
   $all: handleArray,
-  $gt: handleSingle,
-  $gte: handleSingle,
   $in: handleArray,
-  $lt: handleSingle,
-  $lte: handleSingle,
   $ne: handleSingle,
   $nin: handleArray
 };
@@ -278,7 +256,7 @@ Object.defineProperty(SchemaUUID.prototype, '$conditionalHandlers', {
 /**
  * Casts contents for queries.
  *
- * @param {String} $conditional
+ * @param {string} $conditional
  * @param {any} val
  * @api private
  */
@@ -305,14 +283,13 @@ SchemaUUID.prototype.castForQuery = function($conditional, val, context) {
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaUUID.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('string', 'binData', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('string', 'binData', options);
 };
 
 SchemaUUID.prototype.autoEncryptionType = function autoEncryptionType() {