arkormx 2.0.0-next.2 → 2.0.0-next.3

package/dist/index.mjs

@@ -78,6 +78,8 @@ var UnsupportedAdapterFeatureException = class extends ArkormException {
 * @since 2.0.0-next.0
 */
 var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
+	static migrationStateTable = "arkormx_migrations";
+	static migrationRunTable = "arkormx_migration_runs";
 	capabilities = {
 		transactions: true,
 		returning: true,
@@ -95,6 +97,161 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		this.db = db;
 		this.mapping = mapping;
 	}
+	quoteIdentifier(value) {
+		return `"${value.replace(/"/g, "\"\"")}"`;
+	}
+	quoteLiteral(value) {
+		if (value == null) return "null";
+		if (typeof value === "number" || typeof value === "bigint") return String(value);
+		if (typeof value === "boolean") return value ? "true" : "false";
+		if (value instanceof Date) return `'${value.toISOString().replace(/'/g, "''")}'`;
+		return `'${String(value).replace(/'/g, "''")}'`;
+	}
+	async executeRawStatement(statement, executor = this.db) {
+		await sql.raw(statement).execute(executor);
+	}
+	resolveSchemaColumnName(columnName, columns = []) {
+		return columns.find((column) => column.name === columnName)?.map ?? columnName;
+	}
+	resolveSchemaIndexName(table, index) {
+		if (typeof index.name === "string" && index.name.trim().length > 0) return index.name;
+		return `${table}_${index.columns.join("_")}_idx`;
+	}
+	resolveSchemaForeignKeyName(table, foreignKey) {
+		return `${table}_${foreignKey.column}_fkey`;
+	}
+	resolveSchemaColumnType(column) {
+		if (column.type === "id") return "integer";
+		if (column.type === "uuid") return "uuid";
+		if (column.type === "enum") return this.quoteIdentifier(column.enumName ?? `${column.name}_enum`);
+		if (column.type === "string") return "varchar(255)";
+		if (column.type === "text") return "text";
+		if (column.type === "integer") return "integer";
+		if (column.type === "bigInteger") return "bigint";
+		if (column.type === "float") return "double precision";
+		if (column.type === "boolean") return "boolean";
+		if (column.type === "json") return "jsonb";
+		if (column.type === "date") return "date";
+		return "timestamptz";
+	}
+	resolveSchemaColumnDefault(column) {
+		const value = column.default ?? (column.updatedAt ? "now()" : void 0);
+		if (value === void 0) return null;
+		if (value === "now()") return "now()";
+		return this.quoteLiteral(value);
+	}
+	shouldUseIdentity(column) {
+		if (column.autoIncrement === false) return false;
+		if (column.type === "id") return column.default === void 0;
+		return column.autoIncrement === true;
+	}
+	buildSchemaColumnDefinition(column) {
+		const parts = [this.quoteIdentifier(column.map ?? column.name), this.resolveSchemaColumnType(column)];
+		if (this.shouldUseIdentity(column)) parts.push("generated by default as identity");
+		const defaultValue = this.resolveSchemaColumnDefault(column);
+		if (defaultValue && !this.shouldUseIdentity(column)) parts.push(`default ${defaultValue}`);
+		if (column.primary) parts.push("primary key");
+		else if (column.unique) parts.push("unique");
+		if (!column.nullable && !column.primary) parts.push("not null");
+		return parts.join(" ");
+	}
+	buildSchemaForeignKeyConstraint(table, foreignKey, columns = []) {
+		const localColumn = this.resolveSchemaColumnName(foreignKey.column, columns);
+		const referencedTable = this.resolveMappedTable(foreignKey.referencesTable);
+		const action = foreignKey.onDelete ? ` on delete ${foreignKey.onDelete === "setNull" ? "set null" : foreignKey.onDelete === "setDefault" ? "set default" : foreignKey.onDelete}` : "";
+		return `constraint ${this.quoteIdentifier(this.resolveSchemaForeignKeyName(table, foreignKey))} foreign key (${this.quoteIdentifier(localColumn)}) references ${this.quoteIdentifier(referencedTable)} (${this.quoteIdentifier(foreignKey.referencesColumn)})${action}`;
+	}
+	buildSchemaIndexStatement(table, index, columns = []) {
+		const mappedColumns = index.columns.map((column) => this.quoteIdentifier(this.resolveSchemaColumnName(column, columns))).join(", ");
+		return `create index if not exists ${this.quoteIdentifier(this.resolveSchemaIndexName(table, index))} on ${this.quoteIdentifier(table)} (${mappedColumns})`;
+	}
+	async ensureEnumTypes(columns, executor = this.db) {
+		for (const column of columns) {
+			if (column.type !== "enum") continue;
+			const enumName = column.enumName ?? `${column.name}_enum`;
+			if ((await sql`
+                select exists(
+                    select 1
+                    from pg_type
+                    where typname = ${enumName}
+                ) as exists
+            `.execute(executor)).rows[0]?.exists) continue;
+			const values = column.enumValues ?? [];
+			if (values.length === 0) throw new ArkormException(`Enum column [${column.name}] requires enum values for database-backed migrations.`);
+			await this.executeRawStatement(`create type ${this.quoteIdentifier(enumName)} as enum (${values.map((value) => this.quoteLiteral(value)).join(", ")})`, executor);
+		}
+	}
+	async executeCreateTableOperation(operation, executor) {
+		const table = this.resolveMappedTable(operation.table);
+		await this.ensureEnumTypes(operation.columns, executor);
+		const columnDefinitions = operation.columns.map((column) => this.buildSchemaColumnDefinition(column));
+		const foreignKeys = (operation.foreignKeys ?? []).map((foreignKey) => this.buildSchemaForeignKeyConstraint(table, foreignKey, operation.columns));
+		const definitions = [...columnDefinitions, ...foreignKeys].join(", ");
+		await this.executeRawStatement(`create table if not exists ${this.quoteIdentifier(table)} (${definitions})`, executor);
+		for (const index of operation.indexes ?? []) await this.executeRawStatement(this.buildSchemaIndexStatement(table, index, operation.columns), executor);
+	}
+	async executeAlterTableOperation(operation, executor) {
+		const table = this.resolveMappedTable(operation.table);
+		await this.ensureEnumTypes(operation.addColumns, executor);
+		for (const column of operation.addColumns) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add column if not exists ${this.buildSchemaColumnDefinition(column)}`, executor);
+		for (const column of operation.dropColumns) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} drop column if exists ${this.quoteIdentifier(column)}`, executor);
+		for (const foreignKey of operation.addForeignKeys ?? []) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add ${this.buildSchemaForeignKeyConstraint(table, foreignKey, operation.addColumns)}`, executor);
+		for (const index of operation.addIndexes ?? []) await this.executeRawStatement(this.buildSchemaIndexStatement(table, index, operation.addColumns), executor);
+	}
+	async executeDropTableOperation(operation, executor) {
+		const table = this.resolveMappedTable(operation.table);
+		await this.executeRawStatement(`drop table if exists ${this.quoteIdentifier(table)} cascade`, executor);
+	}
+	async ensureMigrationStateTables(executor = this.db) {
+		await this.executeRawStatement(`
+            create table if not exists ${this.quoteIdentifier(KyselyDatabaseAdapter.migrationStateTable)} (
+                id text primary key,
+                file text not null,
+                class_name text not null,
+                applied_at timestamptz not null,
+                checksum text null
+            )
+        `, executor);
+		await this.executeRawStatement(`
+            create table if not exists ${this.quoteIdentifier(KyselyDatabaseAdapter.migrationRunTable)} (
+                id text primary key,
+                applied_at timestamptz not null,
+                migration_ids jsonb not null
+            )
+        `, executor);
+	}
+	async writeAppliedMigrationsStateInternal(state, executor) {
+		await this.ensureMigrationStateTables(executor);
+		await this.executeRawStatement(`delete from ${this.quoteIdentifier(KyselyDatabaseAdapter.migrationRunTable)}`, executor);
+		await this.executeRawStatement(`delete from ${this.quoteIdentifier(KyselyDatabaseAdapter.migrationStateTable)}`, executor);
+		for (const migration of state.migrations) await sql`
+                insert into ${sql.table(KyselyDatabaseAdapter.migrationStateTable)} (id, file, class_name, applied_at, checksum)
+                values (${migration.id}, ${migration.file}, ${migration.className}, ${migration.appliedAt}, ${migration.checksum ?? null})
+            `.execute(executor);
+		for (const run of state.runs ?? []) await sql`
+                insert into ${sql.table(KyselyDatabaseAdapter.migrationRunTable)} (id, applied_at, migration_ids)
+                values (${run.id}, ${run.appliedAt}, cast(${JSON.stringify(run.migrationIds)} as jsonb))
+            `.execute(executor);
+	}
+	async resetDatabaseInternal(executor) {
+		const tablesResult = await sql`
+            select table_name, table_schema
+            from information_schema.tables
+            where table_schema = current_schema()
+              and table_type = 'BASE TABLE'
+            order by table_name asc
+        `.execute(executor);
+		for (const row of tablesResult.rows) await this.executeRawStatement(`drop table if exists ${this.quoteIdentifier(row.table_schema)}.${this.quoteIdentifier(row.table_name)} cascade`, executor);
+		const enumTypesResult = await sql`
+            select t.typname as enum_name, n.nspname as enum_schema
+            from pg_type t
+            inner join pg_namespace n on n.oid = t.typnamespace
+            where t.typtype = 'e'
+              and n.nspname = current_schema()
+            order by t.typname asc
+        `.execute(executor);
+		for (const row of enumTypesResult.rows) await this.executeRawStatement(`drop type if exists ${this.quoteIdentifier(row.enum_schema)}.${this.quoteIdentifier(row.enum_name)} cascade`, executor);
+	}
 	introspectionTypeToTs(typeName, enumValues) {
 		if (enumValues && enumValues.length > 0) return enumValues.map((value) => `'${value.replace(/'/g, "\\'")}'`).join(" | ");
 		switch (typeName) {
@@ -721,6 +878,63 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		});
 		return [...models.values()];
 	}
