@zodyac/zod-mongoose 1.1.2 → 1.3.0

package/dist/index.js

@@ -1,29 +1,81 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
 // src/index.ts
-import { Schema, SchemaTypes, Types, isValidObjectId } from "mongoose";
-import {
-  ZodAny,
-  ZodArray,
-  ZodBoolean,
-  ZodDate,
-  ZodDefault,
-  ZodEffects,
-  ZodEnum,
-  ZodNumber,
-  ZodObject,
-  ZodOptional,
-  ZodString,
-  ZodUnion,
-  z
-} from "zod";
-function zodSchema(schema) {
+import { Schema, SchemaTypes } from "mongoose";
+import { ZodArray, ZodDate, ZodDefault, ZodEffects, ZodEnum, ZodMap, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodRecord, ZodString, ZodUnion } from "zod";
+
+// src/extension.ts
+import { Types, isValidObjectId } from "mongoose";
+import { z } from "zod";
+var zod_extended = false;
+function extendZod(z_0) {
+  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 (typeof opts === "string") message = opts;
+    else if ("message" in opts) message = opts.message;
+    zEffect._def.effect.__zm_validation = {
+      validator: check,
+      message
+    };
+    return zEffect;
+  };
+  z_0.ZodString.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.ZodNumber.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.ZodDate.prototype.unique = function(arg = true) {
+    this.__zm_unique = arg;
+    return this;
+  };
+  z_0.objectId = (ref) => {
+    const output = z.string().refine((v) => isValidObjectId(v), {
+      message: "Invalid ObjectId"
+    }).or(z.instanceof(Types.ObjectId));
+    output.__zm_type = "ObjectId";
+    output.__zm_ref = ref;
+    output.ref = function(ref2) {
+      this.__zm_ref = ref2;
+      return this;
+    };
+    output.unique = function(val = true) {
+      this.__zm_unique = val;
+      return this;
+    };
+    return output;
+  };
+  z_0.mongoUUID = () => {
+    const output = z.string().uuid({
+      message: "Invalid UUID"
+    }).or(z.instanceof(Types.UUID).describe("UUID"));
+    output.__zm_type = "UUID";
+    output.unique = function(val = true) {
+      this.__zm_unique = val;
+      return this;
+    };
+    return output;
+  };
+}
+__name(extendZod, "extendZod");
+
+// src/index.ts
+function zodSchema(schema, options) {
   const definition = parseObject(schema);
-  return new Schema(definition);
+  return new Schema(definition, options);
 }
+__name(zodSchema, "zodSchema");
 function zodSchemaRaw(schema) {
   return parseObject(schema);
 }
-var zId = z.string().refine((v) => isValidObjectId(v), { message: "Invalid ObjectId" }).or(z.instanceof(Types.ObjectId).describe("ObjectId"));
-var zUUID = z.string().uuid({ message: "Invalid UUID" }).or(z.instanceof(Types.UUID).describe("UUID"));
+__name(zodSchemaRaw, "zodSchemaRaw");
 function parseObject(obj) {
   const object = {};
   for (const [key, field] of Object.entries(obj.shape)) {
@@ -31,139 +83,112 @@ function parseObject(obj) {
       object[key] = parseObject(field);
     } else {
       const f = parseField(field);
-      if (f)
-        object[key] = f;
-      else
-        console.error(
-          `Key ${key}: Unsupported field type: ${field.constructor}`
-        );
+      if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+      object[key] = f;
     }
   }
   return object;
 }
