arkormx 2.0.0-next.1 → 2.0.0-next.3

package/README.md

@@ -7,12 +7,12 @@
 [![Deploy Documentation](https://github.com/arkstack-hq/arkormx/actions/workflows/deploy-docs.yml/badge.svg)](https://github.com/arkstack-hq/arkormx/actions/workflows/deploy-docs.yml)
 [![codecov](https://codecov.io/gh/arkstack-hq/arkormx/graph/badge.svg?token=ls1VVoFkYh)](https://codecov.io/gh/arkstack-hq/arkormx)
 
-Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It brings a familiar model layer and fluent query builder on top of Prisma delegates, enabling clean, modern, and type-safe development.
+Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It brings a familiar model layer and fluent query builder on top of adapter-backed execution, with Prisma compatibility kept during the current transition window.
 
 ## Features
 
-- Arkormˣ is built on top of Prisma, providing a familiar and powerful API for database interactions.
-- Delegate-backed query execution with practical ORM ergonomics.
+- Adapter-backed query execution with practical ORM ergonomics.
+- Adapter-first runtime setup with Kysely/Postgres support and a Prisma compatibility adapter during migration.
 - End-to-end guides for setup, querying, relationships, migrations, and CLI usage.
 - Full TypeScript support, providing strong typing and improved developer experience.
 - Follows best practices for security, ensuring your data is protected.
@@ -26,27 +26,49 @@ Arkormˣ is a framework-agnostic ORM designed to run anywhere Node.js runs. It b
 Stable release:
 
 ```sh
-pnpm add arkormx @prisma/client
-pnpm add -D prisma
+pnpm add arkormx kysely pg
 ```
 
 Preview release (`next`):
 
 ```sh
-pnpm add arkormx@next @prisma/client
-pnpm add -D prisma
+pnpm add arkormx@next kysely pg
 ```
 
 ### Configuration
 
+Primary runtime path:
+
+```ts
+import { createKyselyAdapter, defineConfig } from 'arkormx';
+import { Kysely, PostgresDialect } from 'kysely';
+import { Pool } from 'pg';
+
+export default defineConfig({
+  adapter: createKyselyAdapter(
+    new Kysely<Record<string, never>>({
+      dialect: new PostgresDialect({
+        pool: new Pool({
+          connectionString: process.env.DATABASE_URL,
+        }),
+      }),
+    }),
+  ),
+});
+```
+
+Optional compatibility/runtime config for CLI and transaction helpers:
+
 Create `arkormx.config.js` in your project root:
 
 ```ts
 import { defineConfig } from 'arkormx';
 import { PrismaClient } from '@prisma/client';
 
+const prisma = new PrismaClient();
+
 export default defineConfig({
-  prisma: new PrismaClient(...),
+  prisma: () => prisma,
 });
 ```
 
@@ -57,15 +79,21 @@ Or run the Arkormˣ CLI command `npx arkorm init` to initialize your project alo
 ```ts
 import { Model } from 'arkormx';
 
-export class User extends Model<'users'> {
-  protected static override delegate = 'users'; // not required if your model name matches the delegate name or the pluralized form of it
-}
+type UserAttributes = {
+  id: number;
+  email: string;
+  name: string;
+  isActive: boolean;
+};
+
+export class User extends Model<UserAttributes> {}
 ```
 
-### Generate Prisma client
+### Optional Prisma compatibility
 
 ```sh
-pnpm prisma generate
+pnpm add @prisma/client
+pnpm add -D prisma
 ```
 
 ### Run queries
@@ -98,6 +126,7 @@ await User.transaction(async () => {
 
 - [Setup](https://arkormx.toneflix.net/guide/setup)
 - [Configuration](https://arkormx.dev/guide/configuration)
+- [Prisma Compatibility](https://arkormx.dev/guide/prisma-compatibility)
 - [Typing](https://arkormx.dev/guide/typing)
 - [Models](https://arkormx.dev/guide/models)
 - [Query Builder](https://arkormx.dev/guide/query-builder)

package/dist/cli.mjs

@@ -1371,6 +1371,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 
@@ -1458,6 +1480,7 @@ const userConfig = {
 let runtimeConfigLoaded = false;
 let runtimeConfigLoadingPromise;
 let runtimeClientResolver;
+let runtimeAdapter;
 let runtimePaginationURLDriverFactory;
 let runtimePaginationCurrentPageResolver;
 const transactionClientStorage = new AsyncLocalStorage();
@@ -1474,6 +1497,12 @@ const mergePathConfig = (paths) => {
 		...incoming
 	};
 };
+const bindAdapterToModels = (adapter, models) => {
+	models.forEach((model) => {
+		model.setAdapter(adapter);
+	});
+	return adapter;
+};
 /**
 * Get the user-provided ArkORM configuration. 
 * 
@@ -1493,15 +1522,35 @@ const getUserConfig = (key) => {
 const configureArkormRuntime = (prisma, options = {}) => {
 	const nextConfig = {
 		...userConfig,
-		prisma,
 		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.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
 	Object.assign(userConfig, { ...nextConfig });
 	runtimeClientResolver = prisma;
+	runtimeAdapter = options.adapter;
 	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
 	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+	options.boot?.({
+		prisma: resolveClient(prisma),
+		bindAdapter: bindAdapterToModels
+	});
+};
+/**
+* Resolve a Prisma client instance from the provided resolver, which can be either
+* a direct client instance or a function that returns a client instance.
+* 
+* @param resolver 
+* @returns 
+*/
+const resolveClient = (resolver) => {
+	if (!resolver) return void 0;
+	const client = typeof resolver === "function" ? resolver() : resolver;
+	if (!client || typeof client !== "object") return void 0;
+	return client;
 };
 /**
 * Resolve and apply the ArkORM configuration from an imported module. 
@@ -1513,8 +1562,10 @@ const configureArkormRuntime = (prisma, options = {}) => {
 */
 const resolveAndApplyConfig = (imported) => {
 	const config = imported?.default ?? imported;
-	if (!config || typeof config !== "object" || !config.prisma) return;
+	if (!config || typeof config !== "object") return;
 	configureArkormRuntime(config.prisma, {
+		adapter: config.adapter,
+		boot: config.boot,
 		pagination: config.pagination,
 		paths: config.paths,
 		outputExt: config.outputExt
@@ -2072,6 +2123,40 @@ var CliApp = class {
 		lines.splice(insertionIndex, 0, `import type { ${enumTypes.join(", ")} } from '@prisma/client'`);
 		return lines.join("\n");
 	}
+	parseModelSyncSource(modelSource) {
+		const classMatch = modelSource.match(/export\s+class\s+(\w+)\s+extends\s+Model(?:<[^\n]+>)?\s*\{/);
+		if (!classMatch) return null;
+		const className = classMatch[1];
+		const tableMatch = modelSource.match(/protected\s+static\s+override\s+table\s*=\s*['"]([^'"]+)['"]/) ?? modelSource.match(/static\s+table\s*=\s*['"]([^'"]+)['"]/);
+		const delegateMatch = modelSource.match(/protected\s+static\s+override\s+delegate\s*=\s*['"]([^'"]+)['"]/) ?? modelSource.match(/static\s+delegate\s*=\s*['"]([^'"]+)['"]/);
+		return {
+			className,
+			table: tableMatch?.[1] ?? delegateMatch?.[1] ?? str(className).camel().plural().toString()
+		};
+	}
+	syncModelFiles(modelFiles, resolveStructure, enums) {
+		const updated = [];
+		const skipped = [];
+		modelFiles.forEach((filePath) => {
+			const source = readFileSync$1(filePath, "utf-8");
+			const structure = resolveStructure(filePath, source);
+			if (!structure || structure.fields.length === 0) {
+				skipped.push(filePath);
+				return;
+			}
+			const synced = this.syncModelDeclarations(source, structure.fields, enums);
+			if (!synced.updated) {
+				skipped.push(filePath);
+				return;
+			}
+			writeFileSync$1(filePath, synced.content);
+			updated.push(filePath);
+		});
+		return {
+			updated,
+			skipped
+		};
+	}
 	/**
 	* Parse Prisma enum definitions from a schema and return their member names.
 	*
@@ -2164,7 +2249,7 @@ var CliApp = class {
 	*/
 	syncModelDeclarations(modelSource, declarations, enums) {
 		const lines = modelSource.split("\n");
-		const classIndex = lines.findIndex((line) => /export\s+class\s+\w+\s+extends\s+Model<.+>\s*\{/.test(line));
+		const classIndex = lines.findIndex((line) => /export\s+class\s+\w+\s+extends\s+Model(?:<[^\n]+>)?\s*\{/.test(line));
 		if (classIndex < 0) return {
 			content: modelSource,
 			updated: false
@@ -2218,6 +2303,36 @@ var CliApp = class {
 			updated: contentWithImports !== modelSource
 		};
 	}
+	async syncModels(options = {}) {
+		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", join$1(process.cwd(), "src", "models"));
+		if (!existsSync$1(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
+		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => join$1(modelsDir, file));
+		const adapter = this.getConfig("adapter");
+		if (adapter && typeof adapter.introspectModels === "function") {
+			const sources = modelFiles.reduce((all, filePath) => {
+				const parsed = this.parseModelSyncSource(readFileSync$1(filePath, "utf-8"));
+				if (parsed) all.set(filePath, parsed);
+				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 result = this.syncModelFiles(modelFiles, (filePath) => {
+				const parsed = sources.get(filePath);
+				return parsed ? structuresByTable.get(parsed.table) : void 0;
+			}, /* @__PURE__ */ new Map());
+			return {
+				source: "adapter",
+				modelsDir,
+				total: modelFiles.length,
+				updated: result.updated,
+				skipped: result.skipped
+			};
+		}
+		return {
+			source: "prisma",
+			...this.syncModelsFromPrisma(options)
+		};
+	}
 	/**
 	* Sync model attribute declarations in model files based on the Prisma schema.
 	* This method reads the Prisma schema to extract model definitions and their 
@@ -2237,38 +2352,18 @@ var CliApp = class {
 		const schema = readFileSync$1(schemaPath, "utf-8");
 		const prismaEnums = this.parsePrismaEnums(schema);
 		const prismaModels = this.parsePrismaModels(schema);
-		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts"));
-		const updated = [];
-		const skipped = [];
-		modelFiles.forEach((file) => {
-			const filePath = join$1(modelsDir, file);
-			const source = readFileSync$1(filePath, "utf-8");
-			const classMatch = source.match(/export\s+class\s+(\w+)\s+extends\s+Model<'([^']+)'>/);
-			if (!classMatch) {
-				skipped.push(filePath);
-				return;
-			}
-			const className = classMatch[1];
-			const delegate = classMatch[2];
-			const prismaModel = prismaModels.find((model) => model.table === delegate) ?? prismaModels.find((model) => model.name === className);
-			if (!prismaModel || prismaModel.fields.length === 0) {
-				skipped.push(filePath);
-				return;
-			}
-			const synced = this.syncModelDeclarations(source, prismaModel.fields, prismaEnums);
-			if (!synced.updated) {
-				skipped.push(filePath);
-				return;
-			}
-			writeFileSync$1(filePath, synced.content);
-			updated.push(filePath);
-		});
+		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => join$1(modelsDir, file));
+		const result = this.syncModelFiles(modelFiles, (filePath, source) => {
+			const parsed = this.parseModelSyncSource(source);
+			if (!parsed) return void 0;
+			return prismaModels.find((model) => model.table === parsed.table) ?? prismaModels.find((model) => model.name === parsed.className);
+		}, prismaEnums);
 		return {
 			schemaPath,
 			modelsDir,
 			total: modelFiles.length,
-			updated,
-			skipped
+			updated: result.updated,
+			skipped: result.skipped
 		};
 	}
 };
@@ -2436,10 +2531,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);
@@ -2454,10 +2552,10 @@ const computeMigrationChecksum = (filePath) => {
 	return createHash("sha256").update(source).digest("hex");
 };
 const readAppliedMigrationsState = (stateFilePath) => {
-	if (!existsSync(stateFilePath)) return { ...DEFAULT_STATE };
+	if (!existsSync(stateFilePath)) return createEmptyAppliedMigrationsState();
 	try {
 		const parsed = JSON.parse(readFileSync(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) => {
@@ -2468,14 +2566,25 @@ 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(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;
@@ -2594,7 +2703,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]) => {
@@ -2616,10 +2727,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) {
@@ -2638,10 +2755,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",
@@ -2701,6 +2818,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(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(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);
+		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
 /**
@@ -2729,7 +2925,9 @@ 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);
+		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.");
@@ -2751,17 +2949,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",
@@ -2805,7 +3009,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(stateFilePath)) {
 				this.success(`No migration state file found at ${this.app.formatPathForLog(stateFilePath)}`);
 				return;
@@ -2815,22 +3026,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.");
@@ -2846,20 +3054,21 @@ var MigrationHistoryCommand = class extends Command {
 //#region src/cli/commands/ModelsSyncCommand.ts
 var ModelsSyncCommand = class extends Command {
 	signature = `models:sync
-        {--schema= : Path to prisma schema file}
+        {--schema= : Path to prisma schema file used when adapter introspection is unavailable}
         {--models= : Path to models directory}
     `;
-	description = "Sync model declare attributes from prisma schema for all model files";
+	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 = this.app.syncModelsFromPrisma({
+		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
 		});
 		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:");
 		[
-			this.app.splitLogger("Schema", result.schemaPath),
+			this.app.splitLogger("Source", result.source === "adapter" ? "adapter introspection" : "prisma schema"),
+			...result.schemaPath ? [this.app.splitLogger("Schema", result.schemaPath)] : [],
 			this.app.splitLogger("Models", result.modelsDir),
 			this.app.splitLogger("Processed", String(result.total)),
 			...updatedLines,
@@ -3022,6 +3231,7 @@ await Kernel.init(app, {
 		ModelsSyncCommand,
 		SeedCommand,
 		MigrateCommand,
+		MigrateFreshCommand,
 		MigrateRollbackCommand,
 		MigrationHistoryCommand
 	],