@classytic/mongokit 3.6.2 → 3.6.3

package/dist/index.mjs

@@ -7,7 +7,7 @@ import { isGeoOperator, parseGeoFilter } from "./query/primitives/geo.mjs";
 import { i as getMongooseProjection, n as filterResponseData, r as getFieldsForUser, t as createFieldPreset } from "./field-selection-C5o7jyyA.mjs";
 import { buildFieldTypeMap, coerceFieldValue, coerceHeuristic } from "./query/primitives/coercion.mjs";
 import { extractSchemaIndexes } from "./query/primitives/indexes.mjs";
-import { a as isFieldUpdateAllowed, i as getSystemManagedFields, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel } from "./mongooseToJsonSchema-8Cyu3NFJ.mjs";
+import { a as isFieldUpdateAllowed, i as getSystemManagedFields, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel } from "./mongooseToJsonSchema-MlaD3C0B.mjs";
 //#region src/query/QueryParser.ts
 /**
 * Modern Query Parser

package/dist/mongooseToJsonSchema-MlaD3C0B.mjs

@@ -0,0 +1,630 @@
+import { n as isObjectIdInstance } from "./id-resolution-LZ-cCwR5.mjs";
+import mongoose from "mongoose";
+//#region src/utils/memory-cache.ts
+/**
+* Creates an in-memory cache adapter
+*
+* Features:
+* - Automatic TTL expiration
+* - Pattern-based clearing (simple glob with *)
+* - Max entries limit to prevent memory leaks
+*
+* @param maxEntries - Maximum cache entries before oldest are evicted (default: 1000)
+*/
+function createMemoryCache(maxEntries = 1e3) {
+	const cache = /* @__PURE__ */ new Map();
+	let lastCleanup = Date.now();
+	const CLEANUP_INTERVAL_MS = 6e4;
+	function cleanupIfNeeded() {
+		const now = Date.now();
+		if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
+		lastCleanup = now;
+		for (const [key, entry] of cache) if (entry.expiresAt < now) cache.delete(key);
+	}
+	function evictOldest() {
+		while (cache.size >= maxEntries) {
+			const firstKey = cache.keys().next().value;
+			if (firstKey) cache.delete(firstKey);
+			else break;
+		}
+	}
+	return {
+		async get(key) {
+			const entry = cache.get(key);
+			if (!entry) return null;
+			if (entry.expiresAt < Date.now()) {
+				cache.delete(key);
+				return null;
+			}
+			cache.delete(key);
+			cache.set(key, entry);
+			return entry.value;
+		},
+		async set(key, value, ttl) {
+			cache.delete(key);
+			if (cache.size >= maxEntries) {
+				cleanupIfNeeded();
+				evictOldest();
+			}
+			cache.set(key, {
+				value,
+				expiresAt: Date.now() + ttl * 1e3
+			});
+		},
+		async del(key) {
+			cache.delete(key);
+		},
+		async clear(pattern) {
+			if (!pattern) {
+				cache.clear();
+				return;
+			}
+			const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+			const regex = new RegExp(`^${escaped}$`);
+			for (const key of cache.keys()) if (regex.test(key)) cache.delete(key);
+		}
+	};
+}
+//#endregion
+//#region src/utils/mongooseToJsonSchema.ts
+/**
+* Mongoose to JSON Schema Converter with Field Rules
+*
+* Generates Fastify JSON schemas from Mongoose models with declarative field rules.
+*
+* Field Rules (options.fieldRules):
+* - immutable: Field cannot be updated (omitted from update schema)
+* - immutableAfterCreate: Alias for immutable
+* - systemManaged: System-only field (omitted from create/update)
+* - optional: Remove from required array
+*
+* Additional Options:
+* - strictAdditionalProperties: Set to true to add "additionalProperties: false" to schemas
+*   This makes Fastify reject unknown fields at validation level (default: false for backward compatibility)
+* - update.requireAtLeastOne: Set to true to add "minProperties: 1" to update schema
+*   This prevents empty update payloads (default: false)
+*
+* @example
+* buildCrudSchemasFromModel(Model, {
+*   strictAdditionalProperties: true, // Reject unknown fields
+*   fieldRules: {
+*     organizationId: { immutable: true },
+*     status: { systemManaged: true },
+*   },
+*   create: { omitFields: ['verifiedAt'] },
+*   update: {
+*     omitFields: ['customerId'],
+*     requireAtLeastOne: true // Reject empty updates
+*   }
+* })
+*/
+function isMongooseSchema(value) {
+	return value instanceof mongoose.Schema;
+}
+function isPlainObject(value) {
+	return Object.prototype.toString.call(value) === "[object Object]";
+}
+function isObjectIdType(t) {
+	return t === mongoose.Schema.Types.ObjectId || t === mongoose.Types.ObjectId;
+}
+/**
+* Build CRUD schemas from Mongoose schema
+*/
+function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
+	const jsonCreate = buildJsonSchemaFromPaths(mongooseSchema, options);
+	return {
+		createBody: jsonCreate,
+		updateBody: buildJsonSchemaForUpdate(jsonCreate, options),
+		params: {
+			type: "object",
+			properties: { id: {
+				type: "string",
+				pattern: "^[0-9a-fA-F]{24}$"
+			} },
+			required: ["id"]
+		},
+		listQuery: buildJsonSchemaForQuery(mongooseSchema?.obj || {}, options)
+	};
+}
+/**
+* Build CRUD schemas from Mongoose model
+*/
+function buildCrudSchemasFromModel(mongooseModel, options = {}) {
+	if (!mongooseModel?.schema) throw new Error("Invalid mongoose model");
+	return buildCrudSchemasFromMongooseSchema(mongooseModel.schema, options);
+}
+/**
+* Collect fields to omit from a generated schema based on field rules and
+* explicit omit lists. This is the single source of truth for "which fields
+* should NOT appear in the create/update body" — called by both the
+* path-based and tree-based schema builders.
+*/
+function collectFieldsToOmit(options, purpose) {
+	const result = new Set([
+		"createdAt",
+		"updatedAt",
+		"__v"
+	]);
+	const rules = options?.fieldRules || {};
+	for (const [field, rule] of Object.entries(rules)) {
+		if (rule.systemManaged) result.add(field);
+		if (purpose === "update" && (rule.immutable || rule.immutableAfterCreate)) result.add(field);
+	}
+	const explicit = purpose === "create" ? options?.create?.omitFields : options?.update?.omitFields;
+	if (explicit) for (const f of explicit) result.add(f);
+	return result;
+}
+/**
+* Apply omissions + optional-overrides to a built JSON schema in-place.
+* Removes properties and adjusts the `required` array.
+*/
+function applyFieldRules(schema, fieldsToOmit, options) {
+	for (const field of fieldsToOmit) {
+		if (schema.properties?.[field]) delete schema.properties[field];
+		if (schema.required) schema.required = schema.required.filter((k) => k !== field);
+	}
+	const rules = options?.fieldRules || {};
+	for (const [field, rule] of Object.entries(rules)) if (rule.optional && schema.required) schema.required = schema.required.filter((k) => k !== field);
+}
+/**
+* Get fields that are immutable (cannot be updated).
+* Delegates to `collectFieldsToOmit` internally.
+*/
+function getImmutableFields(options = {}) {
+	const immutable = [];
+	const rules = options?.fieldRules || {};
+	for (const [field, rule] of Object.entries(rules)) if (rule.immutable || rule.immutableAfterCreate) immutable.push(field);
+	for (const f of options?.update?.omitFields || []) if (!immutable.includes(f)) immutable.push(f);
+	return immutable;
+}
+/**
+* Get fields that are system-managed (cannot be set by users).
+*/
+function getSystemManagedFields(options = {}) {
+	const systemManaged = [];
+	const rules = options?.fieldRules || {};
+	for (const [field, rule] of Object.entries(rules)) if (rule.systemManaged) systemManaged.push(field);
+	return systemManaged;
+}
+/**
+* Check if field is allowed in update
+*/
+function isFieldUpdateAllowed(fieldName, options = {}) {
+	const immutableFields = getImmutableFields(options);
+	const systemManagedFields = getSystemManagedFields(options);
+	return !immutableFields.includes(fieldName) && !systemManagedFields.includes(fieldName);
+}
+/**
+* Validate update body against field rules
+*/
+function validateUpdateBody(body = {}, options = {}) {
+	const violations = [];
+	const immutableFields = getImmutableFields(options);
+	const systemManagedFields = getSystemManagedFields(options);
+	Object.keys(body).forEach((field) => {
+		if (immutableFields.includes(field)) violations.push({
+			field,
+			reason: "Field is immutable"
+		});
+		else if (systemManagedFields.includes(field)) violations.push({
+			field,
+			reason: "Field is system-managed"
+		});
+	});
+	return {
+		valid: violations.length === 0,
+		violations
+	};
+}
+/**
+* Build JSON schema from Mongoose schema.paths (accurate type information)
+*/
+function buildJsonSchemaFromPaths(mongooseSchema, options) {
+	const properties = {};
+	const required = [];
+	const paths = mongooseSchema.paths;
+	const softRequiredSet = new Set(options?.softRequiredFields ?? []);
+	const isSoftRequired = (name, schemaType) => {
+		if (softRequiredSet.has(name)) return true;
+		return schemaType?.options?.softRequired === true;
+	};
+	const rootFields = /* @__PURE__ */ new Map();
+	for (const [path, schemaType] of Object.entries(paths)) {
+		if (path === "__v") continue;
+		if (path.includes("$*")) continue;
+		if (path === "_id") {
+			const instance = schemaType.instance;
+			if (!instance || isObjectIdInstance(instance)) continue;
+		}
+		const rootField = path.split(".")[0];
+		if (!rootFields.has(rootField)) rootFields.set(rootField, []);
+		rootFields.get(rootField)?.push({
+			path,
+			schemaType
+		});
+	}
+	for (const [rootField, fieldPaths] of rootFields.entries()) if (fieldPaths.length === 1 && fieldPaths[0].path === rootField) {
+		const schemaType = fieldPaths[0].schemaType;
+		properties[rootField] = schemaTypeToJsonSchema(schemaType);
+		if (schemaType.isRequired && !isSoftRequired(rootField, schemaType)) required.push(rootField);
+	} else {
+		const nestedSchema = buildNestedJsonSchema(fieldPaths, rootField);
+		properties[rootField] = nestedSchema.schema;
+		if (nestedSchema.required) required.push(rootField);
+	}
+	const schema = {
+		type: "object",
+		properties
+	};
+	if (required.length) schema.required = required;
+	applyFieldRules(schema, collectFieldsToOmit(options, "create"), options);
+	const reqOv = options?.create?.requiredOverrides || {};
+	const optOv = options?.create?.optionalOverrides || {};
+	schema.required = schema.required || [];
+	for (const [k, v] of Object.entries(reqOv)) if (v && !schema.required.includes(k)) schema.required.push(k);
+	for (const [k, v] of Object.entries(optOv)) if (v && schema.required) schema.required = schema.required.filter((x) => x !== k);
+	const schemaOverrides = options?.create?.schemaOverrides || {};
+	for (const [k, override] of Object.entries(schemaOverrides)) if (schema.properties?.[k]) schema.properties[k] = override;
+	if (options?.strictAdditionalProperties === true) schema.additionalProperties = false;
+	return schema;
+}
+/**
+* Build nested JSON schema from dot-notation paths
+*/
+function buildNestedJsonSchema(fieldPaths, rootField) {
+	const properties = {};
+	const required = [];
+	let hasRequiredFields = false;
+	for (const { path, schemaType } of fieldPaths) {
+		const parts = path.substring(rootField.length + 1).split(".");
+		if (parts.length === 1) {
+			properties[parts[0]] = schemaTypeToJsonSchema(schemaType);
+			if (schemaType.isRequired) {
+				required.push(parts[0]);
+				hasRequiredFields = true;
+			}
+		} else {
+			const fieldName = parts[0];
+			if (!properties[fieldName]) properties[fieldName] = {
+				type: "object",
+				properties: {}
+			};
+			const nestedObj = properties[fieldName];
+			if (!nestedObj.properties) nestedObj.properties = {};
+			const deepPath = parts.slice(1).join(".");
+			nestedObj.properties[deepPath] = schemaTypeToJsonSchema(schemaType);
+		}
+	}
+	const schema = {
+		type: "object",
+		properties
+	};
+	if (required.length) schema.required = required;
+	return {
+		schema,
+		required: hasRequiredFields
+	};
+}
+/**
+* Introspect the element type of a Mongoose array SchemaType and produce a
+* JSON Schema `items` clause that matches what clients will actually POST.
+*
+* Falls through four tiers so we cover every Mongoose array shape:
+*
+*   1. DocumentArray / explicit subschema — `schemaType.schema.paths` exists.
+*      Recurse into the inner paths so `[{ name, url }]` yields
+*      `items: { type: 'object', properties: { name, url }, required: [...] }`.
+*   2. Legacy Mongoose (v6/v7) — `schemaType.caster` exposes the casted
+*      element's `instance` ('String', 'Number', 'ObjectId', …).
+*   3. Modern Mongoose (v8+/v9) — `caster` is undefined for
+*      `[{ type: String }]`; the declaration lives on
+*      `schemaType.options.type[0]`. Hand it to `jsonTypeFor` which already
+*      handles bare constructors, `{ type: Fn }` shorthand, and Mixed.
+*   4. Everything else (Mixed arrays, unknown casters) — a permissive
+*      `{ type: 'object', additionalProperties: true }` so we never block a
+*      valid payload with the old `{ type: 'string' }` default.
+*/
+function introspectArrayItems(schemaType) {
+	if (hasInnerSchema(schemaType)) return subSchemaToJsonSchema(schemaType.schema);
+	const caster = schemaType?.caster;
+	if (caster && typeof caster === "object" && "instance" in caster && caster.instance) return schemaTypeToJsonSchema(caster);
+	const declaredType = schemaType?.options?.type;
+	if (Array.isArray(declaredType) && declaredType.length > 0) {
+		const inner = declaredType[0];
+		if (inner === mongoose.Schema.Types.Mixed) return {
+			type: "object",
+			additionalProperties: true
+		};
+		return jsonTypeFor(inner, {}, /* @__PURE__ */ new WeakSet());
+	}
+	return {
+		type: "object",
+		additionalProperties: true
+	};
+}
+/**
+* Convert a Mongoose sub-Schema (as found on a DocumentArray's `.schema`)
+* into a JSON Schema object clause. Unlike `buildJsonSchemaFromPaths`, this
+* does NOT apply create/update field rules — subdocument shape should faithfully
+* reflect the declared schema, not the top-level CRUD-mode omissions.
+*/
+function subSchemaToJsonSchema(subSchema) {
+	const properties = {};
+	const required = [];
+	const paths = subSchema.paths ?? {};
+	for (const [path, st] of Object.entries(paths)) {
+		if (path === "__v") continue;
+		if (path === "_id") {
+			const instance = st.instance;
+			if (!instance || isObjectIdInstance(instance)) continue;
+		}
+		properties[path] = schemaTypeToJsonSchema(st);
+		if (st.isRequired) required.push(path);
+	}
+	const result = {
+		type: "object",
+		properties
+	};
+	if (required.length) result.required = required;
+	return result;
+}
+/**
+* Convert Mongoose SchemaType to JSON Schema
+*/
+function schemaTypeToJsonSchema(schemaType) {
+	if (typeof schemaType?.jsonSchema === "function") try {
+		const custom = schemaType.jsonSchema();
+		if (custom && typeof custom === "object") return custom;
+	} catch {}
+	const result = {};
+	const instance = schemaType.instance;
+	const options = schemaType.options || {};
+	if (instance === "String") {
+		result.type = "string";
+		const minLen = typeof options.minlength === "number" ? options.minlength : typeof options.minLength === "number" ? options.minLength : void 0;
+		const maxLen = typeof options.maxlength === "number" ? options.maxlength : typeof options.maxLength === "number" ? options.maxLength : void 0;
+		if (minLen !== void 0) result.minLength = minLen;
+		if (maxLen !== void 0) result.maxLength = maxLen;
+		if (options.match instanceof RegExp) result.pattern = options.match.source;
+		else if (typeof options.match === "string") result.pattern = options.match;
+		const enumValues = Array.isArray(options.enum) ? options.enum : options.enum && Array.isArray(options.enum.values) ? options.enum.values : void 0;
+		if (enumValues) result.enum = enumValues;
+	} else if (instance === "Number") {
+		result.type = "number";
+		if (typeof options.min === "number") result.minimum = options.min;
+		if (typeof options.max === "number") result.maximum = options.max;
+	} else if (instance === "Boolean") result.type = "boolean";
+	else if (instance === "Date") {
+		result.type = "string";
+		result.format = "date-time";
+	} else if (isObjectIdInstance(instance)) {
+		result.type = "string";
+		result.pattern = "^[0-9a-fA-F]{24}$";
+		if (typeof options.ref === "string" && options.ref.length > 0) result["x-ref"] = options.ref;
+	} else if (instance === "Array") {
+		result.type = "array";
+		result.items = introspectArrayItems(schemaType);
+	} else if (instance === "Map") {
+		result.type = "object";
+		const ofDef = options.of;
+		if (ofDef !== void 0 && ofDef !== null) result.additionalProperties = jsonTypeFor(ofDef, {}, /* @__PURE__ */ new WeakSet());
+		else result.additionalProperties = true;
+	} else if (hasInnerSchema(schemaType)) return subSchemaToJsonSchema(schemaType.schema);
+	else {
+		result.type = "object";
+		result.additionalProperties = true;
+	}
+	if (options.default === null && typeof result.type === "string") {
+		result.type = [result.type, "null"];
+		result.default = null;
+	}
+	if (typeof options.description === "string" && options.description.length > 0) result.description = options.description;
+	if (typeof options.title === "string" && options.title.length > 0) result.title = options.title;
+	return result;
+}
+function hasInnerSchema(schemaType) {
+	const inner = schemaType?.schema;
+	return !!inner && typeof inner === "object" && "paths" in inner && typeof inner.paths === "object";
+}
+function jsonTypeFor(def, options, seen) {
+	if (Array.isArray(def)) {
+		if (def[0] === mongoose.Schema.Types.Mixed) return {
+			type: "array",
+			items: {
+				type: "object",
+				additionalProperties: true
+			}
+		};
+		return {
+			type: "array",
+			items: jsonTypeFor(def[0] ?? String, options, seen)
+		};
+	}
+	if (isPlainObject(def) && "type" in def) {
+		const typedDef = def;
+		if (typedDef.enum && Array.isArray(typedDef.enum) && typedDef.enum.length) return {
+			type: "string",
+			enum: typedDef.enum.map(String)
+		};
+		if (Array.isArray(typedDef.type)) {
+			const inner = typedDef.type[0] !== void 0 ? typedDef.type[0] : String;
+			if (inner === mongoose.Schema.Types.Mixed) return {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: true
+				}
+			};
+			return {
+				type: "array",
+				items: jsonTypeFor(inner, options, seen)
+			};
+		}
+		const validators = {};
+		if (typedDef.type === String) {
+			validators.type = "string";
+			if (typeof typedDef.minlength === "number") validators.minLength = typedDef.minlength;
+			if (typeof typedDef.maxlength === "number") validators.maxLength = typedDef.maxlength;
+			if (typedDef.match instanceof RegExp) validators.pattern = typedDef.match.source;
+			if (typeof typedDef.lowercase === "boolean" && typedDef.lowercase) validators.pattern = validators.pattern ? `(?=.*[a-z])${validators.pattern}` : "^[a-z]*$";
+			if (typeof typedDef.uppercase === "boolean" && typedDef.uppercase) validators.pattern = validators.pattern ? `(?=.*[A-Z])${validators.pattern}` : "^[A-Z]*$";
+			if (typeof typedDef.trim === "boolean") {}
+			return validators;
+		}
+		if (typedDef.type === Number) {
+			validators.type = "number";
+			if (typeof typedDef.min === "number") validators.minimum = typedDef.min;
+			if (typeof typedDef.max === "number") validators.maximum = typedDef.max;
+			return validators;
+		}
+		if (typedDef.type === Boolean) return { type: "boolean" };
+		if (typedDef.type === Date) return (options?.dateAs || "datetime") === "date" ? {
+			type: "string",
+			format: "date"
+		} : {
+			type: "string",
+			format: "date-time"
+		};
+		if (typedDef.type === Map || typedDef.type === mongoose.Schema.Types.Map) return {
+			type: "object",
+			additionalProperties: jsonTypeFor(typedDef.of || String, options, seen)
+		};
+		if (typedDef.type === mongoose.Schema.Types.Mixed) return {
+			type: "object",
+			additionalProperties: true
+		};
+		if (typedDef.type === Object) {
+			if (isPlainObject(typedDef) && Object.keys(typedDef).some((k) => k !== "type")) {
+				const nested = {};
+				for (const [k, v] of Object.entries(typedDef)) if (k !== "type") nested[k] = v;
+				if (Object.keys(nested).length > 0) {
+					if (seen.has(nested)) return {
+						type: "object",
+						additionalProperties: true
+					};
+					seen.add(nested);
+					return convertTreeToJsonSchema(nested, options, seen);
+				}
+			}
+			return {
+				type: "object",
+				additionalProperties: true
+			};
+		}
+		if (isObjectIdType(typedDef.type)) return {
+			type: "string",
+			pattern: "^[0-9a-fA-F]{24}$"
+		};
+		if (isMongooseSchema(typedDef.type)) {
+			const obj = typedDef.type.obj;
+			if (obj && typeof obj === "object") {
+				if (seen.has(obj)) return {
+					type: "object",
+					additionalProperties: true
+				};
+				seen.add(obj);
+				return convertTreeToJsonSchema(obj, options, seen);
+			}
+		}
+	}
+	if (def === String) return { type: "string" };
+	if (def === Number) return { type: "number" };
+	if (def === Boolean) return { type: "boolean" };
+	if (def === Date) return (options?.dateAs || "datetime") === "date" ? {
+		type: "string",
+		format: "date"
+	} : {
+		type: "string",
+		format: "date-time"
+	};
+	if (isObjectIdType(def)) return {
+		type: "string",
+		pattern: "^[0-9a-fA-F]{24}$"
+	};
+	if (isMongooseSchema(def)) {
+		if (seen.has(def)) return {
+			type: "object",
+			additionalProperties: true
+		};
+		seen.add(def);
+		return subSchemaToJsonSchema(def);
+	}
+	if (isPlainObject(def)) {
+		if (seen.has(def)) return {
+			type: "object",
+			additionalProperties: true
+		};
+		seen.add(def);
+		return convertTreeToJsonSchema(def, options, seen);
+	}
+	return {};
+}
+function convertTreeToJsonSchema(tree, options, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!tree || typeof tree !== "object") return {
+		type: "object",
+		properties: {}
+	};
+	if (seen.has(tree)) return {
+		type: "object",
+		additionalProperties: true
+	};
+	seen.add(tree);
+	const properties = {};
+	const required = [];
+	for (const [key, val] of Object.entries(tree || {})) {
+		if (key === "__v" || key === "_id" || key === "id") continue;
+		const cfg = isPlainObject(val) && "type" in val ? val : { type: val };
+		properties[key] = jsonTypeFor(val, options, seen);
+		if (cfg.required === true) required.push(key);
+	}
+	const schema = {
+		type: "object",
+		properties
+	};
+	if (required.length) schema.required = required;
+	return schema;
+}
+function buildJsonSchemaForUpdate(createJson, options) {
+	const clone = JSON.parse(JSON.stringify(createJson));
+	delete clone.required;
+	applyFieldRules(clone, collectFieldsToOmit(options, "update"), options);
+	if (options?.strictAdditionalProperties === true) clone.additionalProperties = false;
+	if (options?.update?.requireAtLeastOne === true) clone.minProperties = 1;
+	return clone;
+}
+function buildJsonSchemaForQuery(_tree, options) {
+	const basePagination = {
+		type: "object",
+		properties: {
+			page: {
+				type: "integer",
+				minimum: 1,
+				default: 1
+			},
+			limit: {
+				type: "integer",
+				minimum: 1,
+				default: 20
+			},
+			sort: { type: "string" },
+			populate: { type: "string" },
+			search: { type: "string" },
+			select: { type: "string" },
+			after: { type: "string" },
+			lean: {
+				type: "boolean",
+				default: false
+			},
+			includeDeleted: {
+				type: "boolean",
+				default: false
+			}
+		},
+		additionalProperties: true
+	};
+	const filterable = options?.query?.filterableFields || {};
+	for (const [k, v] of Object.entries(filterable)) if (basePagination.properties) basePagination.properties[k] = v && typeof v === "object" && "type" in v ? v : { type: "string" };
+	return basePagination;
+}
+//#endregion
+export { isFieldUpdateAllowed as a, getSystemManagedFields as i, buildCrudSchemasFromMongooseSchema as n, validateUpdateBody as o, getImmutableFields as r, createMemoryCache as s, buildCrudSchemasFromModel as t };