-function parseField(field, required, def) {
+__name(parseObject, "parseObject");
+function parseField(field, required = true, def, refinement) {
+  const field_type = field.constructor.name;
+  if ("__zm_type" in field && field.__zm_type === "ObjectId") {
+    const ref = field.__zm_ref;
+    const unique = field.__zm_unique;
+    return parseObjectId(required, ref, unique);
+  }
+  if ("__zm_type" in field && field.__zm_type === "UUID") {
+    const unique = field.__zm_unique;
+    return parseUUID(required, unique);
+  }
   if (field instanceof ZodObject) {
     return parseObject(field);
   }
   if (field instanceof ZodNumber) {
-    return parseNumber(
-      field,
-      required,
-      def
-      // validate as (v: number) => boolean,
-    );
+    const isUnique = field.__zm_unique ?? false;
+    return parseNumber(field, required, def, isUnique, refinement);
   }
   if (field instanceof ZodString) {
-    return parseString(
-      field,
-      required,
-      def
-      // validate as (v: string) => boolean,
-    );
+    const isUnique = field.__zm_unique ?? false;
+    return parseString(field, required, def, isUnique, refinement);
   }
   if (field instanceof ZodEnum) {
     return parseEnum(Object.keys(field.Values), required, def);
   }
-  if (field instanceof ZodBoolean) {
+  if (field_type === "ZodBoolean") {
     return parseBoolean(required, def);
   }
   if (field instanceof ZodDate) {
-    return parseDate(required, def);
+    const isUnique = field.__zm_unique ?? false;
+    return parseDate(required, def, refinement, isUnique);
   }
   if (field instanceof ZodArray) {
-    return [parseField(field.element)];
+    return parseArray(required, field.element, def);
   }
   if (field instanceof ZodDefault) {
-    return parseField(
-      field._def.innerType,
-      required,
-      field._def.defaultValue()
-    );
+    return parseField(field._def.innerType, required, field._def.defaultValue());
   }
   if (field instanceof ZodOptional) {
     return parseField(field._def.innerType, false, void 0);
   }
-  if (field.description?.startsWith("ObjectId")) {
-    const ref = field.description.split(":")[1];
-    if (ref)
-      return parseObjectIdRef(required, ref);
-    return parseObjectId(required);
-  }
-  if (field.description?.startsWith("UUID")) {
-    const ref = field.description.split(":")[1];
-    if (ref)
-      return parseUUIDRef(required, ref);
-    return parseUUID(required);
+  if (field instanceof ZodNullable) {
+    return parseField(field._def.innerType, false, def || null);
   }
   if (field instanceof ZodUnion) {
     return parseField(field._def.options[0]);
   }
-  if (field instanceof ZodAny) {
+  if (field_type === "ZodAny") {
     return parseMixed(required, def);
   }
+  if (field instanceof ZodMap || field instanceof ZodRecord) {
+    return parseMap(required, field.keySchema, def);
+  }
   if (field instanceof ZodEffects) {
-    if (field._def.effect.type === "refinement") {
-      return parseField(
-        field._def.schema,
-        required,
-        def
-        // field._def.effect.refinement as (v: T) => boolean,
-      );
+    const effect = field._def.effect;
+    if (effect.type === "refinement") {
+      const validation = effect.__zm_validation;
+      return parseField(field._def.schema, required, def, validation);
     }
   }
   return null;
 }
-function parseNumber(field, required = true, def, validate) {
-  if (validate) {
-    return {
-      type: Number,
-      default: def,
-      min: field.minValue ?? void 0,
-      max: field.maxValue ?? void 0,
-      validation: {
-        validate
-      },
-      required
-    };
-  }
-  return {
+__name(parseField, "parseField");
+function parseNumber(field, required = true, def, unique = false, validate) {
+  const output = {
     type: Number,
     default: def,
     min: field.minValue ?? void 0,
     max: field.maxValue ?? void 0,
-    required
+    required,
+    unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
-function parseString(field, required = true, def, validate) {
-  if (validate) {
-    return {
-      type: String,
-      default: def,
-      required,
-      minLength: field.minLength ?? void 0,
-      maxLength: field.maxLength ?? void 0,
-      validation: {
-        validate
-      }
-    };
-  }
-  return {
+__name(parseNumber, "parseNumber");
+function parseString(field, required = true, def, unique = false, validate) {
+  const output = {
     type: String,
     default: def,
-    // TODO: match: field.regex(),
     required,
     minLength: field.minLength ?? void 0,
-    maxLength: field.maxLength ?? void 0
+    maxLength: field.maxLength ?? void 0,
+    unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
+__name(parseString, "parseString");
 function parseEnum(values, required = true, def) {
   return {
     type: String,
+    unique: false,
     default: def,
     enum: values,
     required
   };
 }
+__name(parseEnum, "parseEnum");
 function parseBoolean(required = true, def) {
   return {
     type: Boolean,
@@ -171,39 +196,73 @@ function parseBoolean(required = true, def) {
     required
   };
 }
-function parseDate(required = true, def) {
-  return {
+__name(parseBoolean, "parseBoolean");
+function parseDate(required = true, def, validate, unique = false) {
+  const output = {
     type: Date,
     default: def,
-    required
+    required,
+    unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
-function parseObjectId(required = true) {
-  return {
+__name(parseDate, "parseDate");
+function parseObjectId(required = true, ref, unique = false) {
+  const output = {
     type: SchemaTypes.ObjectId,
-    required
+    required,
+    unique
   };
+  if (ref) output.ref = ref;
+  return output;
 }
-function parseObjectIdRef(required = true, ref) {
+__name(parseObjectId, "parseObjectId");
+function parseArray(required = true, element, def) {
+  const innerType = parseField(element);
+  if (!innerType) throw new Error("Unsupported array type");
   return {
-    type: SchemaTypes.ObjectId,
-    ref,
+    type: [
+      innerType
+    ],
+    default: def,
     required
   };
 }
-function parseUUID(required = true) {
+__name(parseArray, "parseArray");
+function parseMap(required = true, key, def) {
+  const pointer = typeConstructor(key);
   return {
-    type: SchemaTypes.UUID,
+    type: Map,
+    of: pointer,
+    default: def,
     required
   };
 }
-function parseUUIDRef(required = true, ref) {
+__name(parseMap, "parseMap");
+function typeConstructor(t) {
+  switch (true) {
+    case t instanceof ZodString:
+      return String;
+    case t instanceof ZodEnum:
+      return String;
+    case t instanceof ZodNumber:
+      return Number;
+    case t instanceof ZodDate:
+      return Date;
+    default:
+      return void 0;
+  }
+}
+__name(typeConstructor, "typeConstructor");
+function parseUUID(required = true, unique = false) {
   return {
     type: SchemaTypes.UUID,
-    ref,
-    required
+    required,
+    unique
   };
 }
+__name(parseUUID, "parseUUID");
 function parseMixed(required = true, def) {
   return {
     type: SchemaTypes.Mixed,
@@ -211,11 +270,11 @@ function parseMixed(required = true, def) {
     required
   };
 }
+__name(parseMixed, "parseMixed");
 var src_default = zodSchema;
 export {
   src_default as default,
-  zId,
-  zUUID,
+  extendZod,
   zodSchema,
   zodSchemaRaw
 };

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { zm } from \"./mongoose.types.js\";\nimport { Schema, SchemaTypes, Types, isValidObjectId } from \"mongoose\";\nimport {\n  ZodAny,\n  ZodArray,\n  ZodBoolean,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  ZodRawShape,\n  ZodString,\n  ZodType,\n  ZodUnion,\n  z,\n} from \"zod\";\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 { zId, zodSchema } from '@zodyac/zod-mongoose';\n * import { model } from 'mongoose';\n * import { z } from 'zod';\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.describe('ObjectId: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): Schema<z.infer<typeof schema>> {\n  const definition = parseObject(schema);\n  return new Schema<z.infer<typeof schema>>(definition);\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 { zId, zodSchemaRaw } from '@zodyac/zod-mongoose';\n * import { model, Schema } from 'mongoose';\n * import { z } from 'zod';\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.describe('ObjectId: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>(\n  schema: ZodObject<T>,\n): zm._Schema<T> {\n  return parseObject(schema);\n}\n\n/**\n * Zod ObjectId type\n *\n * You can provide a reference to a model to enable population via zod .describe() method.\n * Description must start with 'ObjectId:' followed by the collection name.\n *\n * Can also be used for string validation for ObjectId.\n *\n * @example\n * import { zId } from '@zodyac/zod-mongoose';\n * import { z } from 'zod';\n *\n * const zUser = z.object({\n *  name: z.string().min(3).max(255),\n *  companyId: zId.describe('ObjectId:Company'),\n * });\n */\nexport const zId = z\n  .string()\n  .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n  .or(z.instanceof(Types.ObjectId).describe(\"ObjectId\"));\n\n/**\n * Zod UUID type (experimental)\n *\n * Use with caution.\n *\n * You can provide a reference to a model to enable population via zod .describe() method.\n * Description must start with 'UUID:' followed by the collection name.\n *\n * Can also be used for string validation for UUID.\n *\n * @warning\n * This is an expreimental feature.\n * UUIDs in Mongoose are a bit of a pain.\n * Mongoose uses version 4 UUIDs, which may not be compatible with the UUIDs used in other languages, e.g. C#.\n *\n * @example\n * import { zUUID, zodSchema } from '@zodyac/zod-mongoose';\n * import { z } from 'zod';\n *\n * const zUser = z.object({\n *   name: z.string().min(3).max(255),\n *   wearable: zUUID.describe('UUID:Wearable'),\n * });\n */\nexport const zUUID = z\n  .string()\n  .uuid({ message: \"Invalid UUID\" })\n  .or(z.instanceof(Types.UUID).describe(\"UUID\"));\n\n// Helpers\nfunction parseObject<T extends ZodRawShape>(obj: ZodObject<T>): zm._Schema<T> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const object: any = {};\n  for (const [key, field] of Object.entries(obj.shape)) {\n    if (field instanceof ZodObject) {\n      object[key] = parseObject(field);\n    } else {\n      const f = parseField(field);\n      if (f) object[key] = f;\n      else\n        console.error(\n          `Key ${key}: Unsupported field type: ${field.constructor}`,\n        );\n    }\n  }\n  return object;\n}\n\nfunction parseField<T>(\n  field: ZodType<T>,\n  required?: boolean,\n  def?: T,\n  // validate?: (v: T) => boolean,\n): zm.mField | null {\n  if (field instanceof ZodObject) {\n    return parseObject(field);\n  }\n\n  if (field instanceof ZodNumber) {\n    return parseNumber(\n      field,\n      required,\n      def as number,\n      // validate as (v: number) => boolean,\n    );\n  }\n\n  if (field instanceof ZodString) {\n    return parseString(\n      field,\n      required,\n      def as string,\n      // validate as (v: string) => boolean,\n    );\n  }\n\n  if (field instanceof ZodEnum) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (field instanceof ZodBoolean) {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (field instanceof ZodDate) {\n    return parseDate(required, def as Date);\n  }\n\n  if (field instanceof ZodArray) {\n    return [parseField(field.element)];\n  }\n\n  if (field instanceof ZodDefault) {\n    return parseField(\n      field._def.innerType,\n      required,\n      field._def.defaultValue(),\n    );\n  }\n\n  if (field instanceof ZodOptional) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (field.description?.startsWith(\"ObjectId\")) {\n    const ref = field.description.split(\":\")[1];\n    if (ref) return parseObjectIdRef(required, ref);\n    return parseObjectId(required);\n  }\n\n  if (field.description?.startsWith(\"UUID\")) {\n    const ref = field.description.split(\":\")[1];\n    if (ref) return parseUUIDRef(required, ref);\n    return parseUUID(required);\n  }\n\n  if (field instanceof ZodUnion) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (field instanceof ZodAny) {\n    return parseMixed(required, def);\n  }\n\n  if (field instanceof ZodEffects) {\n    if (field._def.effect.type === \"refinement\") {\n      return parseField(\n        field._def.schema,\n        required,\n        def,\n        // field._def.effect.refinement as (v: T) => boolean,\n      );\n    }\n  }\n  return null;\n}\n\nfunction parseNumber(\n  field: ZodNumber,\n  required: boolean = true,\n  def?: number,\n  validate?: (v: number) => boolean,\n): zm.mNumber {\n  if (validate) {\n    return {\n      type: Number,\n      default: def,\n      min: field.minValue ?? undefined,\n      max: field.maxValue ?? undefined,\n      validation: {\n        validate,\n      },\n      required,\n    };\n  }\n\n  return {\n    type: Number,\n    default: def,\n    min: field.minValue ?? undefined,\n    max: field.maxValue ?? undefined,\n    required,\n  };\n}\n\nfunction parseString(\n  field: ZodString,\n  required: boolean = true,\n  def?: string,\n  validate?: ((v: string) => boolean) | undefined,\n): zm.mString {\n  if (validate) {\n    return {\n      type: String,\n      default: def,\n      required,\n      minLength: field.minLength ?? undefined,\n      maxLength: field.maxLength ?? undefined,\n      validation: {\n        validate,\n      },\n    };\n  }\n\n  return {\n    type: String,\n    default: def,\n    // TODO: match: field.regex(),\n    required,\n    minLength: field.minLength ?? undefined,\n    maxLength: field.maxLength ?? undefined,\n  };\n}\n\nfunction parseEnum(\n  values: string[],\n  required: boolean = true,\n  def?: string,\n): zm.mString {\n  return {\n    type: String,\n    default: def,\n    enum: values,\n    required,\n  };\n}\n\nfunction parseBoolean(required: boolean = true, def?: boolean): zm.mBoolean {\n  return {\n    type: Boolean,\n    default: def,\n    required,\n  };\n}\n\nfunction parseDate(required: boolean = true, def?: Date): zm.mDate {\n  return {\n    type: Date,\n    default: def,\n    required,\n  };\n}\n\nfunction parseObjectId(required: boolean = true): zm.mObjectId {\n  return {\n    type: SchemaTypes.ObjectId,\n    required,\n  };\n}\n\nfunction parseObjectIdRef(required: boolean = true, ref: string): zm.mObjectId {\n  return {\n    type: SchemaTypes.ObjectId,\n    ref,\n    required,\n  };\n}\n\nfunction parseUUID(required: boolean = true): zm.mUUID {\n  return {\n    type: SchemaTypes.UUID,\n    required,\n  };\n}\n\nfunction parseUUIDRef(required: boolean = true, ref: string): zm.mUUID {\n  return {\n    type: SchemaTypes.UUID,\n    ref,\n    required,\n  };\n}\n\nfunction parseMixed(\n  required: boolean = true,\n  def?: unknown,\n): zm.mMixed<unknown> {\n  return {\n    type: SchemaTypes.Mixed,\n    default: def,\n    required,\n  };\n}\n\nexport { zm };\nexport default zodSchema;\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/extension.ts"],"sourcesContent":["import { Schema, type SchemaOptions, SchemaTypes } from \"mongoose\";\nimport {\n  ZodArray,\n  ZodDate,\n  ZodDefault,\n  ZodEffects,\n  ZodEnum,\n  ZodMap,\n  ZodNullable,\n  ZodNumber,\n  ZodObject,\n  ZodOptional,\n  type ZodRawShape,\n  ZodRecord,\n  ZodString,\n  type ZodType,\n  ZodUnion,\n  type z,\n} from \"zod\";\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: z.objectId('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: z.objectId('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 (field instanceof ZodObject) {\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  const field_type = field.constructor.name;\n\n  if (\"__zm_type\" in field && field.__zm_type === \"ObjectId\") {\n    const ref = (<any>field).__zm_ref;\n    const unique = (<any>field).__zm_unique;\n    return parseObjectId(required, ref, unique);\n  }\n\n  if (\"__zm_type\" in field && field.__zm_type === \"UUID\") {\n    const unique = (<any>field).__zm_unique;\n    return parseUUID(required, unique);\n  }\n\n  if (field instanceof ZodObject) {\n    return parseObject(field);\n  }\n\n  if (field instanceof ZodNumber) {\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 (field instanceof ZodString) {\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 (field instanceof ZodEnum) {\n    return parseEnum(Object.keys(field.Values), required, def as string);\n  }\n\n  if (field_type === \"ZodBoolean\") {\n    return parseBoolean(required, def as boolean);\n  }\n\n  if (field instanceof ZodDate) {\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 (field instanceof ZodArray) {\n    return parseArray(\n      required,\n      field.element,\n      def as T extends Array<infer K> ? K[] : never,\n    );\n  }\n\n  if (field instanceof ZodDefault) {\n    return parseField(field._def.innerType, required, field._def.defaultValue());\n  }\n\n  if (field instanceof ZodOptional) {\n    return parseField(field._def.innerType, false, undefined);\n  }\n\n  if (field instanceof ZodNullable) {\n    return parseField(field._def.innerType, false, def || null);\n  }\n\n  if (field instanceof ZodUnion) {\n    return parseField(field._def.options[0]);\n  }\n\n  if (field_type === \"ZodAny\") {\n    return parseMixed(required, def);\n  }\n\n  if (field instanceof ZodMap || field instanceof ZodRecord) {\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 (field instanceof ZodEffects) {\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(required = true, ref?: string, unique = false): zm.mObjectId {\n  const output: zm.mObjectId = {\n    type: SchemaTypes.ObjectId,\n    required,\n    unique,\n  };\n\n  if (ref) output.ref = ref;\n  return output;\n}\n\n// biome-ignore lint/style/useDefaultParameterLast: Should be consistent with other functions\nfunction parseArray<T>(required = true, element: ZodType<T>, def?: T[]): 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\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 t instanceof ZodString:\n      return String;\n    case t instanceof ZodEnum:\n      return String;\n    case t instanceof ZodNumber:\n      return Number;\n    case t instanceof ZodDate:\n      return Date;\n    default:\n      return undefined;\n  }\n}\n\nfunction parseUUID(required = true, unique = false): zm.mUUID {\n  return {\n    type: SchemaTypes.UUID,\n    required,\n    unique,\n  };\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 { Types, isValidObjectId } from \"mongoose\";\nimport type { zm } from \"mongoose.types\";\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  namespace z {\n    function objectId(ref?: string): zm.zID;\n    function mongoUUID(): zm.zUUID;\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;\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  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 (typeof opts === \"string\") message = opts;\n    else if (\"message\" in opts) message = opts.message;\n\n    (<any>zEffect._def.effect).__zm_validation = {\n      validator: check,\n      message: message,\n    };\n\n    return zEffect;\n  };\n\n  z_0.ZodString.prototype.unique = function (arg = true) {\n    this.__zm_unique = arg;\n    return this;\n  };\n\n  z_0.ZodNumber.prototype.unique = function (arg = true) {\n    this.__zm_unique = arg;\n    return this;\n  };\n\n  z_0.ZodDate.prototype.unique = function (arg = true) {\n    this.__zm_unique = arg;\n    return this;\n  };\n\n  (<any>z_0).objectId = (ref?: string) => {\n    const output = z\n      .string()\n      .refine((v) => isValidObjectId(v), { message: \"Invalid ObjectId\" })\n      .or(z.instanceof(Types.ObjectId));\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).unique = function (val = true) {\n      (<any>this).__zm_unique = val;\n      return this;\n    };\n\n    return output;\n  };\n\n  (<any>z_0).mongoUUID = () => {\n    const output = z\n      .string()\n      .uuid({ message: \"Invalid UUID\" })\n      .or(z.instanceof(Types.UUID).describe(\"UUID\"));\n    (<any>output).__zm_type = \"UUID\";\n\n    (<any>output).unique = function (val = true) {\n      (<any>this).__zm_unique = val;\n      return this;\n    };\n\n    return output;\n  };\n}\n"],"mappings":"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","names":["Schema","SchemaTypes","ZodArray","ZodDate","ZodDefault","ZodEffects","ZodEnum","ZodMap","ZodNullable","ZodNumber","ZodObject","ZodOptional","ZodRecord","ZodString","ZodUnion","Types","isValidObjectId","z","zod_extended","extendZod","z_0","_refine","ZodType","prototype","refine","check","opts","zEffect","bind","message","undefined","_def","effect","__zm_validation","validator","ZodString","unique","arg","__zm_unique","ZodNumber","ZodDate","objectId","ref","output","z","string","v","isValidObjectId","or","instanceof","Types","ObjectId","__zm_type","__zm_ref","val","mongoUUID","uuid","UUID","describe","zodSchema","schema","options","definition","parseObject","Schema","zodSchemaRaw","obj","object","key","field","Object","entries","shape","ZodObject","f","parseField","Error","constructor","required","def","refinement","field_type","name","__zm_type","ref","__zm_ref","unique","__zm_unique","parseObjectId","parseUUID","ZodNumber","isUnique","parseNumber","ZodString","parseString","ZodEnum","parseEnum","keys","Values","parseBoolean","ZodDate","parseDate","ZodArray","parseArray","element","ZodDefault","_def","innerType","defaultValue","ZodOptional","undefined","ZodNullable","ZodUnion","parseMixed","ZodMap","ZodRecord","parseMap","keySchema","ZodEffects","effect","type","validation","__zm_validation","validate","output","Number","default","min","minValue","max","maxValue","String","minLength","maxLength","values","enum","Boolean","Date","SchemaTypes","ObjectId","pointer","typeConstructor","Map","of","t","UUID","Mixed"]}

package/package.json

@@ -1,19 +1,32 @@
 {
   "name": "@zodyac/zod-mongoose",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "A library that allows you to generate mongoose schemas from zod objects.",
   "scripts": {
+    "test": "jest",
+    "test:run": "node test.js",
+    "test:badges": "jest --coverage && make-coverage-badge --report-path ./artifacts/coverage/coverage-summary.json --output-path ./badges/coverage.svg",
     "build": "tsup",
-    "test": "ts-node --esm ./src/test/test.ts"
+    "lint": "biome check",
+    "lint:fix": "biome check --write ."
   },
   "type": "module",
-  "main": "./dist/index.js",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
+  "typings": "./dist/index.d.ts",
   "private": false,
+  "sideEffects": true,
   "files": [
     "dist"
   ],
+  "author": "bebrasmell",
+  "license": "MIT",
+  "homepage": "https://zodyac.dev/toolbox/zod-mongoose",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/git-zodyac/mongoose"
+  },
   "keywords": [
     "zod",
     "mongoose",
@@ -32,20 +45,16 @@
     "odm",
     "document"
   ],
-  "author": "bebrasmell",
-  "license": "MIT",
-  "homepage": "https://zodyac.dev/toolbox/zod-mongoose",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/git-zodyac/mongoose"
-  },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^6.15.0",
-    "@typescript-eslint/parser": "^6.15.0",
-    "eslint": "^8.56.0",
-    "eslint-plugin-prettier": "^5.1.0",
-    "prettier": "^3.1.1",
-    "tsup": "^8.0.1"
+    "@biomejs/biome": "^1.8.3",
+    "@swc/core": "^1.7.11",
+    "@swc/jest": "^0.2.36",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.3.0",
+    "jest": "^29.7.0",
+    "make-coverage-badge": "^1.2.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.5.4"
   },
   "dependencies": {
     "mongoose": "^8.0.3",