arkormx 2.0.0-next.3 → 2.0.0-next.4

package/dist/cli.mjs

@@ -3,6 +3,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync
 import { dirname, extname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { str } from "@h3ravel/support";
+import { createHash } from "node:crypto";
 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";
@@ -12,7 +13,6 @@ import { createRequire } from "module";
 import { fileURLToPath } from "url";
 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 {
@@ -1436,6 +1436,377 @@ const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) =>
 	};
 };
 
+//#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/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"))) 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;
+		}, {})
+	};
+};
+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) 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;
+		}, {})
+	};
+};
+const getPersistedEnumMap = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).enums;
+};
+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];
+	});
+};
+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;
+			}, {})
+		};
+		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);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0) 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);
+			});
+			operation.dropColumns.forEach((columnName) => {
+				removePersistedColumnMetadata(tableMetadata, columnName);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0) 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 {
@@ -1463,6 +1834,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"),
@@ -1475,6 +1850,7 @@ const baseConfig = {
 };
 const userConfig = {
 	...baseConfig,
+	features: { ...baseConfig.features ?? {} },
 	paths: { ...baseConfig.paths ?? {} }
 };
 let runtimeConfigLoaded = false;
@@ -1497,6 +1873,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);
@@ -1522,6 +1907,7 @@ const getUserConfig = (key) => {
 const configureArkormRuntime = (prisma, options = {}) => {
 	const nextConfig = {
 		...userConfig,
+		features: mergeFeatureConfig(options.features),
 		paths: mergePathConfig(options.paths)
 	};
 	nextConfig.prisma = prisma;
@@ -1566,6 +1952,7 @@ const resolveAndApplyConfig = (imported) => {
 	configureArkormRuntime(config.prisma, {
 		adapter: config.adapter,
 		boot: config.boot,
+		features: config.features,
 		pagination: config.pagination,
 		paths: config.paths,
 		outputExt: config.outputExt
@@ -2157,6 +2544,26 @@ var CliApp = class {
 			skipped
 		};
 	}
+	applyPersistedEnumMetadata(structure) {
+		const persistedEnums = getPersistedEnumMap(structure.table, {
+			features: resolvePersistedMetadataFeatures(this.getConfig("features")),
+			strict: true
+		});
+		if (Object.keys(persistedEnums).length === 0) return structure;
+		return {
+			...structure,
+			fields: structure.fields.map((field) => {
+				const enumValues = persistedEnums[field.name];
+				if (!enumValues || enumValues.length === 0) return field;
+				const enumType = getPersistedEnumTsType(enumValues);
+				const isArray = /^Array<.+>$/.test(field.type);
+				return {
+					...field,
+					type: isArray ? `Array<${enumType}>` : enumType
+				};
+			})
+		};
+	}
 	/**
 	* Parse Prisma enum definitions from a schema and return their member names.
 	*
@@ -2315,7 +2722,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.applyPersistedEnumMetadata(model);
+				return [enriched.table, enriched];
+			}));
 			const result = this.syncModelFiles(modelFiles, (filePath) => {
 				const parsed = sources.get(filePath);
 				return parsed ? structuresByTable.get(parsed.table) : void 0;
@@ -2529,126 +2939,6 @@ var MakeSeederCommand = class extends Command {
 	}
 };
 
-//#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/database/Migration.ts
 const MIGRATION_BRAND = Symbol.for("arkormx.migration");
@@ -2706,6 +2996,7 @@ var MigrateCommand = class extends Command {
 		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]) => {
@@ -2724,9 +3015,21 @@ 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;
 		}
+		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);
@@ -2756,6 +3059,12 @@ var MigrateCommand = class extends Command {
 				migrationIds: runAppliedIds
 			});
 			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 (!useDatabaseMigrations && !this.option("skip-generate")) runPrismaCommand(["generate"], process.cwd());
 		if (!useDatabaseMigrations && !this.option("skip-migrate")) if (this.option("deploy")) runPrismaCommand(["migrate", "deploy"], process.cwd());
@@ -2835,12 +3144,24 @@ var MigrateFreshCommand = class extends Command {
 		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 (supportsDatabaseReset(adapter)) await adapter.resetDatabase();
-		else {
+		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")));
 		}
@@ -2869,6 +3190,12 @@ var MigrateFreshCommand = class extends Command {
 			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());
@@ -2927,6 +3254,7 @@ var MigrateRollbackCommand = class extends Command {
 		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
 		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);
@@ -2964,6 +3292,12 @@ var MigrateRollbackCommand = class extends Command {
 			appliedState = removeAppliedMigration(appliedState, identity);
 		}
 		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([
@@ -3014,6 +3348,7 @@ var MigrationHistoryCommand = class extends Command {
 		if (this.option("delete")) {
 			if (usesDatabaseState) {
 				await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
+				deletePersistedColumnMappingsState(resolveColumnMappingsFilePath(process.cwd()));
 				this.success("Deleted tracked migration state from database.");
 				return;
 			}
@@ -3022,11 +3357,13 @@ var MigrationHistoryCommand = class extends Command {
 				return;
 			}
 			rmSync(stateFilePath);
+			deletePersistedColumnMappingsState(resolveColumnMappingsFilePath(process.cwd()));
 			this.success(`Deleted migration state file: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
 		if (this.option("reset")) {
 			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;
 		}
@@ -3060,10 +3397,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:");
 		[