arkormx 0.2.4 → 0.2.6

package/dist/cli.mjs

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
-import path, { dirname, extname, join, relative } from "path";
-import { createRequire } from "module";
-import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, writeFileSync as writeFileSync$1 } from "node:fs";
-import { join as join$1, resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, extname, join, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { str } from "@h3ravel/support";
+import path, { dirname as dirname$1, extname as extname$1, join as join$1, relative } from "path";
+import { copyFileSync, existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, readdirSync as readdirSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "fs";
 import { fileURLToPath, pathToFileURL } from "url";
+import { createRequire } from "module";
 import { Logger } from "@h3ravel/shared";
 import { Command, Kernel } from "@h3ravel/musket";
+import { createHash } from "node:crypto";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
 
 //#region src/Exceptions/ArkormException.ts
@@ -1007,14 +1008,14 @@ const generateMigrationFile = (name, options = {}) => {
 	const fileSlug = toMigrationFileSlug(name);
 	const className = resolveMigrationClassName(name);
 	const extension = options.extension ?? "ts";
-	const directory = options.directory ?? join$1(process.cwd(), "database", "migrations");
+	const directory = options.directory ?? join(process.cwd(), "database", "migrations");
 	const fileName = `${timestamp}_${fileSlug}.${extension}`;
-	const filePath = join$1(directory, fileName);
+	const filePath = join(directory, fileName);
 	const content = buildMigrationSource(className, extension);
 	if (options.write ?? true) {
-		if (!existsSync$1(directory)) mkdirSync$1(directory, { recursive: true });
-		if (existsSync$1(filePath)) throw new ArkormException(`Migration file already exists: ${filePath}`);
-		writeFileSync$1(filePath, content);
+		if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+		if (existsSync(filePath)) throw new ArkormException(`Migration file already exists: ${filePath}`);
+		writeFileSync(filePath, content);
 	}
 	return {
 		fileName,
@@ -1047,12 +1048,32 @@ const getMigrationPlan = async (migration, direction = "up") => {
 * @returns         A promise that resolves to an object containing the updated schema, schema path, and list of operations applied.
 */
 const applyMigrationToPrismaSchema = async (migration, options = {}) => {
-	const schemaPath = options.schemaPath ?? join$1(process.cwd(), "prisma", "schema.prisma");
-	if (!existsSync$1(schemaPath)) throw new ArkormException(`Prisma schema file not found: ${schemaPath}`);
-	const source = readFileSync$1(schemaPath, "utf-8");
+	const schemaPath = options.schemaPath ?? join(process.cwd(), "prisma", "schema.prisma");
+	if (!existsSync(schemaPath)) throw new ArkormException(`Prisma schema file not found: ${schemaPath}`);
+	const source = readFileSync(schemaPath, "utf-8");
 	const operations = await getMigrationPlan(migration, "up");
 	const schema = applyOperationsToPrismaSchema(source, operations);
-	if (options.write ?? true) writeFileSync$1(schemaPath, schema);
+	if (options.write ?? true) writeFileSync(schemaPath, schema);
+	return {
+		schema,
+		schemaPath,
+		operations
+	};
+};
+/**
+* Apply the rollback (down) operations defined in a migration to a Prisma schema file.
+*
+* @param migration The migration class or instance to rollback.
+* @param options   Options for applying the rollback, including schema path and write flag.
+* @returns         A promise that resolves to an object containing the updated schema, schema path, and rollback operations applied.
+*/
+const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) => {
+	const schemaPath = options.schemaPath ?? join(process.cwd(), "prisma", "schema.prisma");
+	if (!existsSync(schemaPath)) throw new ArkormException(`Prisma schema file not found: ${schemaPath}`);
+	const source = readFileSync(schemaPath, "utf-8");
+	const operations = await getMigrationPlan(migration, "down");
+	const schema = applyOperationsToPrismaSchema(source, operations);
+	if (options.write ?? true) writeFileSync(schemaPath, schema);
 	return {
 		schema,
 		schemaPath,
@@ -1067,7 +1088,7 @@ const resolveDefaultStubsPath = () => {
 	while (true) {
 		const packageJsonPath = path.join(current, "package.json");
 		const stubsPath = path.join(current, "stubs");
-		if (existsSync(packageJsonPath) && existsSync(stubsPath)) return stubsPath;
+		if (existsSync$1(packageJsonPath) && existsSync$1(stubsPath)) return stubsPath;
 		const parent = path.dirname(current);
 		if (parent === current) break;
 		current = parent;
@@ -1166,7 +1187,7 @@ const loadRuntimeConfigSync = () => {
 	const require = createRequire(import.meta.url);
 	const syncConfigPaths = [path.join(process.cwd(), "arkormx.config.cjs")];
 	for (const configPath of syncConfigPaths) {
-		if (!existsSync(configPath)) continue;
+		if (!existsSync$1(configPath)) continue;
 		try {
 			resolveAndApplyConfig(require(configPath));
 			return true;
@@ -1188,7 +1209,7 @@ const loadArkormConfig = async () => {
 	runtimeConfigLoadingPromise = (async () => {
 		const configPaths = [path.join(process.cwd(), "arkormx.config.js"), path.join(process.cwd(), "arkormx.config.ts")];
 		for (const configPath of configPaths) {
-			if (!existsSync(configPath)) continue;
+			if (!existsSync$1(configPath)) continue;
 			try {
 				resolveAndApplyConfig(await importConfigFile(configPath));
 				return;
@@ -1232,8 +1253,8 @@ var CliApp = class {
 	* @param filePath
 	*/
 	ensureDirectory(filePath) {
-		const dir = dirname(filePath);
-		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const dir = dirname$1(filePath);
+		if (!existsSync$1(dir)) mkdirSync$1(dir, { recursive: true });
 	}
 	/**
 	* Convert absolute paths under current working directory into relative display paths.
@@ -1282,13 +1303,13 @@ var CliApp = class {
 	* @returns
 	*/
 	resolveRuntimeDirectoryPath(directoryPath) {
-		if (existsSync(directoryPath)) return directoryPath;
+		if (existsSync$1(directoryPath)) return directoryPath;
 		const { buildOutput } = this.getConfig("paths") || {};
 		if (typeof buildOutput !== "string" || buildOutput.trim().length === 0) return directoryPath;
 		const relativeSource = relative(process.cwd(), directoryPath);
 		if (!relativeSource || relativeSource.startsWith("..")) return directoryPath;
-		const mappedDirectory = join(buildOutput, relativeSource);
-		return existsSync(mappedDirectory) ? mappedDirectory : directoryPath;
+		const mappedDirectory = join$1(buildOutput, relativeSource);
+		return existsSync$1(mappedDirectory) ? mappedDirectory : directoryPath;
 	}
 	/**
 	* Resolve a script file path for runtime execution.
@@ -1299,7 +1320,7 @@ var CliApp = class {
 	* @returns
 	*/
 	resolveRuntimeScriptPath(filePath) {
-		const extension = extname(filePath).toLowerCase();
+		const extension = extname$1(filePath).toLowerCase();
 		const isTsFile = extension === ".ts" || extension === ".mts" || extension === ".cts";
 		const candidates = [];
 		if (isTsFile) {
@@ -1310,15 +1331,15 @@ var CliApp = class {
 		if (typeof buildOutput === "string" && buildOutput.trim().length > 0) {
 			const relativeSource = relative(process.cwd(), filePath);
 			if (relativeSource && !relativeSource.startsWith("..")) {
-				const mappedFile = join(buildOutput, relativeSource);
-				const mappedExtension = extname(mappedFile).toLowerCase();
+				const mappedFile = join$1(buildOutput, relativeSource);
+				const mappedExtension = extname$1(mappedFile).toLowerCase();
 				if (mappedExtension === ".ts" || mappedExtension === ".mts" || mappedExtension === ".cts") {
 					const mappedBase = mappedFile.slice(0, -mappedExtension.length);
 					candidates.push(`${mappedBase}.js`, `${mappedBase}.cjs`, `${mappedBase}.mjs`);
 				} else candidates.push(mappedFile);
 			}
 		}
-		const runtimeMatch = candidates.find((path) => existsSync(path));
+		const runtimeMatch = candidates.find((path) => existsSync$1(path));
 		if (runtimeMatch) return runtimeMatch;
 		return filePath;
 	}
@@ -1330,14 +1351,14 @@ var CliApp = class {
 	* @param replacements
 	*/
 	generateFile(stubPath, outputPath, replacements, options) {
-		if (existsSync(outputPath) && !options?.force) {
+		if (existsSync$1(outputPath) && !options?.force) {
 			this.command.error(`Error: ${this.formatPathForLog(outputPath)} already exists.`);
 			process.exit(1);
-		} else if (existsSync(outputPath) && options?.force) rmSync(outputPath);
-		let content = readFileSync(stubPath, "utf-8");
+		} else if (existsSync$1(outputPath) && options?.force) rmSync$1(outputPath);
+		let content = readFileSync$1(stubPath, "utf-8");
 		for (const [key, value] of Object.entries(replacements)) content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
 		this.ensureDirectory(outputPath);
-		writeFileSync(outputPath, content);
+		writeFileSync$1(outputPath, content);
 		return outputPath;
 	}
 	/**
@@ -1359,7 +1380,7 @@ var CliApp = class {
 	* @returns 
 	*/
 	resolveStubPath(stubName) {
-		return join(this.resolveConfigPath("stubs", getDefaultStubsPath()), stubName);
+		return join$1(this.resolveConfigPath("stubs", getDefaultStubsPath()), stubName);
 	}
 	/**
 	* Generate a factory file for a given model name.
@@ -1373,9 +1394,9 @@ var CliApp = class {
 		const factoryName = `${baseName}Factory`;
 		const modelName = options.modelName ? str(options.modelName).pascal() : baseName;
 		const outputExt = this.resolveOutputExt();
-		const outputPath = join(this.resolveConfigPath("factories", join(process.cwd(), "database", "factories")), `${factoryName}.${outputExt}`);
-		const modelPath = join(this.resolveConfigPath("models", join(process.cwd(), "src", "models")), `${modelName}.${outputExt}`);
-		const relativeImport = options.modelImportPath ?? `./${this.stripKnownSourceExtension(relative(dirname(outputPath), modelPath).replace(/\\/g, "/"))}${outputExt === "js" ? ".js" : ""}`;
+		const outputPath = join$1(this.resolveConfigPath("factories", join$1(process.cwd(), "database", "factories")), `${factoryName}.${outputExt}`);
+		const modelPath = join$1(this.resolveConfigPath("models", join$1(process.cwd(), "src", "models")), `${modelName}.${outputExt}`);
+		const relativeImport = options.modelImportPath ?? `./${this.stripKnownSourceExtension(relative(dirname$1(outputPath), modelPath).replace(/\\/g, "/"))}${outputExt === "js" ? ".js" : ""}`;
 		const stubPath = this.resolveStubPath(outputExt === "js" ? "factory.js.stub" : "factory.stub");
 		return {
 			name: factoryName,
@@ -1396,7 +1417,7 @@ var CliApp = class {
 	makeSeeder(name, options = {}) {
 		const seederName = `${str(name.replace(/Seeder$/, "")).pascal()}Seeder`;
 		const outputExt = this.resolveOutputExt();
-		const outputPath = join(this.resolveConfigPath("seeders", join(process.cwd(), "database", "seeders")), `${seederName}.${outputExt}`);
+		const outputPath = join$1(this.resolveConfigPath("seeders", join$1(process.cwd(), "database", "seeders")), `${seederName}.${outputExt}`);
 		const stubPath = this.resolveStubPath(outputExt === "js" ? "seeder.js.stub" : "seeder.stub");
 		return {
 			name: seederName,
@@ -1411,7 +1432,7 @@ var CliApp = class {
 	*/
 	makeMigration(name) {
 		const generated = generateMigrationFile(name, {
-			directory: this.resolveConfigPath("migrations", join(process.cwd(), "database", "migrations")),
+			directory: this.resolveConfigPath("migrations", join$1(process.cwd(), "database", "migrations")),
 			extension: this.resolveOutputExt()
 		});
 		return {
@@ -1431,13 +1452,13 @@ var CliApp = class {
 		const modelName = `${baseName}`;
 		const delegateName = str(baseName).camel().plural().toString();
 		const outputExt = this.resolveOutputExt();
-		const outputPath = join(this.resolveConfigPath("models", join(process.cwd(), "src", "models")), `${modelName}.${outputExt}`);
+		const outputPath = join$1(this.resolveConfigPath("models", join$1(process.cwd(), "src", "models")), `${modelName}.${outputExt}`);
 		const shouldBuildFactory = options.all || options.factory;
 		const shouldBuildSeeder = options.all || options.seeder;
 		const shouldBuildMigration = options.all || options.migration;
 		const factoryName = `${baseName}Factory`;
-		const factoryPath = join(this.resolveConfigPath("factories", join(process.cwd(), "database", "factories")), `${factoryName}.${outputExt}`);
-		const factoryImportPath = `./${relative(dirname(outputPath), factoryPath).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "")}${outputExt === "js" ? ".js" : ""}`;
+		const factoryPath = join$1(this.resolveConfigPath("factories", join$1(process.cwd(), "database", "factories")), `${factoryName}.${outputExt}`);
+		const factoryImportPath = `./${relative(dirname$1(outputPath), factoryPath).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "")}${outputExt === "js" ? ".js" : ""}`;
 		const stubPath = this.resolveStubPath(outputExt === "js" ? "model.js.stub" : "model.stub");
 		const modelPath = this.generateFile(stubPath, outputPath, {
 			ModelName: modelName,
@@ -1459,7 +1480,7 @@ var CliApp = class {
 		if (shouldBuildFactory) created.factory = this.makeFactory(baseName, {
 			force: options.force,
 			modelName,
-			modelImportPath: `./${relative(dirname(factoryPath), outputPath).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "")}${outputExt === "js" ? ".js" : ""}`
+			modelImportPath: `./${relative(dirname$1(factoryPath), outputPath).replace(/\\/g, "/").replace(/\.(ts|tsx|mts|cts|js|mjs|cjs)$/i, "")}${outputExt === "js" ? ".js" : ""}`
 		});
 		if (shouldBuildSeeder) created.seeder = this.makeSeeder(baseName, { force: options.force });
 		if (shouldBuildMigration) created.migration = this.makeMigration(`create ${delegateName} table`);
@@ -1474,26 +1495,28 @@ var CliApp = class {
 	* @param delegateName The name of the delegate (table) to ensure in the Prisma schema.
 	*/
 	ensurePrismaModelEntry(modelName, delegateName) {
-		const schemaPath = join(process.cwd(), "prisma", "schema.prisma");
-		if (!existsSync(schemaPath)) return {
+		const schemaPath = join$1(process.cwd(), "prisma", "schema.prisma");
+		if (!existsSync$1(schemaPath)) return {
 			path: schemaPath,
 			updated: false
 		};
-		const source = readFileSync(schemaPath, "utf-8");
+		const source = readFileSync$1(schemaPath, "utf-8");
 		const existingByTable = findModelBlock(source, delegateName);
 		const existingByName = new RegExp(`model\\s+${modelName}\\s*\\{`, "m").test(source);
 		if (existingByTable || existingByName) return {
 			path: schemaPath,
 			updated: false
 		};
-		writeFileSync(schemaPath, applyCreateTableOperation(source, {
+		writeFileSync$1(schemaPath, applyCreateTableOperation(source, {
 			type: "createTable",
 			table: delegateName,
 			columns: [{
 				name: "id",
 				type: "id",
 				primary: true
-			}]
+			}],
+			indexes: [],
+			foreignKeys: []
 		}));
 		return {
 			path: schemaPath,
@@ -1545,14 +1568,14 @@ var CliApp = class {
 			body.split("\n").forEach((rawLine) => {
 				const line = rawLine.trim();
 				if (!line || line.startsWith("@@") || line.startsWith("//")) return;
-				const fieldMatch = line.match(/^(\w+)\s+([A-Za-z]+)(\?)?\b/);
+				const fieldMatch = line.match(/^(\w+)\s+([A-Za-z]+)(\?)?(?:\s|$)/);
 				if (!fieldMatch) return;
 				const fieldType = fieldMatch[2];
 				if (!scalarTypes.has(fieldType)) return;
 				fields.push({
 					name: fieldMatch[1],
 					type: this.prismaTypeToTs(fieldType),
-					optional: Boolean(fieldMatch[3])
+					nullable: Boolean(fieldMatch[3])
 				});
 			});
 			models.push({
@@ -1619,18 +1642,18 @@ var CliApp = class {
 	* @returns An object with details about the synchronization process, including updated and skipped files.
 	*/
 	syncModelsFromPrisma(options = {}) {
-		const schemaPath = options.schemaPath ?? join(process.cwd(), "prisma", "schema.prisma");
-		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", join(process.cwd(), "src", "models"));
-		if (!existsSync(schemaPath)) throw new Error(`Prisma schema file not found: ${schemaPath}`);
-		if (!existsSync(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
-		const schema = readFileSync(schemaPath, "utf-8");
+		const schemaPath = options.schemaPath ?? join$1(process.cwd(), "prisma", "schema.prisma");
+		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", join$1(process.cwd(), "src", "models"));
+		if (!existsSync$1(schemaPath)) throw new Error(`Prisma schema file not found: ${schemaPath}`);
+		if (!existsSync$1(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
+		const schema = readFileSync$1(schemaPath, "utf-8");
 		const prismaModels = this.parsePrismaModels(schema);
-		const modelFiles = readdirSync(modelsDir).filter((file) => file.endsWith(".ts"));
+		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts"));
 		const updated = [];
 		const skipped = [];
 		modelFiles.forEach((file) => {
-			const filePath = join(modelsDir, file);
-			const source = readFileSync(filePath, "utf-8");
+			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);
@@ -1643,13 +1666,13 @@ var CliApp = class {
 				skipped.push(filePath);
 				return;
 			}
-			const declarations = prismaModel.fields.map((field) => `declare ${field.name}${field.optional ? "?" : ""}: ${field.type}`);
+			const declarations = prismaModel.fields.map((field) => `declare ${field.name}: ${field.type}${field.nullable ? " | null" : ""}`);
 			const synced = this.syncModelDeclarations(source, declarations);
 			if (!synced.updated) {
 				skipped.push(filePath);
 				return;
 			}
-			writeFileSync(filePath, synced.content);
+			writeFileSync$1(filePath, synced.content);
 			updated.push(filePath);
 		});
 		return {
@@ -1681,23 +1704,23 @@ var InitCommand = class extends Command {
 	*/
 	async handle() {
 		this.app.command = this;
-		const outputDir = join$1(process.cwd(), "arkormx.config.js");
+		const outputDir = join(process.cwd(), "arkormx.config.js");
 		const { stubs } = getUserConfig("paths") ?? {};
 		const stubsDir = typeof stubs === "string" && stubs.trim().length > 0 ? stubs : getDefaultStubsPath();
-		const preferredStubPath = join$1(stubsDir, "arkormx.config.stub");
-		const legacyStubPath = join$1(stubsDir, "arkorm.config.stub");
-		const stubPath = existsSync(preferredStubPath) ? preferredStubPath : legacyStubPath;
-		if (existsSync(outputDir) && !this.option("force")) {
+		const preferredStubPath = join(stubsDir, "arkormx.config.stub");
+		const legacyStubPath = join(stubsDir, "arkorm.config.stub");
+		const stubPath = existsSync$1(preferredStubPath) ? preferredStubPath : legacyStubPath;
+		if (existsSync$1(outputDir) && !this.option("force")) {
 			this.error("Error: Arkormˣ has already been initialized. Use --force to reinitialize.");
 			process.exit(1);
 		}
 		this.app.ensureDirectory(outputDir);
-		if (existsSync(outputDir) && this.option("force")) copyFileSync(outputDir, outputDir.replace(/\.js$/, `.backup.${Date.now()}.js`));
-		if (!existsSync(stubPath)) {
+		if (existsSync$1(outputDir) && this.option("force")) copyFileSync(outputDir, outputDir.replace(/\.js$/, `.backup.${Date.now()}.js`));
+		if (!existsSync$1(stubPath)) {
 			this.error(`Error: Missing config stub at ${preferredStubPath} (or ${legacyStubPath})`);
 			process.exit(1);
 		}
-		writeFileSync(outputDir, readFileSync(stubPath, "utf-8"));
+		writeFileSync$1(outputDir, readFileSync$1(stubPath, "utf-8"));
 		this.success("Arkormˣ initialized successfully!");
 	}
 };
@@ -1823,6 +1846,98 @@ var MakeSeederCommand = class extends Command {
 	}
 };
 
+//#endregion
+//#region src/helpers/migration-history.ts
+const DEFAULT_STATE = {
+	version: 1,
+	migrations: [],
+	runs: []
+};
+const resolveMigrationStateFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
+	return join(cwd, ".arkormx", "migrations.applied.json");
+};
+const buildMigrationIdentity = (filePath, className) => {
+	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
+	return `${fileName.slice(0, fileName.length - extname(fileName).length)}:${className}`;
+};
+const computeMigrationChecksum = (filePath) => {
+	const source = readFileSync(filePath, "utf-8");
+	return createHash("sha256").update(source).digest("hex");
+};
+const readAppliedMigrationsState = (stateFilePath) => {
+	if (!existsSync(stateFilePath)) return { ...DEFAULT_STATE };
+	try {
+		const parsed = JSON.parse(readFileSync(stateFilePath, "utf-8"));
+		if (!Array.isArray(parsed.migrations)) return { ...DEFAULT_STATE };
+		return {
+			version: 1,
+			migrations: parsed.migrations.filter((migration) => {
+				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
+			}),
+			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
+				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
+			}) : []
+		};
+	} catch {
+		return { ...DEFAULT_STATE };
+	}
+};
+const writeAppliedMigrationsState = (stateFilePath, state) => {
+	const directory = dirname(stateFilePath);
+	if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
+	writeFileSync(stateFilePath, JSON.stringify(state, null, 2));
+};
+const isMigrationApplied = (state, identity, checksum) => {
+	const matched = state.migrations.find((migration) => migration.id === identity);
+	if (!matched) return false;
+	if (checksum && matched.checksum) return matched.checksum === checksum;
+	if (checksum && !matched.checksum) return false;
+	return true;
+};
+const findAppliedMigration = (state, identity) => {
+	return state.migrations.find((migration) => migration.id === identity);
+};
+const markMigrationApplied = (state, entry) => {
+	const next = state.migrations.filter((migration) => migration.id !== entry.id);
+	next.push(entry);
+	return {
+		version: 1,
+		migrations: next,
+		runs: state.runs ?? []
+	};
+};
+const removeAppliedMigration = (state, identity) => {
+	return {
+		version: 1,
+		migrations: state.migrations.filter((migration) => migration.id !== identity),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			migrationIds: run.migrationIds.filter((id) => id !== identity)
+		})).filter((run) => run.migrationIds.length > 0)
+	};
+};
+const buildMigrationRunId = () => {
+	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+};
+const markMigrationRun = (state, run) => {
+	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
+	nextRuns.push(run);
+	return {
+		version: 1,
+		migrations: state.migrations,
+		runs: nextRuns
+	};
+};
+const getLastMigrationRun = (state) => {
+	const runs = state.runs ?? [];
+	if (runs.length === 0) return void 0;
+	return [...runs].sort((left, right) => right.appliedAt.localeCompare(left.appliedAt))[0];
+};
+const getLatestAppliedMigrations = (state, steps) => {
+	return [...state.migrations].sort((left, right) => right.appliedAt.localeCompare(left.appliedAt)).slice(0, Math.max(0, steps));
+};
+
 //#endregion
 //#region src/database/Migration.ts
 const MIGRATION_BRAND = Symbol.for("arkormx.migration");
@@ -1854,6 +1969,7 @@ var MigrateCommand = class extends Command {
         {--deploy : Use prisma migrate deploy instead of migrate dev}
         {--skip-generate : Skip prisma generate}
         {--skip-migrate : Skip prisma migrate command}
+        {--state-file= : Path to applied migration state file}
         {--schema= : Explicit prisma schema path}
         {--migration-name= : Name for prisma migrate dev}
     `;
@@ -1869,16 +1985,59 @@ var MigrateCommand = class extends Command {
 	*/
 	async handle() {
 		this.app.command = this;
-		const configuredMigrationsDir = this.app.getConfig("paths")?.migrations ?? join$1(process.cwd(), "database", "migrations");
+		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 schemaPath = this.option("schema") ? resolve(String(this.option("schema"))) : join$1(process.cwd(), "prisma", "schema.prisma");
+		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 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.");
-		for (const [MigrationClassItem] of classes) await applyMigrationToPrismaSchema(MigrationClassItem, {
+		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		let appliedState = readAppliedMigrationsState(stateFilePath);
+		const skipped = [];
+		const changed = [];
+		const pending = classes.filter(([migrationClass, file]) => {
+			if (!appliedState) return true;
+			const identity = buildMigrationIdentity(file, migrationClass.name);
+			const checksum = computeMigrationChecksum(file);
+			const alreadyApplied = isMigrationApplied(appliedState, identity, checksum);
+			if (alreadyApplied) skipped.push([migrationClass, file]);
+			else if (findAppliedMigration(appliedState, identity)) changed.push([migrationClass, file]);
+			return !alreadyApplied;
+		});
+		skipped.forEach(([migrationClass, file]) => {
+			this.success(this.app.splitLogger("Skipped", `${file} (${migrationClass.name})`));
+		});
+		changed.forEach(([migrationClass, file]) => {
+			this.success(this.app.splitLogger("Changed", `${file} (${migrationClass.name})`));
+		});
+		if (pending.length === 0) {
+			this.success("No pending migration classes to apply.");
+			return;
+		}
+		for (const [MigrationClassItem] of pending) await applyMigrationToPrismaSchema(MigrationClassItem, {
 			schemaPath,
 			write: true
 		});
+		if (appliedState) {
+			const runAppliedIds = [];
+			for (const [migrationClass, file] of pending) {
+				const identity = buildMigrationIdentity(file, migrationClass.name);
+				appliedState = markMigrationApplied(appliedState, {
+					id: identity,
+					file,
+					className: migrationClass.name,
+					appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					checksum: computeMigrationChecksum(file)
+				});
+				runAppliedIds.push(identity);
+			}
+			appliedState = markMigrationRun(appliedState, {
+				id: buildMigrationRunId(),
+				appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				migrationIds: runAppliedIds
+			});
+			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());
 		else runPrismaCommand([
@@ -1887,8 +2046,8 @@ var MigrateCommand = class extends Command {
 			"--name",
 			this.option("migration-name") ? String(this.option("migration-name")) : `arkorm_cli_${Date.now()}`
 		], process.cwd());
-		this.success(`Applied ${classes.length} migration(s).`);
-		classes.forEach(([_, file]) => this.success(this.app.splitLogger("Migrated", file)));
+		this.success(`Applied ${pending.length} migration(s).`);
+		pending.forEach(([_, file]) => this.success(this.app.splitLogger("Migrated", file)));
 	}
 	/**
 	* Load all migration classes from the specified directory.
@@ -1896,7 +2055,7 @@ var MigrateCommand = class extends Command {
 	* @param migrationsDir The directory to load migration classes from.
 	*/
 	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$1(migrationsDir, file)));
+		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();
 	}
 	/**
@@ -1918,7 +2077,7 @@ var MigrateCommand = class extends Command {
 			`${base}Migration.js`,
 			`${base}Migration.mjs`,
 			`${base}Migration.cjs`
-		].map((file) => join$1(migrationsDir, file)).find((file) => existsSync$1(file));
+		].map((file) => join(migrationsDir, file)).find((file) => existsSync(file));
 		if (!target) return [[void 0, name]];
 		const runtimeTarget = this.app.resolveRuntimeScriptPath(target);
 		return (await this.loadMigrationClassesFromFile(runtimeTarget)).map((cls) => [cls, runtimeTarget]);
@@ -1940,6 +2099,147 @@ var MigrateCommand = class extends Command {
 	}
 };
 
+//#endregion
+//#region src/cli/commands/MigrateRollbackCommand.ts
+/**
+* Rollback migration classes from the Prisma schema and run Prisma workflow.
+* By default, rolls back classes applied in the last migrate run.
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.2.4
+*/
+var MigrateRollbackCommand = class extends Command {
+	signature = `migrate:rollback
+        {--step= : Number of latest applied migration classes to rollback}
+        {--dry-run : Preview rollback targets without applying changes}
+        {--deploy : Use prisma migrate deploy instead of migrate dev}
+        {--skip-generate : Skip prisma generate}
+        {--skip-migrate : Skip prisma migrate command}
+        {--state-file= : Path to applied migration state file}
+        {--schema= : Explicit prisma schema path}
+        {--migration-name= : Name for prisma migrate dev}
+    `;
+	description = "Rollback migration classes from schema.prisma and run Prisma workflow";
+	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 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 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.");
+		const targets = stepCount ? getLatestAppliedMigrations(appliedState, stepCount) : (() => {
+			const lastRun = getLastMigrationRun(appliedState);
+			if (!lastRun) return [];
+			return lastRun.migrationIds.map((id) => appliedState.migrations.find((migration) => migration.id === id)).filter((migration) => Boolean(migration));
+		})();
+		if (targets.length === 0) return void this.error("Error: No tracked migrations available to rollback.");
+		const available = await this.loadAllMigrations(migrationsDir);
+		const rollbackClasses = targets.map((target) => {
+			return available.find(([migrationClass, file]) => {
+				return buildMigrationIdentity(file, migrationClass.name) === target.id || migrationClass.name === target.className;
+			});
+		}).filter((entry) => Boolean(entry));
+		if (rollbackClasses.length === 0) return void this.error("Error: Unable to resolve rollback migration classes from tracked history.");
+		if (this.option("dry-run")) {
+			this.success(`Dry run: ${rollbackClasses.length} migration(s) would be rolled back.`);
+			rollbackClasses.forEach(([_, file]) => this.success(this.app.splitLogger("WouldRollback", file)));
+			return;
+		}
+		for (const [MigrationClassItem] of rollbackClasses) 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());
+		else runPrismaCommand([
+			"migrate",
+			"dev",
+			"--name",
+			this.option("migration-name") ? String(this.option("migration-name")) : `arkorm_cli_rollback_${Date.now()}`
+		], process.cwd());
+		this.success(`Rolled back ${rollbackClasses.length} migration(s).`);
+		rollbackClasses.forEach(([_, file]) => this.success(this.app.splitLogger("RolledBack", 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 import(`${pathToFileURL$1(resolve(filePath)).href}?arkorm_rollback=${Date.now()}`);
+		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/MigrationHistoryCommand.ts
+/**
+* The MigrationHistoryCommand class manages tracked migration run history.
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.2.4
+*/
+var MigrationHistoryCommand = class extends Command {
+	signature = `migrate:history
+        {--state-file= : Path to applied migration state file}
+        {--reset : Clear tracked migration history file}
+        {--delete : Delete tracked migration history file}
+        {--json : Print raw JSON output}
+    `;
+	description = "Inspect or reset tracked migration history";
+	async handle() {
+		this.app.command = this;
+		const stateFilePath = resolveMigrationStateFilePath(process.cwd(), this.option("state-file") ? String(this.option("state-file")) : void 0);
+		if (this.option("delete")) {
+			if (!existsSync(stateFilePath)) {
+				this.success(`No migration state file found at ${this.app.formatPathForLog(stateFilePath)}`);
+				return;
+			}
+			rmSync(stateFilePath);
+			this.success(`Deleted migration state file: ${this.app.formatPathForLog(stateFilePath)}`);
+			return;
+		}
+		if (this.option("reset")) {
+			writeAppliedMigrationsState(stateFilePath, {
+				version: 1,
+				migrations: []
+			});
+			this.success(`Reset migration state: ${this.app.formatPathForLog(stateFilePath)}`);
+			return;
+		}
+		const state = readAppliedMigrationsState(stateFilePath);
+		if (this.option("json")) {
+			this.success(JSON.stringify({
+				path: stateFilePath,
+				...state
+			}, null, 2));
+			return;
+		}
+		this.success(this.app.splitLogger("State", stateFilePath));
+		this.success(this.app.splitLogger("Tracked", String(state.migrations.length)));
+		if (state.migrations.length === 0) {
+			this.success("No tracked migrations found.");
+			return;
+		}
+		state.migrations.sort((left, right) => left.appliedAt.localeCompare(right.appliedAt)).forEach((migration) => {
+			this.success(this.app.splitLogger("Applied", `${migration.id} @ ${migration.appliedAt}`));
+		});
+	}
+};
+
 //#endregion
 //#region src/cli/commands/ModelsSyncCommand.ts
 var ModelsSyncCommand = class extends Command {
@@ -2035,9 +2335,9 @@ var SeedCommand = class extends Command {
 	*/
 	async handle() {
 		this.app.command = this;
-		const configuredSeedersDir = this.app.getConfig("paths")?.seeders ?? join$1(process.cwd(), "database", "seeders");
+		const configuredSeedersDir = this.app.getConfig("paths")?.seeders ?? join(process.cwd(), "database", "seeders");
 		const seedersDir = this.app.resolveRuntimeDirectoryPath(configuredSeedersDir);
-		if (!existsSync$1(seedersDir)) return void this.error(`ERROR: Seeders directory not found: ${this.app.formatPathForLog(configuredSeedersDir)}`);
+		if (!existsSync(seedersDir)) return void this.error(`ERROR: Seeders directory not found: ${this.app.formatPathForLog(configuredSeedersDir)}`);
 		const classes = this.option("all") ? await this.loadAllSeeders(seedersDir) : await this.loadNamedSeeder(seedersDir, this.argument("name") ?? "DatabaseSeeder");
 		if (classes.length === 0) return void this.error("ERROR: No seeder classes found to run.");
 		for (const SeederClassItem of classes) await new SeederClassItem().run();
@@ -2051,7 +2351,7 @@ var SeedCommand = class extends Command {
 	* @returns 
 	*/
 	async loadAllSeeders(seedersDir) {
-		const files = readdirSync$1(seedersDir).filter((file) => /\.(ts|js|mjs|cjs)$/i.test(file)).map((file) => this.app.resolveRuntimeScriptPath(join$1(seedersDir, file)));
+		const files = readdirSync(seedersDir).filter((file) => /\.(ts|js|mjs|cjs)$/i.test(file)).map((file) => this.app.resolveRuntimeScriptPath(join(seedersDir, file)));
 		return (await Promise.all(files.map(async (file) => await this.loadSeederClassesFromFile(file)))).flat();
 	}
 	/**
@@ -2072,7 +2372,7 @@ var SeedCommand = class extends Command {
 			`${base}Seeder.js`,
 			`${base}Seeder.mjs`,
 			`${base}Seeder.cjs`
-		].map((file) => join$1(seedersDir, file)).find((file) => existsSync$1(file));
+		].map((file) => join(seedersDir, file)).find((file) => existsSync(file));
 		if (!target) return [];
 		const runtimeTarget = this.app.resolveRuntimeScriptPath(target);
 		return await this.loadSeederClassesFromFile(runtimeTarget);
@@ -2119,7 +2419,9 @@ await Kernel.init(app, {
 		MakeMigrationCommand,
 		ModelsSyncCommand,
 		SeedCommand,
-		MigrateCommand
+		MigrateCommand,
+		MigrateRollbackCommand,
+		MigrationHistoryCommand
 	],
 	exceptionHandler(exception) {
 		throw exception;