arkormx 2.0.0-next.2 → 2.0.0-next.21

package/dist/cli.mjs

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { AsyncLocalStorage } from "async_hooks";
 import { dirname, extname, join, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { str } from "@h3ravel/support";
-import path, { dirname as dirname$1, extname as extname$1, join as join$1, relative } from "path";
-import { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
-import { AsyncLocalStorage } from "async_hooks";
 import { createJiti } from "@rexxars/jiti";
 import { pathToFileURL } from "node:url";
 import { createRequire } from "module";
+import { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { fileURLToPath } from "url";
+import path, { dirname as dirname$1, extname as extname$1, join as join$1, relative } from "path";
 import { Logger } from "@h3ravel/shared";
 import { Command, Kernel } from "@h3ravel/musket";
-import { createHash } from "node:crypto";
 
 //#region src/Exceptions/ArkormException.ts
 var ArkormException = class extends Error {
@@ -55,6 +55,188 @@ var ArkormException = class extends Error {
 	}
 };
 
+//#endregion
+//#region src/Exceptions/MissingDelegateException.ts
+var MissingDelegateException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "MISSING_DELEGATE",
+			...context
+		});
+		this.name = "MissingDelegateException";
+	}
+};
+
+//#endregion
+//#region src/Exceptions/QueryExecutionException.ts
+var QueryExecutionException = class extends ArkormException {
+	inspection;
+	constructor(message = "Database query execution failed.", context = {}) {
+		super(message, {
+			code: "QUERY_EXECUTION_FAILED",
+			...context,
+			meta: {
+				...context.meta ?? {},
+				...context.inspection ? { inspection: context.inspection } : {}
+			}
+		});
+		this.name = "QueryExecutionException";
+		this.inspection = context.inspection;
+	}
+	getInspection() {
+		return this.inspection;
+	}
+};
+
+//#endregion
+//#region src/Exceptions/UnsupportedAdapterFeatureException.ts
+var UnsupportedAdapterFeatureException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "UNSUPPORTED_ADAPTER_FEATURE",
+			...context
+		});
+		this.name = "UnsupportedAdapterFeatureException";
+	}
+};
+
+//#endregion
+//#region src/helpers/migration-history.ts
+const createEmptyAppliedMigrationsState = () => ({
+	version: 1,
+	migrations: [],
+	runs: []
+});
+const supportsDatabaseMigrationState = (adapter) => {
+	return typeof adapter?.readAppliedMigrationsState === "function" && typeof adapter?.writeAppliedMigrationsState === "function";
+};
+const resolveMigrationStateFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
+	return join(cwd, ".arkormx", "migrations.applied.json");
+};
+const buildMigrationIdentity = (filePath, className) => {
+	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
+	return `${fileName.slice(0, fileName.length - extname(fileName).length)}:${className}`;
+};
+const computeMigrationChecksum = (filePath) => {
+	const source = readFileSync(filePath, "utf-8");
+	return createHash("sha256").update(source).digest("hex");
+};
+const readAppliedMigrationsState = (stateFilePath) => {
+	if (!existsSync(stateFilePath)) return createEmptyAppliedMigrationsState();
+	try {
+		const parsed = JSON.parse(readFileSync(stateFilePath, "utf-8"));
+		if (!Array.isArray(parsed.migrations)) return createEmptyAppliedMigrationsState();
+		return {
+			version: 1,
+			migrations: parsed.migrations.filter((migration) => {
+				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
+			}),
+			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
+				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
+			}) : []
+		};
+	} catch {
+		return createEmptyAppliedMigrationsState();
+	}
+};
+const readAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) return await adapter.readAppliedMigrationsState();
+	return readAppliedMigrationsState(stateFilePath);
+};
+const writeAppliedMigrationsState = (stateFilePath, state) => {
+	const directory = dirname(stateFilePath);
+	if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+	writeFileSync(stateFilePath, JSON.stringify(state, null, 2));
+};
+const writeAppliedMigrationsStateToStore = async (adapter, stateFilePath, state) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(state);
+		return;
+	}
+	writeAppliedMigrationsState(stateFilePath, state);
+};
+const isMigrationApplied = (state, identity, checksum) => {
+	const matched = state.migrations.find((migration) => migration.id === identity);
+	if (!matched) return false;
+	if (checksum && matched.checksum) return matched.checksum === checksum;
+	if (checksum && !matched.checksum) return false;
+	return true;
+};
+const findAppliedMigration = (state, identity) => {
+	return state.migrations.find((migration) => migration.id === identity);
+};
+const markMigrationApplied = (state, entry) => {
+	const next = state.migrations.filter((migration) => migration.id !== entry.id);
+	next.push(entry);
+	return {
+		version: 1,
+		migrations: next,
+		runs: state.runs ?? []
+	};
+};
+const removeAppliedMigration = (state, identity) => {
+	return {
+		version: 1,
+		migrations: state.migrations.filter((migration) => migration.id !== identity),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			migrationIds: run.migrationIds.filter((id) => id !== identity)
+		})).filter((run) => run.migrationIds.length > 0)
+	};
+};
+const buildMigrationRunId = () => {
+	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+};
+const markMigrationRun = (state, run) => {
+	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
+	nextRuns.push(run);
+	return {
+		version: 1,
+		migrations: state.migrations,
+		runs: nextRuns
+	};
+};
+const getLastMigrationRun = (state) => {
+	const runs = state.runs ?? [];
+	if (runs.length === 0) return void 0;
+	return runs.map((run, index) => ({
+		run,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	})[0]?.run;
+};
+const getLatestAppliedMigrations = (state, steps) => {
+	return state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
+};
+
+//#endregion
+//#region src/helpers/PrimaryKeyGenerationPlanner.ts
+var PrimaryKeyGenerationPlanner = class {
+	static plan(column) {
+		if (!column.primary || column.default !== void 0) return void 0;
+		if (column.type === "uuid" || column.type === "string") return {
+			strategy: "uuid",
+			prismaDefault: "@default(uuid())",
+			databaseDefault: column.type === "uuid" ? "gen_random_uuid()" : "gen_random_uuid()::text",
+			runtimeFactory: "uuid"
+		};
+	}
+	static generate(generation) {
+		if (generation?.runtimeFactory === "uuid") return randomUUID();
+	}
+};
+
 //#endregion
 //#region src/database/ForeignKeyBuilder.ts
 /**
@@ -248,6 +430,7 @@ var TableBuilder = class {
 		column.primary = true;
 		if (typeof config.autoIncrement === "boolean") column.autoIncrement = config.autoIncrement;
 		if (Object.prototype.hasOwnProperty.call(config, "default")) column.default = config.default;
+		column.primaryKeyGeneration = PrimaryKeyGenerationPlanner.plan(column);
 		return this;
 	}
 	/**
@@ -611,8 +794,11 @@ var TableBuilder = class {
 			autoIncrement: options.autoIncrement,
 			after: options.after,
 			default: options.default,
-			updatedAt: options.updatedAt
+			updatedAt: options.updatedAt,
+			primaryKeyGeneration: options.primaryKeyGeneration
 		});
+		const column = this.columns[this.columns.length - 1];
+		column.primaryKeyGeneration = PrimaryKeyGenerationPlanner.plan(column);
 		this.latestColumnName = name;
 		return this;
 	}
@@ -867,7 +1053,7 @@ const buildFieldLine = (column) => {
 	const primary = column.primary ? " @id" : "";
 	const mapped = typeof column.map === "string" && column.map.trim().length > 0 ? ` @map("${column.map.replace(/"/g, "\\\"")}")` : "";
 	const updatedAt = column.updatedAt ? " @updatedAt" : "";
-	const defaultValue = column.type === "enum" ? formatEnumDefaultValue(column.default) : formatDefaultValue(column.default) ?? (column.type === "uuid" && column.primary ? "@default(uuid())" : void 0);
+	const defaultValue = column.type === "enum" ? formatEnumDefaultValue(column.default) : column.primaryKeyGeneration?.prismaDefault ?? formatDefaultValue(column.default);
 	const defaultSuffix = defaultValue ? ` ${defaultValue}` : "";
 	return `  ${column.name} ${scalar}${nullable}${primary}${unique}${defaultSuffix}${updatedAt}${mapped}`;
 };
@@ -1371,6 +1557,28 @@ const getMigrationPlan = async (migration, direction = "up") => {
 	else await instance.down(schema);
 	return schema.getOperations();
 };
+const supportsDatabaseMigrationExecution = (adapter) => {
+	return typeof adapter?.executeSchemaOperations === "function";
+};
+const supportsDatabaseReset = (adapter) => {
+	return typeof adapter?.resetDatabase === "function";
+};
+const stripPrismaSchemaModelsAndEnums = (schema) => {
+	const stripped = schema.replace(PRISMA_MODEL_REGEX, "").replace(PRISMA_ENUM_REGEX, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+	return stripped.length > 0 ? `${stripped}\n` : "";
+};
+const applyMigrationToDatabase = async (adapter, migration) => {
+	if (!supportsDatabaseMigrationExecution(adapter)) throw new ArkormException("The configured adapter does not support database-backed migration execution.");
+	const operations = await getMigrationPlan(migration, "up");
+	await adapter.executeSchemaOperations(operations);
+	return { operations };
+};
+const applyMigrationRollbackToDatabase = async (adapter, migration) => {
+	if (!supportsDatabaseMigrationExecution(adapter)) throw new ArkormException("The configured adapter does not support database-backed migration execution.");
+	const operations = await getMigrationPlan(migration, "down");
+	await adapter.executeSchemaOperations(operations);
+	return { operations };
+};
 /**
 * Apply the schema operations defined in a migration to a Prisma schema 
 * file, updating the file on disk if specified, and return the updated 
@@ -1414,6 +1622,321 @@ const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) =>
 	};
 };
 
+//#endregion
+//#region src/helpers/column-mappings.ts
+let cachedColumnMappingsPath;
+let cachedColumnMappingsState;
+const resolvePersistedMetadataFeatures = (features) => {
+	return {
+		persistedColumnMappings: features?.persistedColumnMappings !== false,
+		persistedEnums: features?.persistedEnums !== false
+	};
+};
+const createEmptyPersistedColumnMappingsState = () => ({
+	version: 1,
+	tables: {}
+});
+const resolveColumnMappingsFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
+	return join(cwd, ".arkormx", "column-mappings.json");
+};
+const normalizePersistedEnumValues = (values) => {
+	if (!Array.isArray(values)) return [];
+	return values.filter((value) => typeof value === "string" && value.trim().length > 0);
+};
+const normalizeLegacyTableColumns = (columns) => {
+	return Object.entries(columns).reduce((mapped, [attribute, column]) => {
+		if (attribute.trim().length === 0) return mapped;
+		if (typeof column !== "string" || column.trim().length === 0) return mapped;
+		mapped[attribute] = column;
+		return mapped;
+	}, {});
+};
+const normalizePersistedTableMetadata = (table) => {
+	if (!table || typeof table !== "object" || Array.isArray(table)) return {
+		columns: {},
+		enums: {}
+	};
+	const candidate = table;
+	if (!(Object.prototype.hasOwnProperty.call(candidate, "columns") || Object.prototype.hasOwnProperty.call(candidate, "enums") || Object.prototype.hasOwnProperty.call(candidate, "primaryKeyGeneration") || Object.prototype.hasOwnProperty.call(candidate, "timestampColumns"))) return {
+		columns: normalizeLegacyTableColumns(candidate),
+		enums: {}
+	};
+	return {
+		columns: normalizeLegacyTableColumns(candidate.columns ?? {}),
+		enums: Object.entries(candidate.enums ?? {}).reduce((all, [columnName, values]) => {
+			if (columnName.trim().length === 0) return all;
+			const normalizedValues = normalizePersistedEnumValues(values);
+			if (normalizedValues.length > 0) all[columnName] = normalizedValues;
+			return all;
+		}, {}),
+		primaryKeyGeneration: normalizePersistedPrimaryKeyGeneration(candidate.primaryKeyGeneration),
+		timestampColumns: normalizePersistedTimestampColumns(candidate.timestampColumns)
+	};
+};
+const normalizePersistedPrimaryKeyGeneration = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const candidate = value;
+	if (candidate.strategy !== "uuid" || typeof candidate.column !== "string" || candidate.column.trim().length === 0) return void 0;
+	return {
+		column: candidate.column,
+		strategy: "uuid",
+		prismaDefault: typeof candidate.prismaDefault === "string" && candidate.prismaDefault.trim().length > 0 ? candidate.prismaDefault : void 0,
+		databaseDefault: typeof candidate.databaseDefault === "string" && candidate.databaseDefault.trim().length > 0 ? candidate.databaseDefault : void 0,
+		runtimeFactory: candidate.runtimeFactory === "uuid" ? "uuid" : void 0
+	};
+};
+const normalizePersistedTimestampColumns = (value) => {
+	if (!Array.isArray(value)) return void 0;
+	const columns = value.reduce((all, entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return all;
+		const candidate = entry;
+		if (typeof candidate.column !== "string" || candidate.column.trim().length === 0) return all;
+		const normalized = { column: candidate.column };
+		if (candidate.default === "now()") normalized.default = "now()";
+		if (candidate.updatedAt === true) normalized.updatedAt = true;
+		if (!normalized.default && !normalized.updatedAt) return all;
+		all.push(normalized);
+		return all;
+	}, []);
+	return columns.length > 0 ? columns : void 0;
+};
+const normalizePersistedColumnMappingsState = (state) => {
+	return {
+		version: 1,
+		tables: Object.entries(state?.tables ?? {}).reduce((all, [tableName, tableMetadata]) => {
+			if (tableName.trim().length === 0) return all;
+			const normalized = normalizePersistedTableMetadata(tableMetadata);
+			if (Object.keys(normalized.columns).length > 0 || Object.keys(normalized.enums).length > 0 || normalized.primaryKeyGeneration || normalized.timestampColumns?.length) all[tableName] = normalized;
+			return all;
+		}, {})
+	};
+};
+const buildPersistedFeatureDisabledError = (feature, table) => {
+	return new ArkormException(`Table [${table}] requires ${feature === "persistedColumnMappings" ? "persisted column mappings" : "persisted enum metadata"}, but ${feature === "persistedColumnMappings" ? "features.persistedColumnMappings" : "features.persistedEnums"} is disabled in arkormx.config.*.`, {
+		operation: "metadata.persisted",
+		meta: {
+			feature,
+			table
+		}
+	});
+};
+const assertPersistedTableMetadataEnabled = (table, metadata, features, strict) => {
+	if (!strict) return;
+	if (!features.persistedColumnMappings && Object.keys(metadata.columns).length > 0) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+	if (!features.persistedEnums && Object.keys(metadata.enums).length > 0) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+};
+const buildEnumUnionType = (values) => {
+	return values.map((value) => {
+		return `'${value.replace(/'/g, String.raw`\'`)}'`;
+	}).join(" | ");
+};
+const resetPersistedColumnMappingsCache = () => {
+	cachedColumnMappingsPath = void 0;
+	cachedColumnMappingsState = void 0;
+};
+const readPersistedColumnMappingsState = (filePath) => {
+	if (cachedColumnMappingsPath === filePath && cachedColumnMappingsState) return cachedColumnMappingsState;
+	if (!existsSync(filePath)) {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+	try {
+		const normalized = normalizePersistedColumnMappingsState(JSON.parse(readFileSync(filePath, "utf-8")));
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = normalized;
+		return normalized;
+	} catch {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+};
+const writePersistedColumnMappingsState = (filePath, state) => {
+	const normalized = normalizePersistedColumnMappingsState(state);
+	const directory = dirname(filePath);
+	if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+	writeFileSync(filePath, JSON.stringify(normalized, null, 2));
+	cachedColumnMappingsPath = filePath;
+	cachedColumnMappingsState = normalized;
+};
+const deletePersistedColumnMappingsState = (filePath) => {
+	if (existsSync(filePath)) rmSync(filePath, { force: true });
+	resetPersistedColumnMappingsCache();
+};
+const getPersistedTableMetadata = (table, options = {}) => {
+	const metadata = readPersistedColumnMappingsState(resolveColumnMappingsFilePath(options.cwd ?? process.cwd(), options.configuredPath)).tables[table] ?? {
+		columns: {},
+		enums: {}
+	};
+	assertPersistedTableMetadataEnabled(table, metadata, options.features ?? resolvePersistedMetadataFeatures(), options.strict ?? false);
+	return {
+		columns: { ...metadata.columns },
+		enums: Object.entries(metadata.enums).reduce((all, [columnName, values]) => {
+			all[columnName] = [...values];
+			return all;
+		}, {}),
+		primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+		timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+	};
+};
+const applyMappedColumn = (tableColumns, column, features, table) => {
+	if (typeof column.map === "string" && column.map.trim().length > 0 && column.map !== column.name) {
+		if (!features.persistedColumnMappings) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+		tableColumns[column.name] = column.map;
+		return;
+	}
+	delete tableColumns[column.name];
+};
+const applyEnumColumn = (tableEnums, column, features, table) => {
+	const values = column.enumValues ?? [];
+	if (column.type === "enum" && values.length > 0) {
+		if (!features.persistedEnums) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+		tableEnums[column.name] = [...values];
+		return;
+	}
+	delete tableEnums[column.name];
+};
+const removePersistedColumnMetadata = (tableMetadata, columnName) => {
+	delete tableMetadata.columns[columnName];
+	delete tableMetadata.enums[columnName];
+	Object.entries(tableMetadata.columns).forEach(([attribute, mappedColumn]) => {
+		if (mappedColumn === columnName) delete tableMetadata.columns[attribute];
+	});
+	if (tableMetadata.primaryKeyGeneration?.column === columnName) delete tableMetadata.primaryKeyGeneration;
+	if (tableMetadata.timestampColumns) {
+		tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((column) => column.column !== columnName);
+		if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+	}
+};
+const applyPrimaryKeyGeneration = (tableMetadata, column) => {
+	if (!column.primary || !column.primaryKeyGeneration) {
+		if (tableMetadata.primaryKeyGeneration?.column === column.name) delete tableMetadata.primaryKeyGeneration;
+		return;
+	}
+	tableMetadata.primaryKeyGeneration = {
+		column: column.name,
+		...column.primaryKeyGeneration
+	};
+};
+const applyTimestampColumn = (tableMetadata, column) => {
+	if (column.type !== "timestamp" || column.default !== "now()" && column.updatedAt !== true) {
+		if (tableMetadata.timestampColumns) {
+			tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((entry) => entry.column !== column.name);
+			if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+		}
+		return;
+	}
+	const nextColumn = {
+		column: column.name,
+		...column.default === "now()" ? { default: "now()" } : {},
+		...column.updatedAt ? { updatedAt: true } : {}
+	};
+	tableMetadata.timestampColumns = [...(tableMetadata.timestampColumns ?? []).filter((entry) => entry.column !== column.name), nextColumn];
+};
+const applyOperationsToPersistedColumnMappingsState = (state, operations, features = resolvePersistedMetadataFeatures()) => {
+	const nextTables = Object.entries(state.tables).reduce((all, [table, metadata]) => {
+		all[table] = {
+			columns: { ...metadata.columns },
+			enums: Object.entries(metadata.enums).reduce((nextEnums, [columnName, values]) => {
+				nextEnums[columnName] = [...values];
+				return nextEnums;
+			}, {}),
+			primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+			timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+		};
+		return all;
+	}, {});
+	operations.forEach((operation) => {
+		if (operation.type === "createTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.columns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		if (operation.type === "alterTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.addColumns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			operation.dropColumns.forEach((columnName) => {
+				removePersistedColumnMetadata(tableMetadata, columnName);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		delete nextTables[operation.table];
+	});
+	return {
+		version: 1,
+		tables: nextTables
+	};
+};
+const rebuildPersistedColumnMappingsState = async (state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const availableByIdentity = new Map(availableMigrations.map(([migrationClass, file]) => [buildMigrationIdentity(file, migrationClass.name), migrationClass]));
+	let nextState = createEmptyPersistedColumnMappingsState();
+	const orderedMigrations = state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = left.migration.appliedAt.localeCompare(right.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return left.index - right.index;
+	});
+	for (const { migration } of orderedMigrations) {
+		const migrationClass = availableByIdentity.get(migration.id);
+		if (!migrationClass) throw new ArkormException(`Unable to rebuild persisted column mappings because migration [${migration.id}] could not be resolved from the current migration files.`, {
+			operation: "migration.columnMappings",
+			meta: {
+				migrationId: migration.id,
+				file: migration.file,
+				className: migration.className
+			}
+		});
+		const operations = await getMigrationPlan(migrationClass, "up");
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+	return nextState;
+};
+const syncPersistedColumnMappingsFromState = async (cwd, state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const filePath = resolveColumnMappingsFilePath(cwd);
+	const nextState = await rebuildPersistedColumnMappingsState(state, availableMigrations, features);
+	if (Object.keys(nextState.tables).length === 0) {
+		deletePersistedColumnMappingsState(filePath);
+		return;
+	}
+	writePersistedColumnMappingsState(filePath, nextState);
+};
+const validatePersistedMetadataFeaturesForMigrations = async (migrations, features = resolvePersistedMetadataFeatures()) => {
+	let nextState = createEmptyPersistedColumnMappingsState();
+	for (const [migrationClass] of migrations) {
+		const operations = await getMigrationPlan(migrationClass, "up");
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+};
+const getPersistedEnumTsType = (values) => {
+	return buildEnumUnionType(values);
+};
+
 //#endregion
 //#region src/helpers/runtime-module-loader.ts
 var RuntimeModuleLoader = class {
@@ -1441,6 +1964,10 @@ const resolveDefaultStubsPath = () => {
 	return path.join(process.cwd(), "stubs");
 };
 const baseConfig = {
+	features: {
+		persistedColumnMappings: true,
+		persistedEnums: true
+	},
 	paths: {
 		stubs: resolveDefaultStubsPath(),
 		seeders: path.join(process.cwd(), "database", "seeders"),
@@ -1453,6 +1980,7 @@ const baseConfig = {
 };
 const userConfig = {
 	...baseConfig,
+	features: { ...baseConfig.features ?? {} },
 	paths: { ...baseConfig.paths ?? {} }
 };
 let runtimeConfigLoaded = false;
@@ -1461,7 +1989,27 @@ let runtimeClientResolver;
 let runtimeAdapter;
 let runtimePaginationURLDriverFactory;
 let runtimePaginationCurrentPageResolver;
+let runtimeDebugHandler;
 const transactionClientStorage = new AsyncLocalStorage();
+const defaultDebugHandler = (event) => {
+	const prefix = `[arkorm:${event.adapter}] ${event.operation}${event.target ? ` [${event.target}]` : ""}`;
+	const payload = {
+		phase: event.phase,
+		durationMs: event.durationMs,
+		inspection: event.inspection ?? void 0,
+		meta: event.meta,
+		error: event.error
+	};
+	if (event.phase === "error") {
+		console.error(prefix, payload);
+		return;
+	}
+	console.debug(prefix, payload);
+};
+const resolveDebugHandler = (debug) => {
+	if (debug === true) return defaultDebugHandler;
+	return typeof debug === "function" ? debug : void 0;
+};
 const mergePathConfig = (paths) => {
 	const defaults = baseConfig.paths ?? {};
 	const current = userConfig.paths ?? {};
@@ -1475,6 +2023,15 @@ const mergePathConfig = (paths) => {
 		...incoming
 	};
 };
+const mergeFeatureConfig = (features) => {
+	const defaults = baseConfig.features ?? {};
+	const current = userConfig.features ?? {};
+	return {
+		...defaults,
+		...current,
+		...features ?? {}
+	};
+};
 const bindAdapterToModels = (adapter, models) => {
 	models.forEach((model) => {
 		model.setAdapter(adapter);
@@ -1500,18 +2057,21 @@ const getUserConfig = (key) => {
 const configureArkormRuntime = (prisma, options = {}) => {
 	const nextConfig = {
 		...userConfig,
+		features: mergeFeatureConfig(options.features),
 		paths: mergePathConfig(options.paths)
 	};
 	nextConfig.prisma = prisma;
 	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
 	if (options.adapter !== void 0) nextConfig.adapter = options.adapter;
 	if (options.boot !== void 0) nextConfig.boot = options.boot;
+	if (options.debug !== void 0) nextConfig.debug = options.debug;
 	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
 	Object.assign(userConfig, { ...nextConfig });
 	runtimeClientResolver = prisma;
 	runtimeAdapter = options.adapter;
 	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
 	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+	runtimeDebugHandler = resolveDebugHandler(nextConfig.debug);
 	options.boot?.({
 		prisma: resolveClient(prisma),
 		bindAdapter: bindAdapterToModels
@@ -1544,6 +2104,8 @@ const resolveAndApplyConfig = (imported) => {
 	configureArkormRuntime(config.prisma, {
 		adapter: config.adapter,
 		boot: config.boot,
+		debug: config.debug,
+		features: config.features,
 		pagination: config.pagination,
 		paths: config.paths,
 		outputExt: config.outputExt
@@ -1601,8 +2163,497 @@ const loadArkormConfig = async () => {
 const getDefaultStubsPath = () => {
 	return resolveDefaultStubsPath();
 };
+const getRuntimeDebugHandler = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimeDebugHandler;
+};
+const emitRuntimeDebugEvent = (event) => {
+	getRuntimeDebugHandler()?.(event);
+};
+/**
+* Check if a given value is a Prisma delegate-like object 
+* by verifying the presence of common delegate methods.
+* 
+* @param value The value to check.
+* @returns True if the value is a Prisma delegate-like object, false otherwise.    
+*/
+const isDelegateLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return [
+		"findMany",
+		"findFirst",
+		"create",
+		"update",
+		"delete",
+		"count"
+	].every((method) => typeof candidate[method] === "function");
+};
 loadArkormConfig();
 
