@classytic/mongokit 3.6.1 → 3.6.3

package/dist/index.d.mts

@@ -1,7 +1,7 @@
 import { $ as ReadPreferenceType, A as InferDocument, At as LookupOptions, B as NonNullableFields, C as EventPayload, Ct as WithPlugins, D as GroupResult, Dt as IRequestContext, E as FieldRules, Et as IControllerResponse, F as KeysetPaginationResult, G as PaginationConfig, H as OffsetPaginationOptions, I as Logger, J as Plugin, K as PaginationResult, L as LookupPopulateOptions, M as JsonSchema, N as KeysOfType, O as HookMode, Ot as IResponseFormatter, P as KeysetPaginationOptions, Q as ReadOptions, R as LookupPopulateResult, S as EventHandlers, St as ValidatorDefinition, T as FieldPreset, Tt as IController, U as OffsetPaginationResult, V as ObjectId, W as OperationOptions, X as PluginType, Y as PluginFunction, Z as PopulateSpec, _ as CrudSchemas, _t as UpdateOptions, a as AnyDocument, at as RequiredBy, b as DeleteResult, bt as ValidationChainOptions, c as CacheOperationOptions, ct as SessionOptions, d as CacheableOptions, dt as SoftDeleteRepository, et as RepositoryContext, f as CascadeOptions, ft as SortDirection, g as CreateOptions, gt as UpdateManyResult, h as CreateInput, ht as UpdateInput, i as AllPluginMethods, it as RepositoryOptions, j as InferRawDoc, k as HttpError, kt as LookupBuilder, l as CacheOptions, lt as SoftDeleteFilterMode, m as CollationOptions, mt as Strict, n as AggregatePaginationOptions, nt as RepositoryInstance, o as AnyModel, ot as SchemaBuilderOptions, p as CascadeRelation, pt as SortSpec, q as PartialBy, r as AggregatePaginationResult, rt as RepositoryOperation, s as CacheAdapter, st as SelectSpec, t as AggregateOptions, tt as RepositoryEvent, u as CacheStats, ut as SoftDeleteOptions, v as DecodedCursor, vt as UpdateWithValidationResult, w as EventPhase, wt as WithTransactionOptions, x as DocField, xt as ValidationResult, y as DeepPartial, yt as UserContext, z as MinMaxResult } from "./types-DiQfDesD.mjs";
 import { t as index_d_exports } from "./index-BSRSsRRx.mjs";
 import { PaginationEngine } from "./pagination/PaginationEngine.mjs";
-import { A as dateSequentialId, B as AuditEntry, C as elasticSearchPlugin, D as PrefixedIdOptions, E as IdGenerator, F as CacheMethods, G as AuditTrailOptions, H as AuditQueryOptions, I as cachePlugin, J as auditLogPlugin, K as AuditTrailQuery, L as BatchOperationsMethods, M as prefixedId, N as sequentialId, O as SequentialIdOptions, P as cascadePlugin, R as BulkWriteResult, S as ElasticSearchOptions, T as DateSequentialIdOptions, U as AuditQueryResult, V as AuditOperation, W as AuditTrailMethods, X as aggregateHelpersPlugin, Y as AggregateHelpersMethods, _ as MongoOperationsMethods, a as uniqueField, b as methodRegistryPlugin, c as SubdocumentMethods, d as softDeletePlugin, f as ObservabilityOptions, g as multiTenantPlugin, h as MultiTenantOptions, i as requireField, j as getNextSequence, k as customIdPlugin, l as subdocumentPlugin, m as observabilityPlugin, n as blockIf, o as validationChainPlugin, p as OperationMetric, q as auditTrailPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as SoftDeleteMethods, v as mongoOperationsPlugin, w as CustomIdOptions, x as fieldFilterPlugin, z as batchOperationsPlugin } from "./validation-chain.plugin-mI2Z19lM.mjs";
+import { A as dateSequentialId, B as AuditEntry, C as elasticSearchPlugin, D as PrefixedIdOptions, E as IdGenerator, F as CacheMethods, G as AuditTrailOptions, H as AuditQueryOptions, I as cachePlugin, J as auditLogPlugin, K as AuditTrailQuery, L as BatchOperationsMethods, M as prefixedId, N as sequentialId, O as SequentialIdOptions, P as cascadePlugin, R as BulkWriteResult, S as ElasticSearchOptions, T as DateSequentialIdOptions, U as AuditQueryResult, V as AuditOperation, W as AuditTrailMethods, X as aggregateHelpersPlugin, Y as AggregateHelpersMethods, _ as MongoOperationsMethods, a as uniqueField, b as methodRegistryPlugin, c as SubdocumentMethods, d as softDeletePlugin, f as ObservabilityOptions, g as multiTenantPlugin, h as MultiTenantOptions, i as requireField, j as getNextSequence, k as customIdPlugin, l as subdocumentPlugin, m as observabilityPlugin, n as blockIf, o as validationChainPlugin, p as OperationMetric, q as auditTrailPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as SoftDeleteMethods, v as mongoOperationsPlugin, w as CustomIdOptions, x as fieldFilterPlugin, z as batchOperationsPlugin } from "./validation-chain.plugin-BsFzKVnO.mjs";
 import { n as SchemaPathsLike, t as FieldType$1 } from "./coercion-B19MD38s.mjs";
 import { n as SchemaIndexes } from "./indexes-qIBCZ3mY.mjs";
 import { a as isFieldUpdateAllowed, c as configureLogger, d as getFieldsForUser, f as getMongooseProjection, i as getSystemManagedFields, l as createFieldPreset, m as parseDuplicateKeyError, n as buildCrudSchemasFromMongooseSchema, o as validateUpdateBody, p as createError, r as getImmutableFields, s as createMemoryCache, t as buildCrudSchemasFromModel, u as filterResponseData } from "./mongooseToJsonSchema-D2YjHo7W.mjs";

