pecunia-cli 0.2.8 → 0.3.0

package/dist/generators-BXA4y5O8.mjs

@@ -1,1542 +0,0 @@
-import fs, { existsSync, statSync } 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/utils/drizzle-migrations.ts
-/**
-* Find or create the Drizzle migrations directory.
-* Never places migrations under src/ to avoid drizzle-kit crashes.
-* 
-* @param projectRoot - The project root directory (where package.json typically lives)
-* @returns The path to the drizzle migrations directory
-*/
-async function getDrizzleMigrationsDir(projectRoot) {
-	const drizzleDir = path.resolve(projectRoot, "drizzle");
-	if (existsSync(drizzleDir)) {
-		if (!statSync(drizzleDir).isDirectory()) throw new Error(`"drizzle" exists but is not a directory. Please remove it or rename it.`);
-		return drizzleDir;
-	}
-	await fs$1.mkdir(drizzleDir, { recursive: true });
-	return drizzleDir;
-}
-/**
-* Get the path to the Drizzle meta directory.
-*/
-function getDrizzleMetaDir(projectRoot) {
-	return path.resolve(projectRoot, "drizzle", "meta");
-}
-/**
-* Get the path to the Drizzle journal file.
-*/
-function getJournalPath(projectRoot) {
-	return path.resolve(projectRoot, "drizzle", "meta", "_journal.json");
-}
-/**
-* Read the Drizzle journal file, or return null if it doesn't exist.
-*/
-async function readJournal(projectRoot) {
-	const journalPath = getJournalPath(projectRoot);
-	if (!existsSync(journalPath)) return null;
-	const content = await fs$1.readFile(journalPath, "utf-8");
-	return JSON.parse(content);
-}
-/**
-* Write the Drizzle journal file with stable JSON formatting (2-space indent).
-*/
-async function writeJournal(projectRoot, journal) {
-	const journalPath = getJournalPath(projectRoot);
-	await fs$1.writeFile(journalPath, JSON.stringify(journal, null, 2) + "\n", "utf-8");
-}
-/**
-* Ensure the Drizzle journal exists. If it doesn't exist, create it with a baseline init migration.
-* 
-* @param projectRoot - The project root directory
-* @returns true if journal was created, false if it already existed
-*/
-async function ensureDrizzleJournal(projectRoot) {
-	if (existsSync(getJournalPath(projectRoot))) return false;
-	const metaDir = getDrizzleMetaDir(projectRoot);
-	await fs$1.mkdir(metaDir, { recursive: true });
-	await writeJournal(projectRoot, {
-		version: "7",
-		dialect: "postgresql",
-		entries: []
-	});
-	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
-	const initMigrationPath = path.join(migrationsDir, "0000_pecunia_init.sql");
-	await fs$1.writeFile(initMigrationPath, "-- Initial no-op migration created by pecunia-cli\n", "utf-8");
-	await upsertJournalEntry(projectRoot, "0000_pecunia_init");
-	return true;
-}
-/**
-* Upsert a journal entry. If an entry with the same tag exists, do nothing.
-* Otherwise, append a new entry with the next available idx.
-* 
-* @param projectRoot - The project root directory
-* @param tag - The migration tag (filename base without .sql)
-*/
-async function upsertJournalEntry(projectRoot, tag) {
-	const journal = await readJournal(projectRoot);
-	if (!journal) throw new Error("Journal does not exist. Call ensureDrizzleJournal() first.");
-	if (journal.entries.find((entry) => entry.tag === tag)) return;
-	const nextIdx = (journal.entries.length > 0 ? Math.max(...journal.entries.map((e) => e.idx)) : -1) + 1;
-	const hasBreakpoints = journal.entries.some((e) => e.breakpoints === true);
-	const newEntry = {
-		tag,
-		idx: nextIdx,
-		version: journal.version,
-		when: Date.now(),
-		...hasBreakpoints && { breakpoints: true }
-	};
-	journal.entries.push(newEntry);
-	await writeJournal(projectRoot, journal);
-}
-/**
-* Find existing invariants migration tag in the journal.
-* 
-* @param projectRoot - The project root directory
-* @returns The tag if found, or null
-*/
-async function findExistingInvariantsTag(projectRoot) {
-	const journal = await readJournal(projectRoot);
-	if (!journal) return null;
-	const invariantsEntry = journal.entries.find((entry) => entry.tag.endsWith("_pecunia_invariants"));
-	return invariantsEntry ? invariantsEntry.tag : null;
-}
-/**
-* Determine the next migration number by checking journal entries and existing files.
-* Prefers checking journal entries first, then falls back to scanning files.
-* 
-* @param projectRoot - The project root directory
-* @returns The next migration number (4-digit string, e.g., "0001")
-*/
-async function nextMigrationNumber(projectRoot) {
-	const existingInvariantsTag = await findExistingInvariantsTag(projectRoot);
-	if (existingInvariantsTag) {
-		const match = existingInvariantsTag.match(/^(\d{4})_/);
-		if (match) return match[1];
-	}
-	const journal = await readJournal(projectRoot);
-	if (journal && journal.entries.length > 0) {
-		const numbers$1 = journal.entries.map((entry) => {
-			const match = entry.tag.match(/^(\d{4})_/);
-			return match ? parseInt(match[1], 10) : 0;
-		}).filter((n) => n >= 0);
-		if (numbers$1.length > 0) {
-			const nextNumber$1 = Math.max(...numbers$1) + 1;
-			if (nextNumber$1 >= 9999) return "9999";
-			return String(nextNumber$1).padStart(4, "0");
-		}
-	}
-	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
-	if (!existsSync(migrationsDir)) return "0001";
-	const migrationFiles = (await fs$1.readdir(migrationsDir)).filter((file) => file.endsWith(".sql") && /^\d{4}_/.test(file));
-	if (migrationFiles.length === 0) return "0001";
-	const numbers = migrationFiles.map((file) => {
-		const match = file.match(/^(\d{4})_/);
-		return match ? parseInt(match[1], 10) : 0;
-	}).filter((n) => n > 0);
-	if (numbers.length === 0) return "0001";
-	const nextNumber = Math.max(...numbers) + 1;
-	if (nextNumber >= 9999) return "9999";
-	return String(nextNumber).padStart(4, "0");
-}
-/**
-* Get the path for the invariants migration file.
-* Uses a deterministic name based on migration number to ensure it runs after
-* base table creation migrations.
-* 
-* @param migrationsDir - Path to the drizzle migrations directory
-* @param migrationNumber - The migration number to use (4-digit string)
-* @returns The full path to the invariants migration file
-*/
-function getInvariantsMigrationPath(migrationsDir, migrationNumber) {
-	return path.join(migrationsDir, `${migrationNumber}_pecunia_invariants.sql`);
-}
-/**
-* Upsert a Drizzle migration file and register it in the journal.
-* 
-* @param projectRoot - The project root directory
-* @param tag - The migration tag (filename base without .sql)
-* @param sql - The SQL content to write
-*/
-async function upsertDrizzleMigration(projectRoot, tag, sql) {
-	const migrationsDir = await getDrizzleMigrationsDir(projectRoot);
-	const migrationPath = path.join(migrationsDir, `${tag}.sql`);
-	if (existsSync(migrationPath)) {
-		if (await fs$1.readFile(migrationPath, "utf-8") === sql) {
-			await upsertJournalEntry(projectRoot, tag);
-			return;
-		}
-	}
-	await fs$1.writeFile(migrationPath, sql, "utf-8");
-	await upsertJournalEntry(projectRoot, tag);
-}
-/**
-* Write the invariants SQL file to the drizzle migrations directory.
-* Ensures journal exists, determines migration number, and registers in journal.
-* 
-* @param projectRoot - The project root directory
-* @param sqlContent - The SQL content to write
-* @returns The path to the written file and status flags
-*/
-async function writeInvariantsMigration(projectRoot, sqlContent) {
-	const journalCreated = await ensureDrizzleJournal(projectRoot);
-	const migrationNumber = await nextMigrationNumber(projectRoot);
-	const tag = `${migrationNumber}_pecunia_invariants`;
-	const migrationPath = getInvariantsMigrationPath(await getDrizzleMigrationsDir(projectRoot), migrationNumber);
-	let created = false;
-	let updated = false;
-	if (existsSync(migrationPath)) {
-		if (await fs$1.readFile(migrationPath, "utf-8") === sqlContent) {
-			await upsertJournalEntry(projectRoot, tag);
-			return {
-				path: migrationPath,
-				created: false,
-				updated: false,
-				journalCreated
-			};
-		}
-		updated = true;
-	} else created = true;
-	await upsertDrizzleMigration(projectRoot, tag, sqlContent);
-	return {
-		path: migrationPath,
-		created,
-		updated,
-		journalCreated
-	};
-}
-
-//#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 || "./src/db/schema.ts";
-	const databaseType = adapter.options?.provider;
-	const projectRoot = process.cwd();
-	if (!databaseType) throw new Error("Database provider type is undefined during Drizzle schema generation. Please define a `provider` in the Drizzle adapter config.");
-	const resolvedSchemaPath = path.isAbsolute(filePath) ? filePath : path.resolve(projectRoot, filePath);
-	const schemaDir = path.dirname(resolvedSchemaPath);
-	if (!existsSync(schemaDir)) await fs$1.mkdir(schemaDir, { recursive: true });
-	const fileExist = existsSync(resolvedSchemaPath);
-	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);
-				const onDelete = attr.references.onDelete || "no action";
-				references.push({
-					fieldName,
-					referencedTable: referencedModelName,
-					referencedField: getFieldName({
-						model: attr.references.model,
-						field: attr.references.field
-					}),
-					onDelete,
-					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) {
-			const thisIsNullableWithSetNull = !ref.required && ref.onDelete === "set null";
-			const reverseIsNullableWithSetNull = !reverseRef.required && reverseRef.onDelete === "set null";
-			if (thisIsNullableWithSetNull) continue;
-			if (reverseIsNullableWithSetNull) continue;
-			if (!ref.required && (reverseRef.required || ref.onDelete !== "cascade" && reverseRef.onDelete === "cascade")) 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 hasCircularRef = references.some((ref) => {
-			const referencedTableKey = modelKeyToTableKey.get(ref.originalModel);
-			if (!referencedTableKey) return false;
-			const reverseKey = `${referencedTableKey}->${tableDef.tableKey}`;
-			return referenceGraph.has(reverseKey);
-		});
-		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 isRequired = attr.required === true;
-			const fieldDef = `${fieldName}: ${type}${isRequired ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${referenceChain}`;
-			return comment ? `${comment}\n					${fieldDef}` : fieldDef;
-		});
-		const typeAssertion = hasCircularRef ? " as any" : "";
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
-					id: ${id},
-					${fieldDefinitions.join(",\n ")}
-					}${assignIndexes(indexes)})${typeAssertion};`;
-		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];
-				const isSelfReferential = relationDef.model === tableKey || referencedModelName === modelName;
-				const generateRelationName = (fkName) => {
-					let cleaned = convertToSnakeCase(fkName, adapter.options?.camelCase).replace(/_by_id$/, "").replace(/_id$/, "");
-					const participleToNoun = {
-						"reversed": "reversal",
-						"created": "creation",
-						"updated": "update"
-					};
-					if (participleToNoun[cleaned]) cleaned = participleToNoun[cleaned];
-					return `${convertToSnakeCase(modelName, adapter.options?.camelCase)}_${cleaned}`;
-				};
-				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
-							},
-							relationName: isSelfReferential ? generateRelationName(relationDef.foreignKey) : void 0
-						});
-					}
-				} 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"
-							})}`;
-							let relationNameForMany;
-							if (isSelfReferential) {
-								const matchingOne = oneRelations.find((rel) => rel.reference?.fieldName === fkFieldName && rel.model === referencedModelName);
-								if (matchingOne?.relationName) relationNameForMany = matchingOne.relationName;
-								else {
-									let cleaned = convertToSnakeCase(fkFieldName, adapter.options?.camelCase).replace(/_by_id$/, "").replace(/_id$/, "");
-									const participleToNoun = {
-										"reversed": "reversal",
-										"created": "creation",
-										"updated": "update"
-									};
-									if (participleToNoun[cleaned]) cleaned = participleToNoun[cleaned];
-									relationNameForMany = `${convertToSnakeCase(modelName, adapter.options?.camelCase)}_${cleaned}`;
-								}
-							}
-							manyRelations.push({
-								key: relationName,
-								model: referencedModelName,
-								type: "many",
-								reference: {
-									field: fieldRef,
-									references: referenceRef,
-									fieldName: fkFieldName
-								},
-								relationName: relationNameForMany
-							});
-						} else manyRelations.push({
-							key: relationName,
-							model: referencedModelName,
-							type: "many"
-						});
-					}
-				}
-			}
-			for (const oneRel of oneRelations) {
-				if (!oneRel.relationName || !oneRel.reference) continue;
-				const oneRelFieldName = oneRel.reference.fieldName;
-				const matchingMany = manyRelations.find((manyRel) => manyRel.model === oneRel.model && manyRel.reference?.fieldName === oneRelFieldName);
-				if (matchingMany) matchingMany.relationName = oneRel.relationName;
-			}
-		}
-		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 relationExportName = `${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`;
-			const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
-			const tableRelation = `export const ${relationExportName} = relations(${modelName}, ({ one }) => ({
-				${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}]${relationNameParam}
-				})
-			}))`;
-			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) => {
-				if (!relation.reference) return "";
-				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
-				return ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}]${relationNameParam}
-				})`;
-			}).filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
-				${manyRelations.map(({ key, model, relationName }) => {
-				return ` ${key}: many(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
-			}).join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasOne) {
-			const tableRelation = `export const ${modelName}Relations = relations(${modelName}, ({ one }) => ({
-				${singleRelations.map((relation) => {
-				if (!relation.reference) return "";
-				const relationNameParam = relation.relationName ? `,\n					relationName: "${relation.relationName}"` : "";
-				return ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}]${relationNameParam}
-				})`;
-			}).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, relationName }) => {
-				return ` ${key}: many(${model}${relationName ? `, { relationName: "${relationName}" }` : ""})`;
-			}).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 result = await writeInvariantsMigration(projectRoot, emitPostgresInvariantSql(normalizeInvariants(tables, {
-			getModelName,
-			getFieldName
-		}), "public"));
-		if (result.journalCreated) console.log(`Created Drizzle migration journal and invariants migration; now run \`npx drizzle-kit migrate\`.`);
-		else if (result.created) console.log(`Generated invariants migration: ${path.relative(projectRoot, result.path)}`);
-		else if (result.updated) console.log(`Updated invariants migration: ${path.relative(projectRoot, result.path)}`);
-		else console.log(`Invariants migration up to date: ${path.relative(projectRoot, result.path)}`);
-	}
-	return {
-		code: formattedCode,
-		fileName: path.relative(projectRoot, resolvedSchemaPath),
-		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 = "NoAction";
-					if (attr.references.onDelete === "cascade") action = "Cascade";
-					else 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 };