+//#endregion
+//#region src/helpers/prisma.ts
+/**
+* Infer the Prisma delegate name for a given model name using a simple convention.
+* 
+* @param modelName The name of the model to infer the delegate name for.
+* @returns The inferred Prisma delegate name.
+*/
+function inferDelegateName(modelName) {
+	return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}s`;
+}
+
+//#endregion
+//#region src/adapters/PrismaDatabaseAdapter.ts
+/**
+* Database adapter implementation for Prisma, allowing Arkorm to execute queries using Prisma 
+* as the underlying query builder and executor.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 2.0.0-next.0
+*/
+var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
+	capabilities;
+	delegates;
+	constructor(prisma, mapping = {}) {
+		this.prisma = prisma;
+		this.mapping = mapping;
+		this.delegates = Object.entries(prisma).reduce((accumulator, [key, value]) => {
+			if (!isDelegateLike(value)) return accumulator;
+			accumulator[key] = value;
+			return accumulator;
+		}, {});
+		this.capabilities = {
+			transactions: this.hasTransactionSupport(prisma),
+			insertMany: Object.values(this.delegates).some((delegate) => typeof delegate.createMany === "function"),
+			upsert: false,
+			updateMany: Object.values(this.delegates).some((delegate) => typeof delegate.updateMany === "function"),
+			deleteMany: false,
+			exists: true,
+			relationLoads: false,
+			relationAggregates: false,
+			relationFilters: false,
+			rawWhere: false,
+			returning: false
+		};
+	}
+	hasTransactionSupport(client) {
+		return Boolean(client) && typeof client.$transaction === "function";
+	}
+	normalizeCandidate(value) {
+		return value.trim();
+	}
+	unique(values) {
+		return [...new Set(values.filter(Boolean))];
+	}
+	runtimeModelTypeToTs(typeName, kind, enumValues) {
+		if (kind === "enum" && enumValues && enumValues.length > 0) return enumValues.map((value) => `'${value.replace(/'/g, "\\'")}'`).join(" | ");
+		switch (typeName) {
+			case "Int":
+			case "Float":
+			case "Decimal":
+			case "BigInt": return "number";
+			case "Boolean": return "boolean";
+			case "DateTime": return "Date";
+			case "Json": return "Record<string, unknown> | unknown[]";
+			case "Bytes": return "Uint8Array";
+			case "String":
+			case "UUID": return "string";
+			default: return "string";
+		}
+	}
+	getRuntimeDataModel() {
+		const runtimeDataModel = this.prisma._runtimeDataModel;
+		if (runtimeDataModel && typeof runtimeDataModel === "object") return runtimeDataModel;
+		return null;
+	}
+	toQuerySelect(columns) {
+		if (!columns || columns.length === 0) return void 0;
+		return columns.reduce((select, column) => {
+			select[column.column] = true;
+			return select;
+		}, {});
+	}
+	toQueryOrderBy(orderBy) {
+		if (!orderBy || orderBy.length === 0) return void 0;
+		return orderBy.map((entry) => ({ [entry.column]: entry.direction }));
+	}
+	toComparisonWhere(condition) {
+		if (condition.operator === "is-null") return { [condition.column]: null };
+		if (condition.operator === "is-not-null") return { [condition.column]: { not: null } };
+		if (condition.operator === "=") return { [condition.column]: condition.value };
+		if (condition.operator === "!=") return { [condition.column]: { not: condition.value } };
+		if (condition.operator === ">") return { [condition.column]: { gt: condition.value } };
+		if (condition.operator === ">=") return { [condition.column]: { gte: condition.value } };
+		if (condition.operator === "<") return { [condition.column]: { lt: condition.value } };
+		if (condition.operator === "<=") return { [condition.column]: { lte: condition.value } };
+		if (condition.operator === "in") return { [condition.column]: { in: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+		if (condition.operator === "not-in") return { [condition.column]: { notIn: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+		if (condition.operator === "contains") return { [condition.column]: { contains: condition.value } };
+		if (condition.operator === "starts-with") return { [condition.column]: { startsWith: condition.value } };
+		return { [condition.column]: { endsWith: condition.value } };
+	}
+	toQueryWhere(condition) {
+		if (!condition) return void 0;
+		if (condition.type === "comparison") return this.toComparisonWhere(condition);
+		if (condition.type === "group") {
+			const group = condition;
+			const grouped = group.conditions.map((entry) => this.toQueryWhere(entry)).filter((entry) => Boolean(entry));
+			if (grouped.length === 0) return void 0;
+			return group.operator === "and" ? { AND: grouped } : { OR: grouped };
+		}
+		if (condition.type === "not") {
+			const notCondition = condition;
+			const nested = this.toQueryWhere(notCondition.condition);
+			if (!nested) return void 0;
+			return { NOT: nested };
+		}
+		throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the Prisma compatibility adapter.", {
+			operation: "adapter.where",
+			meta: {
+				feature: "rawWhere",
+				sql: condition.sql
+			}
+		});
+	}
+	buildFindArgs(spec) {
+		return {
+			include: this.toQueryInclude(spec.relationLoads),
+			where: this.toQueryWhere(spec.where),
+			orderBy: this.toQueryOrderBy(spec.orderBy),
+			select: this.toQuerySelect(spec.columns),
+			skip: spec.offset,
+			take: spec.limit
+		};
+	}
+	emitDebugQuery(phase, operation, target, meta, durationMs, error, inspection = null) {
+		emitRuntimeDebugEvent({
+			type: "query",
+			phase,
+			adapter: "prisma",
+			operation,
+			target: target.table,
+			inspection,
+			meta,
+			durationMs,
+			error
+		});
+	}
+	wrapExecutionError(error, operation, target, meta) {
+		if (error instanceof ArkormException) return error;
+		return new QueryExecutionException(`Failed to execute ${operation} query.`, {
+			operation: `adapter.${operation}`,
+			model: target.modelName,
+			delegate: target.table,
+			meta,
+			cause: error
+		});
+	}
+	async runWithDebug(operation, target, executor, meta) {
+		const startedAt = Date.now();
+		this.emitDebugQuery("before", operation, target, meta);
+		try {
+			const result = await executor();
+			this.emitDebugQuery("after", operation, target, meta, Date.now() - startedAt);
+			return result;
+		} catch (error) {
+			const wrapped = this.wrapExecutionError(error, operation, target, meta);
+			this.emitDebugQuery("error", operation, target, meta, Date.now() - startedAt, wrapped);
+			throw wrapped;
+		}
+	}
+	inspectQuery(_request) {
+		return null;
+	}
+	toQueryInclude(relationLoads) {
+		if (!relationLoads || relationLoads.length === 0) return void 0;
+		return relationLoads.reduce((include, plan) => {
+			const nestedInclude = this.toQueryInclude(plan.relationLoads);
+			const nestedSelect = this.toQuerySelect(plan.columns);
+			const nestedWhere = this.toQueryWhere(plan.constraint);
+			const nestedOrderBy = this.toQueryOrderBy(plan.orderBy);
+			if (!nestedInclude && !nestedSelect && !nestedWhere && !nestedOrderBy && plan.offset === void 0 && plan.limit === void 0) {
+				include[plan.relation] = true;
+				return include;
+			}
+			include[plan.relation] = {
+				where: nestedWhere,
+				orderBy: nestedOrderBy,
+				select: nestedSelect,
+				include: nestedInclude,
+				skip: plan.offset,
+				take: plan.limit
+			};
+			return include;
+		}, {});
+	}
+	async introspectModels(options = {}) {
+		const runtimeDataModel = this.getRuntimeDataModel();
+		if (!runtimeDataModel?.models) return [];
+		const requestedTables = new Set(options.tables?.filter(Boolean) ?? []);
+		const enums = runtimeDataModel.enums ?? {};
+		return Object.entries(runtimeDataModel.models).flatMap(([name, model]) => {
+			const table = model.dbName ?? `${str(name).camel().plural()}`;
+			if (requestedTables.size > 0 && !requestedTables.has(table)) return [];
+			return [{
+				name,
+				table,
+				fields: (model.fields ?? []).filter((field) => field.kind !== "object").map((field) => {
+					const enumValues = field.kind === "enum" ? (enums[field.type]?.values ?? []).map((value) => typeof value === "string" ? value : value.name ?? "").filter(Boolean) : null;
+					const baseType = this.runtimeModelTypeToTs(field.type, field.kind, enumValues);
+					return {
+						name: field.name,
+						type: field.isList ? `Array<${baseType}>` : baseType,
+						nullable: field.isRequired === false
+					};
+				})
+			}];
+		});
+	}
+	resolveDelegate(target) {
+		const tableName = target.table ? this.normalizeCandidate(target.table) : "";
+		const singularTableName = tableName ? `${str(tableName).singular()}` : "";
+		const camelTableName = tableName ? `${str(tableName).camel()}` : "";
+		const camelSingularTableName = tableName ? `${str(tableName).camel().singular()}` : "";
+		const candidates = this.unique([
+			target.table ? this.mapping[target.table] : "",
+			tableName,
+			singularTableName ? this.mapping[singularTableName] : "",
+			singularTableName,
+			camelTableName ? this.mapping[camelTableName] : "",
+			camelTableName,
+			camelSingularTableName ? this.mapping[camelSingularTableName] : "",
+			camelSingularTableName,
+			target.modelName ? this.mapping[target.modelName] : "",
+			target.modelName ? this.normalizeCandidate(target.modelName) : "",
+			target.modelName ? inferDelegateName(target.modelName) : "",
+			target.modelName ? this.mapping[inferDelegateName(target.modelName)] : ""
+		]);
+		const resolved = candidates.map((candidate) => this.delegates[candidate]).find(Boolean);
+		if (resolved) return resolved;
+		throw new MissingDelegateException("Prisma delegate could not be resolved for adapter target.", {
+			operation: "getDelegate",
+			model: target.modelName,
+			delegate: target.table,
+			meta: {
+				target,
+				candidates
+			}
+		});
+	}
+	/**
+	* @todo Implement relationLoads by performing separate queries and merging results 
+	* in-memory, since Prisma does not support nested reads with constraints, ordering, or
+	* pagination on related models as of now.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async select(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const args = this.buildFindArgs(spec);
+		return await this.runWithDebug("select", spec.target, async () => {
+			return await delegate.findMany(args);
+		}, { args });
+	}
+	/**
+	* Selects a single record matching the specified criteria. 
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async selectOne(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const args = this.buildFindArgs(spec);
+		return await this.runWithDebug("selectOne", spec.target, async () => {
+			return await delegate.findFirst(args);
+		}, { args });
+	}
+	/**
+	* Inserts a single record into the database and returns the created record.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async insert(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		return await this.runWithDebug("insert", spec.target, async () => {
+			return await delegate.create({ data: spec.values });
+		}, { values: spec.values });
+	}
+	/**
+	* Inserts multiple records into the database. 
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async insertMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const meta = {
+			values: spec.values,
+			ignoreDuplicates: spec.ignoreDuplicates
+		};
+		if (typeof delegate.createMany === "function") {
+			const result = await this.runWithDebug("insertMany", spec.target, async () => {
+				return await delegate.createMany?.({
+					data: spec.values,
+					skipDuplicates: spec.ignoreDuplicates
+				});
+			}, meta);
+			if (typeof result === "number") return result;
+			return typeof result?.count === "number" ? result.count : spec.values.length;
+		}
+		let inserted = 0;
+		for (const values of spec.values) try {
+			await delegate.create({ data: values });
+			inserted += 1;
+		} catch (error) {
+			if (!spec.ignoreDuplicates) throw error;
+		}
+		return spec.ignoreDuplicates ? inserted : spec.values.length;
+	}
+	/**
+	* Updates a single record matching the specified criteria and returns the updated record.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async update(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		if (!where) return null;
+		return await this.runWithDebug("update", spec.target, async () => {
+			return await delegate.update({
+				where,
+				data: spec.values
+			});
+		}, {
+			where,
+			values: spec.values
+		});
+	}
+	/**
+	* Updates multiple records matching the specified criteria. 
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async updateMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		const meta = {
+			where,
+			values: spec.values
+		};
+		if (typeof delegate.updateMany === "function") {
+			const result = await this.runWithDebug("updateMany", spec.target, async () => {
+				return await delegate.updateMany?.({
+					where,
+					data: spec.values
+				});
+			}, meta);
+			if (typeof result === "number") return result;
+			return typeof result?.count === "number" ? result.count : 0;
+		}
+		const rows = await delegate.findMany({ where });
+		await Promise.all(rows.map(async (row) => {
+			await delegate.update({
+				where: row,
+				data: spec.values
+			});
+		}));
+		return rows.length;
+	}
+	/**
+	* Deletes a single record matching the specified criteria and returns the deleted record.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async delete(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		if (!where) return null;
+		return await this.runWithDebug("delete", spec.target, async () => {
+			return await delegate.delete({ where });
+		}, { where });
+	}
+	/**
+	* Deletes multiple records matching the specified criteria. 
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async deleteMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		const rows = await this.runWithDebug("deleteMany", spec.target, async () => {
+			return await delegate.findMany({ where });
+		}, { where });
+		await Promise.all(rows.map(async (row) => {
+			await delegate.delete({ where: row });
+		}));
+		return rows.length;
+	}
+	/**
+	* Counts the number of records matching the specified criteria.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async count(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		return await this.runWithDebug("count", spec.target, async () => {
+			return await delegate.count({ where });
+		}, { where });
+	}
+	/**
+	* Checks for the existence of records matching the specified criteria.
+	* 
+	* @param spec 
+	* @returns 
+	*/
+	async exists(spec) {
+		return await this.selectOne({
+			...spec,
+			limit: 1
+		}) != null;
+	}
+	/**
+	* Loads related models for a batch of parent records based on the specified relation load plans.
+	* 
+	* @param _spec 
+	*/
+	async loadRelations(_spec) {
+		throw new UnsupportedAdapterFeatureException("Relation batch loading is not supported by the Prisma compatibility adapter yet.", {
+			operation: "adapter.loadRelations",
+			meta: { feature: "relationLoads" }
+		});
+	}
+	/**
+	* Executes a series of database operations within a transaction. 
+	* If the underlying Prisma client does not support transactions, an exception is thrown.
+	* 
+	* @param callback 
+	* @param context 
+	* @returns 
+	*/
+	async transaction(callback, context = {}) {
+		if (!this.hasTransactionSupport(this.prisma)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the Prisma compatibility adapter.", {
+			operation: "adapter.transaction",
+			meta: { feature: "transactions" }
+		});
+		return await this.prisma.$transaction(async (transactionClient) => {
+			return await callback(new PrismaDatabaseAdapter(transactionClient, this.mapping));
+		}, {
+			isolationLevel: context.isolationLevel,
+			maxWait: context.maxWait,
+			timeout: context.timeout
+		});
+	}
+};
+
 //#endregion
 //#region src/cli/CliApp.ts
 /**
@@ -1624,6 +2675,9 @@ var CliApp = class {
 	* @returns The entire configuration object or the value of the specified key
 	*/
 	getConfig = getUserConfig;