+	async executeSchemaOperations(operations) {
+		if (operations.length === 0) return;
+		await this.transaction(async (adapter) => {
+			const transactionAdapter = adapter;
+			for (const operation of operations) {
+				if (operation.type === "createTable") {
+					await transactionAdapter.executeCreateTableOperation(operation, transactionAdapter.db);
+					continue;
+				}
+				if (operation.type === "alterTable") {
+					await transactionAdapter.executeAlterTableOperation(operation, transactionAdapter.db);
+					continue;
+				}
+				await transactionAdapter.executeDropTableOperation(operation, transactionAdapter.db);
+			}
+		});
+	}
+	async resetDatabase() {
+		await this.transaction(async (adapter) => {
+			const transactionAdapter = adapter;
+			await transactionAdapter.resetDatabaseInternal(transactionAdapter.db);
+		});
+	}
+	async readAppliedMigrationsState() {
+		await this.ensureMigrationStateTables();
+		const migrationsResult = await sql`
+            select id, file, class_name, applied_at, checksum
+            from ${sql.table(KyselyDatabaseAdapter.migrationStateTable)}
+            order by applied_at asc, id asc
+        `.execute(this.db);
+		const runsResult = await sql`
+            select id, applied_at, migration_ids
+            from ${sql.table(KyselyDatabaseAdapter.migrationRunTable)}
+            order by applied_at asc, id asc
+        `.execute(this.db);
+		return {
+			version: 1,
+			migrations: migrationsResult.rows.map((row) => ({
+				id: row.id,
+				file: row.file,
+				className: row.class_name,
+				appliedAt: row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),
+				checksum: row.checksum ?? void 0
+			})),
+			runs: runsResult.rows.map((row) => ({
+				id: row.id,
+				appliedAt: row.applied_at instanceof Date ? row.applied_at.toISOString() : String(row.applied_at),
+				migrationIds: Array.isArray(row.migration_ids) ? row.migration_ids.filter((value) => typeof value === "string") : typeof row.migration_ids === "string" ? JSON.parse(row.migration_ids) : []
+			}))
+		};
+	}
+	async writeAppliedMigrationsState(state) {
+		await this.transaction(async (adapter) => {
+			const transactionAdapter = adapter;
+			await transactionAdapter.writeAppliedMigrationsStateInternal(state, transactionAdapter.db);
+		});
+	}
 	/**
 	* Executes a series of database operations within a transaction. 
 	* The provided callback function is called with a new instance of the 
@@ -2909,6 +3123,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 
@@ -3889,10 +4125,13 @@ var MakeSeederCommand = class extends Command {
 
 //#endregion
 //#region src/helpers/migration-history.ts
-const DEFAULT_STATE = {
+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);
@@ -3907,10 +4146,10 @@ const computeMigrationChecksum = (filePath) => {
 	return createHash("sha256").update(source).digest("hex");
 };
 const readAppliedMigrationsState = (stateFilePath) => {
-	if (!existsSync$1(stateFilePath)) return { ...DEFAULT_STATE };
+	if (!existsSync$1(stateFilePath)) return createEmptyAppliedMigrationsState();
 	try {
 		const parsed = JSON.parse(readFileSync$1(stateFilePath, "utf-8"));
-		if (!Array.isArray(parsed.migrations)) return { ...DEFAULT_STATE };
+		if (!Array.isArray(parsed.migrations)) return createEmptyAppliedMigrationsState();
 		return {
 			version: 1,
 			migrations: parsed.migrations.filter((migration) => {
@@ -3921,14 +4160,34 @@ const readAppliedMigrationsState = (stateFilePath) => {
 			}) : []
 		};
 	} catch {
-		return { ...DEFAULT_STATE };
+		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$1(directory)) mkdirSync$1(directory, { recursive: true });
 	writeFileSync$1(stateFilePath, JSON.stringify(state, null, 2));
 };
+const writeAppliedMigrationsStateToStore = async (adapter, stateFilePath, state) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(state);
+		return;
+	}
+	writeAppliedMigrationsState(stateFilePath, state);
+};
+const deleteAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
+		return "database";
+	}
+	if (!existsSync$1(stateFilePath)) return "missing-file";
+	writeAppliedMigrationsState(stateFilePath, createEmptyAppliedMigrationsState());
+	return "file";
+};
 const isMigrationApplied = (state, identity, checksum) => {
 	const matched = state.migrations.find((migration) => migration.id === identity);
 	if (!matched) return false;
@@ -4047,7 +4306,9 @@ 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 skipped = [];
 		const changed = [];
 		const pending = classes.filter(([migrationClass, file]) => {
@@ -4069,10 +4330,16 @@ var MigrateCommand = class extends Command {
 			this.success("No pending migration classes to apply.");
 			return;
 		}
-		for (const [MigrationClassItem] of pending) await applyMigrationToPrismaSchema(MigrationClassItem, {
-			schemaPath,
-			write: true
-		});
+		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) {
@@ -4091,10 +4358,10 @@ var MigrateCommand = class extends Command {
 				appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				migrationIds: runAppliedIds
 			});
-			writeAppliedMigrationsState(stateFilePath, appliedState);
+			await writeAppliedMigrationsStateToStore(adapter, 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());
+		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",
@@ -4154,6 +4421,85 @@ 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$1(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 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 (!existsSync$1(schemaPath)) return void this.error(`Error: Prisma schema file not found: ${this.app.formatPathForLog(schemaPath)}`);
+			writeFileSync$1(schemaPath, stripPrismaSchemaModelsAndEnums(readFileSync$1(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);
+		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$1(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
 /**
@@ -4182,7 +4528,9 @@ var MigrateRollbackCommand = class extends Command {
 		if (!existsSync$1(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);
+		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.");
@@ -4204,17 +4552,23 @@ 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);
+		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",
@@ -4258,7 +4612,14 @@ 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());
+				this.success("Deleted tracked migration state from database.");
+				return;
+			}
 			if (!existsSync$1(stateFilePath)) {
 				this.success(`No migration state file found at ${this.app.formatPathForLog(stateFilePath)}`);
 				return;
@@ -4268,22 +4629,19 @@ var MigrationHistoryCommand = class extends Command {
 			return;
 		}
 		if (this.option("reset")) {
-			writeAppliedMigrationsState(stateFilePath, {
-				version: 1,
-				migrations: []
-			});
-			this.success(`Reset migration state: ${this.app.formatPathForLog(stateFilePath)}`);
+			await writeAppliedMigrationsStateToStore(adapter, stateFilePath, createEmptyAppliedMigrationsState());
+			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.");
@@ -9250,4 +9608,4 @@ var Model = class Model {
 };
 
 //#endregion
-export { ArkormCollection, ArkormException, Attribute, CliApp, EnumBuilder, ForeignKeyBuilder, InitCommand, InlineFactory, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateRollbackCommand, Migration, MigrationHistoryCommand, MissingDelegateException, Model, ModelFactory, ModelNotFoundException, ModelsSyncCommand, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, Paginator, PrismaDatabaseAdapter, QueryBuilder, QueryConstraintException, RelationResolutionException, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, ScopeNotDefinedException, SeedCommand, Seeder, TableBuilder, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToPrismaSchema, applyMigrationToPrismaSchema, applyOperationsToPrismaSchema, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildRelationLine, computeMigrationChecksum, configureArkormRuntime, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getRuntimeAdapter, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isTransactionCapableClient, loadArkormConfig, markMigrationApplied, markMigrationRun, pad, readAppliedMigrationsState, removeAppliedMigration, resetArkormRuntimeForTests, resolveCast, resolveEnumName, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePrismaType, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, toMigrationFileSlug, toModelName, writeAppliedMigrationsState };
+export { ArkormCollection, ArkormException, Attribute, CliApp, EnumBuilder, ForeignKeyBuilder, InitCommand, InlineFactory, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateFreshCommand, MigrateRollbackCommand, Migration, MigrationHistoryCommand, MissingDelegateException, Model, ModelFactory, ModelNotFoundException, ModelsSyncCommand, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, Paginator, PrismaDatabaseAdapter, QueryBuilder, QueryConstraintException, RelationResolutionException, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, ScopeNotDefinedException, SeedCommand, Seeder, TableBuilder, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToDatabase, applyMigrationRollbackToPrismaSchema, applyMigrationToDatabase, applyMigrationToPrismaSchema, applyOperationsToPrismaSchema, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildRelationLine, computeMigrationChecksum, configureArkormRuntime, createEmptyAppliedMigrationsState, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deleteAppliedMigrationsStateFromStore, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getRuntimeAdapter, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isTransactionCapableClient, loadArkormConfig, markMigrationApplied, markMigrationRun, pad, readAppliedMigrationsState, readAppliedMigrationsStateFromStore, removeAppliedMigration, resetArkormRuntimeForTests, resolveCast, resolveEnumName, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePrismaType, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, stripPrismaSchemaModelsAndEnums, supportsDatabaseMigrationExecution, supportsDatabaseMigrationState, supportsDatabaseReset, toMigrationFileSlug, toModelName, writeAppliedMigrationsState, writeAppliedMigrationsStateToStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arkormx",
-  "version": "2.0.0-next.2",
+  "version": "2.0.0-next.3",
   "description": "Modern TypeScript-first ORM for Node.js.",
   "keywords": [
     "orm",