npm - @zodyac/zod-mongoose - Versions diffs - 1.1.3 → 1.3.0 - Mend

@zodyac/zod-mongoose 1.1.3 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/dist/index.cjs.map CHANGED Viewed

	@@ -1 +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 ZodNullable,\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 field.description?.toLocaleLowerCase() === \"unique\",\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 field.description?.toLocaleLowerCase() === \"unique\",\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 instanceof ZodNullable) {\n return parseField(field._def.innerType, false, def \|\| null);\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 unique: boolean = false,\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 unique,\n };\n }\n\n return {\n type: Number,\n default: def,\n min: field.minValue ?? undefined,\n max: field.maxValue ?? undefined,\n required,\n unique,\n };\n}\n\nfunction parseString(\n field: ZodString,\n required: boolean = true,\n def?: string,\n unique: boolean = false,\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 unique,\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 unique,\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 unique: false,\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 default zodSchema;\n"],"mappings":"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","names":[]}
1	+ {"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":["import_mongoose","import_zod","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/dist/index.d.cts CHANGED Viewed

@@ -1,12 +1,25 @@
-import { Types, SchemaTypes, Schema } from 'mongoose';
-import { ZodRawShape, ZodObject, z, ZodUnion, ZodEffects, ZodString, ZodType } from 'zod';
+import { Types, SchemaTypes, SchemaOptions, Schema } from 'mongoose';
+import { z, ZodType, ZodRawShape, ZodObject } from 'zod';
 declare namespace zm {
+    interface zID extends z.ZodUnion<[
+        z.ZodString,
+        z.ZodType<Types.ObjectId, z.ZodTypeDef, Types.ObjectId>
+    ]> {
+        __zm_type: "ObjectId";
+        __zm_ref?: string;
+        ref: (ref: string) => zID;
+        unique: (val?: boolean) => zID;
+    }
+    interface zUUID extends z.ZodUnion<[z.ZodString, z.ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]> {
+        __zm_type: "UUID";
+        unique: (val?: boolean) => zID;
+    }
     interface _Field<T> {
         required: boolean;
         default?: T;
-        validation?: {
-            validate: (v: T) => boolean;
+        validate?: {
+            validator: (v: T) => boolean;
             message?: string;
         };
     }
@@ -29,28 +42,63 @@ declare namespace zm {
     }
     interface mDate extends _Field<Date> {
         type: DateConstructor;
+        unique: boolean;
     }
     interface mObjectId extends _Field<Types.ObjectId> {
         type: typeof SchemaTypes.ObjectId;
+        unique?: boolean;
         ref?: string;
     }
     interface mUUID extends _Field<Types.UUID> {
         type: typeof SchemaTypes.UUID;
+        unique?: boolean;
         ref?: string;
     }
-    type mArray<K> = [_Field<K[]>];
+    interface mArray<K> extends _Field<K[]> {
+        type: [_Field<K>];
+    }
     interface mMixed<T> extends _Field<T> {
         type: typeof SchemaTypes.Mixed;
     }
-    type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown>;
+    type Constructor = StringConstructor | NumberConstructor | ObjectConstructor | DateConstructor | BooleanConstructor | BigIntConstructor;
+    interface mMap<T, K> extends _Field<Map<T, K>> {
+        type: typeof Map;
+        of?: Constructor;
+    }
+    type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown> | mMap<unknown, unknown>;
     type _Schema<T> = {
         [K in keyof T]: _Field<T[K]> | _Schema<T[K]>;
     };
+    type UnwrapZodType<T> = T extends ZodType<infer K> ? K : never;
+    type EffectValidator<T> = {
+        validator: (v: T) => boolean;
+        message?: string;
+    };
+}
+declare module "zod" {
+    interface ZodString {
+        unique: (arg?: boolean) => ZodString;
+        __zm_unique: boolean;
+    }
+    interface ZodNumber {
+        unique: (arg?: boolean) => ZodNumber;
+        __zm_unique: boolean;
+    }
+    interface ZodDate {
+        unique: (arg?: boolean) => ZodDate;
+        __zm_unique: boolean;
+    }
+    namespace z {
+        function objectId(ref?: string): zm.zID;
+        function mongoUUID(): zm.zUUID;
+    }
+    interface ZodType<Output = any, Def extends z.ZodTypeDef = z.ZodTypeDef, Input = Output> {
+    }
 }
+declare function extendZod(z_0: typeof z): void;
-declare function zodSchema<T extends ZodRawShape>(schema: ZodObject<T>): Schema<z.infer<typeof schema>>;
+declare function zodSchema<T extends ZodRawShape>(schema: ZodObject<T>, options?: SchemaOptions<any>): Schema<z.infer<typeof schema>>;
 declare function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T>;
-declare const zId: ZodUnion<[ZodEffects<ZodString, string, string>, ZodType<Types.ObjectId, z.ZodTypeDef, Types.ObjectId>]>;
-declare const zUUID: ZodUnion<[ZodString, ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]>;
-export { zodSchema as default, zId, zUUID, zodSchema, zodSchemaRaw };
+export { zodSchema as default, extendZod, zodSchema, zodSchemaRaw };

package/dist/index.d.ts CHANGED Viewed

@@ -1,12 +1,25 @@
-import { Types, SchemaTypes, Schema } from 'mongoose';
-import { ZodRawShape, ZodObject, z, ZodUnion, ZodEffects, ZodString, ZodType } from 'zod';
+import { Types, SchemaTypes, SchemaOptions, Schema } from 'mongoose';
+import { z, ZodType, ZodRawShape, ZodObject } from 'zod';
 declare namespace zm {
+    interface zID extends z.ZodUnion<[
+        z.ZodString,
+        z.ZodType<Types.ObjectId, z.ZodTypeDef, Types.ObjectId>
+    ]> {
+        __zm_type: "ObjectId";
+        __zm_ref?: string;
+        ref: (ref: string) => zID;
+        unique: (val?: boolean) => zID;
+    }
+    interface zUUID extends z.ZodUnion<[z.ZodString, z.ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]> {
+        __zm_type: "UUID";
+        unique: (val?: boolean) => zID;
+    }
     interface _Field<T> {
         required: boolean;
         default?: T;
-        validation?: {
-            validate: (v: T) => boolean;
+        validate?: {
+            validator: (v: T) => boolean;
             message?: string;
         };
     }
@@ -29,28 +42,63 @@ declare namespace zm {
     }
     interface mDate extends _Field<Date> {
         type: DateConstructor;
+        unique: boolean;
     }
     interface mObjectId extends _Field<Types.ObjectId> {
         type: typeof SchemaTypes.ObjectId;
+        unique?: boolean;
         ref?: string;
     }
     interface mUUID extends _Field<Types.UUID> {
         type: typeof SchemaTypes.UUID;
+        unique?: boolean;
         ref?: string;
     }
-    type mArray<K> = [_Field<K[]>];
+    interface mArray<K> extends _Field<K[]> {
+        type: [_Field<K>];
+    }
     interface mMixed<T> extends _Field<T> {
         type: typeof SchemaTypes.Mixed;
     }
-    type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown>;
+    type Constructor = StringConstructor | NumberConstructor | ObjectConstructor | DateConstructor | BooleanConstructor | BigIntConstructor;
+    interface mMap<T, K> extends _Field<Map<T, K>> {
+        type: typeof Map;
+        of?: Constructor;
+    }
+    type mField = mString | mNumber | mBoolean | mDate | mObjectId | mUUID | mMixed<unknown> | mArray<unknown> | _Schema<unknown> | mMap<unknown, unknown>;
     type _Schema<T> = {
         [K in keyof T]: _Field<T[K]> | _Schema<T[K]>;
     };
+    type UnwrapZodType<T> = T extends ZodType<infer K> ? K : never;
+    type EffectValidator<T> = {
+        validator: (v: T) => boolean;
+        message?: string;
+    };
+}
+declare module "zod" {
+    interface ZodString {
+        unique: (arg?: boolean) => ZodString;
+        __zm_unique: boolean;
+    }
+    interface ZodNumber {
+        unique: (arg?: boolean) => ZodNumber;
+        __zm_unique: boolean;
+    }
+    interface ZodDate {
+        unique: (arg?: boolean) => ZodDate;
+        __zm_unique: boolean;
+    }
+    namespace z {
+        function objectId(ref?: string): zm.zID;
+        function mongoUUID(): zm.zUUID;
+    }
+    interface ZodType<Output = any, Def extends z.ZodTypeDef = z.ZodTypeDef, Input = Output> {
+    }
 }
+declare function extendZod(z_0: typeof z): void;
-declare function zodSchema<T extends ZodRawShape>(schema: ZodObject<T>): Schema<z.infer<typeof schema>>;
+declare function zodSchema<T extends ZodRawShape>(schema: ZodObject<T>, options?: SchemaOptions<any>): Schema<z.infer<typeof schema>>;
 declare function zodSchemaRaw<T extends ZodRawShape>(schema: ZodObject<T>): zm._Schema<T>;
-declare const zId: ZodUnion<[ZodEffects<ZodString, string, string>, ZodType<Types.ObjectId, z.ZodTypeDef, Types.ObjectId>]>;
-declare const zUUID: ZodUnion<[ZodString, ZodType<Types.UUID, z.ZodTypeDef, Types.UUID>]>;
-export { zodSchema as default, zId, zUUID, zodSchema, zodSchemaRaw };
+export { zodSchema as default, extendZod, zodSchema, zodSchemaRaw };

package/dist/index.js CHANGED Viewed

@@ -1,30 +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,
-  ZodNullable,
-  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)) {
@@ -32,56 +83,50 @@ 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,
-      field.description?.toLocaleLowerCase() === "unique"
-      // 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,
-      field.description?.toLocaleLowerCase() === "unique"
-      // 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);
@@ -89,51 +134,27 @@ function parseField(field, required, def) {
   if (field instanceof ZodNullable) {
     return parseField(field._def.innerType, false, def || null);
   }
-  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 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;
 }
+__name(parseField, "parseField");
 function parseNumber(field, required = true, def, unique = false, validate) {
-  if (validate) {
-    return {
-      type: Number,
-      default: def,
-      min: field.minValue ?? void 0,
-      max: field.maxValue ?? void 0,
-      validation: {
-        validate
-      },
-      required,
-      unique
-    };
-  }
-  return {
+  const output = {
     type: Number,
     default: def,
     min: field.minValue ?? void 0,
@@ -141,40 +162,33 @@ function parseNumber(field, required = true, def, unique = false, validate) {
     required,
     unique
   };
+  if (validate) output.validate = validate;
+  return output;
 }
+__name(parseNumber, "parseNumber");
 function parseString(field, required = true, def, unique = false, validate) {
-  if (validate) {
-    return {
-      type: String,
-      default: def,
-      required,
-      minLength: field.minLength ?? void 0,
-      maxLength: field.maxLength ?? void 0,
-      validation: {
-        validate
-      },
-      unique
-    };
-  }
-  return {
+  const output = {
     type: String,
     default: def,
-    // TODO: match: field.regex(),
     required,
     minLength: field.minLength ?? 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,
-    unique: false
+    required
   };
 }
+__name(parseEnum, "parseEnum");
 function parseBoolean(required = true, def) {
   return {
     type: Boolean,
@@ -182,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,
@@ -222,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
 };