+	isUsingPrismaAdapter() {
+		return this.getConfig("adapter") instanceof PrismaDatabaseAdapter;
+	}
 	/**
 	* Utility to ensure directory exists
 	*
@@ -1836,14 +2890,16 @@ var CliApp = class {
 		const factoryName = `${baseName}Factory`;
 		const factoryPath = join$1(this.resolveConfigPath("factories", join$1(process.cwd(), "database", "factories")), `${factoryName}.${outputExt}`);
 		const factoryImportPath = `./${relative(dirname$1(outputPath), factoryPath).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "")}${outputExt === "js" ? ".js" : ""}`;
-		const stubPath = this.resolveStubPath(outputExt === "js" ? "model.js.stub" : "model.stub");
+		let stubPath;
+		if (options.pivot) stubPath = this.resolveStubPath("pivot-model.stub");
+		else stubPath = this.resolveStubPath(outputExt === "js" ? "model.js.stub" : "model.stub");
 		const modelPath = this.generateFile(stubPath, outputPath, {
 			ModelName: modelName,
 			DelegateName: delegateName,
 			FactoryImport: shouldBuildFactory ? `import { ${factoryName} } from '${factoryImportPath}'\n` : "",
 			FactoryLink: shouldBuildFactory ? outputExt === "js" ? `\n    static factoryClass = ${factoryName}` : `\n    protected static override factoryClass = ${factoryName}` : ""
 		}, options);
-		const prisma = this.ensurePrismaModelEntry(modelName, delegateName);
+		const prisma = this.isUsingPrismaAdapter() ? this.ensurePrismaModelEntry(modelName, delegateName) : void 0;
 		const created = {
 			model: {
 				name: modelName,
@@ -1873,10 +2929,7 @@ var CliApp = class {
 	*/
 	ensurePrismaModelEntry(modelName, delegateName) {
 		const schemaPath = join$1(process.cwd(), "prisma", "schema.prisma");
-		if (!existsSync$1(schemaPath)) return {
-			path: schemaPath,
-			updated: false
-		};
+		if (!existsSync$1(schemaPath)) return void 0;
 		const source = readFileSync$1(schemaPath, "utf-8");
 		const existingByTable = findModelBlock(source, delegateName);
 		const existingByName = new RegExp(`model\\s+${modelName}\\s*\\{`, "m").test(source);
@@ -2135,6 +3188,35 @@ var CliApp = class {
 			skipped
 		};
 	}