package/dist/index.mjs

@@ -2,12 +2,12 @@ import { a as warn, n as parseDuplicateKeyError, r as configureLogger, t as crea
 import { y as LookupBuilder } from "./update-AVfKWNGt.mjs";
 import { t as actions_exports } from "./actions/index.mjs";
 import { t as PaginationEngine } from "./PaginationEngine-CunXkR9p.mjs";
-import { A as auditTrailPlugin, C as HOOK_PRIORITY, D as AggregationBuilder, E as withTransaction, M as aggregateHelpersPlugin, O as batchOperationsPlugin, S as cachePlugin, T as isTransactionUnsupported, _ as dateSequentialId, a as uniqueField, b as sequentialId, c as subdocumentPlugin, d as multiTenantPlugin, f as mongoOperationsPlugin, g as customIdPlugin, h as elasticSearchPlugin, i as requireField, j as auditLogPlugin, k as AuditTrailQuery, l as softDeletePlugin, m as fieldFilterPlugin, n as blockIf, o as validationChainPlugin, p as methodRegistryPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as observabilityPlugin, v as getNextSequence, w as Repository, x as cascadePlugin, y as prefixedId } from "./validation-chain.plugin-DoOEyM_g.mjs";
+import { A as auditTrailPlugin, C as HOOK_PRIORITY, D as AggregationBuilder, E as withTransaction, M as aggregateHelpersPlugin, O as batchOperationsPlugin, S as cachePlugin, T as isTransactionUnsupported, _ as dateSequentialId, a as uniqueField, b as sequentialId, c as subdocumentPlugin, d as multiTenantPlugin, f as mongoOperationsPlugin, g as customIdPlugin, h as elasticSearchPlugin, i as requireField, j as auditLogPlugin, k as AuditTrailQuery, l as softDeletePlugin, m as fieldFilterPlugin, n as blockIf, o as validationChainPlugin, p as methodRegistryPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as observabilityPlugin, v as getNextSequence, w as Repository, x as cascadePlugin, y as prefixedId } from "./validation-chain.plugin-7A5qGEQq.mjs";
 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/plugins/index.d.mts

@@ -1,2 +1,2 @@
-import { A as dateSequentialId, B as AuditEntry, C as elasticSearchPlugin, D as PrefixedIdOptions, E as IdGenerator, F as CacheMethods, G as AuditTrailOptions, H as AuditQueryOptions, I as cachePlugin, J as auditLogPlugin, K as AuditTrailQuery, L as BatchOperationsMethods, M as prefixedId, N as sequentialId, O as SequentialIdOptions, P as cascadePlugin, S as ElasticSearchOptions, T as DateSequentialIdOptions, U as AuditQueryResult, V as AuditOperation, W as AuditTrailMethods, X as aggregateHelpersPlugin, Y as AggregateHelpersMethods, _ as MongoOperationsMethods, a as uniqueField, b as methodRegistryPlugin, c as SubdocumentMethods, d as softDeletePlugin, f as ObservabilityOptions, g as multiTenantPlugin, h as MultiTenantOptions, i as requireField, j as getNextSequence, k as customIdPlugin, l as subdocumentPlugin, m as observabilityPlugin, n as blockIf, o as validationChainPlugin, p as OperationMetric, q as auditTrailPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as SoftDeleteMethods, v as mongoOperationsPlugin, w as CustomIdOptions, x as fieldFilterPlugin, y as MethodRegistryRepository, z as batchOperationsPlugin } from "../validation-chain.plugin-mI2Z19lM.mjs";
+import { A as dateSequentialId, B as AuditEntry, C as elasticSearchPlugin, D as PrefixedIdOptions, E as IdGenerator, F as CacheMethods, G as AuditTrailOptions, H as AuditQueryOptions, I as cachePlugin, J as auditLogPlugin, K as AuditTrailQuery, L as BatchOperationsMethods, M as prefixedId, N as sequentialId, O as SequentialIdOptions, P as cascadePlugin, S as ElasticSearchOptions, T as DateSequentialIdOptions, U as AuditQueryResult, V as AuditOperation, W as AuditTrailMethods, X as aggregateHelpersPlugin, Y as AggregateHelpersMethods, _ as MongoOperationsMethods, a as uniqueField, b as methodRegistryPlugin, c as SubdocumentMethods, d as softDeletePlugin, f as ObservabilityOptions, g as multiTenantPlugin, h as MultiTenantOptions, i as requireField, j as getNextSequence, k as customIdPlugin, l as subdocumentPlugin, m as observabilityPlugin, n as blockIf, o as validationChainPlugin, p as OperationMetric, q as auditTrailPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as SoftDeleteMethods, v as mongoOperationsPlugin, w as CustomIdOptions, x as fieldFilterPlugin, y as MethodRegistryRepository, z as batchOperationsPlugin } from "../validation-chain.plugin-BsFzKVnO.mjs";
 export { type AggregateHelpersMethods, type AuditEntry, type AuditOperation, type AuditQueryOptions, type AuditQueryResult, type AuditTrailMethods, type AuditTrailOptions, AuditTrailQuery, type BatchOperationsMethods, type CacheMethods, type CustomIdOptions, type DateSequentialIdOptions, type ElasticSearchOptions, type IdGenerator, type MethodRegistryRepository, type MongoOperationsMethods, type MultiTenantOptions, type ObservabilityOptions, type OperationMetric, type PrefixedIdOptions, type SequentialIdOptions, type SoftDeleteMethods, type SubdocumentMethods, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

package/dist/plugins/index.mjs

@@ -1,2 +1,2 @@
-import { A as auditTrailPlugin, M as aggregateHelpersPlugin, O as batchOperationsPlugin, S as cachePlugin, _ as dateSequentialId, a as uniqueField, b as sequentialId, c as subdocumentPlugin, d as multiTenantPlugin, f as mongoOperationsPlugin, g as customIdPlugin, h as elasticSearchPlugin, i as requireField, j as auditLogPlugin, k as AuditTrailQuery, l as softDeletePlugin, m as fieldFilterPlugin, n as blockIf, o as validationChainPlugin, p as methodRegistryPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as observabilityPlugin, v as getNextSequence, x as cascadePlugin, y as prefixedId } from "../validation-chain.plugin-DoOEyM_g.mjs";
+import { A as auditTrailPlugin, M as aggregateHelpersPlugin, O as batchOperationsPlugin, S as cachePlugin, _ as dateSequentialId, a as uniqueField, b as sequentialId, c as subdocumentPlugin, d as multiTenantPlugin, f as mongoOperationsPlugin, g as customIdPlugin, h as elasticSearchPlugin, i as requireField, j as auditLogPlugin, k as AuditTrailQuery, l as softDeletePlugin, m as fieldFilterPlugin, n as blockIf, o as validationChainPlugin, p as methodRegistryPlugin, r as immutableField, s as timestampPlugin, t as autoInject, u as observabilityPlugin, v as getNextSequence, x as cascadePlugin, y as prefixedId } from "../validation-chain.plugin-7A5qGEQq.mjs";
 export { AuditTrailQuery, aggregateHelpersPlugin, auditLogPlugin, auditTrailPlugin, autoInject, batchOperationsPlugin, blockIf, cachePlugin, cascadePlugin, customIdPlugin, dateSequentialId, elasticSearchPlugin, fieldFilterPlugin, getNextSequence, immutableField, methodRegistryPlugin, mongoOperationsPlugin, multiTenantPlugin, observabilityPlugin, prefixedId, requireField, sequentialId, softDeletePlugin, subdocumentPlugin, timestampPlugin, uniqueField, validationChainPlugin };

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/dist/{validation-chain.plugin-DoOEyM_g.mjs → validation-chain.plugin-7A5qGEQq.mjs}

@@ -3154,6 +3154,11 @@ function getCounterModel(connection) {
 *
 * @param counterKey - Unique key identifying this counter (e.g., "Invoice" or "Invoice:2026-02")
 * @param increment - Value to increment by (default: 1)
+* @param connection - Mongoose connection to use (defaults to the default connection)
+* @param session - Optional client session. When provided, the counter bump
+*   participates in the caller's transaction — if the surrounding transaction
+*   aborts, the counter does NOT advance. Without a session, the bump commits
+*   immediately and is not rolled back if a sibling write fails.
 * @returns The next sequence number (after increment)
 *
 * @example
@@ -3163,11 +3168,19 @@ function getCounterModel(connection) {
 * @example Batch increment for createMany
 * const startSeq = await getNextSequence('invoices', 5);
 * // If current was 10, returns 15 (you use 11, 12, 13, 14, 15)
+*
+* @example Transactional counter bump
+* await withTransaction(conn, async (session) => {
+*   const seq = await getNextSequence('invoices', 1, conn, session);
+*   await invoiceRepo.create({ invoiceNumber: `INV-${seq}` }, { session });
+*   // if this throws, the counter is rolled back with the insert
+* });
 */
-async function getNextSequence(counterKey, increment = 1, connection) {
+async function getNextSequence(counterKey, increment = 1, connection, session) {
 	const result = await getCounterModel(connection).findOneAndUpdate({ _id: counterKey }, { $inc: { seq: increment } }, {
 		upsert: true,
-		returnDocument: "after"
+		returnDocument: "after",
+		session
 	});
 	if (!result) throw new Error(`Failed to increment counter '${counterKey}'`);
 	return result.seq;
@@ -3190,7 +3203,7 @@ function sequentialId(options) {
 	const { prefix, model, padding = 4, separator = "-", counterKey } = options;
 	const key = counterKey || model.modelName;
 	return async (context) => {
-		const seq = await getNextSequence(key, 1, context._counterConnection);
+		const seq = await getNextSequence(key, 1, context._counterConnection, context.session);
 		return `${prefix}${separator}${String(seq).padStart(padding, "0")}`;
 	};
 }
@@ -3238,7 +3251,7 @@ function dateSequentialId(options) {
 				counterKey = `${model.modelName}:${year}-${month}`;
 				break;
 		}
-		const seq = await getNextSequence(counterKey, 1, context._counterConnection);
+		const seq = await getNextSequence(counterKey, 1, context._counterConnection, context.session);
 		return `${prefix}${separator}${datePart}${separator}${String(seq).padStart(padding, "0")}`;
 	};
 }

package/dist/{validation-chain.plugin-mI2Z19lM.d.mts → validation-chain.plugin-BsFzKVnO.d.mts}

@@ -432,6 +432,11 @@ interface CustomIdOptions {
  *
  * @param counterKey - Unique key identifying this counter (e.g., "Invoice" or "Invoice:2026-02")
  * @param increment - Value to increment by (default: 1)
+ * @param connection - Mongoose connection to use (defaults to the default connection)
+ * @param session - Optional client session. When provided, the counter bump
+ *   participates in the caller's transaction — if the surrounding transaction
+ *   aborts, the counter does NOT advance. Without a session, the bump commits
+ *   immediately and is not rolled back if a sibling write fails.
  * @returns The next sequence number (after increment)
  *
  * @example
@@ -441,8 +446,15 @@ interface CustomIdOptions {
  * @example Batch increment for createMany
  * const startSeq = await getNextSequence('invoices', 5);
  * // If current was 10, returns 15 (you use 11, 12, 13, 14, 15)
+ *
+ * @example Transactional counter bump
+ * await withTransaction(conn, async (session) => {
+ *   const seq = await getNextSequence('invoices', 1, conn, session);
+ *   await invoiceRepo.create({ invoiceNumber: `INV-${seq}` }, { session });
+ *   // if this throws, the counter is rolled back with the insert
+ * });
  */
-declare function getNextSequence(counterKey: string, increment?: number, connection?: mongoose.Connection): Promise<number>;
+declare function getNextSequence(counterKey: string, increment?: number, connection?: mongoose.Connection, session?: mongoose.ClientSession): Promise<number>;
 interface SequentialIdOptions {
   /** Prefix string (e.g., 'INV', 'ORD') */
   prefix: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@classytic/mongokit",
-  "version": "3.6.1",
+  "version": "3.6.3",
   "description": "Production-grade MongoDB repositories with zero dependencies - smart pagination, events, and plugins",
   "type": "module",
   "sideEffects": false,
@@ -118,13 +118,17 @@
     "release:major": "npm version major && npm run release"
   },
   "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.2",
     "@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",
-    "tsdown": "^0.21.7",
+    "publint": "^0.3.18",
+    "tsdown": "^0.21.8",
     "typescript": "^5.7.0",
     "vitest": "^3.2.4"
   }

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 };