pecunia-cli 0.1.8 → 0.2.0

package/dist/generators-DjXYs9VN.mjs

@@ -0,0 +1,1268 @@
+import fs, { existsSync } from "node:fs";
+import fs$1 from "node:fs/promises";
+import path from "node:path";
+import { getMigrations, getPaymentTables } from "pecunia-root";
+import { capitalizeFirstLetter, getPaymentTables as getPaymentTables$1, initGetFieldName, initGetModelName } from "pecunia-core";
+import prettier from "prettier";
+import { produceSchema } from "@mrleebo/prisma-ast";
+
+//#region src/generators/invariants.ts
+/**
+* Normalize invariants from schema into IR format.
+* This parses invariant descriptions and extracts structured logic.
+*/
+function normalizeInvariants(schema, options) {
+	const invariants = [];
+	for (const [tableKey, table] of Object.entries(schema)) {
+		if (!table.invariants) continue;
+		const modelName = options.getModelName(tableKey);
+		const tableName = table.modelName;
+		for (const invariant of table.invariants) {
+			const logic = parseInvariantLogic(invariant.description, tableKey, table, schema, options);
+			invariants.push({
+				id: invariant.id,
+				description: invariant.description,
+				modelName,
+				tableName,
+				appliesTo: invariant.appliesTo,
+				enforcement: invariant.enforcement || {},
+				logic
+			});
+		}
+	}
+	return invariants;
+}
+/**
+* Parse invariant description into structured logic.
+* This is a heuristic parser that extracts common patterns.
+*/
+function parseInvariantLogic(description, tableKey, table, schema, options) {
+	const desc = description.toLowerCase();
+	if (desc.includes("determines") && desc.includes("presence")) {
+		const modeMatch = description.match(/(\w+)\.(\w+)\s+determines/);
+		const subMatch = description.match(/(\w+)\s+must be (present|null\/absent)/);
+		const enumMatches = description.matchAll(/(\w+)\s*=>\s*(\w+)\s+must be (present|null\/absent)/g);
+		if (modeMatch && subMatch) {
+			const [, modelName, fieldName] = modeMatch;
+			const [, conditionalField] = subMatch;
+			const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+			const conditional = Object.keys(table.fields).find((k) => k.toLowerCase() === conditionalField.toLowerCase());
+			if (field && conditional) {
+				const fieldAttr = table.fields[field];
+				let allowedValues = [];
+				if (typeof fieldAttr.type !== "string" && Array.isArray(fieldAttr.type) && fieldAttr.type.every((x) => typeof x === "string")) allowedValues = fieldAttr.type;
+				else {
+					const enumValues = /* @__PURE__ */ new Set();
+					for (const match of enumMatches) {
+						const val = match[1]?.trim();
+						if (val) enumValues.add(val);
+					}
+					if (enumValues.size > 0) allowedValues = Array.from(enumValues);
+					else allowedValues = ["PAYMENT", "SUBSCRIPTION"].filter((e) => desc.includes(e.toLowerCase()));
+				}
+				let whenPresent = false;
+				for (const match of enumMatches) {
+					const enumVal = match[1];
+					const requirement = match[3];
+					if (enumVal && requirement === "present") {
+						whenPresent = true;
+						break;
+					}
+				}
+				if (!whenPresent && desc.includes("subscription") && desc.includes("must be present")) whenPresent = true;
+				return {
+					type: "field_enum_constraint",
+					field,
+					fieldName: options.getFieldName({
+						model: tableKey,
+						field
+					}),
+					allowedValues: allowedValues.length > 0 ? allowedValues : ["PAYMENT", "SUBSCRIPTION"],
+					conditionalField: {
+						field: conditional,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field: conditional
+						}),
+						whenPresent
+					}
+				};
+			}
+		}
+	}
+	if (desc.includes("must belong to same") || desc.includes("must equal") && desc.includes("when")) {
+		const fieldMatch = description.match(/(\w+)\.(\w+)\s+must/);
+		const refMatch = description.match(/(\w+)\.(\w+)\s+must equal\s+(\w+)\.(\w+)/);
+		description.match(/(\w+)\.(\w+)\s+must equal/);
+		if (fieldMatch && refMatch) {
+			const [, modelName, fieldName] = fieldMatch;
+			const [, refTable, refField, ownerTable, ownerField] = refMatch;
+			const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+			if (field && table.fields[field]?.references) {
+				table.fields[field].references;
+				const refTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === refTable || k === refTable);
+				const ownerTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === ownerTable || k === ownerTable);
+				if (refTableKey && ownerTableKey) {
+					const ownershipField = Object.keys(table.fields).find((k) => k.toLowerCase() === ownerField.toLowerCase());
+					if (ownershipField) return {
+						type: "cross_table_ownership",
+						field,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field
+						}),
+						referencedTable: options.getModelName(refTableKey),
+						referencedField: options.getFieldName({
+							model: refTableKey,
+							field: refField
+						}),
+						ownershipField,
+						ownershipFieldName: options.getFieldName({
+							model: tableKey,
+							field: ownershipField
+						})
+					};
+				}
+			}
+		}
+	}
+	if (desc.includes("must match") && desc.includes("of its")) {
+		const fieldMatch = description.match(/(\w+)\.(\w+)\s+must match/);
+		const refMatch = description.match(/of its\s+(\w+)/);
+		const equalityMatch = description.match(/(\w+)\.(\w+)\s+must equal\s+(\w+)\.(\w+)/);
+		if (fieldMatch && refMatch && equalityMatch) {
+			const [, , equalityFieldName] = fieldMatch;
+			const [, refFieldName] = refMatch;
+			const [, refTable, refEqualityField, , sourceEqualityField] = equalityMatch;
+			const equalityField = Object.keys(table.fields).find((k) => k.toLowerCase() === equalityFieldName.toLowerCase());
+			const refField = Object.keys(table.fields).find((k) => k.toLowerCase() === refFieldName.toLowerCase());
+			if (equalityField && refField && table.fields[refField]?.references) {
+				const ref = table.fields[refField].references;
+				const refTableKey = Object.keys(schema).find((k) => schema[k]?.modelName === refTable || k === refTable);
+				if (refTableKey) {
+					const refEquality = Object.keys(schema[refTableKey].fields).find((k) => k.toLowerCase() === refEqualityField.toLowerCase());
+					if (refEquality) return {
+						type: "cross_table_equality",
+						field: refField,
+						fieldName: options.getFieldName({
+							model: tableKey,
+							field: refField
+						}),
+						referencedTable: options.getModelName(refTableKey),
+						referencedField: options.getFieldName({
+							model: refTableKey,
+							field: ref.field
+						}),
+						equalityField,
+						equalityFieldName: options.getFieldName({
+							model: tableKey,
+							field: equalityField
+						}),
+						referencedEqualityField: refEquality,
+						referencedEqualityFieldName: options.getFieldName({
+							model: refTableKey,
+							field: refEquality
+						})
+					};
+				}
+			}
+		}
+	}
+	return {
+		type: "raw",
+		description
+	};
+}
+
+//#endregion
+//#region src/generators/invariants-sql.ts
+/**
+* Generate SQL for enforcing invariants in Postgres (and compatible databases).
+* Returns SQL statements for CHECK constraints and triggers.
+*/
+function emitPostgresInvariantSql(invariants, schemaName = "public") {
+	const statements = [];
+	const checkInvariants = invariants.filter((inv) => inv.enforcement.postgres === "check" && inv.appliesTo.includes("postgres"));
+	const triggerInvariants = invariants.filter((inv) => inv.enforcement.postgres === "trigger" && inv.appliesTo.includes("postgres"));
+	for (const inv of checkInvariants) {
+		const sql = generateCheckConstraint(inv, schemaName);
+		if (sql) statements.push(sql);
+	}
+	for (const inv of triggerInvariants) {
+		const sql = generateTrigger(inv, schemaName);
+		if (sql) statements.push(...sql);
+	}
+	if (statements.length === 0) return "-- No invariant enforcement SQL generated\n";
+	return `-- Invariant enforcement SQL
+-- Generated from schema invariants
+-- DO NOT EDIT MANUALLY - This file is auto-generated
+
+${statements.join("\n\n")}
+`;
+}
+/**
+* Generate CHECK constraint SQL for an invariant.
+*/
+function generateCheckConstraint(inv, schemaName) {
+	const { logic, tableName, id } = inv;
+	switch (logic.type) {
+		case "field_enum_constraint": {
+			const { fieldName, allowedValues, conditionalField } = logic;
+			if (conditionalField) {
+				const constraintName$1 = `${tableName}_${id}_check`;
+				const enumCheck$1 = allowedValues.map((val) => `'${val}'`).join(", ");
+				const subscriptionValue = allowedValues.find((v) => v === "SUBSCRIPTION") || allowedValues.find((v) => v !== "PAYMENT") || allowedValues[0];
+				const paymentValue = allowedValues.find((v) => v === "PAYMENT") || allowedValues[0];
+				const conditionalCheck = `(
+  (${fieldName} = '${subscriptionValue}') = (${conditionalField.fieldName} IS NOT NULL) AND
+  (${fieldName} = '${paymentValue}') = (${conditionalField.fieldName} IS NULL)
+)`;
+				return `-- ${inv.description}
+ALTER TABLE ${schemaName}.${tableName}
+ADD CONSTRAINT ${constraintName$1}
+CHECK (
+  ${fieldName} IN (${enumCheck$1}) AND
+  ${conditionalCheck}
+);`;
+			}
+			const constraintName = `${tableName}_${id}_check`;
+			const enumCheck = allowedValues.map((val) => `'${val}'`).join(", ");
+			return `-- ${inv.description}
+ALTER TABLE ${schemaName}.${tableName}
+ADD CONSTRAINT ${constraintName}
+CHECK (${fieldName} IN (${enumCheck}));`;
+		}
+		default: return null;
+	}
+}
+/**
+* Generate trigger SQL for an invariant.
+* Returns array of SQL statements (function + trigger).
+*/
+function generateTrigger(inv, schemaName) {
+	const { logic, tableName, id } = inv;
+	switch (logic.type) {
+		case "cross_table_ownership": {
+			const { fieldName, referencedTable, referencedField, ownershipFieldName } = logic;
+			const functionName = `${tableName}_${id}_fn`;
+			const triggerName = `${tableName}_${id}_trigger`;
+			return [`-- Function to enforce: ${inv.description}
+CREATE OR REPLACE FUNCTION ${schemaName}.${functionName}()
+RETURNS TRIGGER AS $$
+BEGIN
+  IF NEW.${fieldName} IS NOT NULL THEN
+    IF NOT EXISTS (
+      SELECT 1
+      FROM ${schemaName}.${referencedTable}
+      WHERE ${referencedTable}.${referencedField} = NEW.${fieldName}
+        AND ${referencedTable}.${ownershipFieldName} = NEW.${ownershipFieldName}
+    ) THEN
+      RAISE EXCEPTION 'Invariant violation: % must belong to the same % as the record', '${fieldName}', '${ownershipFieldName}';
+    END IF;
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;`, `-- Trigger to enforce: ${inv.description}
+DROP TRIGGER IF EXISTS ${triggerName} ON ${schemaName}.${tableName};
+CREATE TRIGGER ${triggerName}
+  BEFORE INSERT OR UPDATE ON ${schemaName}.${tableName}
+  FOR EACH ROW
+  EXECUTE FUNCTION ${schemaName}.${functionName}();`];
+		}
+		case "cross_table_equality": {
+			const { fieldName, referencedTable, referencedField, equalityFieldName, referencedEqualityFieldName } = logic;
+			const functionName = `${tableName}_${id}_fn`;
+			const triggerName = `${tableName}_${id}_trigger`;
+			return [`-- Function to enforce: ${inv.description}
+CREATE OR REPLACE FUNCTION ${schemaName}.${functionName}()
+RETURNS TRIGGER AS $$
+DECLARE
+  ref_${referencedEqualityFieldName} TEXT;
+BEGIN
+  IF NEW.${fieldName} IS NOT NULL THEN
+    SELECT ${referencedEqualityFieldName} INTO ref_${referencedEqualityFieldName}
+    FROM ${schemaName}.${referencedTable}
+    WHERE ${referencedTable}.${referencedField} = NEW.${fieldName}
+    LIMIT 1;
+
+    IF ref_${referencedEqualityFieldName} IS NULL THEN
+      RAISE EXCEPTION 'Invariant violation: Referenced record not found in ${referencedTable}';
+    END IF;
+
+    IF NEW.${equalityFieldName} != ref_${referencedEqualityFieldName} THEN
+      RAISE EXCEPTION 'Invariant violation: % must equal %.%', '${equalityFieldName}', '${referencedTable}', '${referencedEqualityFieldName}';
+    END IF;
+  END IF;
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;`, `-- Trigger to enforce: ${inv.description}
+DROP TRIGGER IF EXISTS ${triggerName} ON ${schemaName}.${tableName};
+CREATE TRIGGER ${triggerName}
+  BEFORE INSERT OR UPDATE ON ${schemaName}.${tableName}
+  FOR EACH ROW
+  EXECUTE FUNCTION ${schemaName}.${functionName}();`];
+		}
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/generators/drizzle.ts
+function convertToSnakeCase(str, camelCase) {
+	if (camelCase) return str;
+	return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
+}
+const generateDrizzleSchema = async ({ options, file, adapter }) => {
+	const tables = getPaymentTables$1(options);
+	const filePath = file || "./payment-schema.ts";
+	const databaseType = adapter.options?.provider;
+	if (!databaseType) throw new Error("Database provider type is undefined during Drizzle schema generation. Please define a `provider` in the Drizzle adapter config.");
+	const fileExist = existsSync(filePath);
+	let code = generateImport({
+		databaseType,
+		tables,
+		options
+	});
+	const getModelName = initGetModelName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getFieldName = initGetFieldName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const tableNameMap = /* @__PURE__ */ new Map();
+	for (const tableKey in tables) tableNameMap.set(tableKey, getModelName(tableKey));
+	function getType(name, field, databaseType$1) {
+		name = convertToSnakeCase(name, adapter.options?.camelCase);
+		if (field.references?.field === "id") {
+			if (databaseType$1 === "mysql") return `varchar('${name}', { length: 36 })`;
+			return `text('${name}')`;
+		}
+		const type = field.type;
+		if (typeof type !== "string") {
+			if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
+				sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
+			}[databaseType$1];
+			throw new TypeError(`Invalid field type for field ${name}`);
+		}
+		const dbTypeMap = {
+			string: {
+				sqlite: `text('${name}')`,
+				pg: `text('${name}')`,
+				mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
+			},
+			boolean: {
+				sqlite: `integer('${name}', { mode: 'boolean' })`,
+				pg: `boolean('${name}')`,
+				mysql: `boolean('${name}')`
+			},
+			number: {
+				sqlite: `integer('${name}')`,
+				pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
+				mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
+			},
+			date: {
+				sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
+				pg: `timestamp('${name}')`,
+				mysql: `timestamp('${name}', { fsp: 3 })`
+			},
+			"number[]": {
+				sqlite: `text('${name}', { mode: "json" })`,
+				pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
+				mysql: `text('${name}', { mode: 'json' })`
+			},
+			"string[]": {
+				sqlite: `text('${name}', { mode: "json" })`,
+				pg: `text('${name}').array()`,
+				mysql: `text('${name}', { mode: "json" })`
+			},
+			json: {
+				sqlite: `text('${name}', { mode: "json" })`,
+				pg: `jsonb('${name}')`,
+				mysql: `json('${name}', { mode: "json" })`
+			},
+			uuid: {
+				sqlite: `text('${name}')`,
+				pg: `uuid('${name}')`,
+				mysql: `varchar('${name}', { length: 36 })`
+			}
+		}[type];
+		if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+		return dbTypeMap[databaseType$1];
+	}
+	const tableDefinitions = [];
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const modelName = getModelName(tableKey);
+		const fields = table.fields;
+		const idFieldType = table.fields.id?.type;
+		let id;
+		if (databaseType === "pg" && idFieldType === "uuid") id = `uuid('id').primaryKey()`;
+		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
+		else id = `text('id').primaryKey()`;
+		const indexes = [];
+		const references = [];
+		for (const field of Object.keys(fields)) {
+			if (field === "id") continue;
+			const attr = fields[field];
+			const fieldName = attr.fieldName || field;
+			if (attr.index && !attr.unique) indexes.push({
+				type: "index",
+				name: `${modelName}_${fieldName}_idx`,
+				on: fieldName
+			});
+			else if (attr.index && attr.unique) indexes.push({
+				type: "uniqueIndex",
+				name: `${modelName}_${fieldName}_uidx`,
+				on: fieldName
+			});
+			if (attr.references) {
+				const referencedModelName = tableNameMap.get(attr.references.model) || getModelName(attr.references.model);
+				references.push({
+					fieldName,
+					referencedTable: referencedModelName,
+					referencedField: getFieldName({
+						model: attr.references.model,
+						field: attr.references.field
+					}),
+					onDelete: attr.references.onDelete || "cascade",
+					required: attr.required || false,
+					originalModel: attr.references.model
+				});
+			}
+		}
+		tableDefinitions.push({
+			modelName,
+			tableKey,
+			fields,
+			id,
+			indexes,
+			references
+		});
+	}
+	const modelKeyToTableKey = /* @__PURE__ */ new Map();
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const modelName = getModelName(tableKey);
+		modelKeyToTableKey.set(tableKey, tableKey);
+		modelKeyToTableKey.set(modelName, tableKey);
+		modelKeyToTableKey.set(table.modelName, tableKey);
+	}
+	const referenceGraph = /* @__PURE__ */ new Map();
+	for (const tableDef of tableDefinitions) for (const ref of tableDef.references) {
+		const referencedTableKey = modelKeyToTableKey.get(ref.originalModel);
+		if (!referencedTableKey) continue;
+		const key = `${tableDef.tableKey}->${referencedTableKey}`;
+		referenceGraph.set(key, {
+			...ref,
+			sourceTable: tableDef.tableKey,
+			sourceModelName: tableDef.modelName
+		});
+	}
+	const skipReferences = /* @__PURE__ */ new Set();
+	for (const tableDef of tableDefinitions) for (const ref of tableDef.references) {
+		const referencedTableKey = modelKeyToTableKey.get(ref.originalModel);
+		if (!referencedTableKey) continue;
+		const reverseKey = `${referencedTableKey}->${tableDef.tableKey}`;
+		const reverseRef = referenceGraph.get(reverseKey);
+		if (reverseRef) {
+			if (!ref.required && ref.onDelete === "set null" && (reverseRef.required || reverseRef.onDelete !== "set null")) skipReferences.add(`${tableDef.tableKey}.${ref.fieldName}`);
+		}
+	}
+	for (const tableDef of tableDefinitions) {
+		const { modelName, fields, id, indexes, references } = tableDef;
+		const assignIndexes = (indexesToAssign) => {
+			if (!indexesToAssign.length) return "";
+			const parts = [`, (table) => [`];
+			for (const index of indexesToAssign) parts.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+			parts.push(`]`);
+			return parts.join("\n");
+		};
+		const referenceMap = /* @__PURE__ */ new Map();
+		for (const ref of references) referenceMap.set(ref.fieldName, ref);
+		const fieldDefinitions = Object.keys(fields).filter((field) => field !== "id").map((field) => {
+			const attr = fields[field];
+			const fieldName = attr.fieldName || field;
+			let type = getType(fieldName, attr, databaseType);
+			let comment = "";
+			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
+				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
+				else type += `.defaultNow()`;
+			} else if (typeof attr.defaultValue === "string") type += `.default("${attr.defaultValue}")`;
+			else type += `.default(${attr.defaultValue})`;
+			if (attr.onUpdate && attr.type === "date") {
+				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
+			}
+			const ref = referenceMap.get(fieldName);
+			const shouldSkipReference = skipReferences.has(`${tableDef.tableKey}.${fieldName}`);
+			let referenceChain = "";
+			if (ref && !shouldSkipReference) referenceChain = `.references(() => ${ref.referencedTable}.${ref.referencedField}, { onDelete: '${ref.onDelete}' })`;
+			else if (ref && shouldSkipReference) {
+				const reverseKey = `${ref.originalModel}->${tableDef.tableKey}`;
+				const reverseRef = referenceGraph.get(reverseKey);
+				if (reverseRef) comment = `\n					// FK constraint removed to break circular dependency with ${ref.referencedTable}\n					// Primary FK: ${reverseRef.sourceModelName}.${reverseRef.fieldName} -> ${modelName}.${fieldName}\n					// This field still maintains referential integrity via application logic and Drizzle relations`;
+				else comment = `\n					// FK constraint removed to break circular dependency with ${ref.referencedTable}\n					// This field still maintains referential integrity via application logic and Drizzle relations`;
+			}
+			const fieldDef = `${fieldName}: ${type}${attr.required ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${referenceChain}`;
+			return comment ? `${comment}\n					${fieldDef}` : fieldDef;
+		});
+		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+					id: ${id},
+					${fieldDefinitions.join(",\n ")}
+					}${assignIndexes(indexes)});`;
+		code += `\n${schema}\n`;
+	}
+	let relationsString = "";
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		const modelName = getModelName(tableKey);
+		const oneRelations = [];
+		const manyRelations = [];
+		if (table.relations) for (const [relationName, relationDef] of Object.entries(table.relations)) {
+			const referencedModelName = getModelName(relationDef.model);
+			const foreignKeyField = table.fields[relationDef.foreignKey];
+			if (relationDef.kind === "one") {
+				if (foreignKeyField?.references) {
+					const fieldRef = `${modelName}.${getFieldName({
+						model: tableKey,
+						field: relationDef.foreignKey
+					})}`;
+					const referenceRef = `${referencedModelName}.${getFieldName({
+						model: relationDef.model,
+						field: foreignKeyField.references.field || "id"
+					})}`;
+					oneRelations.push({
+						key: relationName,
+						model: referencedModelName,
+						type: "one",
+						reference: {
+							field: fieldRef,
+							references: referenceRef,
+							fieldName: relationDef.foreignKey
+						}
+					});
+				}
+			} else if (relationDef.kind === "many") {
+				const referencedTable = tables[relationDef.model];
+				if (referencedTable) {
+					const fkField = Object.entries(referencedTable.fields).find(([_, field]) => field.references && (field.references.model === tableKey || field.references.model === getModelName(tableKey)));
+					if (fkField) {
+						const [fkFieldName] = fkField;
+						const fieldRef = `${referencedModelName}.${getFieldName({
+							model: relationDef.model,
+							field: fkFieldName
+						})}`;
+						const referenceRef = `${modelName}.${getFieldName({
+							model: tableKey,
+							field: "id"
+						})}`;
+						manyRelations.push({
+							key: relationName,
+							model: referencedModelName,
+							type: "many",
+							reference: {
+								field: fieldRef,
+								references: referenceRef,
+								fieldName: fkFieldName
+							}
+						});
+					} else manyRelations.push({
+						key: relationName,
+						model: referencedModelName,
+						type: "many"
+					});
+				}
+			}
+		}
+		const relationsByModel = /* @__PURE__ */ new Map();
+		for (const relation of oneRelations) {
+			if (!relation.reference) continue;
+			const modelKey = relation.key;
+			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
+			relationsByModel.get(modelKey).push(relation);
+		}
+		const duplicateRelations = [];
+		const singleRelations = [];
+		for (const [_modelKey, rels] of relationsByModel.entries()) if (rels.length > 1) duplicateRelations.push(...rels);
+		else singleRelations.push(rels[0]);
+		for (const relation of duplicateRelations) {
+			if (!relation.reference) continue;
+			const fieldName = relation.reference.fieldName;
+			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${modelName}, ({ one }) => ({
+				${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		}
+		const hasOne = singleRelations.length > 0;
+		const hasMany = manyRelations.length > 0;
+		if (hasOne && hasMany) {
+			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one, many }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		} else if (hasOne) {
+			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})` : "").filter((x) => x !== "").join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		} else if (hasMany) {
+			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ many }) => ({
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		}
+	}
+	code += `\n${relationsString}`;
+	const typeHints = generateInvariantTypeHints(tables, getModelName, getFieldName);
+	if (typeHints) code += `\n\n${typeHints}`;
+	const formattedCode = await prettier.format(code, { parser: "typescript" });
+	if (databaseType === "pg") {
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables, {
+			getModelName,
+			getFieldName
+		}), "public");
+		const sqlFilePath = filePath.replace(/\.ts$/, "-invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
+	return {
+		code: formattedCode,
+		fileName: filePath,
+		overwrite: fileExist
+	};
+};
+/**
+* Generate TypeScript type hints for invariants (e.g., enum unions).
+*/
+function generateInvariantTypeHints(tables, getModelName, getFieldName) {
+	const hints = [];
+	for (const [tableKey, table] of Object.entries(tables)) {
+		if (!table.invariants) continue;
+		for (const invariant of table.invariants) {
+			const desc = invariant.description.toLowerCase();
+			if (desc.includes("determines") && desc.includes("presence")) {
+				const modeMatch = invariant.description.match(/(\w+)\.(\w+)\s+determines/);
+				if (modeMatch) {
+					const [, , fieldName] = modeMatch;
+					const field = Object.keys(table.fields).find((k) => k.toLowerCase() === fieldName.toLowerCase());
+					if (field) {
+						const fieldAttr = table.fields[field];
+						if (typeof fieldAttr.type !== "string" && Array.isArray(fieldAttr.type) && fieldAttr.type.every((x) => typeof x === "string")) {
+							const enumName = `${getModelName(tableKey)}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Mode`;
+							const enumValues = fieldAttr.type.map((v) => `"${v}"`).join(" | ");
+							hints.push(`// Type hint for invariant: ${invariant.id}`);
+							hints.push(`export type ${enumName} = ${enumValues};`);
+						}
+					}
+				}
+			}
+		}
+	}
+	return hints.length > 0 ? `\n// Invariant type hints\n${hints.join("\n")}` : "";
+}
+function generateImport({ databaseType, tables }) {
+	const rootImports = ["relations"];
+	const coreImports = [];
+	let hasBigint = false;
+	let hasJson = false;
+	let hasUuid = false;
+	for (const table of Object.values(tables)) {
+		for (const field of Object.values(table.fields)) {
+			if (field.bigint) hasBigint = true;
+			if (field.type === "json") hasJson = true;
+			if (field.type === "uuid") hasUuid = true;
+		}
+		if (hasJson && hasBigint && hasUuid) break;
+	}
+	coreImports.push(`${databaseType}Table`);
+	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
+	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
+	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
+	if (databaseType === "mysql") {
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("int");
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
+	} else if (databaseType === "pg") {
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint))) coreImports.push("integer");
+		if (hasUuid) coreImports.push("uuid");
+	} else coreImports.push("integer");
+	if (hasJson) {
+		if (databaseType === "pg") coreImports.push("jsonb");
+		if (databaseType === "mysql") coreImports.push("json");
+	}
+	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
+	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
+	if (hasIndexes) coreImports.push("index");
+	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
+	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
+}
+
+//#endregion
+//#region src/generators/kysely.ts
+const generateKyselySchema = async ({ options, file, adapter }) => {
+	const { compileMigrations } = await getMigrations(options);
+	const migrations = await compileMigrations();
+	const migrationFile = file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`;
+	if ((adapter?.options?.type || "postgres") === "postgres") {
+		const tables = getPaymentTables(options);
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables, {
+			getModelName: initGetModelName({
+				schema: tables,
+				usePlural: adapter?.options?.adapterConfig?.usePlural
+			}),
+			getFieldName: initGetFieldName({
+				schema: tables,
+				usePlural: false
+			})
+		}), "public");
+		const sqlFilePath = path.join(path.dirname(migrationFile), "invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
+	return {
+		code: migrations.trim() === ";" ? "" : migrations,
+		fileName: migrationFile
+	};
+};
+
+//#endregion
+//#region src/utils/get-package-info.ts
+function getPackageInfo(cwd) {
+	const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
+	return JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+}
+function getPrismaVersion(cwd) {
+	try {
+		const packageInfo = getPackageInfo(cwd);
+		const prismaVersion = packageInfo.dependencies?.prisma || packageInfo.devDependencies?.prisma || packageInfo.dependencies?.["@prisma/client"] || packageInfo.devDependencies?.["@prisma/client"];
+		if (!prismaVersion) return null;
+		const match = prismaVersion.match(/(\d+)/);
+		return match ? parseInt(match[1], 10) : null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/generators/prisma.ts
+const generatePrismaSchema = async ({ adapter, options, file }) => {
+	const provider = adapter.options?.provider || "postgresql";
+	const tables = getPaymentTables$1(options);
+	const filePath = file || "./prisma/schema.prisma";
+	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+	const getModelName = initGetModelName({
+		schema: getPaymentTables$1(options),
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getFieldName = initGetFieldName({
+		schema: getPaymentTables$1(options),
+		usePlural: false
+	});
+	let schemaPrisma = "";
+	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
+	else schemaPrisma = getNewPrisma(provider, process.cwd());
+	const prismaVersion = getPrismaVersion(process.cwd());
+	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
+		const generator = builder.findByType("generator", { name: "client" });
+		if (generator && generator.properties) {
+			const providerProp = generator.properties.find((prop) => prop.type === "assignment" && prop.key === "provider");
+			if (providerProp && providerProp.value === "\"prisma-client-js\"") providerProp.value = "\"prisma-client\"";
+		}
+	});
+	const manyToManyRelations = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		const fields = tables[table]?.fields;
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.references) {
+				const referencedOriginalModel = attr.references.model;
+				const referencedModelNameCap = capitalizeFirstLetter(getModelName(tables[referencedOriginalModel]?.modelName || referencedOriginalModel));
+				if (!manyToManyRelations.has(referencedModelNameCap)) manyToManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
+				const currentModelNameCap = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
+				manyToManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
+			}
+		}
+	}
+	const indexedFields = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		const fields = tables[table]?.fields;
+		const modelName = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
+		indexedFields.set(modelName, []);
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.index && !attr.unique) {
+				const fieldName = attr.fieldName || field;
+				indexedFields.get(modelName).push(fieldName);
+			}
+		}
+	}
+	const schema = produceSchema(schemaPrisma, (builder) => {
+		for (const table in tables) {
+			const originalTableName = table;
+			const customModelName = tables[table]?.modelName || table;
+			const modelName = capitalizeFirstLetter(getModelName(customModelName));
+			const fields = tables[table]?.fields;
+			function getType({ isBigint, isOptional, type }) {
+				if (type === "string") return isOptional ? "String?" : "String";
+				if (type === "number" && isBigint) return isOptional ? "BigInt?" : "BigInt";
+				if (type === "number") return isOptional ? "Int?" : "Int";
+				if (type === "boolean") return isOptional ? "Boolean?" : "Boolean";
+				if (type === "date") return isOptional ? "DateTime?" : "DateTime";
+				if (type === "json") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return isOptional ? "Json?" : "Json";
+				}
+				if (type === "string[]") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return "String[]";
+				}
+				if (type === "number[]") {
+					if (provider === "sqlite" || provider === "mysql") return "String";
+					return "Int[]";
+				}
+			}
+			const prismaModel = builder.findByType("model", { name: modelName });
+			if (!prismaModel) builder.model(modelName).field("id", "String").attribute("id");
+			for (const field in fields) {
+				const attr = fields[field];
+				const fieldName = attr.fieldName || field;
+				if (prismaModel) {
+					if (builder.findByType("field", {
+						name: fieldName,
+						within: prismaModel.properties
+					})) continue;
+				}
+				const fieldBuilder = builder.model(modelName).field(fieldName, getType({
+					isBigint: attr?.bigint || false,
+					isOptional: !attr?.required,
+					type: "string"
+				}));
+				if (field === "id") fieldBuilder.attribute("id");
+				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+				if (attr.defaultValue !== void 0) {
+					if (Array.isArray(attr.defaultValue)) {
+						if (attr.type === "json") {
+							if (Object.prototype.toString.call(attr.defaultValue[0]) === "[object Object]") {
+								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+								continue;
+							}
+							let jsonArray = [];
+							for (const value of attr.defaultValue) jsonArray.push(value);
+							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
+							continue;
+						}
+						if (attr.defaultValue.length === 0) {
+							fieldBuilder.attribute(`default([])`);
+							continue;
+						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
+							let valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						} else if (typeof attr.defaultValue[0] === "number") {
+							let valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(`${value}`);
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						}
+					} else if (typeof attr.defaultValue === "object" && !Array.isArray(attr.defaultValue) && attr.defaultValue !== null) {
+						if (Object.entries(attr.defaultValue).length === 0) {
+							fieldBuilder.attribute(`default("{}")`);
+							continue;
+						}
+						fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+					}
+					if (field === "createdAt") fieldBuilder.attribute("default(now())");
+					else if (typeof attr.defaultValue === "string" && provider !== "mysql") fieldBuilder.attribute(`default("${attr.defaultValue}")`);
+					else if (typeof attr.defaultValue === "boolean" || typeof attr.defaultValue === "number") fieldBuilder.attribute(`default(${attr.defaultValue})`);
+					else if (typeof attr.defaultValue === "function") {}
+				}
+				if (field === "updatedAt" && attr.onUpdate) fieldBuilder.attribute("updatedAt");
+				else if (attr.onUpdate) {}
+				if (attr.references) {
+					const referencedOriginalModelName = getModelName(attr.references.model);
+					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
+					let action = "Cascade";
+					if (attr.references.onDelete === "no action") action = "NoAction";
+					else if (attr.references.onDelete === "set null") action = "SetNull";
+					else if (attr.references.onDelete === "set default") action = "SetDefault";
+					else if (attr.references.onDelete === "restrict") action = "Restrict";
+					const relationField = `relation(fields: [${getFieldName({
+						model: originalTableName,
+						field: fieldName
+					})}], references: [${getFieldName({
+						model: attr.references.model,
+						field: attr.references.field
+					})}], onDelete: ${action})`;
+					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${!attr.required ? "?" : ""}`).attribute(relationField);
+				}
+				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
+			}
+			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
+				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);
+				const relatedFields = relatedTableName ? tables[relatedTableName]?.fields : {};
+				const [_fieldKey, fkFieldAttr] = Object.entries(relatedFields || {}).find(([_fieldName, fieldAttr]) => fieldAttr.references && getModelName(fieldAttr.references.model) === getModelName(originalTableName)) || [];
+				const isUnique = fkFieldAttr?.unique === true;
+				const fieldName = isUnique || adapter.options?.usePlural === true ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
+				if (!builder.findByType("field", {
+					name: fieldName,
+					within: prismaModel?.properties
+				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
+			}
+			const indexedFieldsForModel = indexedFields.get(modelName);
+			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {
+				if (prismaModel) {
+					if (prismaModel.properties.some((v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args[0]?.value).includes(fieldName))) continue;
+				}
+				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
+				let indexField = fieldName;
+				if (provider === "mysql" && field && field.type === "string") indexField = `${fieldName}(length: 191)`;
+				builder.model(modelName).blockAttribute(`index([${indexField}])`);
+			}
+			const hasAttribute = builder.findByType("attribute", {
+				name: "map",
+				within: prismaModel?.properties
+			});
+			const hasChanged = customModelName !== originalTableName;
+			if (!hasAttribute) builder.model(modelName).blockAttribute("map", `${getModelName(hasChanged ? customModelName : originalTableName)}`);
+		}
+	});
+	const schemaChanged = schema.trim() !== schemaPrisma.trim();
+	if (provider === "postgresql") {
+		const tables$1 = getPaymentTables$1(options);
+		const sql = emitPostgresInvariantSql(normalizeInvariants(tables$1, {
+			getModelName: initGetModelName({
+				schema: tables$1,
+				usePlural: adapter.options?.adapterConfig?.usePlural
+			}),
+			getFieldName: initGetFieldName({
+				schema: tables$1,
+				usePlural: false
+			})
+		}), "public");
+		const sqlFilePath = path.join(path.dirname(filePath), "invariants.sql");
+		const sqlDir = path.dirname(path.resolve(process.cwd(), sqlFilePath));
+		await fs$1.mkdir(sqlDir, { recursive: true });
+		await fs$1.writeFile(path.resolve(process.cwd(), sqlFilePath), sql);
+		console.log(`📝 Generated invariant SQL: ${sqlFilePath}`);
+	}
+	return {
+		code: schemaChanged ? schema : "",
+		fileName: filePath,
+		overwrite: schemaPrismaExist && schemaChanged
+	};
+};
+const getNewPrisma = (provider, cwd) => {
+	const prismaVersion = getPrismaVersion(cwd);
+	return `generator client {
+    provider = "${prismaVersion && prismaVersion >= 7 ? "prisma-client" : "prisma-client-js"}"
+  }
+
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;
+};
+
+//#endregion
+//#region src/generators/invariants-mongo.ts
+/**
+* Generate MongoDB collection validator JSON schema for invariants.
+*/
+function emitMongoValidators(invariants) {
+	const validators = {};
+	for (const inv of invariants) {
+		if (inv.enforcement.mongo !== "validator" || !inv.appliesTo.includes("mongo")) continue;
+		const collectionName = inv.tableName;
+		if (!validators[collectionName]) validators[collectionName] = { $jsonSchema: {
+			bsonType: "object",
+			required: [],
+			properties: {},
+			additionalProperties: true
+		} };
+		const validator = generateMongoValidator(inv);
+		if (validator) {
+			Object.assign(validators[collectionName].$jsonSchema.properties, validator.properties || {});
+			if (validator.required) validators[collectionName].$jsonSchema.required = [...validators[collectionName].$jsonSchema.required || [], ...validator.required];
+			if (validator.anyOf) {
+				if (!validators[collectionName].$jsonSchema.anyOf) validators[collectionName].$jsonSchema.anyOf = [];
+				validators[collectionName].$jsonSchema.anyOf.push(...validator.anyOf);
+			}
+		}
+	}
+	return validators;
+}
+/**
+* Generate MongoDB validator JSON schema for a single invariant.
+*/
+function generateMongoValidator(inv) {
+	const { logic } = inv;
+	switch (logic.type) {
+		case "field_enum_constraint": {
+			const { fieldName, allowedValues, conditionalField } = logic;
+			if (conditionalField) {
+				const anyOf = [];
+				if (!conditionalField.whenPresent) anyOf.push({ properties: {
+					[fieldName]: { enum: ["PAYMENT"] },
+					[conditionalField.fieldName]: { bsonType: "null" }
+				} });
+				if (conditionalField.whenPresent) anyOf.push({
+					properties: {
+						[fieldName]: { enum: ["SUBSCRIPTION"] },
+						[conditionalField.fieldName]: { bsonType: "string" }
+					},
+					required: [conditionalField.fieldName]
+				});
+				return {
+					properties: { [fieldName]: { enum: allowedValues } },
+					anyOf
+				};
+			}
+			return { properties: { [fieldName]: { enum: allowedValues } } };
+		}
+		default: return null;
+	}
+}
+/**
+* Generate TypeScript guard module for MongoDB "app" enforcement invariants.
+*/
+function emitMongoGuards(invariants) {
+	const guardInvariants = invariants.filter((inv) => inv.enforcement.mongo === "app" && inv.appliesTo.includes("mongo"));
+	if (guardInvariants.length === 0) return `// No MongoDB app-level invariant guards generated
+// This file is auto-generated - DO NOT EDIT MANUALLY
+
+export {};
+`;
+	const guards = [];
+	const imports = [];
+	for (const inv of guardInvariants) {
+		const guard = generateMongoGuard(inv);
+		if (guard) {
+			guards.push(guard);
+			if (guard.imports) imports.push(...guard.imports);
+		}
+	}
+	const uniqueImports = Array.from(new Set(imports));
+	return `// MongoDB invariant guards
+// Generated from schema invariants
+// DO NOT EDIT MANUALLY - This file is auto-generated
+// 
+// These guards should be called before write operations to enforce invariants
+// at the application level.
+
+${uniqueImports.length > 0 ? uniqueImports.join("\n") + "\n" : ""}
+
+${guards.join("\n\n")}
+`;
+}
+/**
+* Generate TypeScript guard function for a single invariant.
+*/
+function generateMongoGuard(inv) {
+	const { logic, tableName, id, description } = inv;
+	switch (logic.type) {
+		case "cross_table_ownership": {
+			const { fieldName, referencedTable, referencedField, ownershipFieldName } = logic;
+			return { code: `/**
+ * Guard: ${description}
+ * 
+ * @param data - The record being created/updated (use camelCase field names)
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: { ${fieldName}?: string | null; ${ownershipFieldName}: string },
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  if (!data.${fieldName}) {
+    return true; // Field is optional/nullable
+  }
+
+  const referenced = await db.collection("${referencedTable}").findOne({
+    ${referencedField}: data.${fieldName}
+  });
+
+  if (!referenced) {
+    throw new Error(\`Invariant violation: \${data.${fieldName}} not found in ${referencedTable}\`);
+  }
+
+  // Compare ownership field (use database field name for referenced record)
+  const dataOwnerValue = data.${ownershipFieldName};
+  const refOwnerValue = referenced.${ownershipFieldName};
+  
+  if (refOwnerValue !== dataOwnerValue) {
+    throw new Error(
+      \`Invariant violation: ${fieldName} must belong to the same ${ownershipFieldName} as the record. \` +
+      \`Expected \${dataOwnerValue}, got \${refOwnerValue}\`
+    );
+  }
+
+  return true;
+}` };
+		}
+		case "cross_table_equality": {
+			const { fieldName, referencedTable, referencedField, equalityFieldName, referencedEqualityFieldName } = logic;
+			return { code: `/**
+ * Guard: ${description}
+ * 
+ * @param data - The record being created/updated
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: { ${fieldName}: string; ${equalityFieldName}: string },
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  if (!data.${fieldName}) {
+    throw new Error(\`Invariant violation: ${fieldName} is required\`);
+  }
+
+  const referenced = await db.collection("${referencedTable}").findOne({
+    ${referencedField}: data.${fieldName}
+  });
+
+  if (!referenced) {
+    throw new Error(\`Invariant violation: Referenced record not found in ${referencedTable}\`);
+  }
+
+  if (referenced.${referencedEqualityFieldName} !== data.${equalityFieldName}) {
+    throw new Error(
+      \`Invariant violation: ${equalityFieldName} must equal ${referencedTable}.${referencedEqualityFieldName}. \` +
+      \`Expected \${referenced.${referencedEqualityFieldName}}, got \${data.${equalityFieldName}}\`
+    );
+  }
+
+  return true;
+}` };
+		}
+		case "raw": return { code: `/**
+ * Guard: ${description}
+ * 
+ * TODO: Implement this guard based on the invariant description.
+ * This is a placeholder - you must implement the actual validation logic.
+ * 
+ * @param data - The record being created/updated
+ * @param db - MongoDB database instance
+ * @returns true if invariant is satisfied, throws error otherwise
+ */
+export async function ${id}Guard(
+  data: any,
+  db: { collection(name: string): { findOne(filter: any): Promise<any | null> } }
+): Promise<boolean> {
+  // TODO: Implement invariant: ${description}
+  console.warn("Guard ${id}Guard is not yet implemented");
+  return true;
+}` };
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/generators/mongodb.ts
+const generateMongoDBSchema = async ({ options, file, adapter }) => {
+	const tables = getPaymentTables$1(options);
+	const filePath = file || "./mongodb-schema.ts";
+	const invariants = normalizeInvariants(tables, {
+		getModelName: initGetModelName({
+			schema: tables,
+			usePlural: adapter?.options?.adapterConfig?.usePlural
+		}),
+		getFieldName: initGetFieldName({
+			schema: tables,
+			usePlural: false
+		})
+	});
+	const validators = emitMongoValidators(invariants);
+	const validatorsJson = JSON.stringify(validators, null, 2);
+	const guards = emitMongoGuards(invariants);
+	const validatorsPath = filePath.replace(/\.ts$/, "-validators.json");
+	const validatorsDir = path.dirname(path.resolve(process.cwd(), validatorsPath));
+	await fs$1.mkdir(validatorsDir, { recursive: true });
+	await fs$1.writeFile(path.resolve(process.cwd(), validatorsPath), validatorsJson);
+	console.log(`📝 Generated MongoDB validators: ${validatorsPath}`);
+	const guardsPath = filePath.replace(/\.ts$/, "-guards.ts");
+	const guardsDir = path.dirname(path.resolve(process.cwd(), guardsPath));
+	await fs$1.mkdir(guardsDir, { recursive: true });
+	const formattedGuards = await prettier.format(guards, { parser: "typescript" });
+	await fs$1.writeFile(path.resolve(process.cwd(), guardsPath), formattedGuards);
+	console.log(`📝 Generated MongoDB guards: ${guardsPath}`);
+	const validatorsBaseName = path.basename(validatorsPath, ".json");
+	const guardsBaseName = path.basename(guardsPath, ".ts");
+	const schemaCode = `// MongoDB schema setup
+// Generated from schema definitions
+// DO NOT EDIT MANUALLY - This file is auto-generated
+
+import validators from "./${validatorsBaseName}.json";
+import * as guards from "./${guardsBaseName}";
+
+/**
+ * MongoDB collection validators.
+ * Apply these using db.createCollection() or db.command({ collMod: ... })
+ * 
+ * Example:
+ * \`\`\`
+ * await db.createCollection("checkout_session", {
+ *   validator: validators.checkout_session
+ * });
+ * \`\`\`
+ */
+export { validators };
+
+/**
+ * MongoDB invariant guards.
+ * Call these before write operations to enforce invariants at the application level.
+ * 
+ * Example:
+ * \`\`\`
+ * import { customer_payment_method_ownershipGuard } from "./${guardsBaseName}";
+ * 
+ * await customer_payment_method_ownershipGuard(data, db);
+ * await db.collection("customer").insertOne(data);
+ * \`\`\`
+ */
+export { guards };
+`;
+	return {
+		code: await prettier.format(schemaCode, { parser: "typescript" }),
+		fileName: filePath,
+		overwrite: true
+	};
+};
+
+//#endregion
+//#region src/generators/index.ts
+const adapters = {
+	prisma: generatePrismaSchema,
+	drizzle: generateDrizzleSchema,
+	kysely: generateKyselySchema,
+	mongodb: generateMongoDBSchema
+};
+const generateSchema = async (opts) => {
+	const adapter = opts.adapter;
+	const generator = adapter.id in adapters ? adapters[adapter.id] : null;
+	if (generator) return generator(opts);
+	if (adapter.createSchema) return adapter.createSchema(opts.options, opts.file).then(({ code, path: fileName, overwrite }) => ({
+		code,
+		fileName,
+		overwrite
+	}));
+	throw new Error(`${adapter.id} is not supported. If it is a custom adapter, please request the maintainer to implement createSchema`);
+};
+
+//#endregion
+export { generateKyselySchema as a, getPackageInfo as i, generateSchema as n, generateDrizzleSchema as o, generatePrismaSchema as r, adapters as t };