+	applyPersistedFieldMetadata(structure) {
+		const persistedMetadata = getPersistedTableMetadata(structure.table, {
+			features: resolvePersistedMetadataFeatures(this.getConfig("features")),
+			strict: true
+		});
+		if (Object.keys(persistedMetadata.columns).length === 0 && Object.keys(persistedMetadata.enums).length === 0) return structure;
+		const attributesByColumn = Object.entries(persistedMetadata.columns).reduce((all, [attribute, column]) => {
+			all[column] = attribute;
+			return all;
+		}, {});
+		return {
+			...structure,
+			fields: structure.fields.map((field) => {
+				const logicalName = attributesByColumn[field.name] ?? field.name;
+				const enumValues = persistedMetadata.enums[logicalName] ?? persistedMetadata.enums[field.name];
+				if (!enumValues || enumValues.length === 0) return {
+					...field,
+					name: logicalName
+				};
+				const enumType = getPersistedEnumTsType(enumValues);
+				const isArray = /^Array<.+>$/.test(field.type);
+				return {
+					...field,
+					name: logicalName,
+					type: isArray ? `Array<${enumType}>` : enumType
+				};
+			})
+		};
+	}
 	/**
 	* Parse Prisma enum definitions from a schema and return their member names.
 	*
@@ -2293,7 +3375,10 @@ var CliApp = class {
 				return all;
 			}, /* @__PURE__ */ new Map());
 			const discovered = await adapter.introspectModels({ tables: [...new Set([...sources.values()].map((source) => source.table))] });
