@parziva-1/zod-mongoose 5.0.0

package/dist/index.js

@@ -0,0 +1,703 @@
+import { Schema, SchemaTypes, Types, isValidObjectId } from "mongoose";
+import { z } from "zod";
+//#region src/assertions/custom.ts
+let zmAssertIds;
+(function(_zmAssertIds) {
+	function objectId(f) {
+		return "__zm_type" in f && f.__zm_type === "ObjectId";
+	}
+	_zmAssertIds.objectId = objectId;
+	function uuid(f) {
+		return "__zm_type" in f && f.__zm_type === "UUID";
+	}
+	_zmAssertIds.uuid = uuid;
+})(zmAssertIds || (zmAssertIds = {}));
+//#endregion
+//#region src/assertions/assertions.ts
+var assertions_default = {
+	string(f) {
+		return f._zod.def.type === "string";
+	},
+	number(f) {
+		return f._zod.def.type === "number";
+	},
+	object(f) {
+		return f._zod.def.type === "object";
+	},
+	array(f) {
+		return f._zod.def.type === "array";
+	},
+	boolean(f) {
+		return f._zod.def.type === "boolean";
+	},
+	enumerable(f) {
+		return f._zod.def.type === "enum";
+	},
+	date(f) {
+		return f._zod.def.type === "date";
+	},
+	def(f) {
+		return f._zod.def.type === "default";
+	},
+	optional(f) {
+		return f._zod.def.type === "optional";
+	},
+	nullable(f) {
+		return f._zod.def.type === "nullable";
+	},
+	union(f) {
+		return f._zod.def.type === "union";
+	},
+	any(f) {
+		const type = f._zod.def.type;
+		return type === "any" || type === "unknown";
+	},
+	mapOrRecord(f) {
+		return f._zod.def.type === "map" || f._zod.def.type === "record";
+	},
+	pipe(f) {
+		return f._zod.def.type === "pipe";
+	},
+	tuple(f) {
+		return f._zod.def.type === "tuple";
+	},
+	literal(f) {
+		return f._zod.def.type === "literal";
+	},
+	/**
+	* `z.discriminatedUnion()` is represented by Zod v4 as a plain `ZodUnion`
+	* (`_zod.def.type === "union"`) that additionally carries a `discriminator`
+	* key on its def. It must be checked for *before* the generic `union`
+	* assertion in `parseField`, since a discriminated union also satisfies
+	* that check.
+	*/
+	discriminatedUnion(f) {
+		return f._zod.def.type === "union" && typeof f._zod.def.discriminator === "string";
+	},
+	intersection(f) {
+		return f._zod.def.type === "intersection";
+	},
+	lazy(f) {
+		return f._zod.def.type === "lazy";
+	},
+	catch(f) {
+		return f._zod.def.type === "catch";
+	},
+	...zmAssertIds
+};
+//#endregion
+//#region src/extension.ts
+let zod_extended = false;
+/**
+* Extends the Zod library with additional functionality.
+*
+* This function modifies the Zod library to add custom mongoose-specific
+* metadata methods. It ensures that the extension is only applied once.
+*
+* @param z_0 - The Zod library to extend.
+*
+* @remarks
+* - Adds a `unique` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as unique.
+* - Adds a `sparse` method to `ZodString`, `ZodNumber`, and `ZodDate` to mark them as sparse.
+*
+* As of Zod v4, refinement metadata (validator + message) no longer needs to
+* be captured via a `refine()` override: Zod's own internal `checks` array
+* already exposes the validator function and error message directly, so
+* `zodSchema()` reads that straight off the schema instead.
+*
+* @example
+* ```typescript
+* import { z } from "zod";
+* import { extendZod } from "./extension";
+*
+* extendZod(z);
+*
+* const schema = z.object({
+*   name: z.string().unique();
+* });
+* ```
+*/
+function extendZod(z_0) {
+	if (zod_extended) return;
+	zod_extended = true;
+	const UNIQUE_SUPPORT_LIST = [
+		z_0.ZodString,
+		z_0.ZodNumber,
+		z_0.ZodDate
+	];
+	for (const type of UNIQUE_SUPPORT_LIST) {
+		type.prototype.unique = function(arg = true) {
+			return this.meta({
+				...this.meta(),
+				__zm_unique: arg
+			});
+		};
+		type.prototype.sparse = function(arg = true) {
+			return this.meta({
+				...this.meta(),
+				__zm_sparse: arg
+			});
+		};
+	}
+}
+const createId = () => {
+	return z.string().refine((v) => isValidObjectId(v), { message: "Invalid ObjectId" }).or(z.instanceof(Types.ObjectId));
+};
+const zId = (ref) => {
+	const output = createId();
+	output.__zm_type = "ObjectId";
+	output.__zm_ref = ref;
+	output.ref = function(ref) {
+		this.__zm_ref = ref;
+		return this;
+	};
+	output.refPath = function(ref) {
+		this.__zm_refPath = ref;
+		return this;
+	};
+	output.unique = function(val = true) {
+		this.__zm_unique = val;
+		return this;
+	};
+	output.sparse = function(val = true) {
+		this.__zm_sparse = val;
+		return this;
+	};
+	return output;
+};
+const createUUID = () => {
+	return z.string().uuid({ message: "Invalid UUID" }).or(z.instanceof(Types.UUID));
+};
+const zUUID = (ref) => {
+	const output = createUUID();
+	output.__zm_type = "UUID";
+	output.__zm_ref = ref;
+	output.ref = function(ref) {
+		this.__zm_ref = ref;
+		return this;
+	};
+	output.refPath = function(ref) {
+		this.__zm_refPath = ref;
+		return this;
+	};
+	output.unique = function(val = true) {
+		this.__zm_unique = val;
+		return this;
+	};
+	output.sparse = function(val = true) {
+		this.__zm_sparse = val;
+		return this;
+	};
+	return output;
+};
+//#endregion
+//#region src/index.ts
+/**
+* Maximum number of times `parseField` will follow a given `z.lazy()`
+* getter into itself before bottoming out at `SchemaTypes.Mixed`. Guards
+* against unbounded recursion when parsing a genuinely self-referencing
+* schema (e.g. a comment type whose `replies` field is `z.array(z.lazy(() =>
+* CommentSchema))`) - Mongoose has no native equivalent of an infinitely
+* recursive embedded subdocument, so the structure has to be unrolled to a
+* finite depth. Keyed per-getter (not globally) via `lazyDepth` below, so
+* unrelated lazy schemas in the same document don't share a budget.
+*/
+const LAZY_DEPTH_LIMIT = 5;
+const lazyDepth = /* @__PURE__ */ new WeakMap();
+/**
+* Converts a Zod schema to a Mongoose schema
+* @param schema zod schema to parse
+* @returns mongoose schema
+*
+* @example
+* import { extendZod, zodSchema } from '@zodyac/zod-mongoose';
+* import { model } from 'mongoose';
+* import { z } from 'zod';
+*
+* extendZod(z);
+*
+* const zUser = z.object({
+*   name: z.string().min(3).max(255),
+*   age: z.number().min(18).max(100),
+*   active: z.boolean().default(false),
+*   access: z.enum(['admin', 'user']).default('user'),
+*   companyId: zId('Company'),
+*   address: z.object({
+*     street: z.string(),
+*     city: z.string(),
+*     state: z.enum(['CA', 'NY', 'TX']),
+*   }),
+*   tags: z.array(z.string()),
+*   createdAt: z.date(),
+*   updatedAt: z.date(),
+* });
+*
+* const schema = zodSchema(zDoc);
+* const userModel = model('User', schema);
+*/
+function zodSchema(schema, options) {
+	const definition = parseObject(schema, true);
+	return new Schema(definition, options);
+}
+/**
+* Converts a Zod schema to a raw Mongoose schema object
+* @param schema zod schema to parse
+* @returns mongoose schema
+*
+* @example
+* import { extendZod, zodSchemaRaw } from '@zodyac/zod-mongoose';
+* import { model, Schema } from 'mongoose';
+* import { z } from 'zod';
+*
+* extendZod(z);
+*
+* const zUser = z.object({
+*   name: z.string().min(3).max(255),
+*   age: z.number().min(18).max(100),
+*   active: z.boolean().default(false),
+*   access: z.enum(['admin', 'user']).default('user'),
+*   companyId: zId('Company'),
+*   address: z.object({
+*    street: z.string(),
+*    city: z.string(),
+*    state: z.enum(['CA', 'NY', 'TX']),
+*   }),
+*  tags: z.array(z.string()),
+*  createdAt: z.date(),
+*  updatedAt: z.date(),
+* });
+*
+* const rawSchema = zodSchemaRaw(zDoc);
+* const schema = new Schema(rawSchema);
+* const userModel = model('User', schema);
+*/
+function zodSchemaRaw(schema) {
+	return parseObject(schema, true);
+}
+function parseObject(obj, required = true, def) {
+	const object = parseShape(obj.shape);
+	if (!required || typeof def !== "undefined") return {
+		type: object,
+		required,
+		default: def
+	};
+	return object;
+}
+/**
+* Parses a raw Zod shape (a plain `{ key: ZodType }` map, as found on
+* `ZodObject.shape`) into a Mongoose field-definition object. Shared between
+* `parseObject` (which operates on an actual `ZodObject`) and the
+* `z.intersection()` handler, which needs to merge two shapes into one flat
+* object without constructing a synthetic `ZodObject` instance.
+*/
+function parseShape(shape) {
+	const object = {};
+	for (const [key, field] of Object.entries(shape)) if (assertions_default.object(field)) object[key] = parseObject(field, true);
+	else {
+		const f = parseField(field);
+		if (!f) throw new Error(`Unsupported field type: ${field.constructor}`);
+		object[key] = f;
+	}
+	return object;
+}
+/**
+* Walks a schema's own `checks` array (Zod v4) and returns the metadata for
+* *every* `.refine()` custom check found on it, in declaration order.
+*
+* Zod v4 no longer wraps refined schemas in a `ZodEffects`-like type: calling
+* `.refine()` simply appends a `"custom"` check to the schema's own
+* `_zod.def.checks` array (or, when chained after `.transform()`, to the
+* resulting `ZodPipe`'s own `checks` array). The check object itself already
+* carries the validator function (`fn`) and a normalized error accessor
+* (`error`), so there is no need to monkey-patch `refine()` to capture this
+* metadata as was necessary under Zod v3.
+*
+* A single Zod type can carry multiple `.refine()` checks (e.g.
+* `z.string().refine(a).refine(b)`), and `parseField` also needs to combine
+* checks found on *different* nodes of a `ZodPipe` (a pre-transform refine on
+* the pipe's `in` side plus a post-transform refine on the pipe itself) - so
+* this returns all matches rather than just the last one, leaving the
+* caller free to merge them with refinements collected elsewhere.
+*/
+function extractRefinements(field) {
+	const checks = field._zod?.def?.checks;
+	if (!checks || checks.length === 0) return [];
+	const refinements = [];
+	for (const check of checks) {
+		const checkDef = check?._zod?.def;
+		if (!checkDef || checkDef.check !== "custom") continue;
+		let message;
+		if (typeof checkDef.error === "function") try {
+			message = checkDef.error({});
+		} catch {
+			message = void 0;
+		}
+		else if (typeof checkDef.error === "string") message = checkDef.error;
+		refinements.push({
+			validator: checkDef.fn,
+			message
+		});
+	}
+	return refinements;
+}
+function toRefinementArray(refinement) {
+	if (!refinement) return [];
+	return Array.isArray(refinement) ? refinement : [refinement];
+}
+function parseField(field, required = true, def, refinement) {
+	if (assertions_default.objectId(field)) {
+		const ref = field.__zm_ref;
+		const refPath = field.__zm_refPath;
+		const unique = field.__zm_unique;
+		const sparse = field.__zm_sparse;
+		return parseObjectId(required, ref, unique, refPath, sparse, def);
+	}
+	if (assertions_default.uuid(field)) {
+		const ref = field.__zm_ref;
+		const refPath = field.__zm_refPath;
+		const unique = field.__zm_unique;
+		const sparse = field.__zm_sparse;
+		return parseUUID(required, ref, unique, refPath, sparse, def);
+	}
+	if (assertions_default.object(field)) return parseObject(field, required, def);
+	const combinedRefinements = [...extractRefinements(field), ...toRefinementArray(refinement)];
+	const ownRefinement = combinedRefinements.length === 0 ? void 0 : combinedRefinements.length === 1 ? combinedRefinements[0] : combinedRefinements;
+	if (assertions_default.number(field)) {
+		const numberField = field;
+		const meta = numberField.meta();
+		return parseNumber(numberField, required, def, meta?.__zm_unique ?? false, ownRefinement, meta?.__zm_sparse ?? false);
+	}
+	if (assertions_default.string(field)) {
+		const stringField = field;
+		const meta = stringField.meta();
+		return parseString(stringField, required, def, meta?.__zm_unique ?? false, ownRefinement, meta?.__zm_sparse ?? false);
+	}
+	if (assertions_default.enumerable(field)) return parseEnum(Object.values(field.enum), required, def);
+	if (assertions_default.boolean(field)) return parseBoolean(required, def);
+	if (assertions_default.date(field)) {
+		const meta = field.meta?.();
+		return parseDate(required, def, ownRefinement, meta?.__zm_unique ?? false, meta?.__zm_sparse ?? false);
+	}
+	if (assertions_default.array(field)) return parseArray(field.element, required, def);
+	if (assertions_default.def(field)) {
+		const defField = field;
+		const innerType = defField._zod.def.innerType;
+		return parseField(innerType, required, () => defField._zod.def.defaultValue);
+	}
+	if (assertions_default.optional(field)) {
+		const innerType = field._zod.def.innerType;
+		return parseField(innerType, false, def);
+	}
+	if (assertions_default.nullable(field)) {
+		const innerType = field._zod.def.innerType;
+		return parseField(innerType, false, typeof def !== "undefined" ? def : () => null);
+	}
+	if (assertions_default.discriminatedUnion(field)) return parseDiscriminatedUnion(field, required, def);
+	if (assertions_default.union(field)) {
+		const firstOption = field._zod.def.options[0];
+		if (!firstOption) throw new Error("Union type must have at least one option");
+		return parseField(firstOption);
+	}
+	if (assertions_default.any(field)) return parseMixed(required, def);
+	if (assertions_default.tuple(field)) return parseTuple(field, required, def);
+	if (assertions_default.literal(field)) {
+		const values = field._zod.def.values;
+		return parseLiteral(values, required, def);
+	}
+	if (assertions_default.intersection(field)) {
+		const { left, right } = field._zod.def;
+		if (!assertions_default.object(left) || !assertions_default.object(right)) throw new Error("Unsupported intersection: zod-mongoose can only merge two object-shape schemas (z.object(...).and(z.object(...))) into a flat Mongoose sub-schema");
+		const merged = parseShape({
+			...left.shape,
+			...right.shape
+		});
+		if (!required) return {
+			type: merged,
+			required: false
+		};
+		return merged;
+	}
+	if (assertions_default.lazy(field)) {
+		const getter = field._zod.def.getter;
+		const depth = lazyDepth.get(getter) ?? 0;
+		if (depth >= LAZY_DEPTH_LIMIT) return parseMixed(required, def);
+		lazyDepth.set(getter, depth + 1);
+		try {
+			return parseField(getter(), required, def, refinement);
+		} finally {
+			lazyDepth.set(getter, depth);
+		}
+	}
+	if (assertions_default.catch(field)) {
+		const catchField = field;
+		const innerType = catchField._zod.def.innerType;
+		const catchValueFn = catchField._zod.def.catchValue;
+		const inner = parseField(innerType, required, def, refinement);
+		if (!inner) return inner;
+		const previousSet = inner.set;
+		inner.set = (v) => {
+			const result = innerType.safeParse(v);
+			const resolved = result.success ? result.data : catchValueFn({
+				value: v,
+				issues: result.error.issues,
+				error: result.error
+			});
+			return previousSet ? previousSet(resolved) : resolved;
+		};
+		return inner;
+	}
+	if (assertions_default.mapOrRecord(field)) return parseMap(field.valueType, required, def);
+	if (assertions_default.pipe(field)) {
+		const pipeDef = field._zod.def;
+		return parseField(pipeDef.in._zod.def.type === "transform" ? pipeDef.out : pipeDef.in, required, def, ownRefinement);
+	}
+	return null;
+}
+function parseNumber(field, required = true, def, unique = false, validate, sparse = false) {
+	const output = {
+		type: Number,
+		default: def,
+		min: Number.isFinite(field.minValue) ? field.minValue ?? void 0 : void 0,
+		max: Number.isFinite(field.maxValue) ? field.maxValue ?? void 0 : void 0,
+		required,
+		unique,
+		sparse
+	};
+	if (validate) output.validate = validate;
+	return output;
+}
+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,
+		sparse
+	};
+	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
+	};
+}
+function parseBoolean(required = true, def) {
+	return {
+		type: Boolean,
+		default: def,
+		required
+	};
+}
+function parseDate(required = true, def, validate, unique = false, sparse = false) {
+	const output = {
+		type: Date,
+		default: def,
+		required,
+		unique,
+		sparse
+	};
+	if (validate) output.validate = validate;
+	return output;
+}
+function parseObjectId(required = true, ref, unique = false, refPath, sparse = false, def) {
+	const output = {
+		type: SchemaTypes.ObjectId,
+		required,
+		unique,
+		sparse,
+		default: def
+	};
+	if (ref) output.ref = ref;
+	if (refPath) output.refPath = refPath;
+	return output;
+}
+function parseArray(element, required = true, def) {
+	const innerType = parseField(element);
+	if (!innerType) throw new Error("Unsupported array type");
+	return {
+		type: [innerType],
+		default: def,
+		required
+	};
+}
+function parseMap(valueType, required = true, def) {
+	const pointer = parseMapValue(valueType);
+	return {
+		type: Map,
+		of: pointer,
+		default: def,
+		required
+	};
+}
+/**
+* Resolves a `z.map()`/`z.record()` value type into a Mongoose field
+* definition for the Map's `of`.
+*
+* A plain `z.union([...])` value type (e.g. `z.record(z.string(),
+* z.union([z.string(), z.number()]))`, the real production `params` shape)
+* must NOT go through the generic `parseField` union handling, which
+* collapses to the *first* union member's type - for a `Map<string, string
+* | number>` that silently coerces every numeric value to a string on save
+* (Mongoose's `Map`/`String` casting), which is silent data corruption, not
+* just a missing feature. Instead, the value is stored as `Mixed` (so all
+* union member types round-trip untouched) with a `validate` that re-checks
+* each value against the original union schema via `.safeParse()`, so an
+* invalid value is rejected rather than silently narrowed/coerced.
+*/
+function parseMapValue(valueType) {
+	if (assertions_default.union(valueType) && !assertions_default.discriminatedUnion(valueType)) return {
+		type: SchemaTypes.Mixed,
+		required: false,
+		validate: {
+			validator: (v) => valueType.safeParse(v).success,
+			message: "Value does not match any member of the declared union value type"
+		}
+	};
+	const pointer = parseField(valueType);
+	if (!pointer) throw new Error("Unsupported map value type");
+	return pointer;
+}
+function parseUUID(required = true, ref, unique = false, refPath, sparse = false, def) {
+	const output = {
+		type: SchemaTypes.UUID,
+		required,
+		unique,
+		sparse,
+		default: def
+	};
+	if (ref) output.ref = ref;
+	if (refPath) output.refPath = refPath;
+	return output;
+}
+function parseMixed(required = true, def) {
+	return {
+		type: SchemaTypes.Mixed,
+		default: def,
+		required
+	};
+}
+/**
+* `z.tuple()` has no native Mongoose equivalent (Mongoose arrays are
+* homogeneous and unbounded). It's represented as a Mongoose array of
+* `Mixed` - so it still round-trips through Mongo as a JSON array - with a
+* `validate` that enforces the tuple's actual contract (exact arity, or a
+* minimum arity plus a rest type, and the correct type at each position).
+* Rather than re-deriving per-position type checks by hand, the validator
+* reuses the original Zod item schemas' own `.safeParse()`, which is both
+* simpler and guaranteed to match Zod's own validation semantics exactly.
+*/
+function parseTuple(field, required = true, def) {
+	const tupleDef = field._zod.def;
+	const items = tupleDef.items;
+	const rest = tupleDef.rest;
+	const validator = (value) => {
+		if (!Array.isArray(value)) return false;
+		if (rest) {
+			if (value.length < items.length) return false;
+		} else if (value.length !== items.length) return false;
+		for (let i = 0; i < items.length; i++) {
+			const itemSchema = items[i];
+			if (!itemSchema || !itemSchema.safeParse(value[i]).success) return false;
+		}
+		if (rest) {
+			for (let i = items.length; i < value.length; i++) if (!rest.safeParse(value[i]).success) return false;
+		}
+		return true;
+	};
+	const message = rest ? `Expected a tuple of at least ${items.length} element(s) matching the declared types` : `Expected a tuple of exactly ${items.length} element(s) matching the declared types`;
+	return {
+		type: [{
+			type: SchemaTypes.Mixed,
+			required: false
+		}],
+		default: def,
+		required,
+		validate: {
+			validator,
+			message
+		}
+	};
+}
+/**
+* Maps `z.literal()` to the closest native Mongoose representation of its
+* value(s):
+*  - all-string values -> `String` with Mongoose's native `enum` constraint
+*  - all-number / all-boolean values -> that primitive type plus a
+*    `validate` enforcing membership (Mongoose has no native `enum` for
+*    non-string types)
+*  - anything else (mixed types, or types Mongoose has no primitive for,
+*    e.g. `bigint`) -> `Mixed` plus the same membership `validate`
+* `z.literal()` supports multiple values in Zod v4 (`z.literal(["a", "b"])`),
+* which is why this always validates against the full `values` array rather
+* than assuming a single value.
+*/
+function parseLiteral(values, required = true, def) {
+	const types = new Set(values.map((v) => typeof v));
+	const message = `Value must be one of: ${values.map((v) => JSON.stringify(v)).join(", ")}`;
+	if (types.size === 1 && types.has("string")) return parseEnum(values, required, def);
+	if (types.size === 1 && types.has("number")) return {
+		type: Number,
+		required,
+		unique: false,
+		sparse: false,
+		default: def,
+		validate: {
+			validator: (v) => values.includes(v),
+			message
+		}
+	};
+	if (types.size === 1 && types.has("boolean")) return {
+		type: Boolean,
+		required,
+		default: def,
+		validate: {
+			validator: (v) => values.includes(v),
+			message
+		}
+	};
+	return {
+		type: SchemaTypes.Mixed,
+		required,
+		default: def,
+		validate: {
+			validator: (v) => values.includes(v),
+			message
+		}
+	};
+}
+/**
+* `z.discriminatedUnion()` models real polymorphic documents (variants that
+* share a discriminant key but otherwise diverge in shape), which Mongoose
+* has no first-class support for on a plain nested field (Mongoose's own
+* "discriminator" feature only applies to top-level models / array
+* subdocuments, not to an arbitrary object-valued field). Rather than pick
+* one variant's shape and lose the others (as the plain `union` handling
+* does), this maps the field to `Mixed` and validates it against the
+* *entire* original discriminated-union schema via `.safeParse()` - which
+* already implements exactly the "dispatch on the discriminant, then
+* validate against the matching variant" behavior this needs, so there is no
+* reason to reimplement it.
+*/
+function parseDiscriminatedUnion(field, required = true, def) {
+	return {
+		type: SchemaTypes.Mixed,
+		required,
+		default: def,
+		validate: {
+			validator: (v) => field.safeParse(v).success,
+			message: "Value does not match any variant of the discriminated union"
+		}
+	};
+}
+//#endregion
+export { zodSchema as default, zodSchema, extendZod, zId, zUUID, zodSchemaRaw };
+
+//# sourceMappingURL=index.js.map