@classytic/arc 2.11.3 → 2.13.1

package/dist/adapters-D0tT2Tyo.mjs

@@ -1,949 +0,0 @@
-import { h as SYSTEM_FIELDS, m as RESERVED_QUERY_PARAMS } from "./constants-BhY1OHoH.mjs";
-//#region src/adapters/field-rule-helpers.ts
-/**
-* Merge constraint-style `fieldRules` into an `OpenApiSchemas` bag in place.
-*
-* Operates on the three schema slots that carry property maps — `createBody`,
-* `updateBody`, `response`. `listQuery` and `params` are skipped (their
-* constraint vocabulary is owned by the kit's query parser).
-*
-* Existing constraints on a property always win — the merge only fills in
-* gaps. Adapters that already walk `fieldRules` during base-schema assembly
-* can call this helper for free (the checks are no-ops when constraints
-* already exist).
-*/
-function mergeFieldRuleConstraints(schemas, schemaOptions) {
-	if (!schemas || typeof schemas !== "object") return;
-	const rules = schemaOptions?.fieldRules;
-	if (!rules || Object.keys(rules).length === 0) return;
-	for (const slot of [
-		"createBody",
-		"updateBody",
-		"response"
-	]) {
-		const slotSchema = schemas[slot];
-		if (!slotSchema || typeof slotSchema !== "object") continue;
-		const properties = slotSchema.properties;
-		if (!properties) continue;
-		for (const [field, rule] of Object.entries(rules)) {
-			const prop = properties[field];
-			if (!prop || typeof prop !== "object") continue;
-			if (rule.minLength != null && prop.minLength == null) prop.minLength = rule.minLength;
-			if (rule.maxLength != null && prop.maxLength == null) prop.maxLength = rule.maxLength;
-			if (rule.min != null && prop.minimum == null) prop.minimum = rule.min;
-			if (rule.max != null && prop.maximum == null) prop.maximum = rule.max;
-			if (rule.pattern != null && prop.pattern == null) prop.pattern = rule.pattern;
-			if (rule.enum != null && prop.enum == null) prop.enum = rule.enum;
-			if (rule.description != null && prop.description == null) prop.description = rule.description;
-			if (rule.nullable === true) applyNullable(prop);
-		}
-	}
-}
-/**
-* Widen a JSON Schema property to also accept `null`.
-*
-* Handles the three ways a property can be typed:
-*   - `type: 'string'`     → `type: ['string', 'null']`
-*   - `type: [...]`        → append `'null'` if missing
-*   - `anyOf: [...]`       → append `{ type: 'null' }` branch if missing
-*
-* **Enum interaction:** when the widened prop also carries `enum: [...]`,
-* `null` is appended to the enum list too. AJV's `enum` keyword rejects
-* values not in the list regardless of the widened `type`, so
-* `{ type: ['string','null'], enum: ['a','b'] }` alone would still reject
-* `null`. The fix is `enum: ['a','b', null]`. (The `anyOf` branch dodges
-* this entirely — each branch scopes its own enum.)
-*
-* No-op when the schema already admits null (don't double-wrap) or has
-* no `type` / `anyOf` anchor to widen (e.g. Mixed — already accepts null).
-*
-* Mutates in place — callers already treat the slot schema as owned.
-* Exported so adapters that walk `fieldRules` inline (mongoose fallback,
-* drizzle post-process) can reuse the same widening logic.
-*/
-function applyNullable(prop) {
-	if (Array.isArray(prop.anyOf)) {
-		if (!prop.anyOf.some((b) => b && typeof b === "object" && (b.type === "null" || b.const === null))) prop.anyOf.push({ type: "null" });
-		return;
-	}
-	if (Array.isArray(prop.type)) {
-		if (!prop.type.includes("null")) prop.type.push("null");
-		widenEnumToIncludeNull(prop);
-		return;
-	}
-	if (typeof prop.type === "string") {
-		prop.type = [prop.type, "null"];
-		widenEnumToIncludeNull(prop);
-		return;
-	}
-}
-/**
-* Append `null` to `enum` when present. Required because AJV's `enum`
-* keyword is independent of `type` — a value must appear in the enum
-* array verbatim even if the widened type says null is allowed.
-*/
-function widenEnumToIncludeNull(prop) {
-	if (!Array.isArray(prop.enum)) return;
-	if (prop.enum.includes(null)) return;
-	prop.enum = [...prop.enum, null];
-}
-//#endregion
-//#region src/adapters/types.ts
-/**
-* Check if value is a Mongoose model
-*/
-function isMongooseModel(value) {
-	return typeof value === "function" && value.prototype && "modelName" in value && "schema" in value;
-}
-/**
-* Check if value is a repository
-*/
-function isRepository(value) {
-	return typeof value === "object" && value !== null && "getAll" in value && "getById" in value && "create" in value && "update" in value && "delete" in value;
-}
-//#endregion
-//#region src/adapters/drizzle.ts
-const DRIZZLE_COLUMNS_SYMBOL = Symbol.for("drizzle:Columns");
-function getColumns(table) {
-	const cols = table[DRIZZLE_COLUMNS_SYMBOL];
-	if (!cols || typeof cols !== "object") return {};
-	return cols;
-}
-function columnToJsonSchema(column) {
-	const { dataType, columnType, enumValues, length } = column;
-	if (dataType === "date") return {
-		type: "string",
-		format: "date-time"
-	};
-	if (dataType === "boolean") return { type: "boolean" };
-	if (dataType === "json") return {
-		type: "object",
-		additionalProperties: true
-	};
-	if (dataType === "buffer") return {
-		type: "string",
-		contentEncoding: "base64"
-	};
-	if (dataType === "number" || dataType === "bigint") return { type: columnType === "SQLiteInteger" ? "integer" : "number" };
-	if (dataType === "string") {
-		const result = { type: "string" };
-		if (Array.isArray(enumValues) && enumValues.length > 0) result.enum = [...enumValues];
-		if (typeof length === "number" && length > 0) result.maxLength = length;
-		return result;
-	}
-	return {};
-}
-function columnToFieldMetadata(column) {
-	const { dataType, enumValues } = column;
-	const meta = {
-		type: (dataType && {
-			number: "number",
-			bigint: "number",
-			string: "string",
-			date: "date",
-			boolean: "boolean",
-			json: "object",
-			buffer: "object"
-		}[dataType]) ?? (enumValues?.length ? "enum" : "object"),
-		required: !!column.notNull && !column.hasDefault
-	};
-	if (enumValues?.length) meta.enum = [...enumValues];
-	if (typeof column.length === "number") meta.maxLength = column.length;
-	return meta;
-}
-var DrizzleAdapter = class {
-	type = "drizzle";
-	name;
-	table;
-	repository;
-	schemaGenerator;
-	constructor(options) {
-		if (!options.table || typeof options.table !== "object") throw new TypeError("DrizzleAdapter: Invalid table. Expected a Drizzle table created with sqliteTable / pgTable / mysqlTable.");
-		if (!isRepository(options.repository)) throw new TypeError("DrizzleAdapter: Invalid repository. Expected an object implementing MinimalRepo (getAll / getById / create / update / delete).");
-		this.table = options.table;
-		this.repository = options.repository;
-		this.schemaGenerator = options.schemaGenerator;
-		this.name = options.name ?? "DrizzleAdapter";
-	}
-	/**
-	* Introspect Drizzle columns into arc's schema metadata shape.
-	*/
-	getSchemaMetadata() {
-		const columns = getColumns(this.table);
-		const fields = {};
-		const indexes = [];
-		for (const [name, column] of Object.entries(columns)) {
-			fields[name] = columnToFieldMetadata(column);
-			if (column.primary) indexes.push({
-				fields: [name],
-				unique: true
-			});
-		}
-		return {
-			name: this.name,
-			fields,
-			...indexes.length > 0 ? { indexes } : {}
-		};
-	}
-	/**
-	* Generate OpenAPI schemas. Delegates to the user-provided
-	* `schemaGenerator` when available (strongly recommended — that's where
-	* field rules, omit lists, and param-type narrowing live). The built-in
-	* fallback emits a permissive entity + CRUD body shape so routes still
-	* register when no generator is provided.
-	*
-	* After the kit generator runs, arc merges constraint-style field rules
-	* (`minLength`, `maxLength`, `min`, `max`, `pattern`, `enum`, `description`)
-	* into the resulting property schemas so sqlitekit / pgkit behave
-	* identically to mongoose here — rule-driven AJV constraints apply
-	* regardless of backend.
-	*/
-	generateSchemas(schemaOptions, context) {
-		try {
-			if (this.schemaGenerator) {
-				const generated = this.schemaGenerator(this.table, schemaOptions, context);
-				mergeFieldRuleConstraints(generated, schemaOptions);
-				return generated;
-			}
-			const columns = getColumns(this.table);
-			if (Object.keys(columns).length === 0) return null;
-			const entityProperties = {};
-			const inputProperties = {};
-			const inputRequired = [];
-			const updateProperties = {};
-			const fieldRules = schemaOptions?.fieldRules ?? {};
-			const readonlySet = new Set(schemaOptions?.readonlyFields ?? []);
-			const optionalSet = new Set(schemaOptions?.optionalFields ?? []);
-			const blocked = new Set([
-				...Object.entries(fieldRules).filter(([, rules]) => rules.systemManaged || rules.hidden).map(([field]) => field),
-				...schemaOptions?.excludeFields ?? [],
-				...schemaOptions?.hiddenFields ?? []
-			]);
-			for (const [fieldName, column] of Object.entries(columns)) {
-				const schema = columnToJsonSchema(column);
-				entityProperties[fieldName] = schema;
-				if (blocked.has(fieldName)) continue;
-				if (column.primary && column.columnType === "SQLiteInteger") continue;
-				if (!readonlySet.has(fieldName)) {
-					inputProperties[fieldName] = schema;
-					if (!!column.notNull && !column.hasDefault && !optionalSet.has(fieldName)) inputRequired.push(fieldName);
-					updateProperties[fieldName] = schema;
-				}
-			}
-			return {
-				createBody: {
-					type: "object",
-					properties: inputProperties,
-					required: inputRequired.length > 0 ? inputRequired : void 0,
-					additionalProperties: true
-				},
-				updateBody: {
-					type: "object",
-					properties: updateProperties,
-					additionalProperties: true
-				},
-				response: {
-					type: "object",
-					properties: entityProperties,
-					additionalProperties: true
-				}
-			};
-		} catch {
-			return null;
-		}
-	}
-	async healthCheck() {
-		return typeof this.repository.getAll === "function";
-	}
-};
-/**
-* Factory — preferred construction style for symmetry with
-* `createMongooseAdapter` / `createPrismaAdapter`.
-*/
-function createDrizzleAdapter(options) {
-	return new DrizzleAdapter(options);
-}
-//#endregion
-//#region src/adapters/mongoose.ts
-/**
-* Mongoose data adapter with proper type safety
-*
-* @typeParam TDoc - The document type
-*/
-var MongooseAdapter = class {
-	type = "mongoose";
-	name;
-	model;
-	repository;
-	schemaGenerator;
-	constructor(options) {
-		if (!isMongooseModel(options.model)) throw new TypeError("MongooseAdapter: Invalid model. Expected Mongoose Model instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
-		if (!isRepository(options.repository)) throw new TypeError("MongooseAdapter: Invalid repository. Expected StandardRepo instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })");
-		this.model = options.model;
-		this.repository = options.repository;
-		this.schemaGenerator = options.schemaGenerator;
-		this.name = `MongooseAdapter<${options.model.modelName}>`;
-	}
-	/**
-	* Get schema metadata from Mongoose model
-	*/
-	getSchemaMetadata() {
-		const paths = this.model.schema.paths;
-		const fields = {};
-		for (const [fieldName, schemaType] of Object.entries(paths)) {
-			if (fieldName.startsWith("_") && fieldName !== "_id") continue;
-			const typeInfo = schemaType;
-			fields[fieldName] = {
-				type: {
-					String: "string",
-					Number: "number",
-					Boolean: "boolean",
-					Date: "date",
-					ObjectID: "objectId",
-					ObjectId: "objectId",
-					Array: "array",
-					Mixed: "object",
-					Buffer: "object",
-					Embedded: "object"
-				}[typeInfo.instance || "Mixed"] ?? "object",
-				required: !!typeInfo.isRequired,
-				ref: typeInfo.options?.ref
-			};
-		}
-		return {
-			name: this.model.modelName,
-			fields,
-			relations: this.extractRelations(paths)
-		};
-	}
-	/**
-	* Generate OpenAPI schemas from Mongoose model.
-	*
-	* If a `schemaGenerator` plugin was provided (e.g. MongoKit's buildCrudSchemasFromModel),
-	* it is used instead of the built-in basic conversion.
-	*/
-	generateSchemas(schemaOptions, context) {
-		try {
-			if (this.schemaGenerator) {
-				const generated = this.schemaGenerator(this.model, schemaOptions, context);
-				mergeFieldRuleConstraints(generated, schemaOptions);
-				return generated;
-			}
-			const paths = this.model.schema.paths;
-			const properties = {};
-			const required = [];
-			const fieldRules = schemaOptions?.fieldRules || {};
-			const blockedFields = new Set([
-				...Object.entries(fieldRules).filter(([, rules]) => rules.systemManaged || rules.hidden).map(([field]) => field),
-				...schemaOptions?.excludeFields ?? [],
-				...schemaOptions?.hiddenFields ?? []
-			]);
-			const readonlySet = new Set(schemaOptions?.readonlyFields ?? []);
-			const optionalSet = new Set(schemaOptions?.optionalFields ?? []);
-			for (const [fieldName, schemaType] of Object.entries(paths)) {
-				if (fieldName.startsWith("__")) continue;
-				if (blockedFields.has(fieldName)) continue;
-				const typeInfo = schemaType;
-				properties[fieldName] = this.mongooseTypeToOpenApi(typeInfo);
-				const rule = fieldRules[fieldName];
-				if (rule) {
-					const prop = properties[fieldName];
-					if (rule.minLength != null && prop.minLength == null) prop.minLength = rule.minLength;
-					if (rule.maxLength != null && prop.maxLength == null) prop.maxLength = rule.maxLength;
-					if (rule.min != null && prop.minimum == null) prop.minimum = rule.min;
-					if (rule.max != null && prop.maximum == null) prop.maximum = rule.max;
-					if (rule.pattern != null && prop.pattern == null) prop.pattern = rule.pattern;
-					if (rule.enum != null && prop.enum == null) prop.enum = rule.enum;
-					if (rule.description != null && prop.description == null) prop.description = rule.description;
-					if (rule.nullable === true) applyNullable(prop);
-				}
-				if (typeInfo.isRequired && !optionalSet.has(fieldName) && !fieldRules[fieldName]?.optional) required.push(fieldName);
-			}
-			const readonlyForInput = new Set([...readonlySet]);
-			for (const [field, rules] of Object.entries(fieldRules)) if (rules.immutable || rules.immutableAfterCreate) readonlyForInput.add(field);
-			const inputBlockedSet = new Set([...SYSTEM_FIELDS, ...readonlyForInput]);
-			const inputProperties = Object.fromEntries(Object.entries(properties).filter(([field]) => !inputBlockedSet.has(field)));
-			const inputRequired = required.filter((field) => !inputBlockedSet.has(field) && !blockedFields.has(field));
-			const immutableSet = /* @__PURE__ */ new Set();
-			for (const [field, rules] of Object.entries(fieldRules)) if (rules.immutable || rules.immutableAfterCreate) immutableSet.add(field);
-			const updateProperties = Object.fromEntries(Object.entries(inputProperties).filter(([field]) => !immutableSet.has(field)));
-			return {
-				createBody: {
-					type: "object",
-					properties: inputProperties,
-					required: inputRequired.length > 0 ? inputRequired : void 0,
-					additionalProperties: true
-				},
-				updateBody: {
-					type: "object",
-					properties: updateProperties,
-					additionalProperties: true
-				},
-				response: {
-					type: "object",
-					properties,
-					additionalProperties: true
-				}
-			};
-		} catch {
-			return null;
-		}
-	}
-	/**
-	* Extract relation metadata
-	*/
-	extractRelations(paths) {
-		const relations = {};
-		for (const [fieldName, schemaType] of Object.entries(paths)) {
-			const ref = schemaType.options?.ref;
-			if (ref) relations[fieldName] = {
-				type: "one-to-one",
-				target: ref,
-				foreignKey: fieldName
-			};
-		}
-		return Object.keys(relations).length > 0 ? relations : void 0;
-	}
-	/**
-	* Convert Mongoose type to OpenAPI type
-	*/
-	mongooseTypeToOpenApi(typeInfo) {
-		const instance = typeInfo.instance;
-		const options = typeInfo.options || {};
-		const baseType = {};
-		switch (instance) {
-			case "String":
-				baseType.type = "string";
-				if (options.enum) baseType.enum = options.enum;
-				if (options.minlength) baseType.minLength = options.minlength;
-				if (options.maxlength) baseType.maxLength = options.maxlength;
-				break;
-			case "Number":
-				baseType.type = "number";
-				if (options.min !== void 0) baseType.minimum = options.min;
-				if (options.max !== void 0) baseType.maximum = options.max;
-				break;
-			case "Boolean":
-				baseType.type = "boolean";
-				break;
-			case "Date":
-				baseType.type = "string";
-				break;
-			case "ObjectID":
-			case "ObjectId":
-				baseType.type = "string";
-				baseType.pattern = "^[a-f\\d]{24}$";
-				break;
-			case "Array": {
-				baseType.type = "array";
-				const ti = typeInfo;
-				if (ti.$isMongooseDocumentArray && ti.schema) {
-					const subSchema = ti.schema;
-					const subProps = {};
-					const subRequired = [];
-					for (const [subField, subType] of Object.entries(subSchema.paths)) {
-						if (subField.startsWith("_")) continue;
-						subProps[subField] = this.mongooseTypeToOpenApi(subType);
-						if (subType.isRequired) subRequired.push(subField);
-					}
-					baseType.items = {
-						type: "object",
-						properties: subProps,
-						...subRequired.length > 0 ? { required: subRequired } : {},
-						additionalProperties: true
-					};
-				} else if (ti.embeddedSchemaType?.instance) baseType.items = this.mongooseTypeToOpenApi(ti.embeddedSchemaType);
-				else baseType.items = {};
-				break;
-			}
-			case "Mixed": break;
-			case "Map":
-				baseType.type = "object";
-				baseType.additionalProperties = true;
-				break;
-			case "Embedded":
-			case "SubDocument":
-				baseType.type = "object";
-				baseType.additionalProperties = true;
-				break;
-			case "Buffer":
-				baseType.type = "string";
-				baseType.format = "binary";
-				break;
-			case "Decimal128":
-				baseType.type = "string";
-				baseType.description = "Decimal128 (high-precision number as string)";
-				break;
-			case "UUID":
-				baseType.type = "string";
-				baseType.format = "uuid";
-				break;
-			default:
-				baseType.type = "object";
-				baseType.additionalProperties = true;
-		}
-		if (options.default === null) {
-			applyNullable(baseType);
-			baseType.default = null;
-		}
-		return baseType;
-	}
-};
-function createMongooseAdapter(modelOrOptions, repository) {
-	if (isMongooseModel(modelOrOptions)) {
-		if (!repository) throw new TypeError("createMongooseAdapter: repository is required when using 2-arg form.\nUsage: createMongooseAdapter(Model, repository)");
-		return new MongooseAdapter({
-			model: modelOrOptions,
-			repository
-		});
-	}
-	return new MongooseAdapter(modelOrOptions);
-}
-//#endregion
-//#region src/adapters/prisma.ts
-/**
-* Prisma Query Parser - Converts URL parameters to Prisma query format
-*
-* Translates Arc's query format to Prisma's where/orderBy/take/skip structure.
-*
-* @example
-* ```typescript
-* const parser = new PrismaQueryParser();
-*
-* // URL: ?status=active&price[gte]=100&sort=-createdAt&page=2&limit=10
-* const prismaQuery = parser.toPrismaQuery(parsedQuery);
-* // Returns:
-* // {
-* //   where: { status: 'active', price: { gte: 100 }, deletedAt: null },
-* //   orderBy: { createdAt: 'desc' },
-* //   take: 10,
-* //   skip: 10,
-* // }
-* ```
-*/
-var PrismaQueryParser = class {
-	maxLimit;
-	defaultLimit;
-	softDeleteEnabled;
-	softDeleteField;
-	/** Map Arc operators to Prisma operators */
-	operatorMap = {
-		$eq: "equals",
-		$ne: "not",
-		$gt: "gt",
-		$gte: "gte",
-		$lt: "lt",
-		$lte: "lte",
-		$in: "in",
-		$nin: "notIn",
-		$regex: "contains",
-		$exists: void 0
-	};
-	constructor(options = {}) {
-		this.maxLimit = options.maxLimit ?? 1e3;
-		this.defaultLimit = options.defaultLimit ?? 20;
-		this.softDeleteEnabled = options.softDeleteEnabled ?? true;
-		this.softDeleteField = options.softDeleteField ?? "deletedAt";
-	}
-	/**
-	* Parse URL query parameters (delegates to ArcQueryParser format)
-	*/
-	parse(query) {
-		const q = query ?? {};
-		const page = this.parseNumber(q.page, 1);
-		const limit = Math.min(this.parseNumber(q.limit, this.defaultLimit), this.maxLimit);
-		return {
-			filters: this.parseFilters(q),
-			limit,
-			page,
-			sort: this.parseSort(q.sort),
-			search: q.search,
-			select: this.parseSelect(q.select)
-		};
-	}
-	/**
-	* Convert ParsedQuery to Prisma query options
-	*/
-	toPrismaQuery(parsed, policyFilters) {
-		const where = {};
-		if (parsed.filters) Object.assign(where, this.translateFilters(parsed.filters));
-		if (policyFilters) Object.assign(where, this.translateFilters(policyFilters));
-		if (this.softDeleteEnabled) where[this.softDeleteField] = null;
-		const orderBy = parsed.sort ? Object.entries(parsed.sort).map(([field, dir]) => ({ [field]: dir === 1 ? "asc" : "desc" })) : void 0;
-		const take = parsed.limit ?? this.defaultLimit;
-		const skip = parsed.page ? (parsed.page - 1) * take : 0;
-		const select = parsed.select ? Object.fromEntries(Object.entries(parsed.select).filter(([, v]) => v === 1).map(([k]) => [k, true])) : void 0;
-		return {
-			where: Object.keys(where).length > 0 ? where : void 0,
-			orderBy: orderBy && orderBy.length > 0 ? orderBy : void 0,
-			take,
-			skip,
-			select: select && Object.keys(select).length > 0 ? select : void 0
-		};
-	}
-	/**
-	* Translate Arc/MongoDB-style filters to Prisma where clause
-	*/
-	translateFilters(filters) {
-		const result = {};
-		for (const [field, value] of Object.entries(filters)) {
-			if (value === null || value === void 0) continue;
-			if (typeof value === "object" && !Array.isArray(value)) {
-				const prismaCondition = {};
-				for (const [op, opValue] of Object.entries(value)) {
-					if (op === "$exists") {
-						result[field] = opValue ? { not: null } : null;
-						continue;
-					}
-					const prismaOp = this.operatorMap[op];
-					if (prismaOp) prismaCondition[prismaOp] = opValue;
-				}
-				if (Object.keys(prismaCondition).length > 0) result[field] = prismaCondition;
-			} else result[field] = value;
-		}
-		return result;
-	}
-	parseNumber(value, defaultValue) {
-		if (value === void 0 || value === null) return defaultValue;
-		const num = parseInt(String(value), 10);
-		return Number.isNaN(num) ? defaultValue : Math.max(1, num);
-	}
-	parseSort(value) {
-		if (!value) return void 0;
-		const sortStr = String(value);
-		const result = {};
-		for (const field of sortStr.split(",")) {
-			const trimmed = field.trim();
-			if (!trimmed || !/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
-			if (trimmed.startsWith("-")) result[trimmed.slice(1)] = -1;
-			else result[trimmed] = 1;
-		}
-		return Object.keys(result).length > 0 ? result : void 0;
-	}
-	parseSelect(value) {
-		if (!value) return void 0;
-		const result = {};
-		for (const field of String(value).split(",")) {
-			const trimmed = field.trim();
-			if (!trimmed || !/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
-			result[trimmed.startsWith("-") ? trimmed.slice(1) : trimmed] = trimmed.startsWith("-") ? 0 : 1;
-		}
-		return Object.keys(result).length > 0 ? result : void 0;
-	}
-	parseFilters(query) {
-		const filters = {};
-		const operators = {
-			eq: "$eq",
-			ne: "$ne",
-			gt: "$gt",
-			gte: "$gte",
-			lt: "$lt",
-			lte: "$lte",
-			in: "$in",
-			nin: "$nin",
-			like: "$regex",
-			contains: "$regex",
-			exists: "$exists"
-		};
-		for (const [key, value] of Object.entries(query)) {
-			if (RESERVED_QUERY_PARAMS.has(key) || value === void 0 || value === null) continue;
-			const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)(?:\[([a-z]+)\])?$/);
-			if (!match) continue;
-			const [, fieldName, operator] = match;
-			if (!fieldName) continue;
-			if (operator && operators[operator]) {
-				if (!filters[fieldName]) filters[fieldName] = {};
-				filters[fieldName][operators[operator]] = this.coerceValue(value, operator);
-			} else if (!operator) filters[fieldName] = this.coerceValue(value);
-		}
-		return filters;
-	}
-	coerceValue(value, operator) {
-		if (operator === "in" || operator === "nin") {
-			if (Array.isArray(value)) return value.map((v) => this.coerceValue(v));
-			if (typeof value === "string" && value.includes(",")) return value.split(",").map((v) => this.coerceValue(v.trim()));
-			return [this.coerceValue(value)];
-		}
-		if (operator === "exists") return String(value).toLowerCase() === "true" || value === "1";
-		if (value === "true") return true;
-		if (value === "false") return false;
-		if (value === "null") return null;
-		if (typeof value === "string") {
-			const num = Number(value);
-			if (!Number.isNaN(num) && value.trim() !== "") return num;
-		}
-		return value;
-	}
-};
-var PrismaAdapter = class {
-	type = "prisma";
-	name;
-	repository;
-	queryParser;
-	client;
-	modelName;
-	dmmf;
-	softDeleteEnabled;
-	softDeleteField;
-	constructor(options) {
-		this.client = options.client;
-		this.modelName = options.modelName;
-		this.repository = options.repository;
-		this.dmmf = options.dmmf;
-		this.name = `prisma:${options.modelName}`;
-		this.softDeleteEnabled = options.softDeleteEnabled ?? true;
-		this.softDeleteField = options.softDeleteField ?? "deletedAt";
-		this.queryParser = options.queryParser ?? new PrismaQueryParser({
-			softDeleteEnabled: this.softDeleteEnabled,
-			softDeleteField: this.softDeleteField
-		});
-	}
-	/**
-	* Parse URL query parameters and convert to Prisma query options
-	*/
-	parseQuery(query, policyFilters) {
-		const parsed = this.queryParser.parse(query);
-		return this.queryParser.toPrismaQuery(parsed, policyFilters);
-	}
-	/**
-	* Apply policy filters to existing Prisma where clause
-	* Used for multi-tenant, ownership, and other security filters
-	*/
-	applyPolicyFilters(where, policyFilters) {
-		return {
-			...where,
-			...policyFilters
-		};
-	}
-	generateSchemas(options) {
-		if (!this.dmmf) return null;
-		try {
-			const model = this.dmmf.datamodel?.models?.find((m) => m.name.toLowerCase() === this.modelName.toLowerCase());
-			if (!model) return null;
-			return {
-				entity: this.buildEntitySchema(model, options),
-				createBody: this.buildCreateSchema(model, options),
-				updateBody: this.buildUpdateSchema(model, options),
-				params: {
-					type: "object",
-					properties: { id: { type: "string" } },
-					required: ["id"]
-				},
-				listQuery: {
-					type: "object",
-					properties: {
-						page: {
-							type: "number",
-							minimum: 1,
-							description: "Page number for pagination"
-						},
-						limit: {
-							type: "number",
-							minimum: 1,
-							maximum: 100,
-							description: "Items per page"
-						},
-						sort: {
-							type: "string",
-							description: "Sort field (e.g., \"name\", \"-createdAt\")"
-						}
-					}
-				}
-			};
-		} catch {
-			return null;
-		}
-	}
-	getSchemaMetadata() {
-		if (!this.dmmf) return null;
-		try {
-			const model = this.dmmf.datamodel?.models?.find((m) => m.name.toLowerCase() === this.modelName.toLowerCase());
-			if (!model) return null;
-			const fields = {};
-			for (const field of model.fields) fields[field.name] = this.convertPrismaFieldToMetadata(field);
-			return {
-				name: model.name,
-				fields,
-				indexes: model.uniqueIndexes?.map((idx) => ({
-					fields: idx.fields,
-					unique: true
-				}))
-			};
-		} catch (_err) {
-			return null;
-		}
-	}
-	async validate(data) {
-		if (!data || typeof data !== "object") return {
-			valid: false,
-			errors: [{
-				field: "root",
-				message: "Data must be an object"
-			}]
-		};
-		if (this.dmmf) try {
-			const model = this.dmmf.datamodel?.models?.find((m) => m.name.toLowerCase() === this.modelName.toLowerCase());
-			if (model) {
-				const requiredFields = model.fields.filter((f) => f.isRequired && !f.hasDefaultValue && !f.isGenerated);
-				const errors = [];
-				for (const field of requiredFields) if (!(field.name in data)) errors.push({
-					field: field.name,
-					message: `${field.name} is required`
-				});
-				if (errors.length > 0) return {
-					valid: false,
-					errors
-				};
-			}
-		} catch (_err) {}
-		return { valid: true };
-	}
-	async healthCheck() {
-		try {
-			const delegateName = this.modelName.charAt(0).toLowerCase() + this.modelName.slice(1);
-			const delegate = this.client[delegateName];
-			if (!delegate) return false;
-			await delegate.findMany({ take: 1 });
-			return true;
-		} catch (_err) {
-			return false;
-		}
-	}
-	async close() {
-		try {
-			await this.client.$disconnect();
-		} catch (_err) {}
-	}
-	buildEntitySchema(model, options) {
-		const properties = {};
-		const required = [];
-		for (const field of model.fields) {
-			if (this.shouldSkipField(field, options)) continue;
-			properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-			if (field.isRequired && !field.hasDefaultValue) required.push(field.name);
-		}
-		return {
-			type: "object",
-			properties,
-			...required.length > 0 && { required }
-		};
-	}
-	buildCreateSchema(model, options) {
-		const properties = {};
-		const required = [];
-		for (const field of model.fields) {
-			if (field.isGenerated || field.relationName) continue;
-			if (this.shouldSkipField(field, options)) continue;
-			properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-			if (field.isRequired && !field.hasDefaultValue) required.push(field.name);
-		}
-		return {
-			type: "object",
-			properties,
-			...required.length > 0 && { required }
-		};
-	}
-	buildUpdateSchema(model, options) {
-		const properties = {};
-		for (const field of model.fields) {
-			if (field.isGenerated || field.isId || field.relationName) continue;
-			if (this.shouldSkipField(field, options)) continue;
-			properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-		}
-		return {
-			type: "object",
-			properties
-		};
-	}
-	shouldSkipField(field, options) {
-		if (options?.excludeFields?.includes(field.name)) return true;
-		if (field.name.startsWith("_")) return true;
-		return false;
-	}
-	convertPrismaFieldToJsonSchema(field) {
-		const schema = {};
-		switch (field.type) {
-			case "String":
-				schema.type = "string";
-				break;
-			case "Int":
-			case "BigInt":
-				schema.type = "integer";
-				break;
-			case "Float":
-			case "Decimal":
-				schema.type = "number";
-				break;
-			case "Boolean":
-				schema.type = "boolean";
-				break;
-			case "DateTime":
-				schema.type = "string";
-				schema.format = "date-time";
-				break;
-			case "Json":
-				schema.type = "object";
-				break;
-			default: if (field.kind === "enum") {
-				schema.type = "string";
-				if (this.dmmf?.datamodel?.enums) {
-					const enumDef = this.dmmf.datamodel.enums.find((e) => e.name === field.type);
-					if (enumDef) schema.enum = enumDef.values.map((v) => v.name);
-				}
-			} else schema.type = "string";
-		}
-		if (field.isList) return {
-			type: "array",
-			items: schema
-		};
-		if (field.documentation) schema.description = field.documentation;
-		return schema;
-	}
-	convertPrismaFieldToMetadata(field) {
-		const metadata = {
-			type: this.mapPrismaTypeToMetadataType(field.type, field.kind),
-			required: field.isRequired,
-			array: field.isList
-		};
-		if (field.isUnique) metadata.unique = true;
-		if (field.hasDefaultValue) metadata.default = field.default;
-		if (field.documentation) metadata.description = field.documentation;
-		if (field.relationName) metadata.ref = field.type;
-		return metadata;
-	}
-	mapPrismaTypeToMetadataType(type, kind) {
-		if (kind === "enum") return "enum";
-		switch (type) {
-			case "String": return "string";
-			case "Int":
-			case "BigInt":
-			case "Float":
-			case "Decimal": return "number";
-			case "Boolean": return "boolean";
-			case "DateTime": return "date";
-			case "Json": return "object";
-			default: return "string";
-		}
-	}
-};
-/**
-* Factory function to create Prisma adapter
-*
-* @example
-* import { PrismaClient } from '@prisma/client';
-* import { createPrismaAdapter } from '@classytic/arc';
-*
-* const prisma = new PrismaClient();
-*
-* const userAdapter = createPrismaAdapter({
-*   client: prisma,
-*   modelName: 'user',
-*   repository: userRepository,
-*   dmmf: Prisma.dmmf, // Optional: for schema generation
-* });
-*/
-function createPrismaAdapter(options) {
-	return new PrismaAdapter(options);
-}
-//#endregion
-export { createMongooseAdapter as a, MongooseAdapter as i, PrismaQueryParser as n, DrizzleAdapter as o, createPrismaAdapter as r, createDrizzleAdapter as s, PrismaAdapter as t };