@classytic/arc 1.1.0 → 2.1.2

package/dist/prisma-DJbMt3yf.mjs

@@ -0,0 +1,628 @@
+import { h as SYSTEM_FIELDS, i as DEFAULT_MAX_LIMIT, m as RESERVED_QUERY_PARAMS, r as DEFAULT_LIMIT } from "./constants-DdXFXQtN.mjs";
+
+//#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/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 CrudRepository 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) {
+		try {
+			if (this.schemaGenerator) return this.schemaGenerator(this.model, schemaOptions);
+			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));
+			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);
+				if (typeInfo.isRequired) required.push(fieldName);
+			}
+			const systemFieldSet = new Set(SYSTEM_FIELDS);
+			const inputProperties = Object.fromEntries(Object.entries(properties).filter(([field]) => !systemFieldSet.has(field)));
+			const inputRequired = required.filter((field) => !systemFieldSet.has(field));
+			return {
+				createBody: {
+					type: "object",
+					properties: inputProperties,
+					required: inputRequired.length > 0 ? inputRequired : void 0
+				},
+				updateBody: {
+					type: "object",
+					properties: inputProperties
+				},
+				response: {
+					type: "object",
+					properties
+				}
+			};
+		} 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";
+				baseType.format = "date-time";
+				break;
+			case "ObjectID":
+			case "ObjectId":
+				baseType.type = "string";
+				baseType.pattern = "^[a-f\\d]{24}$";
+				break;
+			case "Array":
+				baseType.type = "array";
+				baseType.items = { type: "string" };
+				break;
+			default: baseType.type = "object";
+		}
+		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 ?? DEFAULT_MAX_LIMIT;
+		this.defaultLimit = options.defaultLimit ?? DEFAULT_LIMIT;
+		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, createPrismaAdapter as r, PrismaAdapter as t };
+//# sourceMappingURL=prisma-DJbMt3yf.mjs.map