-			const structuresByTable = new Map(discovered.map((model) => [model.table, model]));
+			const structuresByTable = new Map(discovered.map((model) => {
+				const enriched = this.applyPersistedFieldMetadata(model);
+				return [enriched.table, enriched];
+			}));
 			const result = this.syncModelFiles(modelFiles, (filePath) => {
 				const parsed = sources.get(filePath);
 				return parsed ? structuresByTable.get(parsed.table) : void 0;
@@ -2457,6 +3542,7 @@ var MakeModelCommand = class extends Command {
         {--factory : Create and link a factory}
         {--seeder : Create a seeder}
         {--migration : Create a migration}
+        {--p|pivot : Indicate the required model is an intermediate pivot model}
         {--all : Create and link factory, seeder, and migration}
     `;
 	description = "Create a new model and optional linked resources";
@@ -2470,14 +3556,13 @@ var MakeModelCommand = class extends Command {
 		const name = this.argument("name");
 		if (!name) return void this.error("Error: Name argument is required.");
 		const created = this.app.makeModel(name, this.options());
+		const createdFiles = [["Model", created.model.path]];
+		if (created.prisma) createdFiles.push([`Prisma schema ${created.prisma.updated ? "(updated)" : "(already up to date)"}`, created.prisma.path]);
+		if (created.factory) createdFiles.push(["Factory", created.factory.path]);
+		if (created.seeder) createdFiles.push(["Seeder", created.seeder.path]);
+		if (created.migration) createdFiles.push(["Migration", created.migration.path]);
 		this.success("Created files:");
-		[
-			["Model", created.model.path],
-			[`Prisma schema ${created.prisma.updated ? "(updated)" : "(already up to date)"}`, created.prisma.path],
-			created.factory ? ["Factory", created.factory.path] : "",
-			created.seeder ? ["Seeder", created.seeder.path] : "",
-			created.migration ? ["Migration", created.migration.path] : ""
-		].filter(Boolean).map(([name, path]) => this.success(this.app.splitLogger(name, path)));
+		createdFiles.map(([fileType, path]) => this.success(this.app.splitLogger(fileType, path)));
 	}
 };
 
@@ -2507,112 +3592,6 @@ var MakeSeederCommand = class extends Command {
 	}
 };
 
-//#endregion
-//#region src/helpers/migration-history.ts
-const DEFAULT_STATE = {
-	version: 1,
-	migrations: [],
-	runs: []
-};
-const resolveMigrationStateFilePath = (cwd, configuredPath) => {
-	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
-	return join(cwd, ".arkormx", "migrations.applied.json");
-};
-const buildMigrationIdentity = (filePath, className) => {
-	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
-	return `${fileName.slice(0, fileName.length - extname(fileName).length)}:${className}`;
-};
-const computeMigrationChecksum = (filePath) => {
-	const source = readFileSync(filePath, "utf-8");
-	return createHash("sha256").update(source).digest("hex");
-};
-const readAppliedMigrationsState = (stateFilePath) => {
-	if (!existsSync(stateFilePath)) return { ...DEFAULT_STATE };
-	try {
-		const parsed = JSON.parse(readFileSync(stateFilePath, "utf-8"));
-		if (!Array.isArray(parsed.migrations)) return { ...DEFAULT_STATE };
-		return {
-			version: 1,
-			migrations: parsed.migrations.filter((migration) => {
-				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
-			}),
-			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
-				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
-			}) : []
-		};
-	} catch {
-		return { ...DEFAULT_STATE };
-	}
-};
-const writeAppliedMigrationsState = (stateFilePath, state) => {
-	const directory = dirname(stateFilePath);
-	if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
-	writeFileSync(stateFilePath, JSON.stringify(state, null, 2));
-};
-const isMigrationApplied = (state, identity, checksum) => {
-	const matched = state.migrations.find((migration) => migration.id === identity);
-	if (!matched) return false;
-	if (checksum && matched.checksum) return matched.checksum === checksum;
-	if (checksum && !matched.checksum) return false;
-	return true;
-};
-const findAppliedMigration = (state, identity) => {
-	return state.migrations.find((migration) => migration.id === identity);
-};
-const markMigrationApplied = (state, entry) => {
-	const next = state.migrations.filter((migration) => migration.id !== entry.id);
-	next.push(entry);
-	return {
-		version: 1,
-		migrations: next,
-		runs: state.runs ?? []
-	};
-};
-const removeAppliedMigration = (state, identity) => {
-	return {
-		version: 1,
-		migrations: state.migrations.filter((migration) => migration.id !== identity),
-		runs: (state.runs ?? []).map((run) => ({
-			...run,
-			migrationIds: run.migrationIds.filter((id) => id !== identity)
-		})).filter((run) => run.migrationIds.length > 0)
-	};
-};
-const buildMigrationRunId = () => {
-	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-};
-const markMigrationRun = (state, run) => {
-	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
-	nextRuns.push(run);
-	return {
-		version: 1,
-		migrations: state.migrations,
-		runs: nextRuns
-	};
-};
-const getLastMigrationRun = (state) => {
-	const runs = state.runs ?? [];
-	if (runs.length === 0) return void 0;
-	return runs.map((run, index) => ({
-		run,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	})[0]?.run;
-};
-const getLatestAppliedMigrations = (state, steps) => {
-	return state.migrations.map((migration, index) => ({
-		migration,
-		index
-	})).sort((left, right) => {
-		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
-		if (appliedAtOrder !== 0) return appliedAtOrder;
-		return right.index - left.index;
-	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
-};
-
 //#endregion
 //#region src/database/Migration.ts
 const MIGRATION_BRAND = Symbol.for("arkormx.migration");
@@ -2667,7 +3646,10 @@ var MigrateCommand = class extends Command {
 		const classes = this.option("all") || !this.argument("name") ? await this.loadAllMigrations(migrationsDir) : (await this.loadNamedMigration(migrationsDir, this.argument("name"))).filter(([cls]) => cls !== void 0);
 		if (classes.length === 0) return void this.error("Error: No migration classes found to run.");
 		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
-		let appliedState = readAppliedMigrationsState(stateFilePath);
+		let appliedState = await readAppliedMigrationsStateFromStore(this.app.getConfig("adapter"), stateFilePath);
+		const adapter = this.app.getConfig("adapter");
+		const useDatabaseMigrations = supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = resolvePersistedMetadataFeatures(this.app.getConfig("features"));
 		const skipped = [];
 		const changed = [];
 		const pending = classes.filter(([migrationClass, file]) => {
@@ -2686,13 +3668,31 @@ var MigrateCommand = class extends Command {
 			this.success(this.app.splitLogger("Changed", `${file} (${migrationClass.name})`));
 		});
 		if (pending.length === 0) {
+			if (appliedState) try {
+				await syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
+			} catch (error) {
+				this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
 			this.success("No pending migration classes to apply.");
 			return;
 		}
-		for (const [MigrationClassItem] of pending) await applyMigrationToPrismaSchema(MigrationClassItem, {
-			schemaPath,
-			write: true
-		});
+		if (useDatabaseMigrations) try {
+			await validatePersistedMetadataFeaturesForMigrations(pending, persistedFeatures);
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		for (const [MigrationClassItem] of pending) {
+			if (useDatabaseMigrations) {
+				await applyMigrationToDatabase(adapter, MigrationClassItem);
+				continue;
+			}
+			await applyMigrationToPrismaSchema(MigrationClassItem, {
+				schemaPath,
+				write: true
+			});
+		}
 		if (appliedState) {
 			const runAppliedIds = [];
 			for (const [migrationClass, file] of pending) {
@@ -2711,10 +3711,16 @@ var MigrateCommand = class extends Command {
 				appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				migrationIds: runAppliedIds
 			});
-			writeAppliedMigrationsState(stateFilePath, appliedState);
+			await writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+			try {
+				await syncPersistedColumnMappingsFromState(process.cwd(), appliedState, await this.loadAllMigrations(migrationsDir), persistedFeatures);
+			} catch (error) {
+				this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
 		}
-		if (!this.option("skip-generate")) runPrismaCommand(["generate"], process.cwd());
-		if (!this.option("skip-migrate")) if (this.option("deploy")) runPrismaCommand(["migrate", "deploy"], process.cwd());
+		if (!useDatabaseMigrations && !this.option("skip-generate")) runPrismaCommand(["generate"], process.cwd());
+		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) runPrismaCommand(["migrate", "deploy"], process.cwd());
 		else runPrismaCommand([
 			"migrate",
 			"dev",
@@ -2774,6 +3780,103 @@ var MigrateCommand = class extends Command {
 	}
 };
 
+//#endregion
+//#region src/cli/commands/MigrateFreshCommand.ts
+var MigrateFreshCommand = class extends Command {
+	signature = `migrate:fresh
+        {--skip-generate : Skip prisma generate}
+        {--skip-migrate : Skip prisma database sync}
+        {--state-file= : Path to applied migration state file}
+        {--schema= : Explicit prisma schema path}
+    `;
+	description = "Reset the database and rerun all migration classes";
+	async handle() {
+		this.app.command = this;
+		const configuredMigrationsDir = this.app.getConfig("paths")?.migrations ?? join(process.cwd(), "database", "migrations");
+		const migrationsDir = this.app.resolveRuntimeDirectoryPath(configuredMigrationsDir);
+		if (!existsSync(migrationsDir)) return void this.error(`Error: Migrations directory not found: ${this.app.formatPathForLog(configuredMigrationsDir)}`);
+		const adapter = this.app.getConfig("adapter");
+		const useDatabaseMigrations = supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = resolvePersistedMetadataFeatures(this.app.getConfig("features"));
+		const schemaPath = this.option("schema") ? resolve(String(this.option("schema"))) : join(process.cwd(), "prisma", "schema.prisma");
+		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		const migrations = await this.loadAllMigrations(migrationsDir);
+		if (migrations.length === 0) return void this.error("Error: No migration classes found to run.");
+		if (useDatabaseMigrations) try {
+			await validatePersistedMetadataFeaturesForMigrations(migrations, persistedFeatures);
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		if (useDatabaseMigrations) {
+			if (!supportsDatabaseReset(adapter)) {
+				this.error("Error: Your current database adapter does not support database reset.");
+				return;
+			}
+			await adapter.resetDatabase();
+		} else {
+			if (!existsSync(schemaPath)) return void this.error(`Error: Prisma schema file not found: ${this.app.formatPathForLog(schemaPath)}`);
+			writeFileSync(schemaPath, stripPrismaSchemaModelsAndEnums(readFileSync(schemaPath, "utf-8")));
+		}
+		let appliedState = createEmptyAppliedMigrationsState();
+		await writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		for (const [MigrationClassItem] of migrations) {
+			if (useDatabaseMigrations) {
+				await applyMigrationToDatabase(adapter, MigrationClassItem);
+				continue;
+			}
+			await applyMigrationToPrismaSchema(MigrationClassItem, {
+				schemaPath,
+				write: true
+			});
+		}
+		for (const [migrationClass, file] of migrations) appliedState = markMigrationApplied(appliedState, {
+			id: buildMigrationIdentity(file, migrationClass.name),
+			file,
+			className: migrationClass.name,
+			appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			checksum: computeMigrationChecksum(file)
+		});
+		appliedState = markMigrationRun(appliedState, {
+			id: buildMigrationRunId(),
+			appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			migrationIds: appliedState.migrations.map((migration) => migration.id)
+		});
+		await writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		try {
+			await syncPersistedColumnMappingsFromState(process.cwd(), appliedState, migrations, persistedFeatures);
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		if (!useDatabaseMigrations) {
+			const schemaArgs = this.option("schema") ? ["--schema", schemaPath] : [];
+			if (!this.option("skip-generate")) runPrismaCommand(["generate", ...schemaArgs], process.cwd());
+			if (!this.option("skip-migrate")) runPrismaCommand([
+				"db",
+				"push",
+				"--force-reset",
+				...schemaArgs
+			], process.cwd());
+		}
+		this.success(`Refreshed database with ${migrations.length} migration(s).`);
+		migrations.forEach(([_, file]) => this.success(this.app.splitLogger("Migrated", file)));
+	}
+	async loadAllMigrations(migrationsDir) {
+		const files = readdirSync(migrationsDir).filter((file) => /\.(ts|js|mjs|cjs)$/i.test(file)).sort((left, right) => left.localeCompare(right)).map((file) => this.app.resolveRuntimeScriptPath(join(migrationsDir, file)));
+		return (await Promise.all(files.map(async (file) => (await this.loadMigrationClassesFromFile(file)).map((cls) => [cls, file])))).flat();
+	}
+	async loadMigrationClassesFromFile(filePath) {
+		const imported = await RuntimeModuleLoader.load(filePath);
+		return Object.values(imported).filter((value) => {
+			if (typeof value !== "function") return false;
+			const candidate = value;
+			const prototype = candidate.prototype;
+			return candidate[MIGRATION_BRAND] === true || typeof prototype?.up === "function" && typeof prototype?.down === "function";
+		});
+	}
+};
+
 //#endregion
 //#region src/cli/commands/MigrateRollbackCommand.ts
 /**
@@ -2802,7 +3905,10 @@ var MigrateRollbackCommand = class extends Command {
 		if (!existsSync(migrationsDir)) return void this.error(`Error: Migrations directory not found: ${this.app.formatPathForLog(configuredMigrationsDir)}`);
 		const schemaPath = this.option("schema") ? resolve(String(this.option("schema"))) : join(process.cwd(), "prisma", "schema.prisma");
 		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
-		let appliedState = readAppliedMigrationsState(stateFilePath);
+		const adapter = this.app.getConfig("adapter");
+		const useDatabaseMigrations = supportsDatabaseMigrationExecution(adapter);
+		const persistedFeatures = resolvePersistedMetadataFeatures(this.app.getConfig("features"));
+		let appliedState = await readAppliedMigrationsStateFromStore(adapter, stateFilePath);
 		const stepOption = this.option("step");
 		const stepCount = stepOption == null ? void 0 : Number(stepOption);
 		if (stepCount != null && (!Number.isFinite(stepCount) || stepCount <= 0 || !Number.isInteger(stepCount))) return void this.error("Error: --step must be a positive integer.");
@@ -2824,17 +3930,29 @@ var MigrateRollbackCommand = class extends Command {
 			rollbackClasses.forEach(([_, file]) => this.success(this.app.splitLogger("WouldRollback", file)));
 			return;
 		}
-		for (const [MigrationClassItem] of rollbackClasses) await applyMigrationRollbackToPrismaSchema(MigrationClassItem, {
-			schemaPath,
-			write: true
-		});
+		for (const [MigrationClassItem] of rollbackClasses) {
+			if (useDatabaseMigrations) {
+				await applyMigrationRollbackToDatabase(adapter, MigrationClassItem);
+				continue;
+			}
+			await applyMigrationRollbackToPrismaSchema(MigrationClassItem, {
+				schemaPath,
+				write: true
+			});
+		}
 		for (const [migrationClass, file] of rollbackClasses) {
 			const identity = buildMigrationIdentity(file, migrationClass.name);
 			appliedState = removeAppliedMigration(appliedState, identity);
 		}
-		writeAppliedMigrationsState(stateFilePath, appliedState);
-		if (!this.option("skip-generate")) runPrismaCommand(["generate"], process.cwd());
-		if (!this.option("skip-migrate")) if (this.option("deploy")) runPrismaCommand(["migrate", "deploy"], process.cwd());
+		await writeAppliedMigrationsStateToStore(adapter, stateFilePath, appliedState);
+		try {
+			await syncPersistedColumnMappingsFromState(process.cwd(), appliedState, available, persistedFeatures);
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		if (!useDatabaseMigrations && !this.option("skip-generate")) runPrismaCommand(["generate"], process.cwd());
+		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) runPrismaCommand(["migrate", "deploy"], process.cwd());
 		else runPrismaCommand([
 			"migrate",
 			"dev",
@@ -2878,32 +3996,39 @@ var MigrationHistoryCommand = class extends Command {
 	async handle() {
 		this.app.command = this;
 		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		const adapter = this.app.getConfig("adapter");
+		const usesDatabaseState = supportsDatabaseMigrationState(adapter);
 		if (this.option("delete")) {
+			if (usesDatabaseState) {
+				await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
+				deletePersistedColumnMappingsState(resolveColumnMappingsFilePath(process.cwd()));
+				this.success("Deleted tracked migration state from database.");
+				return;
+			}
 			if (!existsSync(stateFilePath)) {
 				this.success(`No migration state file found at ${this.app.formatPathForLog(stateFilePath)}`);
 				return;
 			}
 			rmSync(stateFilePath);
+			deletePersistedColumnMappingsState(resolveColumnMappingsFilePath(process.cwd()));
 			this.success(`Deleted migration state file: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
 		if (this.option("reset")) {
-			writeAppliedMigrationsState(stateFilePath, {
-				version: 1,
-				migrations: []
-			});
-			this.success(`Reset migration state: ${this.app.formatPathForLog(stateFilePath)}`);
+			await writeAppliedMigrationsStateToStore(adapter, stateFilePath, createEmptyAppliedMigrationsState());
+			deletePersistedColumnMappingsState(resolveColumnMappingsFilePath(process.cwd()));
+			this.success(usesDatabaseState ? "Reset migration state in database." : `Reset migration state: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
-		const state = readAppliedMigrationsState(stateFilePath);
+		const state = await readAppliedMigrationsStateFromStore(adapter, stateFilePath);
 		if (this.option("json")) {
 			this.success(JSON.stringify({
-				path: stateFilePath,
+				path: usesDatabaseState ? "database" : stateFilePath,
 				...state
 			}, null, 2));
 			return;
 		}
-		this.success(this.app.splitLogger("State", stateFilePath));
+		this.success(this.app.splitLogger("State", usesDatabaseState ? "database" : stateFilePath));
 		this.success(this.app.splitLogger("Tracked", String(state.migrations.length)));
 		if (state.migrations.length === 0) {
 			this.success("No tracked migrations found.");
@@ -2925,10 +4050,16 @@ var ModelsSyncCommand = class extends Command {
 	description = "Sync model declare attributes from the active adapter when supported, otherwise fall back to the Prisma schema";
 	async handle() {
 		this.app.command = this;
-		const result = await this.app.syncModels({
-			schemaPath: this.option("schema") ? resolve(String(this.option("schema"))) : void 0,
-			modelsDir: this.option("models") ? resolve(String(this.option("models"))) : void 0
-		});
+		let result;
+		try {
+			result = await this.app.syncModels({
+				schemaPath: this.option("schema") ? resolve(String(this.option("schema"))) : void 0,
+				modelsDir: this.option("models") ? resolve(String(this.option("models"))) : void 0
+			});
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
 		const updatedLines = result.updated.length === 0 ? [this.app.splitLogger("Updated", "none")] : result.updated.map((path) => this.app.splitLogger("Updated", path));
 		this.success("SUCCESS: Model sync completed with the following results:");
 		[
@@ -3096,6 +4227,7 @@ await Kernel.init(app, {
 		ModelsSyncCommand,
 		SeedCommand,
 		MigrateCommand,
+		MigrateFreshCommand,
 		MigrateRollbackCommand,
 		MigrationHistoryCommand
 	],