package/dist/utils/index.mjs

@@ -1,5 +1,5 @@
 import { r as configureLogger, t as createError } from "../error-Bpbi_NKo.mjs";
 import { n as isObjectIdInstance, r as isValidIdForType, t as getSchemaIdType } from "../id-resolution-LZ-cCwR5.mjs";
 import { a as byIdKey, c as listQueryKey, i as getMongooseProjection, l as modelPattern, n as filterResponseData, o as byQueryKey, r as getFieldsForUser, s as listPattern, t as createFieldPreset, u as versionKey } from "../field-selection-C5o7jyyA.mjs";
-import { a as isFieldUpdateAllowed, i as getSystemManagedFields, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-8Cyu3NFJ.mjs";
+import { a as isFieldUpdateAllowed, i as getSystemManagedFields, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel } from "../mongooseToJsonSchema-MlaD3C0B.mjs";
 export { buildCrudSchemasFromModel, buildCrudSchemasFromMongooseSchema, byIdKey, byQueryKey, configureLogger, createError, createFieldPreset, createMemoryCache, filterResponseData, getFieldsForUser, getImmutableFields, getMongooseProjection, getSchemaIdType, getSystemManagedFields, isFieldUpdateAllowed, isObjectIdInstance, isValidIdForType, listPattern, listQueryKey, modelPattern, validateUpdateBody, versionKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.6.2",
+  "version": "3.6.3",
   "description": "Production-grade MongoDB repositories with zero dependencies - smart pagination, events, and plugins",
   "type": "module",
   "sideEffects": false,
@@ -122,6 +122,8 @@
     "@biomejs/biome": "^2.4.10",
     "@types/node": "^22.0.0",
     "@vitest/coverage-v8": "^3.2.4",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
     "knip": "^6.3.0",
     "mongodb-memory-server": "^10.4.3",
     "mongoose": "^9.4.1",

package/dist/mongooseToJsonSchema-8Cyu3NFJ.mjs

@@ -1,328 +0,0 @@
-import { n as isObjectIdInstance } from "./id-resolution-LZ-cCwR5.mjs";
-import "mongoose";
-//#region src/utils/memory-cache.ts
-/**
-* Creates an in-memory cache adapter
-*
-* Features:
-* - Automatic TTL expiration
-* - Pattern-based clearing (simple glob with *)
-* - Max entries limit to prevent memory leaks
-*
-* @param maxEntries - Maximum cache entries before oldest are evicted (default: 1000)
-*/
-function createMemoryCache(maxEntries = 1e3) {
-	const cache = /* @__PURE__ */ new Map();
-	let lastCleanup = Date.now();
-	const CLEANUP_INTERVAL_MS = 6e4;
-	function cleanupIfNeeded() {
-		const now = Date.now();
-		if (now - lastCleanup < CLEANUP_INTERVAL_MS) return;
-		lastCleanup = now;
-		for (const [key, entry] of cache) if (entry.expiresAt < now) cache.delete(key);
-	}
-	function evictOldest() {
-		while (cache.size >= maxEntries) {
-			const firstKey = cache.keys().next().value;
-			if (firstKey) cache.delete(firstKey);
-			else break;
-		}
-	}
-	return {
-		async get(key) {
-			const entry = cache.get(key);
-			if (!entry) return null;
-			if (entry.expiresAt < Date.now()) {
-				cache.delete(key);
-				return null;
-			}
-			cache.delete(key);
-			cache.set(key, entry);
-			return entry.value;
-		},
-		async set(key, value, ttl) {
-			cache.delete(key);
-			if (cache.size >= maxEntries) {
-				cleanupIfNeeded();
-				evictOldest();
-			}
-			cache.set(key, {
-				value,
-				expiresAt: Date.now() + ttl * 1e3
-			});
-		},
-		async del(key) {
-			cache.delete(key);
-		},
-		async clear(pattern) {
-			if (!pattern) {
-				cache.clear();
-				return;
-			}
-			const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-			const regex = new RegExp(`^${escaped}$`);
-			for (const key of cache.keys()) if (regex.test(key)) cache.delete(key);
-		}
-	};
-}
-//#endregion
-//#region src/utils/mongooseToJsonSchema.ts
-/**
-* Build CRUD schemas from Mongoose schema
-*/
-function buildCrudSchemasFromMongooseSchema(mongooseSchema, options = {}) {
-	const jsonCreate = buildJsonSchemaFromPaths(mongooseSchema, options);
-	return {
-		createBody: jsonCreate,
-		updateBody: buildJsonSchemaForUpdate(jsonCreate, options),
-		params: {
-			type: "object",
-			properties: { id: {
-				type: "string",
-				pattern: "^[0-9a-fA-F]{24}$"
-			} },
-			required: ["id"]
-		},
-		listQuery: buildJsonSchemaForQuery(mongooseSchema?.obj || {}, options)
-	};
-}
-/**
-* Build CRUD schemas from Mongoose model
-*/
-function buildCrudSchemasFromModel(mongooseModel, options = {}) {
-	if (!mongooseModel?.schema) throw new Error("Invalid mongoose model");
-	return buildCrudSchemasFromMongooseSchema(mongooseModel.schema, options);
-}
-/**
-* Collect fields to omit from a generated schema based on field rules and
-* explicit omit lists. This is the single source of truth for "which fields
-* should NOT appear in the create/update body" — called by both the
-* path-based and tree-based schema builders.
-*/
-function collectFieldsToOmit(options, purpose) {
-	const result = new Set([
-		"createdAt",
-		"updatedAt",
-		"__v"
-	]);
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) {
-		if (rule.systemManaged) result.add(field);
-		if (purpose === "update" && (rule.immutable || rule.immutableAfterCreate)) result.add(field);
-	}
-	const explicit = purpose === "create" ? options?.create?.omitFields : options?.update?.omitFields;
-	if (explicit) for (const f of explicit) result.add(f);
-	return result;
-}
-/**
-* Apply omissions + optional-overrides to a built JSON schema in-place.
-* Removes properties and adjusts the `required` array.
-*/
-function applyFieldRules(schema, fieldsToOmit, options) {
-	for (const field of fieldsToOmit) {
-		if (schema.properties?.[field]) delete schema.properties[field];
-		if (schema.required) schema.required = schema.required.filter((k) => k !== field);
-	}
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.optional && schema.required) schema.required = schema.required.filter((k) => k !== field);
-}
-/**
-* Get fields that are immutable (cannot be updated).
-* Delegates to `collectFieldsToOmit` internally.
-*/
-function getImmutableFields(options = {}) {
-	const immutable = [];
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.immutable || rule.immutableAfterCreate) immutable.push(field);
-	for (const f of options?.update?.omitFields || []) if (!immutable.includes(f)) immutable.push(f);
-	return immutable;
-}
-/**
-* Get fields that are system-managed (cannot be set by users).
-*/
-function getSystemManagedFields(options = {}) {
-	const systemManaged = [];
-	const rules = options?.fieldRules || {};
-	for (const [field, rule] of Object.entries(rules)) if (rule.systemManaged) systemManaged.push(field);
-	return systemManaged;
-}
-/**
-* Check if field is allowed in update
-*/
-function isFieldUpdateAllowed(fieldName, options = {}) {
-	const immutableFields = getImmutableFields(options);
-	const systemManagedFields = getSystemManagedFields(options);
-	return !immutableFields.includes(fieldName) && !systemManagedFields.includes(fieldName);
-}
-/**
-* Validate update body against field rules
-*/
-function validateUpdateBody(body = {}, options = {}) {
-	const violations = [];
-	const immutableFields = getImmutableFields(options);
-	const systemManagedFields = getSystemManagedFields(options);
-	Object.keys(body).forEach((field) => {
-		if (immutableFields.includes(field)) violations.push({
-			field,
-			reason: "Field is immutable"
-		});
-		else if (systemManagedFields.includes(field)) violations.push({
-			field,
-			reason: "Field is system-managed"
-		});
-	});
-	return {
-		valid: violations.length === 0,
-		violations
-	};
-}
-/**
-* Build JSON schema from Mongoose schema.paths (accurate type information)
-*/
-function buildJsonSchemaFromPaths(mongooseSchema, options) {
-	const properties = {};
-	const required = [];
-	const paths = mongooseSchema.paths;
-	const softRequiredSet = new Set(options?.softRequiredFields ?? []);
-	const isSoftRequired = (name, schemaType) => {
-		if (softRequiredSet.has(name)) return true;
-		return schemaType?.options?.softRequired === true;
-	};
-	const rootFields = /* @__PURE__ */ new Map();
-	for (const [path, schemaType] of Object.entries(paths)) {
-		if (path === "__v") continue;
-		if (path === "_id") {
-			const instance = schemaType.instance;
-			if (!instance || isObjectIdInstance(instance)) continue;
-		}
-		const rootField = path.split(".")[0];
-		if (!rootFields.has(rootField)) rootFields.set(rootField, []);
-		rootFields.get(rootField)?.push({
-			path,
-			schemaType
-		});
-	}
-	for (const [rootField, fieldPaths] of rootFields.entries()) if (fieldPaths.length === 1 && fieldPaths[0].path === rootField) {
-		const schemaType = fieldPaths[0].schemaType;
-		properties[rootField] = schemaTypeToJsonSchema(schemaType);
-		if (schemaType.isRequired && !isSoftRequired(rootField, schemaType)) required.push(rootField);
-	} else {
-		const nestedSchema = buildNestedJsonSchema(fieldPaths, rootField);
-		properties[rootField] = nestedSchema.schema;
-		if (nestedSchema.required) required.push(rootField);
-	}
-	const schema = {
-		type: "object",
-		properties
-	};
-	if (required.length) schema.required = required;
-	applyFieldRules(schema, collectFieldsToOmit(options, "create"), options);
-	const reqOv = options?.create?.requiredOverrides || {};
-	const optOv = options?.create?.optionalOverrides || {};
-	schema.required = schema.required || [];
-	for (const [k, v] of Object.entries(reqOv)) if (v && !schema.required.includes(k)) schema.required.push(k);
-	for (const [k, v] of Object.entries(optOv)) if (v && schema.required) schema.required = schema.required.filter((x) => x !== k);
-	const schemaOverrides = options?.create?.schemaOverrides || {};
-	for (const [k, override] of Object.entries(schemaOverrides)) if (schema.properties?.[k]) schema.properties[k] = override;
-	if (options?.strictAdditionalProperties === true) schema.additionalProperties = false;
-	return schema;
-}
-/**
-* Build nested JSON schema from dot-notation paths
-*/
-function buildNestedJsonSchema(fieldPaths, rootField) {
-	const properties = {};
-	const required = [];
-	let hasRequiredFields = false;
-	for (const { path, schemaType } of fieldPaths) {
-		const parts = path.substring(rootField.length + 1).split(".");
-		if (parts.length === 1) {
-			properties[parts[0]] = schemaTypeToJsonSchema(schemaType);
-			if (schemaType.isRequired) {
-				required.push(parts[0]);
-				hasRequiredFields = true;
-			}
-		} else {
-			const fieldName = parts[0];
-			if (!properties[fieldName]) properties[fieldName] = {
-				type: "object",
-				properties: {}
-			};
-			const nestedObj = properties[fieldName];
-			if (!nestedObj.properties) nestedObj.properties = {};
-			const deepPath = parts.slice(1).join(".");
-			nestedObj.properties[deepPath] = schemaTypeToJsonSchema(schemaType);
-		}
-	}
-	const schema = {
-		type: "object",
-		properties
-	};
-	if (required.length) schema.required = required;
-	return {
-		schema,
-		required: hasRequiredFields
-	};
-}
-/**
-* Convert Mongoose SchemaType to JSON Schema
-*/
-function schemaTypeToJsonSchema(schemaType) {
-	const result = {};
-	const instance = schemaType.instance;
-	const options = schemaType.options || {};
-	if (instance === "String") {
-		result.type = "string";
-		if (typeof options.minlength === "number") result.minLength = options.minlength;
-		if (typeof options.maxlength === "number") result.maxLength = options.maxlength;
-		if (options.match instanceof RegExp) result.pattern = options.match.source;
-		if (options.enum && Array.isArray(options.enum)) result.enum = options.enum;
-	} else if (instance === "Number") {
-		result.type = "number";
-		if (typeof options.min === "number") result.minimum = options.min;
-		if (typeof options.max === "number") result.maximum = options.max;
-	} else if (instance === "Boolean") result.type = "boolean";
-	else if (instance === "Date") {
-		result.type = "string";
-		result.format = "date-time";
-	} else if (isObjectIdInstance(instance)) {
-		result.type = "string";
-		result.pattern = "^[0-9a-fA-F]{24}$";
-	} else if (instance === "Array") {
-		result.type = "array";
-		result.items = { type: "string" };
-	} else {
-		result.type = "object";
-		result.additionalProperties = true;
-	}
-	return result;
-}
-function buildJsonSchemaForUpdate(createJson, options) {
-	const clone = JSON.parse(JSON.stringify(createJson));
-	delete clone.required;
-	applyFieldRules(clone, collectFieldsToOmit(options, "update"), options);
-	if (options?.strictAdditionalProperties === true) clone.additionalProperties = false;
-	if (options?.update?.requireAtLeastOne === true) clone.minProperties = 1;
-	return clone;
-}
-function buildJsonSchemaForQuery(_tree, options) {
-	const basePagination = {
-		type: "object",
-		properties: {
-			page: { type: "string" },
-			limit: { type: "string" },
-			sort: { type: "string" },
-			populate: { type: "string" },
-			search: { type: "string" },
-			select: { type: "string" },
-			lean: { type: "string" },
-			includeDeleted: { type: "string" }
-		},
-		additionalProperties: true
-	};
-	const filterable = options?.query?.filterableFields || {};
-	for (const [k, v] of Object.entries(filterable)) if (basePagination.properties) basePagination.properties[k] = v && typeof v === "object" && "type" in v ? v : { type: "string" };
-	return basePagination;
-}
-//#endregion
-export { isFieldUpdateAllowed as a, getSystemManagedFields as i, buildCrudSchemasFromMongooseSchema as n, validateUpdateBody as o, getImmutableFields as r, createMemoryCache as s, buildCrudSchemasFromModel as t };