@zodyac/zod-mongoose 3.2.0 → 4.1.0

package/CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 4.1.0 - 2025-05-30
+
+## 4.0.0 - 2025-05-23
+
 ## 3.2.0 - 2025-01-12
 
 ## 3.1.0 - 2025-01-06

package/README.md

@@ -95,6 +95,7 @@ Full support list can be found in [SUPPORTED.md](./SUPPORTED.md):
 - ✅ ZodAny as SchemaTypes.Mixed
 - ✅ Validation using refinement for String, Number, Date
 - ✅ Unique for String, Number, Date, ObjectId and UUID
+- ✅ Sparse for String, Number, Date, ObjectId and UUID
 
 - ⚠️ Record (Being converted to Map)
 - ⚠️ Unions (Not supported by mongoose, will pick first inner type)
@@ -202,6 +203,24 @@ const zUser = z.object({
 //
 ```
 
+## sparse fields
+
+To make a String, Number or Date sparse, call `.sparse()`:
+
+```typescript
+import { z } from "zod";
+import { extendZod, zodSchema } from "@zodyac/zod-mongoose";
+
+extendZod(z);
+
+const zUser = z.object({
+  email: z.string().sparse(),
+  // with unique
+  // email: z.string()..unique().sparse(),
+});
+
+//
+```
 ## Warnings
 
 ### ZodUnion types

package/dist/index.cjs

@@ -200,15 +200,18 @@ var import_mongoose = require("mongoose");
 var import_zod2 = require("zod");
 var zod_extended = false;
 function extendZod(z_0) {
-  if (zod_extended) return;
+  if (zod_extended)
+    return;
   zod_extended = true;
   const _refine = z_0.ZodType.prototype.refine;
   z_0.ZodType.prototype.refine = function(check, opts) {
     const zEffect = _refine.bind(this)(check, opts);
     let message = void 0;
     if (opts) {
-      if (typeof opts === "string") message = opts;
-      else if ("message" in opts) message = opts.message;
+      if (typeof opts === "string")
+        message = opts;
+      else if ("message" in opts)
+        message = opts.message;
     }
     zEffect._def.effect.__zm_validation = {
       validator: check,
@@ -222,6 +225,10 @@ function extendZod(z_0) {
       this.__zm_unique = arg;
       return this;
     };
+    type.prototype.sparse = function(arg = true) {
+      this.__zm_sparse = arg;
+      return this;
+    };
   }
   const TypesMap = {
     String: z_0.ZodString,
@@ -263,6 +270,10 @@ var zId = (ref) => {
     this.__zm_unique = val;
     return this;
   };
+  output.sparse = function(val = true) {
+    this.__zm_sparse = val;
+    return this;
+  };
   return output;
 };
 var createUUID = () => {
@@ -284,6 +295,10 @@ var zUUID = (ref) => {
     this.__zm_unique = val;
     return this;
   };
+  output.sparse = function(val = true) {
+    this.__zm_sparse = val;
+    return this;
+  };
   return output;
 };
 
@@ -302,7 +317,8 @@ function parseObject(obj) {
       object[key] = parseObject(field);
     } else {
       const f = parseField(field);
-      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+      if (!f)
+        throw new Error(`Unsupported field type: ${field.constructor}`);
       object[key] = f;
     }
   }
@@ -313,35 +329,41 @@ function parseField(field, required = true, def, refinement) {
     const ref = field.__zm_ref;
     const refPath = field.__zm_refPath;
     const unique = field.__zm_unique;
-    return parseObjectId(required, ref, unique, refPath);
+    const sparse = field.__zm_sparse;
+    return parseObjectId(required, ref, unique, refPath, sparse);
   }
   if (assertions_default.uuid(field)) {
     const ref = field.__zm_ref;
     const refPath = field.__zm_refPath;
     const unique = field.__zm_unique;
-    return parseUUID(required, ref, unique, refPath);
+    const sparse = field.__zm_unique;
+    return parseUUID(required, ref, unique, refPath, sparse);
   }
   if (assertions_default.object(field)) {
     return parseObject(field);
   }
   if (assertions_default.number(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseNumber(
       field,
       required,
       def,
       isUnique,
-      refinement
+      refinement,
+      isSparse
     );
   }
   if (assertions_default.string(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseString(
       field,
       required,
       def,
       isUnique,
-      refinement
+      refinement,
+      isSparse
     );
   }
   if (assertions_default.enumerable(field)) {
@@ -352,11 +374,13 @@ function parseField(field, required = true, def, refinement) {
   }
   if (assertions_default.date(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseDate(
       required,
       def,
       refinement,
-      isUnique
+      isUnique,
+      isSparse
     );
   }
   if (assertions_default.array(field)) {
@@ -384,7 +408,7 @@ function parseField(field, required = true, def, refinement) {
   if (assertions_default.mapOrRecord(field)) {
     return parseMap(
       required,
-      field.keySchema,
+      field.valueSchema,
       def
     );
   }
@@ -397,34 +421,39 @@ function parseField(field, required = true, def, refinement) {
   }
   return null;
 }
-function parseNumber(field, required = true, def, unique = false, validate) {
+function parseNumber(field, required = true, def, unique = false, validate, sparse = false) {
   const output = {
     type: Number,
     default: def,
     min: field.minValue ?? void 0,
     max: field.maxValue ?? void 0,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
-function parseString(field, required = true, def, unique = false, validate) {
+function parseString(field, required = true, def, unique = false, validate, sparse = false) {
   const output = {
     type: String,
     default: def,
     required,
     minLength: field.minLength ?? void 0,
     maxLength: field.maxLength ?? void 0,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
 function parseEnum(values, required = true, def) {
   return {
     type: String,
     unique: false,
+    sparse: false,
     default: def,
     enum: values,
     required
@@ -437,37 +466,45 @@ function parseBoolean(required = true, def) {
     required
   };
 }
-function parseDate(required = true, def, validate, unique = false) {
+function parseDate(required = true, def, validate, unique = false, sparse = false) {
   const output = {
     type: Date,
     default: def,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
-function parseObjectId(required = true, ref, unique = false, refPath) {
+function parseObjectId(required = true, ref, unique = false, refPath, sparse = false) {
   const output = {
     type: import_mongoose2.SchemaTypes.ObjectId,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (ref) output.ref = ref;
-  if (refPath) output.refPath = refPath;
+  if (ref)
+    output.ref = ref;
+  if (refPath)
+    output.refPath = refPath;
   return output;
 }
 function parseArray(required = true, element, def) {
   const innerType = parseField(element);
-  if (!innerType) throw new Error("Unsupported array type");
+  if (!innerType)
+    throw new Error("Unsupported array type");
   return {
     type: [innerType],
     default: def,
     required
   };
 }
-function parseMap(required = true, key, def) {
-  const pointer = typeConstructor(key);
+function parseMap(required = true, valueType, def) {
+  const pointer = parseField(valueType);
+  if (!pointer)
+    throw new Error("Unsupported map value type");
   return {
     type: Map,
     of: pointer,
@@ -475,32 +512,17 @@ function parseMap(required = true, key, def) {
     required
   };
 }
-function typeConstructor(t) {
-  switch (true) {
-    case assertions_default.string(t):
-      return String;
-    case assertions_default.enumerable(t):
-      return String;
-    case assertions_default.uuid(t):
-      return import_mongoose2.SchemaTypes.UUID;
-    case assertions_default.objectId(t):
-      return import_mongoose2.SchemaTypes.ObjectId;
-    case assertions_default.number(t):
-      return Number;
-    case assertions_default.date(t):
-      return Date;
-    default:
-      return void 0;
-  }
-}
-function parseUUID(required = true, ref, unique = false, refPath) {
+function parseUUID(required = true, ref, unique = false, refPath, sparse = false) {
   const output = {
     type: import_mongoose2.SchemaTypes.UUID,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (ref) output.ref = ref;
-  if (refPath) output.refPath = refPath;
+  if (ref)
+    output.ref = ref;
+  if (refPath)
+    output.refPath = refPath;
   return output;
 }
 function parseMixed(required = true, def) {

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/assertions/constructor.ts","../src/assertions/custom.ts","../src/assertions/instanceOf.ts","../src/assertions/staticNames.ts","../src/assertions/assertions.ts","../src/extension.ts"],"sourcesContent":["import { Schema, type SchemaOptions, SchemaTypes } from \"mongoose\";\nimport type { ZodNumber, ZodObject, ZodRawShape, ZodString, ZodType, z } from \"zod\";\nimport zmAssert from \"./assertions/assertions.js\";\nimport type { zm } from \"./mongoose.types.js\";\nexport * from \"./extension.js\";\n\n/**\n * Converts a Zod schema to a Mongoose schema\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchema } from '@zodyac/zod-mongoose';\n * import { model } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *     street: z.string(),\n *     city: z.string(),\n *     state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *   tags: z.array(z.string()),\n *   createdAt: z.date(),\n *   updatedAt: z.date(),\n * });\n *\n * const schema = zodSchema(zDoc);\n * const userModel = model('User', schema);\n */\nexport function zodSchema<T extends ZodRawShape>(\n  schema: ZodObject<T>,\n  options?: SchemaOptions<any>, // TODO: Fix any\n): Schema<z.infer<typeof schema>> {\n  const definition = parseObject(schema);\n  return new Schema<z.infer<typeof schema>>(definition, options);\n}\n\n/**\n * Converts a Zod schema to a raw Mongoose schema object\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchemaRaw } from '@zodyac/zod-mongoose';\n * import { model, Schema } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *    street: z.string(),\n *    city: z.string(),\n *    state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *  tags: z.array(z.string()),\n *  createdAt: z.date(),\n *  updatedAt: z.date(),\n * });\n *\n * const rawSchema = zodSchemaRaw(zDoc);\n * const schema = new Schema(rawSchema);\n * const userModel = model('User', schema);\n */\nexport function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T> {\n  return parseObject(schema);\n}\n\n// Helpers\nfunction parseObject<T extends ZodRawShape>(obj: ZodObject<T>): zm._Schema<T> {\n  const object: any = {};\n  for (const [key, field] of Object.entries(obj.shape)) {\n    if (zmAssert.object(field)) {\n      object[key] = parseObject(field);\n    } else {\n      const f = parseField(field);\n      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);\n\n      object[key] = f;\n    }\n  }\n\n  return object;\n}\n\nfunction parseField<T>(\n  field: ZodType<T>,\n  required = true,\n  def?: T,\n  refinement?: zm.EffectValidator<T>,\n): zm.mField | null {\n  if (zmAssert.objectId(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    return parseObjectId(required, ref, unique, refPath);\n  }\n\n  if (zmAssert.uuid(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    return parseUUID(required, ref, unique, refPath);\n  }\n\n  if (zmAssert.object(field)) {\n    return parseObject(field);\n  }\n\n  if (zmAssert.number(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseNumber(\n      field,\n      required,\n      def as number,\n      isUnique,\n      refinement as zm.EffectValidator<number>,\n    );\n  }\n\n  if (zmAssert.string(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseString(\n      field,\n      required,\n      def as string,\n      isUnique,\n      refinement as zm.EffectValidator<string>,\n    );\n  }\n\n  if (zmAssert.enumerable(field)) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (zmAssert.boolean(field)) {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (zmAssert.date(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseDate(\n      required,\n      def as Date,\n      refinement as zm.EffectValidator<Date>,\n      isUnique,\n    );\n  }\n\n  if (zmAssert.array(field)) {\n    return parseArray(\n      required,\n      field.element,\n      def as T extends Array<infer K> ? K[] : never,\n    );\n  }\n\n  if (zmAssert.def(field)) {\n    return parseField(field._def.innerType, required, field._def.defaultValue());\n  }\n\n  if (zmAssert.optional(field)) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (zmAssert.nullable(field)) {\n    return parseField(field._def.innerType, false, def || null);\n  }\n\n  if (zmAssert.union(field)) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (zmAssert.any(field)) {\n    return parseMixed(required, def);\n  }\n\n  if (zmAssert.mapOrRecord(field)) {\n    return parseMap(\n      required,\n      field.keySchema,\n      def as Map<\n        zm.UnwrapZodType<typeof field.keySchema>,\n        zm.UnwrapZodType<typeof field.valueSchema>\n      >,\n    );\n  }\n\n  if (zmAssert.effect(field)) {\n    const effect = field._def.effect;\n\n    if (effect.type === \"refinement\") {\n      const validation = (<any>effect).__zm_validation as zm.EffectValidator<T>;\n      return parseField(field._def.schema, required, def, validation);\n    }\n  }\n\n  return null;\n}\n\nfunction parseNumber(\n  field: ZodNumber,\n  required = true,\n  def?: number,\n  unique = false,\n  validate?: zm.EffectValidator<number>,\n): zm.mNumber {\n  const output: zm.mNumber = {\n    type: Number,\n    default: def,\n    min: field.minValue ?? undefined,\n    max: field.maxValue ?? undefined,\n    required,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseString(\n  field: ZodString,\n  required = true,\n  def?: string,\n  unique = false,\n  validate?: zm.EffectValidator<string>,\n): zm.mString {\n  const output: zm.mString = {\n    type: String,\n    default: def,\n    required,\n    minLength: field.minLength ?? undefined,\n    maxLength: field.maxLength ?? undefined,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseEnum(values: string[], required = true, def?: string): zm.mString {\n  return {\n    type: String,\n    unique: false,\n    default: def,\n    enum: values,\n    required,\n  };\n}\n\nfunction parseBoolean(required = true, def?: boolean): zm.mBoolean {\n  return {\n    type: Boolean,\n    default: def,\n    required,\n  };\n}\n\nfunction parseDate(\n  required = true,\n  def?: Date,\n  validate?: zm.EffectValidator<Date>,\n  unique = false,\n): zm.mDate {\n  const output: zm.mDate = {\n    type: Date,\n    default: def,\n    required,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseObjectId(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n): zm.mObjectId {\n  const output: zm.mObjectId = {\n    type: SchemaTypes.ObjectId,\n    required,\n    unique,\n  };\n\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseArray<T>(\n  // biome-ignore lint/style/useDefaultParameterLast: Should be consistent with other functions\n  required = true,\n  element: ZodType<T>,\n  def?: T[],\n): zm.mArray<T> {\n  const innerType = parseField(element);\n  if (!innerType) throw new Error(\"Unsupported array type\");\n  return {\n    type: [innerType as zm._Field<T>],\n    default: def,\n    required,\n  };\n}\n\nfunction parseMap<T, K>(\n  // biome-ignore lint/style/useDefaultParameterLast: Consistency with other functions\n  required = true,\n  key: ZodType<T>,\n  def?: Map<NoInfer<T>, K>,\n): zm.mMap<T, K> {\n  const pointer = typeConstructor(key);\n  return {\n    type: Map,\n    of: pointer,\n    default: def,\n    required,\n  };\n}\n\nfunction typeConstructor<T>(t: ZodType<T>) {\n  switch (true) {\n    case zmAssert.string(t):\n      return String;\n    case zmAssert.enumerable(t):\n      return String;\n    case zmAssert.uuid(t):\n      return SchemaTypes.UUID;\n    case zmAssert.objectId(t):\n      return SchemaTypes.ObjectId;\n    case zmAssert.number(t):\n      return Number;\n    case zmAssert.date(t):\n      return Date;\n    default:\n      return undefined;\n  }\n}\n\nfunction parseUUID(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n): zm.mUUID {\n  const output: zm.mUUID = {\n    type: SchemaTypes.UUID,\n    required,\n    unique,\n  };\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseMixed(required = true, def?: unknown): zm.mMixed<unknown> {\n  return {\n    type: SchemaTypes.Mixed,\n    default: def,\n    required,\n  };\n}\n\nexport default zodSchema;\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Constructor assertions (CommonJS)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the constructor name of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f.constructor.name === \"ZodString\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f.constructor.name === \"ZodNumber\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f.constructor.name === \"ZodObject\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f.constructor.name === \"ZodArray\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f.constructor.name === \"ZodBoolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f.constructor.name === \"ZodEnum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f.constructor.name === \"ZodDate\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f.constructor.name === \"ZodDefault\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f.constructor.name === \"ZodOptional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f.constructor.name === \"ZodNullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f.constructor.name === \"ZodUnion\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f.constructor.name === \"ZodAny\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f.constructor.name === \"ZodMap\" || f.constructor.name === \"ZodRecord\";\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f.constructor.name === \"ZodEffects\";\n  },\n};\n","import type { ZodType } from \"zod\";\n\nexport namespace zmAssertIds {\n  export function objectId(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"ObjectId\";\n  }\n\n  export function uuid(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"UUID\";\n  }\n}\n","import {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  type ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Instance assertions (ESM)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the instance of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f instanceof ZodString;\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f instanceof ZodNumber;\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f instanceof ZodObject;\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f instanceof ZodArray;\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f instanceof ZodBoolean;\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f instanceof ZodEnum;\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f instanceof ZodDate;\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f instanceof ZodDefault;\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f instanceof ZodOptional;\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f instanceof ZodNullable;\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f instanceof ZodUnion;\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f instanceof ZodAny;\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f instanceof ZodMap || f instanceof ZodRecord;\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f instanceof ZodEffects;\n  },\n};\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Static names assertions (Bundlers)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the `__zm_type` property of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return \"__zm_type\" in f && f.__zm_type === \"String\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return \"__zm_type\" in f && f.__zm_type === \"Number\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Object\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Array\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return \"__zm_type\" in f && f.__zm_type === \"Boolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Enum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return \"__zm_type\" in f && f.__zm_type === \"Date\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Default\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Optional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Nullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Union\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return \"__zm_type\" in f && f.__zm_type === \"Any\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return \"__zm_type\" in f && (f.__zm_type === \"Map\" || f.__zm_type === \"Record\");\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Effects\";\n  },\n};\n","import type { ZodType } from \"zod\";\nimport { zmAssert as aConstructor } from \"./constructor\";\nimport { zmAssertIds } from \"./custom\";\nimport { zmAssert as aInstance } from \"./instanceOf\";\nimport { zmAssert as aStaticName } from \"./staticNames\";\nimport type { IAsserts } from \"./types\";\n\nconst assertions = [aConstructor, aInstance, aStaticName];\nconst zmAssert = Object.keys(aConstructor)\n  .map((key) => key as keyof IAsserts)\n  .reduce((acc, key) => {\n    (<any>acc[key]) = (f: ZodType<any>) => {\n      return assertions.some((assertion) => assertion[key](f));\n    };\n\n    return acc;\n  }, {} as IAsserts);\n\nexport default {\n  ...zmAssert,\n  ...zmAssertIds,\n};\n","import { Types, isValidObjectId } from \"mongoose\";\nimport { type CustomErrorParams, z } from \"zod\";\n\ndeclare module \"zod\" {\n  interface ZodString {\n    unique: (arg?: boolean) => ZodString;\n    __zm_unique: boolean;\n  }\n\n  interface ZodNumber {\n    unique: (arg?: boolean) => ZodNumber;\n    __zm_unique: boolean;\n  }\n\n  interface ZodDate {\n    unique: (arg?: boolean) => ZodDate;\n    __zm_unique: boolean;\n  }\n\n  interface ZodType<\n    Output = any,\n    Def extends z.ZodTypeDef = z.ZodTypeDef,\n    Input = Output,\n  > {\n    // For future use\n  }\n}\n\nlet zod_extended = false;\n/**\n * Extends the Zod library with additional functionality.\n *\n * This function modifies the Zod library to add custom validation and uniqueness checks.\n * It ensures that the extension is only applied once.\n *\n * @param z_0 - The Zod library to extend.\n *\n * @remarks\n * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.\n * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { extendZod } from \"./extension\";\n *\n * extendZod(z);\n *\n * const schema = z.object({\n *   name: z.string().unique();\n * });\n * ```\n */\nexport function extendZod(z_0: typeof z) {\n  // Prevent zod from being extended multiple times\n  if (zod_extended) return;\n  zod_extended = true;\n\n  // Refine support\n  const _refine = z_0.ZodType.prototype.refine;\n  z_0.ZodType.prototype.refine = function <T>(\n    check: (arg0: T) => boolean,\n    opts?: string | CustomErrorParams | ((arg: T) => CustomErrorParams),\n  ) {\n    const zEffect = _refine.bind(this)(check, opts);\n\n    let message: string | undefined | ((v: T) => string | undefined) = undefined;\n    if (opts) {\n      if (typeof opts === \"string\") message = opts;\n      else if (\"message\" in opts) message = opts.message;\n    }\n\n    (<any>zEffect._def.effect).__zm_validation = {\n      validator: check,\n      message: message,\n    };\n\n    return zEffect;\n  };\n\n  // Unique support\n  const UNIQUE_SUPPORT_LIST = [z_0.ZodString, z_0.ZodNumber, z_0.ZodDate] as const;\n\n  for (const type of UNIQUE_SUPPORT_LIST) {\n    (<any>type.prototype).unique = function (arg = true) {\n      (<any>this).__zm_unique = arg;\n      return this;\n    };\n  }\n\n  // Assign static names to Zod types\n  const TypesMap = {\n    String: z_0.ZodString,\n    Number: z_0.ZodNumber,\n    Object: z_0.ZodObject,\n    Array: z_0.ZodArray,\n    Boolean: z_0.ZodBoolean,\n    Enum: z_0.ZodEnum,\n    Date: z_0.ZodDate,\n    Default: z_0.ZodDefault,\n    Optional: z_0.ZodOptional,\n    Nullable: z_0.ZodNullable,\n    Union: z_0.ZodUnion,\n    Any: z_0.ZodAny,\n    Map: z_0.ZodMap,\n    Record: z_0.ZodRecord,\n    Effects: z_0.ZodEffects,\n  };\n\n  for (const [key, value] of Object.entries(TypesMap)) {\n    (<any>value.prototype).__zm_type = key;\n  }\n}\n\nexport type TzmId = ReturnType<typeof createId> & {\n  unique: (arg?: boolean) => TzmId;\n  ref: (arg: string) => TzmId;\n  refPath: (arg: string) => TzmId;\n};\n\nconst createId = () => {\n  return z\n    .string()\n    .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n    .or(z.instanceof(Types.ObjectId));\n};\n\nexport const zId = (ref?: string): TzmId => {\n  const output = createId();\n\n  (<any>output).__zm_type = \"ObjectId\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  return output as TzmId;\n};\n\nexport type TzmUUID = ReturnType<typeof createUUID> & {\n  unique: (arg?: boolean) => TzmUUID;\n  ref: (arg: string) => TzmUUID;\n  refPath: (arg: string) => TzmUUID;\n};\n\nconst createUUID = () => {\n  return z.string().uuid({ message: \"Invalid UUID\" }).or(z.instanceof(Types.UUID));\n};\n\nexport const zUUID = (ref?: string): TzmUUID => {\n  const output = createUUID();\n\n  (<any>output).__zm_type = \"UUID\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  return output as TzmUUID;\n};\n"],"mappings":"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","names":["import_mongoose","zmAssertIds","zmAssert","zmAssert","zmAssert","import_zod","ref"]}
+{"version":3,"sources":["../src/index.ts","../src/assertions/constructor.ts","../src/assertions/custom.ts","../src/assertions/instanceOf.ts","../src/assertions/staticNames.ts","../src/assertions/assertions.ts","../src/extension.ts"],"sourcesContent":["import { Schema, type SchemaOptions, SchemaTypes } from \"mongoose\";\nimport type { ZodNumber, ZodObject, ZodRawShape, ZodString, ZodType, z } from \"zod\";\nimport zmAssert from \"./assertions/assertions.js\";\nimport type { zm } from \"./mongoose.types.js\";\nexport * from \"./extension.js\";\n\n/**\n * Converts a Zod schema to a Mongoose schema\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchema } from '@zodyac/zod-mongoose';\n * import { model } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *     street: z.string(),\n *     city: z.string(),\n *     state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *   tags: z.array(z.string()),\n *   createdAt: z.date(),\n *   updatedAt: z.date(),\n * });\n *\n * const schema = zodSchema(zDoc);\n * const userModel = model('User', schema);\n */\nexport function zodSchema<T extends ZodRawShape>(\n  schema: ZodObject<T>,\n  options?: SchemaOptions<any>, // TODO: Fix any\n): Schema<z.infer<typeof schema>> {\n  const definition = parseObject(schema);\n  return new Schema<z.infer<typeof schema>>(definition, options);\n}\n\n/**\n * Converts a Zod schema to a raw Mongoose schema object\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchemaRaw } from '@zodyac/zod-mongoose';\n * import { model, Schema } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *    street: z.string(),\n *    city: z.string(),\n *    state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *  tags: z.array(z.string()),\n *  createdAt: z.date(),\n *  updatedAt: z.date(),\n * });\n *\n * const rawSchema = zodSchemaRaw(zDoc);\n * const schema = new Schema(rawSchema);\n * const userModel = model('User', schema);\n */\nexport function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T> {\n  return parseObject(schema);\n}\n\n// Helpers\nfunction parseObject<T extends ZodRawShape>(obj: ZodObject<T>): zm._Schema<T> {\n  const object: any = {};\n  for (const [key, field] of Object.entries(obj.shape)) {\n    if (zmAssert.object(field)) {\n      object[key] = parseObject(field);\n    } else {\n      const f = parseField(field);\n      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);\n\n      object[key] = f;\n    }\n  }\n\n  return object;\n}\n\nfunction parseField<T>(\n  field: ZodType<T>,\n  required = true,\n  def?: T,\n  refinement?: zm.EffectValidator<T>,\n): zm.mField | null {\n  if (zmAssert.objectId(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    const sparse = (<any>field).__zm_sparse;\n    return parseObjectId(required, ref, unique, refPath, sparse);\n  }\n\n  if (zmAssert.uuid(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    const sparse = (<any>field).__zm_unique;\n    return parseUUID(required, ref, unique, refPath, sparse);\n  }\n\n  if (zmAssert.object(field)) {\n    return parseObject(field);\n  }\n\n  if (zmAssert.number(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseNumber(\n      field,\n      required,\n      def as number,\n      isUnique,\n      refinement as zm.EffectValidator<number>,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.string(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseString(\n      field,\n      required,\n      def as string,\n      isUnique,\n      refinement as zm.EffectValidator<string>,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.enumerable(field)) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (zmAssert.boolean(field)) {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (zmAssert.date(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseDate(\n      required,\n      def as Date,\n      refinement as zm.EffectValidator<Date>,\n      isUnique,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.array(field)) {\n    return parseArray(\n      required,\n      field.element,\n      def as T extends Array<infer K> ? K[] : never,\n    );\n  }\n\n  if (zmAssert.def(field)) {\n    return parseField(field._def.innerType, required, field._def.defaultValue());\n  }\n\n  if (zmAssert.optional(field)) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (zmAssert.nullable(field)) {\n    return parseField(field._def.innerType, false, def || null);\n  }\n\n  if (zmAssert.union(field)) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (zmAssert.any(field)) {\n    return parseMixed(required, def);\n  }\n\n  if (zmAssert.mapOrRecord(field)) {\n    return parseMap(\n      required,\n      field.valueSchema,\n      def as Map<\n        zm.UnwrapZodType<typeof field.keySchema>,\n        zm.UnwrapZodType<typeof field.valueSchema>\n      >,\n    );\n  }\n\n  if (zmAssert.effect(field)) {\n    const effect = field._def.effect;\n\n    if (effect.type === \"refinement\") {\n      const validation = (<any>effect).__zm_validation as zm.EffectValidator<T>;\n      return parseField(field._def.schema, required, def, validation);\n    }\n  }\n\n  return null;\n}\n\nfunction parseNumber(\n  field: ZodNumber,\n  required = true,\n  def?: number,\n  unique = false,\n  validate?: zm.EffectValidator<number>,\n  sparse = false,\n): zm.mNumber {\n  const output: zm.mNumber = {\n    type: Number,\n    default: def,\n    min: field.minValue ?? undefined,\n    max: field.maxValue ?? undefined,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseString(\n  field: ZodString,\n  required = true,\n  def?: string,\n  unique = false,\n  validate?: zm.EffectValidator<string>,\n  sparse = false,\n): zm.mString {\n  const output: zm.mString = {\n    type: String,\n    default: def,\n    required,\n    minLength: field.minLength ?? undefined,\n    maxLength: field.maxLength ?? undefined,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseEnum(values: string[], required = true, def?: string): zm.mString {\n  return {\n    type: String,\n    unique: false,\n    sparse: false,\n    default: def,\n    enum: values,\n    required,\n  };\n}\n\nfunction parseBoolean(required = true, def?: boolean): zm.mBoolean {\n  return {\n    type: Boolean,\n    default: def,\n    required,\n  };\n}\n\nfunction parseDate(\n  required = true,\n  def?: Date,\n  validate?: zm.EffectValidator<Date>,\n  unique = false,\n  sparse = false,\n): zm.mDate {\n  const output: zm.mDate = {\n    type: Date,\n    default: def,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseObjectId(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n  sparse = false,\n): zm.mObjectId {\n  const output: zm.mObjectId = {\n    type: SchemaTypes.ObjectId,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseArray<T>(\n  // biome-ignore lint/style/useDefaultParameterLast: Should be consistent with other functions\n  required = true,\n  element: ZodType<T>,\n  def?: T[],\n): zm.mArray<T> {\n  const innerType = parseField(element);\n  if (!innerType) throw new Error(\"Unsupported array type\");\n  return {\n    type: [innerType as zm._Field<T>],\n    default: def,\n    required,\n  };\n}\n\nfunction parseMap<T, K>(\n  // biome-ignore lint/style/useDefaultParameterLast: Consistency with other functions\n  required = true,\n  valueType: ZodType<K>,\n  def?: Map<NoInfer<T>, K>,\n): zm.mMap<T, K> {\n  const pointer = parseField(valueType);\n  if (!pointer) throw new Error(\"Unsupported map value type\");\n\n  return {\n    type: Map,\n    of: pointer as zm._Field<K>,\n    default: def,\n    required,\n  };\n}\n\nfunction parseUUID(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n  sparse = false,\n): zm.mUUID {\n  const output: zm.mUUID = {\n    type: SchemaTypes.UUID,\n    required,\n    unique,\n    sparse,\n  };\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseMixed(required = true, def?: unknown): zm.mMixed<unknown> {\n  return {\n    type: SchemaTypes.Mixed,\n    default: def,\n    required,\n  };\n}\n\nexport default zodSchema;\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Constructor assertions (CommonJS)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the constructor name of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f.constructor.name === \"ZodString\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f.constructor.name === \"ZodNumber\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f.constructor.name === \"ZodObject\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f.constructor.name === \"ZodArray\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f.constructor.name === \"ZodBoolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f.constructor.name === \"ZodEnum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f.constructor.name === \"ZodDate\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f.constructor.name === \"ZodDefault\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f.constructor.name === \"ZodOptional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f.constructor.name === \"ZodNullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f.constructor.name === \"ZodUnion\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f.constructor.name === \"ZodAny\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f.constructor.name === \"ZodMap\" || f.constructor.name === \"ZodRecord\";\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f.constructor.name === \"ZodEffects\";\n  },\n};\n","import type { ZodType } from \"zod\";\n\nexport namespace zmAssertIds {\n  export function objectId(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"ObjectId\";\n  }\n\n  export function uuid(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"UUID\";\n  }\n}\n","import {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  type ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Instance assertions (ESM)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the instance of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f instanceof ZodString;\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f instanceof ZodNumber;\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f instanceof ZodObject;\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f instanceof ZodArray;\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f instanceof ZodBoolean;\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f instanceof ZodEnum;\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f instanceof ZodDate;\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f instanceof ZodDefault;\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f instanceof ZodOptional;\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f instanceof ZodNullable;\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f instanceof ZodUnion;\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f instanceof ZodAny;\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f instanceof ZodMap || f instanceof ZodRecord;\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f instanceof ZodEffects;\n  },\n};\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Static names assertions (Bundlers)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the `__zm_type` property of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return \"__zm_type\" in f && f.__zm_type === \"String\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return \"__zm_type\" in f && f.__zm_type === \"Number\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Object\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Array\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return \"__zm_type\" in f && f.__zm_type === \"Boolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Enum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return \"__zm_type\" in f && f.__zm_type === \"Date\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Default\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Optional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Nullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Union\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return \"__zm_type\" in f && f.__zm_type === \"Any\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return \"__zm_type\" in f && (f.__zm_type === \"Map\" || f.__zm_type === \"Record\");\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Effects\";\n  },\n};\n","import type { ZodType } from \"zod\";\nimport { zmAssert as aConstructor } from \"./constructor\";\nimport { zmAssertIds } from \"./custom\";\nimport { zmAssert as aInstance } from \"./instanceOf\";\nimport { zmAssert as aStaticName } from \"./staticNames\";\nimport type { IAsserts } from \"./types\";\n\nconst assertions = [aConstructor, aInstance, aStaticName];\nconst zmAssert = Object.keys(aConstructor)\n  .map((key) => key as keyof IAsserts)\n  .reduce((acc, key) => {\n    (<any>acc[key]) = (f: ZodType<any>) => {\n      return assertions.some((assertion) => assertion[key](f));\n    };\n\n    return acc;\n  }, {} as IAsserts);\n\nexport default {\n  ...zmAssert,\n  ...zmAssertIds,\n};\n","import { Types, isValidObjectId } from \"mongoose\";\nimport { type CustomErrorParams, z } from \"zod\";\n\ndeclare module \"zod\" {\n  interface ZodString {\n    unique: (arg?: boolean) => ZodString;\n    sparse: (arg?: boolean) => ZodString;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodNumber {\n    unique: (arg?: boolean) => ZodNumber;\n    sparse: (arg?: boolean) => ZodNumber;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodDate {\n    unique: (arg?: boolean) => ZodDate;\n    sparse: (arg?: boolean) => ZodDate;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodType<\n    Output = any,\n    Def extends z.ZodTypeDef = z.ZodTypeDef,\n    Input = Output,\n  > {\n    // For future use\n  }\n}\n\nlet zod_extended = false;\n/**\n * Extends the Zod library with additional functionality.\n *\n * This function modifies the Zod library to add custom validation and uniqueness checks.\n * It ensures that the extension is only applied once.\n *\n * @param z_0 - The Zod library to extend.\n *\n * @remarks\n * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.\n * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.\n * - Overrides `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { extendZod } from \"./extension\";\n *\n * extendZod(z);\n *\n * const schema = z.object({\n *   name: z.string().unique();\n * });\n * ```\n */\nexport function extendZod(z_0: typeof z) {\n  // Prevent zod from being extended multiple times\n  if (zod_extended) return;\n  zod_extended = true;\n\n  // Refine support\n  const _refine = z_0.ZodType.prototype.refine;\n  z_0.ZodType.prototype.refine = function <T>(\n    check: (arg0: T) => boolean,\n    opts?: string | CustomErrorParams | ((arg: T) => CustomErrorParams),\n  ) {\n    const zEffect = _refine.bind(this)(check, opts);\n\n    let message: string | undefined | ((v: T) => string | undefined) = undefined;\n    if (opts) {\n      if (typeof opts === \"string\") message = opts;\n      else if (\"message\" in opts) message = opts.message;\n    }\n\n    (<any>zEffect._def.effect).__zm_validation = {\n      validator: check,\n      message: message,\n    };\n\n    return zEffect;\n  };\n\n  // Unique support\n  const UNIQUE_SUPPORT_LIST = [z_0.ZodString, z_0.ZodNumber, z_0.ZodDate] as const;\n\n  for (const type of UNIQUE_SUPPORT_LIST) {\n    (<any>type.prototype).unique = function (arg = true) {\n      (<any>this).__zm_unique = arg;\n      return this;\n    };\n\n    (<any>type.prototype).sparse = function (arg = true) {\n      (<any>this).__zm_sparse = arg;\n      return this;\n    };\n  }\n\n  // Assign static names to Zod types\n  const TypesMap = {\n    String: z_0.ZodString,\n    Number: z_0.ZodNumber,\n    Object: z_0.ZodObject,\n    Array: z_0.ZodArray,\n    Boolean: z_0.ZodBoolean,\n    Enum: z_0.ZodEnum,\n    Date: z_0.ZodDate,\n    Default: z_0.ZodDefault,\n    Optional: z_0.ZodOptional,\n    Nullable: z_0.ZodNullable,\n    Union: z_0.ZodUnion,\n    Any: z_0.ZodAny,\n    Map: z_0.ZodMap,\n    Record: z_0.ZodRecord,\n    Effects: z_0.ZodEffects,\n  };\n\n  for (const [key, value] of Object.entries(TypesMap)) {\n    (<any>value.prototype).__zm_type = key;\n  }\n}\n\nexport type TzmId = ReturnType<typeof createId> & {\n  unique: (arg?: boolean) => TzmId;\n  sparse: (arg?: boolean) => TzmId;\n  ref: (arg: string) => TzmId;\n  refPath: (arg: string) => TzmId;\n};\n\nconst createId = () => {\n  return z\n    .string()\n    .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n    .or(z.instanceof(Types.ObjectId));\n};\n\nexport const zId = (ref?: string): TzmId => {\n  const output = createId();\n\n  (<any>output).__zm_type = \"ObjectId\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  (<any>output).sparse = function (val = true) {\n    (<any>this).__zm_sparse = val;\n    return this;\n  };\n\n  return output as TzmId;\n};\n\nexport type TzmUUID = ReturnType<typeof createUUID> & {\n  unique: (arg?: boolean) => TzmUUID;\n  sparse: (arg?: boolean) => TzmUUID;\n  ref: (arg: string) => TzmUUID;\n  refPath: (arg: string) => TzmUUID;\n};\n\nconst createUUID = () => {\n  return z.string().uuid({ message: \"Invalid UUID\" }).or(z.instanceof(Types.UUID));\n};\n\nexport const zUUID = (ref?: string): TzmUUID => {\n  const output = createUUID();\n\n  (<any>output).__zm_type = \"UUID\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  (<any>output).sparse = function (val = true) {\n    (<any>this).__zm_sparse = val;\n    return this;\n  };\n\n  return output as TzmUUID;\n};\n"],"mappings":"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","names":["import_mongoose","zmAssertIds","zmAssert","zmAssert","zmAssert","import_zod","ref"]}

package/dist/index.d.cts

@@ -11,6 +11,7 @@ declare namespace zm {
         __zm_refPath?: string;
         ref: (ref: string) => zID;
         unique: (val?: boolean) => zID;
+        sparse: (val?: boolean) => zID;
         refPath: (ref: string) => zID;
     }
     interface zUUID extends z.ZodUnion<[z.ZodString, z.ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]> {
@@ -18,6 +19,7 @@ declare namespace zm {
         __zm_ref?: string;
         __zm_refPath?: string;
         unique: (val?: boolean) => zUUID;
+        sparse: (val?: boolean) => zUUID;
         ref: (ref: string) => zUUID;
         refPath: (ref: string) => zUUID;
     }
@@ -32,6 +34,7 @@ declare namespace zm {
     interface mString extends _Field<string> {
         type: StringConstructor;
         unique: boolean;
+        sparse: boolean;
         enum?: string[];
         match?: RegExp;
         minLength?: number;
@@ -40,6 +43,7 @@ declare namespace zm {
     interface mNumber extends _Field<number> {
         type: NumberConstructor;
         unique: boolean;
+        sparse: boolean;
         min?: number;
         max?: number;
     }
@@ -49,16 +53,19 @@ declare namespace zm {
     interface mDate extends _Field<Date> {
         type: DateConstructor;
         unique: boolean;
+        sparse: boolean;
     }
     interface mObjectId extends _Field<Types.ObjectId> {
         type: typeof SchemaTypes.ObjectId;
         unique?: boolean;
+        sparse?: boolean;
         ref?: string;
         refPath?: string;
     }
     interface mUUID extends _Field<Types.UUID> {
         type: typeof SchemaTypes.UUID;
         unique?: boolean;
+        sparse?: boolean;
         ref?: string;
         refPath?: string;
     }
@@ -71,7 +78,7 @@ declare namespace zm {
     type Constructor = StringConstructor | NumberConstructor | ObjectConstructor | DateConstructor | BooleanConstructor | BigIntConstructor | typeof SchemaTypes.ObjectId | typeof SchemaTypes.UUID;
     interface mMap<T, K> extends _Field<Map<T, K>> {
         type: typeof Map;
-        of?: Constructor;
+        of?: zm._Field<K>;
     }
     type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown> | mMap<unknown, unknown>;
     type _Schema<T> = SchemaDefinition & {
@@ -87,15 +94,21 @@ declare namespace zm {
 declare module "zod" {
     interface ZodString {
         unique: (arg?: boolean) => ZodString;
+        sparse: (arg?: boolean) => ZodString;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodNumber {
         unique: (arg?: boolean) => ZodNumber;
+        sparse: (arg?: boolean) => ZodNumber;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodDate {
         unique: (arg?: boolean) => ZodDate;
+        sparse: (arg?: boolean) => ZodDate;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodType<Output = any, Def extends z.ZodTypeDef = z.ZodTypeDef, Input = Output> {
     }
@@ -111,6 +124,7 @@ declare module "zod" {
  * @remarks
  * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.
  * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.
+ * - Overrides `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.
  *
  * @example
  * ```typescript
@@ -127,6 +141,7 @@ declare module "zod" {
 declare function extendZod(z_0: typeof z): void;
 type TzmId = ReturnType<typeof createId> & {
     unique: (arg?: boolean) => TzmId;
+    sparse: (arg?: boolean) => TzmId;
     ref: (arg: string) => TzmId;
     refPath: (arg: string) => TzmId;
 };
@@ -134,6 +149,7 @@ declare const createId: () => z.ZodUnion<[z.ZodEffects<z.ZodString, string, stri
 declare const zId: (ref?: string) => TzmId;
 type TzmUUID = ReturnType<typeof createUUID> & {
     unique: (arg?: boolean) => TzmUUID;
+    sparse: (arg?: boolean) => TzmUUID;
     ref: (arg: string) => TzmUUID;
     refPath: (arg: string) => TzmUUID;
 };

package/dist/index.d.ts

@@ -11,6 +11,7 @@ declare namespace zm {
         __zm_refPath?: string;
         ref: (ref: string) => zID;
         unique: (val?: boolean) => zID;
+        sparse: (val?: boolean) => zID;
         refPath: (ref: string) => zID;
     }
     interface zUUID extends z.ZodUnion<[z.ZodString, z.ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]> {
@@ -18,6 +19,7 @@ declare namespace zm {
         __zm_ref?: string;
         __zm_refPath?: string;
         unique: (val?: boolean) => zUUID;
+        sparse: (val?: boolean) => zUUID;
         ref: (ref: string) => zUUID;
         refPath: (ref: string) => zUUID;
     }
@@ -32,6 +34,7 @@ declare namespace zm {
     interface mString extends _Field<string> {
         type: StringConstructor;
         unique: boolean;
+        sparse: boolean;
         enum?: string[];
         match?: RegExp;
         minLength?: number;
@@ -40,6 +43,7 @@ declare namespace zm {
     interface mNumber extends _Field<number> {
         type: NumberConstructor;
         unique: boolean;
+        sparse: boolean;
         min?: number;
         max?: number;
     }
@@ -49,16 +53,19 @@ declare namespace zm {
     interface mDate extends _Field<Date> {
         type: DateConstructor;
         unique: boolean;
+        sparse: boolean;
     }
     interface mObjectId extends _Field<Types.ObjectId> {
         type: typeof SchemaTypes.ObjectId;
         unique?: boolean;
+        sparse?: boolean;
         ref?: string;
         refPath?: string;
     }
     interface mUUID extends _Field<Types.UUID> {
         type: typeof SchemaTypes.UUID;
         unique?: boolean;
+        sparse?: boolean;
         ref?: string;
         refPath?: string;
     }
@@ -71,7 +78,7 @@ declare namespace zm {
     type Constructor = StringConstructor | NumberConstructor | ObjectConstructor | DateConstructor | BooleanConstructor | BigIntConstructor | typeof SchemaTypes.ObjectId | typeof SchemaTypes.UUID;
     interface mMap<T, K> extends _Field<Map<T, K>> {
         type: typeof Map;
-        of?: Constructor;
+        of?: zm._Field<K>;
     }
     type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown> | mMap<unknown, unknown>;
     type _Schema<T> = SchemaDefinition & {
@@ -87,15 +94,21 @@ declare namespace zm {
 declare module "zod" {
     interface ZodString {
         unique: (arg?: boolean) => ZodString;
+        sparse: (arg?: boolean) => ZodString;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodNumber {
         unique: (arg?: boolean) => ZodNumber;
+        sparse: (arg?: boolean) => ZodNumber;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodDate {
         unique: (arg?: boolean) => ZodDate;
+        sparse: (arg?: boolean) => ZodDate;
         __zm_unique: boolean;
+        __zm_sparse: boolean;
     }
     interface ZodType<Output = any, Def extends z.ZodTypeDef = z.ZodTypeDef, Input = Output> {
     }
@@ -111,6 +124,7 @@ declare module "zod" {
  * @remarks
  * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.
  * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.
+ * - Overrides `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.
  *
  * @example
  * ```typescript
@@ -127,6 +141,7 @@ declare module "zod" {
 declare function extendZod(z_0: typeof z): void;
 type TzmId = ReturnType<typeof createId> & {
     unique: (arg?: boolean) => TzmId;
+    sparse: (arg?: boolean) => TzmId;
     ref: (arg: string) => TzmId;
     refPath: (arg: string) => TzmId;
 };
@@ -134,6 +149,7 @@ declare const createId: () => z.ZodUnion<[z.ZodEffects<z.ZodString, string, stri
 declare const zId: (ref?: string) => TzmId;
 type TzmUUID = ReturnType<typeof createUUID> & {
     unique: (arg?: boolean) => TzmUUID;
+    sparse: (arg?: boolean) => TzmUUID;
     ref: (arg: string) => TzmUUID;
     refPath: (arg: string) => TzmUUID;
 };

package/dist/index.js

@@ -187,15 +187,18 @@ import { Types, isValidObjectId } from "mongoose";
 import { z } from "zod";
 var zod_extended = false;
 function extendZod(z_0) {
-  if (zod_extended) return;
+  if (zod_extended)
+    return;
   zod_extended = true;
   const _refine = z_0.ZodType.prototype.refine;
   z_0.ZodType.prototype.refine = function(check, opts) {
     const zEffect = _refine.bind(this)(check, opts);
     let message = void 0;
     if (opts) {
-      if (typeof opts === "string") message = opts;
-      else if ("message" in opts) message = opts.message;
+      if (typeof opts === "string")
+        message = opts;
+      else if ("message" in opts)
+        message = opts.message;
     }
     zEffect._def.effect.__zm_validation = {
       validator: check,
@@ -209,6 +212,10 @@ function extendZod(z_0) {
       this.__zm_unique = arg;
       return this;
     };
+    type.prototype.sparse = function(arg = true) {
+      this.__zm_sparse = arg;
+      return this;
+    };
   }
   const TypesMap = {
     String: z_0.ZodString,
@@ -250,6 +257,10 @@ var zId = (ref) => {
     this.__zm_unique = val;
     return this;
   };
+  output.sparse = function(val = true) {
+    this.__zm_sparse = val;
+    return this;
+  };
   return output;
 };
 var createUUID = () => {
@@ -271,6 +282,10 @@ var zUUID = (ref) => {
     this.__zm_unique = val;
     return this;
   };
+  output.sparse = function(val = true) {
+    this.__zm_sparse = val;
+    return this;
+  };
   return output;
 };
 
@@ -289,7 +304,8 @@ function parseObject(obj) {
       object[key] = parseObject(field);
     } else {
       const f = parseField(field);
-      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+      if (!f)
+        throw new Error(`Unsupported field type: ${field.constructor}`);
       object[key] = f;
     }
   }
@@ -300,35 +316,41 @@ function parseField(field, required = true, def, refinement) {
     const ref = field.__zm_ref;
     const refPath = field.__zm_refPath;
     const unique = field.__zm_unique;
-    return parseObjectId(required, ref, unique, refPath);
+    const sparse = field.__zm_sparse;
+    return parseObjectId(required, ref, unique, refPath, sparse);
   }
   if (assertions_default.uuid(field)) {
     const ref = field.__zm_ref;
     const refPath = field.__zm_refPath;
     const unique = field.__zm_unique;
-    return parseUUID(required, ref, unique, refPath);
+    const sparse = field.__zm_unique;
+    return parseUUID(required, ref, unique, refPath, sparse);
   }
   if (assertions_default.object(field)) {
     return parseObject(field);
   }
   if (assertions_default.number(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseNumber(
       field,
       required,
       def,
       isUnique,
-      refinement
+      refinement,
+      isSparse
     );
   }
   if (assertions_default.string(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseString(
       field,
       required,
       def,
       isUnique,
-      refinement
+      refinement,
+      isSparse
     );
   }
   if (assertions_default.enumerable(field)) {
@@ -339,11 +361,13 @@ function parseField(field, required = true, def, refinement) {
   }
   if (assertions_default.date(field)) {
     const isUnique = field.__zm_unique ?? false;
+    const isSparse = field.__zm_sparse ?? false;
     return parseDate(
       required,
       def,
       refinement,
-      isUnique
+      isUnique,
+      isSparse
     );
   }
   if (assertions_default.array(field)) {
@@ -371,7 +395,7 @@ function parseField(field, required = true, def, refinement) {
   if (assertions_default.mapOrRecord(field)) {
     return parseMap(
       required,
-      field.keySchema,
+      field.valueSchema,
       def
     );
   }
@@ -384,34 +408,39 @@ function parseField(field, required = true, def, refinement) {
   }
   return null;
 }
-function parseNumber(field, required = true, def, unique = false, validate) {
+function parseNumber(field, required = true, def, unique = false, validate, sparse = false) {
   const output = {
     type: Number,
     default: def,
     min: field.minValue ?? void 0,
     max: field.maxValue ?? void 0,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
-function parseString(field, required = true, def, unique = false, validate) {
+function parseString(field, required = true, def, unique = false, validate, sparse = false) {
   const output = {
     type: String,
     default: def,
     required,
     minLength: field.minLength ?? void 0,
     maxLength: field.maxLength ?? void 0,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
 function parseEnum(values, required = true, def) {
   return {
     type: String,
     unique: false,
+    sparse: false,
     default: def,
     enum: values,
     required
@@ -424,37 +453,45 @@ function parseBoolean(required = true, def) {
     required
   };
 }
-function parseDate(required = true, def, validate, unique = false) {
+function parseDate(required = true, def, validate, unique = false, sparse = false) {
   const output = {
     type: Date,
     default: def,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (validate) output.validate = validate;
+  if (validate)
+    output.validate = validate;
   return output;
 }
-function parseObjectId(required = true, ref, unique = false, refPath) {
+function parseObjectId(required = true, ref, unique = false, refPath, sparse = false) {
   const output = {
     type: SchemaTypes.ObjectId,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (ref) output.ref = ref;
-  if (refPath) output.refPath = refPath;
+  if (ref)
+    output.ref = ref;
+  if (refPath)
+    output.refPath = refPath;
   return output;
 }
 function parseArray(required = true, element, def) {
   const innerType = parseField(element);
-  if (!innerType) throw new Error("Unsupported array type");
+  if (!innerType)
+    throw new Error("Unsupported array type");
   return {
     type: [innerType],
     default: def,
     required
   };
 }
-function parseMap(required = true, key, def) {
-  const pointer = typeConstructor(key);
+function parseMap(required = true, valueType, def) {
+  const pointer = parseField(valueType);
+  if (!pointer)
+    throw new Error("Unsupported map value type");
   return {
     type: Map,
     of: pointer,
@@ -462,32 +499,17 @@ function parseMap(required = true, key, def) {
     required
   };
 }
-function typeConstructor(t) {
-  switch (true) {
-    case assertions_default.string(t):
-      return String;
-    case assertions_default.enumerable(t):
-      return String;
-    case assertions_default.uuid(t):
-      return SchemaTypes.UUID;
-    case assertions_default.objectId(t):
-      return SchemaTypes.ObjectId;
-    case assertions_default.number(t):
-      return Number;
-    case assertions_default.date(t):
-      return Date;
-    default:
-      return void 0;
-  }
-}
-function parseUUID(required = true, ref, unique = false, refPath) {
+function parseUUID(required = true, ref, unique = false, refPath, sparse = false) {
   const output = {
     type: SchemaTypes.UUID,
     required,
-    unique
+    unique,
+    sparse
   };
-  if (ref) output.ref = ref;
-  if (refPath) output.refPath = refPath;
+  if (ref)
+    output.ref = ref;
+  if (refPath)
+    output.refPath = refPath;
   return output;
 }
 function parseMixed(required = true, def) {

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/assertions/constructor.ts","../src/assertions/custom.ts","../src/assertions/instanceOf.ts","../src/assertions/staticNames.ts","../src/assertions/assertions.ts","../src/extension.ts"],"sourcesContent":["import { Schema, type SchemaOptions, SchemaTypes } from \"mongoose\";\nimport type { ZodNumber, ZodObject, ZodRawShape, ZodString, ZodType, z } from \"zod\";\nimport zmAssert from \"./assertions/assertions.js\";\nimport type { zm } from \"./mongoose.types.js\";\nexport * from \"./extension.js\";\n\n/**\n * Converts a Zod schema to a Mongoose schema\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchema } from '@zodyac/zod-mongoose';\n * import { model } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *     street: z.string(),\n *     city: z.string(),\n *     state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *   tags: z.array(z.string()),\n *   createdAt: z.date(),\n *   updatedAt: z.date(),\n * });\n *\n * const schema = zodSchema(zDoc);\n * const userModel = model('User', schema);\n */\nexport function zodSchema<T extends ZodRawShape>(\n  schema: ZodObject<T>,\n  options?: SchemaOptions<any>, // TODO: Fix any\n): Schema<z.infer<typeof schema>> {\n  const definition = parseObject(schema);\n  return new Schema<z.infer<typeof schema>>(definition, options);\n}\n\n/**\n * Converts a Zod schema to a raw Mongoose schema object\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchemaRaw } from '@zodyac/zod-mongoose';\n * import { model, Schema } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *    street: z.string(),\n *    city: z.string(),\n *    state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *  tags: z.array(z.string()),\n *  createdAt: z.date(),\n *  updatedAt: z.date(),\n * });\n *\n * const rawSchema = zodSchemaRaw(zDoc);\n * const schema = new Schema(rawSchema);\n * const userModel = model('User', schema);\n */\nexport function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T> {\n  return parseObject(schema);\n}\n\n// Helpers\nfunction parseObject<T extends ZodRawShape>(obj: ZodObject<T>): zm._Schema<T> {\n  const object: any = {};\n  for (const [key, field] of Object.entries(obj.shape)) {\n    if (zmAssert.object(field)) {\n      object[key] = parseObject(field);\n    } else {\n      const f = parseField(field);\n      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);\n\n      object[key] = f;\n    }\n  }\n\n  return object;\n}\n\nfunction parseField<T>(\n  field: ZodType<T>,\n  required = true,\n  def?: T,\n  refinement?: zm.EffectValidator<T>,\n): zm.mField | null {\n  if (zmAssert.objectId(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    return parseObjectId(required, ref, unique, refPath);\n  }\n\n  if (zmAssert.uuid(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    return parseUUID(required, ref, unique, refPath);\n  }\n\n  if (zmAssert.object(field)) {\n    return parseObject(field);\n  }\n\n  if (zmAssert.number(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseNumber(\n      field,\n      required,\n      def as number,\n      isUnique,\n      refinement as zm.EffectValidator<number>,\n    );\n  }\n\n  if (zmAssert.string(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseString(\n      field,\n      required,\n      def as string,\n      isUnique,\n      refinement as zm.EffectValidator<string>,\n    );\n  }\n\n  if (zmAssert.enumerable(field)) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (zmAssert.boolean(field)) {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (zmAssert.date(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    return parseDate(\n      required,\n      def as Date,\n      refinement as zm.EffectValidator<Date>,\n      isUnique,\n    );\n  }\n\n  if (zmAssert.array(field)) {\n    return parseArray(\n      required,\n      field.element,\n      def as T extends Array<infer K> ? K[] : never,\n    );\n  }\n\n  if (zmAssert.def(field)) {\n    return parseField(field._def.innerType, required, field._def.defaultValue());\n  }\n\n  if (zmAssert.optional(field)) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (zmAssert.nullable(field)) {\n    return parseField(field._def.innerType, false, def || null);\n  }\n\n  if (zmAssert.union(field)) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (zmAssert.any(field)) {\n    return parseMixed(required, def);\n  }\n\n  if (zmAssert.mapOrRecord(field)) {\n    return parseMap(\n      required,\n      field.keySchema,\n      def as Map<\n        zm.UnwrapZodType<typeof field.keySchema>,\n        zm.UnwrapZodType<typeof field.valueSchema>\n      >,\n    );\n  }\n\n  if (zmAssert.effect(field)) {\n    const effect = field._def.effect;\n\n    if (effect.type === \"refinement\") {\n      const validation = (<any>effect).__zm_validation as zm.EffectValidator<T>;\n      return parseField(field._def.schema, required, def, validation);\n    }\n  }\n\n  return null;\n}\n\nfunction parseNumber(\n  field: ZodNumber,\n  required = true,\n  def?: number,\n  unique = false,\n  validate?: zm.EffectValidator<number>,\n): zm.mNumber {\n  const output: zm.mNumber = {\n    type: Number,\n    default: def,\n    min: field.minValue ?? undefined,\n    max: field.maxValue ?? undefined,\n    required,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseString(\n  field: ZodString,\n  required = true,\n  def?: string,\n  unique = false,\n  validate?: zm.EffectValidator<string>,\n): zm.mString {\n  const output: zm.mString = {\n    type: String,\n    default: def,\n    required,\n    minLength: field.minLength ?? undefined,\n    maxLength: field.maxLength ?? undefined,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseEnum(values: string[], required = true, def?: string): zm.mString {\n  return {\n    type: String,\n    unique: false,\n    default: def,\n    enum: values,\n    required,\n  };\n}\n\nfunction parseBoolean(required = true, def?: boolean): zm.mBoolean {\n  return {\n    type: Boolean,\n    default: def,\n    required,\n  };\n}\n\nfunction parseDate(\n  required = true,\n  def?: Date,\n  validate?: zm.EffectValidator<Date>,\n  unique = false,\n): zm.mDate {\n  const output: zm.mDate = {\n    type: Date,\n    default: def,\n    required,\n    unique,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseObjectId(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n): zm.mObjectId {\n  const output: zm.mObjectId = {\n    type: SchemaTypes.ObjectId,\n    required,\n    unique,\n  };\n\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseArray<T>(\n  // biome-ignore lint/style/useDefaultParameterLast: Should be consistent with other functions\n  required = true,\n  element: ZodType<T>,\n  def?: T[],\n): zm.mArray<T> {\n  const innerType = parseField(element);\n  if (!innerType) throw new Error(\"Unsupported array type\");\n  return {\n    type: [innerType as zm._Field<T>],\n    default: def,\n    required,\n  };\n}\n\nfunction parseMap<T, K>(\n  // biome-ignore lint/style/useDefaultParameterLast: Consistency with other functions\n  required = true,\n  key: ZodType<T>,\n  def?: Map<NoInfer<T>, K>,\n): zm.mMap<T, K> {\n  const pointer = typeConstructor(key);\n  return {\n    type: Map,\n    of: pointer,\n    default: def,\n    required,\n  };\n}\n\nfunction typeConstructor<T>(t: ZodType<T>) {\n  switch (true) {\n    case zmAssert.string(t):\n      return String;\n    case zmAssert.enumerable(t):\n      return String;\n    case zmAssert.uuid(t):\n      return SchemaTypes.UUID;\n    case zmAssert.objectId(t):\n      return SchemaTypes.ObjectId;\n    case zmAssert.number(t):\n      return Number;\n    case zmAssert.date(t):\n      return Date;\n    default:\n      return undefined;\n  }\n}\n\nfunction parseUUID(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n): zm.mUUID {\n  const output: zm.mUUID = {\n    type: SchemaTypes.UUID,\n    required,\n    unique,\n  };\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseMixed(required = true, def?: unknown): zm.mMixed<unknown> {\n  return {\n    type: SchemaTypes.Mixed,\n    default: def,\n    required,\n  };\n}\n\nexport default zodSchema;\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Constructor assertions (CommonJS)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the constructor name of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f.constructor.name === \"ZodString\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f.constructor.name === \"ZodNumber\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f.constructor.name === \"ZodObject\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f.constructor.name === \"ZodArray\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f.constructor.name === \"ZodBoolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f.constructor.name === \"ZodEnum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f.constructor.name === \"ZodDate\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f.constructor.name === \"ZodDefault\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f.constructor.name === \"ZodOptional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f.constructor.name === \"ZodNullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f.constructor.name === \"ZodUnion\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f.constructor.name === \"ZodAny\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f.constructor.name === \"ZodMap\" || f.constructor.name === \"ZodRecord\";\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f.constructor.name === \"ZodEffects\";\n  },\n};\n","import type { ZodType } from \"zod\";\n\nexport namespace zmAssertIds {\n  export function objectId(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"ObjectId\";\n  }\n\n  export function uuid(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"UUID\";\n  }\n}\n","import {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  type ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Instance assertions (ESM)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the instance of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f instanceof ZodString;\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f instanceof ZodNumber;\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f instanceof ZodObject;\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f instanceof ZodArray;\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f instanceof ZodBoolean;\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f instanceof ZodEnum;\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f instanceof ZodDate;\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f instanceof ZodDefault;\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f instanceof ZodOptional;\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f instanceof ZodNullable;\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f instanceof ZodUnion;\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f instanceof ZodAny;\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f instanceof ZodMap || f instanceof ZodRecord;\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f instanceof ZodEffects;\n  },\n};\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Static names assertions (Bundlers)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the `__zm_type` property of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return \"__zm_type\" in f && f.__zm_type === \"String\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return \"__zm_type\" in f && f.__zm_type === \"Number\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Object\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Array\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return \"__zm_type\" in f && f.__zm_type === \"Boolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Enum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return \"__zm_type\" in f && f.__zm_type === \"Date\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Default\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Optional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Nullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Union\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return \"__zm_type\" in f && f.__zm_type === \"Any\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return \"__zm_type\" in f && (f.__zm_type === \"Map\" || f.__zm_type === \"Record\");\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Effects\";\n  },\n};\n","import type { ZodType } from \"zod\";\nimport { zmAssert as aConstructor } from \"./constructor\";\nimport { zmAssertIds } from \"./custom\";\nimport { zmAssert as aInstance } from \"./instanceOf\";\nimport { zmAssert as aStaticName } from \"./staticNames\";\nimport type { IAsserts } from \"./types\";\n\nconst assertions = [aConstructor, aInstance, aStaticName];\nconst zmAssert = Object.keys(aConstructor)\n  .map((key) => key as keyof IAsserts)\n  .reduce((acc, key) => {\n    (<any>acc[key]) = (f: ZodType<any>) => {\n      return assertions.some((assertion) => assertion[key](f));\n    };\n\n    return acc;\n  }, {} as IAsserts);\n\nexport default {\n  ...zmAssert,\n  ...zmAssertIds,\n};\n","import { Types, isValidObjectId } from \"mongoose\";\nimport { type CustomErrorParams, z } from \"zod\";\n\ndeclare module \"zod\" {\n  interface ZodString {\n    unique: (arg?: boolean) => ZodString;\n    __zm_unique: boolean;\n  }\n\n  interface ZodNumber {\n    unique: (arg?: boolean) => ZodNumber;\n    __zm_unique: boolean;\n  }\n\n  interface ZodDate {\n    unique: (arg?: boolean) => ZodDate;\n    __zm_unique: boolean;\n  }\n\n  interface ZodType<\n    Output = any,\n    Def extends z.ZodTypeDef = z.ZodTypeDef,\n    Input = Output,\n  > {\n    // For future use\n  }\n}\n\nlet zod_extended = false;\n/**\n * Extends the Zod library with additional functionality.\n *\n * This function modifies the Zod library to add custom validation and uniqueness checks.\n * It ensures that the extension is only applied once.\n *\n * @param z_0 - The Zod library to extend.\n *\n * @remarks\n * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.\n * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { extendZod } from \"./extension\";\n *\n * extendZod(z);\n *\n * const schema = z.object({\n *   name: z.string().unique();\n * });\n * ```\n */\nexport function extendZod(z_0: typeof z) {\n  // Prevent zod from being extended multiple times\n  if (zod_extended) return;\n  zod_extended = true;\n\n  // Refine support\n  const _refine = z_0.ZodType.prototype.refine;\n  z_0.ZodType.prototype.refine = function <T>(\n    check: (arg0: T) => boolean,\n    opts?: string | CustomErrorParams | ((arg: T) => CustomErrorParams),\n  ) {\n    const zEffect = _refine.bind(this)(check, opts);\n\n    let message: string | undefined | ((v: T) => string | undefined) = undefined;\n    if (opts) {\n      if (typeof opts === \"string\") message = opts;\n      else if (\"message\" in opts) message = opts.message;\n    }\n\n    (<any>zEffect._def.effect).__zm_validation = {\n      validator: check,\n      message: message,\n    };\n\n    return zEffect;\n  };\n\n  // Unique support\n  const UNIQUE_SUPPORT_LIST = [z_0.ZodString, z_0.ZodNumber, z_0.ZodDate] as const;\n\n  for (const type of UNIQUE_SUPPORT_LIST) {\n    (<any>type.prototype).unique = function (arg = true) {\n      (<any>this).__zm_unique = arg;\n      return this;\n    };\n  }\n\n  // Assign static names to Zod types\n  const TypesMap = {\n    String: z_0.ZodString,\n    Number: z_0.ZodNumber,\n    Object: z_0.ZodObject,\n    Array: z_0.ZodArray,\n    Boolean: z_0.ZodBoolean,\n    Enum: z_0.ZodEnum,\n    Date: z_0.ZodDate,\n    Default: z_0.ZodDefault,\n    Optional: z_0.ZodOptional,\n    Nullable: z_0.ZodNullable,\n    Union: z_0.ZodUnion,\n    Any: z_0.ZodAny,\n    Map: z_0.ZodMap,\n    Record: z_0.ZodRecord,\n    Effects: z_0.ZodEffects,\n  };\n\n  for (const [key, value] of Object.entries(TypesMap)) {\n    (<any>value.prototype).__zm_type = key;\n  }\n}\n\nexport type TzmId = ReturnType<typeof createId> & {\n  unique: (arg?: boolean) => TzmId;\n  ref: (arg: string) => TzmId;\n  refPath: (arg: string) => TzmId;\n};\n\nconst createId = () => {\n  return z\n    .string()\n    .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n    .or(z.instanceof(Types.ObjectId));\n};\n\nexport const zId = (ref?: string): TzmId => {\n  const output = createId();\n\n  (<any>output).__zm_type = \"ObjectId\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  return output as TzmId;\n};\n\nexport type TzmUUID = ReturnType<typeof createUUID> & {\n  unique: (arg?: boolean) => TzmUUID;\n  ref: (arg: string) => TzmUUID;\n  refPath: (arg: string) => TzmUUID;\n};\n\nconst createUUID = () => {\n  return z.string().uuid({ message: \"Invalid UUID\" }).or(z.instanceof(Types.UUID));\n};\n\nexport const zUUID = (ref?: string): TzmUUID => {\n  const output = createUUID();\n\n  (<any>output).__zm_type = \"UUID\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  return output as TzmUUID;\n};\n"],"mappings":"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","names":["zmAssertIds","zmAssert","zmAssert","zmAssert","ref"]}
+{"version":3,"sources":["../src/index.ts","../src/assertions/constructor.ts","../src/assertions/custom.ts","../src/assertions/instanceOf.ts","../src/assertions/staticNames.ts","../src/assertions/assertions.ts","../src/extension.ts"],"sourcesContent":["import { Schema, type SchemaOptions, SchemaTypes } from \"mongoose\";\nimport type { ZodNumber, ZodObject, ZodRawShape, ZodString, ZodType, z } from \"zod\";\nimport zmAssert from \"./assertions/assertions.js\";\nimport type { zm } from \"./mongoose.types.js\";\nexport * from \"./extension.js\";\n\n/**\n * Converts a Zod schema to a Mongoose schema\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchema } from '@zodyac/zod-mongoose';\n * import { model } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *     street: z.string(),\n *     city: z.string(),\n *     state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *   tags: z.array(z.string()),\n *   createdAt: z.date(),\n *   updatedAt: z.date(),\n * });\n *\n * const schema = zodSchema(zDoc);\n * const userModel = model('User', schema);\n */\nexport function zodSchema<T extends ZodRawShape>(\n  schema: ZodObject<T>,\n  options?: SchemaOptions<any>, // TODO: Fix any\n): Schema<z.infer<typeof schema>> {\n  const definition = parseObject(schema);\n  return new Schema<z.infer<typeof schema>>(definition, options);\n}\n\n/**\n * Converts a Zod schema to a raw Mongoose schema object\n * @param schema zod schema to parse\n * @returns mongoose schema\n *\n * @example\n * import { extendZod, zodSchemaRaw } from '@zodyac/zod-mongoose';\n * import { model, Schema } from 'mongoose';\n * import { z } from 'zod';\n *\n * extendZod(z);\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   age: z.number().min(18).max(100),\n *   active: z.boolean().default(false),\n *   access: z.enum(['admin', 'user']).default('user'),\n *   companyId: zId('Company'),\n *   address: z.object({\n *    street: z.string(),\n *    city: z.string(),\n *    state: z.enum(['CA', 'NY', 'TX']),\n *   }),\n *  tags: z.array(z.string()),\n *  createdAt: z.date(),\n *  updatedAt: z.date(),\n * });\n *\n * const rawSchema = zodSchemaRaw(zDoc);\n * const schema = new Schema(rawSchema);\n * const userModel = model('User', schema);\n */\nexport function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T> {\n  return parseObject(schema);\n}\n\n// Helpers\nfunction parseObject<T extends ZodRawShape>(obj: ZodObject<T>): zm._Schema<T> {\n  const object: any = {};\n  for (const [key, field] of Object.entries(obj.shape)) {\n    if (zmAssert.object(field)) {\n      object[key] = parseObject(field);\n    } else {\n      const f = parseField(field);\n      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);\n\n      object[key] = f;\n    }\n  }\n\n  return object;\n}\n\nfunction parseField<T>(\n  field: ZodType<T>,\n  required = true,\n  def?: T,\n  refinement?: zm.EffectValidator<T>,\n): zm.mField | null {\n  if (zmAssert.objectId(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    const sparse = (<any>field).__zm_sparse;\n    return parseObjectId(required, ref, unique, refPath, sparse);\n  }\n\n  if (zmAssert.uuid(field)) {\n    const ref = (<any>field).__zm_ref;\n    const refPath = (<any>field).__zm_refPath;\n    const unique = (<any>field).__zm_unique;\n    const sparse = (<any>field).__zm_unique;\n    return parseUUID(required, ref, unique, refPath, sparse);\n  }\n\n  if (zmAssert.object(field)) {\n    return parseObject(field);\n  }\n\n  if (zmAssert.number(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseNumber(\n      field,\n      required,\n      def as number,\n      isUnique,\n      refinement as zm.EffectValidator<number>,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.string(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseString(\n      field,\n      required,\n      def as string,\n      isUnique,\n      refinement as zm.EffectValidator<string>,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.enumerable(field)) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (zmAssert.boolean(field)) {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (zmAssert.date(field)) {\n    const isUnique = field.__zm_unique ?? false;\n    const isSparse = field.__zm_sparse ?? false;\n    return parseDate(\n      required,\n      def as Date,\n      refinement as zm.EffectValidator<Date>,\n      isUnique,\n      isSparse,\n    );\n  }\n\n  if (zmAssert.array(field)) {\n    return parseArray(\n      required,\n      field.element,\n      def as T extends Array<infer K> ? K[] : never,\n    );\n  }\n\n  if (zmAssert.def(field)) {\n    return parseField(field._def.innerType, required, field._def.defaultValue());\n  }\n\n  if (zmAssert.optional(field)) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (zmAssert.nullable(field)) {\n    return parseField(field._def.innerType, false, def || null);\n  }\n\n  if (zmAssert.union(field)) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (zmAssert.any(field)) {\n    return parseMixed(required, def);\n  }\n\n  if (zmAssert.mapOrRecord(field)) {\n    return parseMap(\n      required,\n      field.valueSchema,\n      def as Map<\n        zm.UnwrapZodType<typeof field.keySchema>,\n        zm.UnwrapZodType<typeof field.valueSchema>\n      >,\n    );\n  }\n\n  if (zmAssert.effect(field)) {\n    const effect = field._def.effect;\n\n    if (effect.type === \"refinement\") {\n      const validation = (<any>effect).__zm_validation as zm.EffectValidator<T>;\n      return parseField(field._def.schema, required, def, validation);\n    }\n  }\n\n  return null;\n}\n\nfunction parseNumber(\n  field: ZodNumber,\n  required = true,\n  def?: number,\n  unique = false,\n  validate?: zm.EffectValidator<number>,\n  sparse = false,\n): zm.mNumber {\n  const output: zm.mNumber = {\n    type: Number,\n    default: def,\n    min: field.minValue ?? undefined,\n    max: field.maxValue ?? undefined,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseString(\n  field: ZodString,\n  required = true,\n  def?: string,\n  unique = false,\n  validate?: zm.EffectValidator<string>,\n  sparse = false,\n): zm.mString {\n  const output: zm.mString = {\n    type: String,\n    default: def,\n    required,\n    minLength: field.minLength ?? undefined,\n    maxLength: field.maxLength ?? undefined,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseEnum(values: string[], required = true, def?: string): zm.mString {\n  return {\n    type: String,\n    unique: false,\n    sparse: false,\n    default: def,\n    enum: values,\n    required,\n  };\n}\n\nfunction parseBoolean(required = true, def?: boolean): zm.mBoolean {\n  return {\n    type: Boolean,\n    default: def,\n    required,\n  };\n}\n\nfunction parseDate(\n  required = true,\n  def?: Date,\n  validate?: zm.EffectValidator<Date>,\n  unique = false,\n  sparse = false,\n): zm.mDate {\n  const output: zm.mDate = {\n    type: Date,\n    default: def,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (validate) output.validate = validate;\n  return output;\n}\n\nfunction parseObjectId(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n  sparse = false,\n): zm.mObjectId {\n  const output: zm.mObjectId = {\n    type: SchemaTypes.ObjectId,\n    required,\n    unique,\n    sparse,\n  };\n\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseArray<T>(\n  // biome-ignore lint/style/useDefaultParameterLast: Should be consistent with other functions\n  required = true,\n  element: ZodType<T>,\n  def?: T[],\n): zm.mArray<T> {\n  const innerType = parseField(element);\n  if (!innerType) throw new Error(\"Unsupported array type\");\n  return {\n    type: [innerType as zm._Field<T>],\n    default: def,\n    required,\n  };\n}\n\nfunction parseMap<T, K>(\n  // biome-ignore lint/style/useDefaultParameterLast: Consistency with other functions\n  required = true,\n  valueType: ZodType<K>,\n  def?: Map<NoInfer<T>, K>,\n): zm.mMap<T, K> {\n  const pointer = parseField(valueType);\n  if (!pointer) throw new Error(\"Unsupported map value type\");\n\n  return {\n    type: Map,\n    of: pointer as zm._Field<K>,\n    default: def,\n    required,\n  };\n}\n\nfunction parseUUID(\n  required = true,\n  ref?: string,\n  unique = false,\n  refPath?: string,\n  sparse = false,\n): zm.mUUID {\n  const output: zm.mUUID = {\n    type: SchemaTypes.UUID,\n    required,\n    unique,\n    sparse,\n  };\n  if (ref) output.ref = ref;\n  if (refPath) output.refPath = refPath;\n  return output;\n}\n\nfunction parseMixed(required = true, def?: unknown): zm.mMixed<unknown> {\n  return {\n    type: SchemaTypes.Mixed,\n    default: def,\n    required,\n  };\n}\n\nexport default zodSchema;\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Constructor assertions (CommonJS)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the constructor name of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f.constructor.name === \"ZodString\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f.constructor.name === \"ZodNumber\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f.constructor.name === \"ZodObject\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f.constructor.name === \"ZodArray\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f.constructor.name === \"ZodBoolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f.constructor.name === \"ZodEnum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f.constructor.name === \"ZodDate\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f.constructor.name === \"ZodDefault\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f.constructor.name === \"ZodOptional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f.constructor.name === \"ZodNullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f.constructor.name === \"ZodUnion\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f.constructor.name === \"ZodAny\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f.constructor.name === \"ZodMap\" || f.constructor.name === \"ZodRecord\";\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f.constructor.name === \"ZodEffects\";\n  },\n};\n","import type { ZodType } from \"zod\";\n\nexport namespace zmAssertIds {\n  export function objectId(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"ObjectId\";\n  }\n\n  export function uuid(f: ZodType<any>): f is ZodType<string> {\n    return \"__zm_type\" in f && f.__zm_type === \"UUID\";\n  }\n}\n","import {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  type ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Instance assertions (ESM)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the instance of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return f instanceof ZodString;\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return f instanceof ZodNumber;\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return f instanceof ZodObject;\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return f instanceof ZodArray;\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return f instanceof ZodBoolean;\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return f instanceof ZodEnum;\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return f instanceof ZodDate;\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return f instanceof ZodDefault;\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return f instanceof ZodOptional;\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return f instanceof ZodNullable;\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return f instanceof ZodUnion;\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return f instanceof ZodAny;\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return f instanceof ZodMap || f instanceof ZodRecord;\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return f instanceof ZodEffects;\n  },\n};\n","import type {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRecord,\n  ZodString,\n  ZodType,\n  ZodUnion,\n} from \"zod\";\nimport type { IAsserts } from \"./types\";\n\n/**\n * Static names assertions (Bundlers)\n * @internal\n *\n * Asserts if a Zod type is a specific type\n * by checking the `__zm_type` property of it's prototype.\n */\nexport const zmAssert: IAsserts = {\n  string(f: ZodType<any>): f is ZodString {\n    return \"__zm_type\" in f && f.__zm_type === \"String\";\n  },\n\n  number(f: ZodType<any>): f is ZodNumber {\n    return \"__zm_type\" in f && f.__zm_type === \"Number\";\n  },\n\n  object(f: ZodType<any>): f is ZodObject<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Object\";\n  },\n\n  array(f: ZodType<any>): f is ZodArray<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Array\";\n  },\n\n  boolean(f: ZodType<any>): f is ZodBoolean {\n    return \"__zm_type\" in f && f.__zm_type === \"Boolean\";\n  },\n\n  enumerable(f: ZodType<any>): f is ZodEnum<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Enum\";\n  },\n\n  date(f: ZodType<any>): f is ZodDate {\n    return \"__zm_type\" in f && f.__zm_type === \"Date\";\n  },\n\n  def(f: ZodType<any>): f is ZodDefault<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Default\";\n  },\n\n  optional(f: ZodType<any>): f is ZodOptional<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Optional\";\n  },\n\n  nullable(f: ZodType<any>): f is ZodNullable<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Nullable\";\n  },\n\n  union(f: ZodType<any>): f is ZodUnion<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Union\";\n  },\n\n  any(f: ZodType<any>): f is ZodAny {\n    return \"__zm_type\" in f && f.__zm_type === \"Any\";\n  },\n\n  mapOrRecord(f: ZodType<any>): f is ZodMap<any> | ZodRecord<any> {\n    return \"__zm_type\" in f && (f.__zm_type === \"Map\" || f.__zm_type === \"Record\");\n  },\n\n  effect(f: ZodType<any>): f is ZodEffects<any> {\n    return \"__zm_type\" in f && f.__zm_type === \"Effects\";\n  },\n};\n","import type { ZodType } from \"zod\";\nimport { zmAssert as aConstructor } from \"./constructor\";\nimport { zmAssertIds } from \"./custom\";\nimport { zmAssert as aInstance } from \"./instanceOf\";\nimport { zmAssert as aStaticName } from \"./staticNames\";\nimport type { IAsserts } from \"./types\";\n\nconst assertions = [aConstructor, aInstance, aStaticName];\nconst zmAssert = Object.keys(aConstructor)\n  .map((key) => key as keyof IAsserts)\n  .reduce((acc, key) => {\n    (<any>acc[key]) = (f: ZodType<any>) => {\n      return assertions.some((assertion) => assertion[key](f));\n    };\n\n    return acc;\n  }, {} as IAsserts);\n\nexport default {\n  ...zmAssert,\n  ...zmAssertIds,\n};\n","import { Types, isValidObjectId } from \"mongoose\";\nimport { type CustomErrorParams, z } from \"zod\";\n\ndeclare module \"zod\" {\n  interface ZodString {\n    unique: (arg?: boolean) => ZodString;\n    sparse: (arg?: boolean) => ZodString;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodNumber {\n    unique: (arg?: boolean) => ZodNumber;\n    sparse: (arg?: boolean) => ZodNumber;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodDate {\n    unique: (arg?: boolean) => ZodDate;\n    sparse: (arg?: boolean) => ZodDate;\n    __zm_unique: boolean;\n    __zm_sparse: boolean;\n  }\n\n  interface ZodType<\n    Output = any,\n    Def extends z.ZodTypeDef = z.ZodTypeDef,\n    Input = Output,\n  > {\n    // For future use\n  }\n}\n\nlet zod_extended = false;\n/**\n * Extends the Zod library with additional functionality.\n *\n * This function modifies the Zod library to add custom validation and uniqueness checks.\n * It ensures that the extension is only applied once.\n *\n * @param z_0 - The Zod library to extend.\n *\n * @remarks\n * - Overrides `refine` method to `ZodType` that includes additional metadata for validation.\n * - Overrides `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.\n * - Overrides `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.\n *\n * @example\n * ```typescript\n * import { z } from \"zod\";\n * import { extendZod } from \"./extension\";\n *\n * extendZod(z);\n *\n * const schema = z.object({\n *   name: z.string().unique();\n * });\n * ```\n */\nexport function extendZod(z_0: typeof z) {\n  // Prevent zod from being extended multiple times\n  if (zod_extended) return;\n  zod_extended = true;\n\n  // Refine support\n  const _refine = z_0.ZodType.prototype.refine;\n  z_0.ZodType.prototype.refine = function <T>(\n    check: (arg0: T) => boolean,\n    opts?: string | CustomErrorParams | ((arg: T) => CustomErrorParams),\n  ) {\n    const zEffect = _refine.bind(this)(check, opts);\n\n    let message: string | undefined | ((v: T) => string | undefined) = undefined;\n    if (opts) {\n      if (typeof opts === \"string\") message = opts;\n      else if (\"message\" in opts) message = opts.message;\n    }\n\n    (<any>zEffect._def.effect).__zm_validation = {\n      validator: check,\n      message: message,\n    };\n\n    return zEffect;\n  };\n\n  // Unique support\n  const UNIQUE_SUPPORT_LIST = [z_0.ZodString, z_0.ZodNumber, z_0.ZodDate] as const;\n\n  for (const type of UNIQUE_SUPPORT_LIST) {\n    (<any>type.prototype).unique = function (arg = true) {\n      (<any>this).__zm_unique = arg;\n      return this;\n    };\n\n    (<any>type.prototype).sparse = function (arg = true) {\n      (<any>this).__zm_sparse = arg;\n      return this;\n    };\n  }\n\n  // Assign static names to Zod types\n  const TypesMap = {\n    String: z_0.ZodString,\n    Number: z_0.ZodNumber,\n    Object: z_0.ZodObject,\n    Array: z_0.ZodArray,\n    Boolean: z_0.ZodBoolean,\n    Enum: z_0.ZodEnum,\n    Date: z_0.ZodDate,\n    Default: z_0.ZodDefault,\n    Optional: z_0.ZodOptional,\n    Nullable: z_0.ZodNullable,\n    Union: z_0.ZodUnion,\n    Any: z_0.ZodAny,\n    Map: z_0.ZodMap,\n    Record: z_0.ZodRecord,\n    Effects: z_0.ZodEffects,\n  };\n\n  for (const [key, value] of Object.entries(TypesMap)) {\n    (<any>value.prototype).__zm_type = key;\n  }\n}\n\nexport type TzmId = ReturnType<typeof createId> & {\n  unique: (arg?: boolean) => TzmId;\n  sparse: (arg?: boolean) => TzmId;\n  ref: (arg: string) => TzmId;\n  refPath: (arg: string) => TzmId;\n};\n\nconst createId = () => {\n  return z\n    .string()\n    .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n    .or(z.instanceof(Types.ObjectId));\n};\n\nexport const zId = (ref?: string): TzmId => {\n  const output = createId();\n\n  (<any>output).__zm_type = \"ObjectId\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  (<any>output).sparse = function (val = true) {\n    (<any>this).__zm_sparse = val;\n    return this;\n  };\n\n  return output as TzmId;\n};\n\nexport type TzmUUID = ReturnType<typeof createUUID> & {\n  unique: (arg?: boolean) => TzmUUID;\n  sparse: (arg?: boolean) => TzmUUID;\n  ref: (arg: string) => TzmUUID;\n  refPath: (arg: string) => TzmUUID;\n};\n\nconst createUUID = () => {\n  return z.string().uuid({ message: \"Invalid UUID\" }).or(z.instanceof(Types.UUID));\n};\n\nexport const zUUID = (ref?: string): TzmUUID => {\n  const output = createUUID();\n\n  (<any>output).__zm_type = \"UUID\";\n  (<any>output).__zm_ref = ref;\n\n  (<any>output).ref = function (ref: string) {\n    (<any>this).__zm_ref = ref;\n    return this;\n  };\n\n  (<any>output).refPath = function (ref: string) {\n    (<any>this).__zm_refPath = ref;\n    return this;\n  };\n\n  (<any>output).unique = function (val = true) {\n    (<any>this).__zm_unique = val;\n    return this;\n  };\n\n  (<any>output).sparse = function (val = true) {\n    (<any>this).__zm_sparse = val;\n    return this;\n  };\n\n  return output as TzmUUID;\n};\n"],"mappings":"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","names":["zmAssertIds","zmAssert","zmAssert","zmAssert","ref"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodyac/zod-mongoose",
-  "version": "3.2.0",
+  "version": "4.1.0",
   "description": "A library that allows you to generate mongoose schemas from zod objects.",
   "scripts": {
     "test": "jest",
@@ -54,9 +54,11 @@
     "jest": "^29.7.0",
     "make-coverage-badge": "^1.2.0",
     "tsup": "^8.0.1",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "mongoose": "^8.0.3",
+    "zod": "^3.22.4"
   },
-  "dependencies": {
+  "peerDependencies": {
     "mongoose": "^8.0.3",
     "zod": "^3.22.4"
   }