arkormx 1.3.3 → 2.0.0-next.0

package/dist/index.mjs

@@ -1,99 +1,20 @@
-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 { sql } from "kysely";
 import { AsyncLocalStorage } from "async_hooks";
 import { createJiti } from "@rexxars/jiti";
 import { pathToFileURL } from "node:url";
+import { dirname, extname, join, resolve } from "node:path";
 import { createRequire } from "module";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { fileURLToPath } from "url";
+import path, { dirname as dirname$1, extname as extname$1, join as join$1, relative } from "path";
+import { str } from "@h3ravel/support";
+import { 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 "node:fs";
+import { spawnSync } from "node:child_process";
 import { Logger } from "@h3ravel/shared";
 import { Command } from "@h3ravel/musket";
 import { createHash } from "node:crypto";
 import { Collection } from "@h3ravel/collect.js";
 
-//#region src/Attribute.ts
-var Attribute = class Attribute {
-	get;
-	set;
-	constructor(options = {}) {
-		this.get = options.get;
-		this.set = options.set;
-	}
-	static make(options) {
-		return new Attribute(options);
-	}
-	static isAttribute(value) {
-		if (!value || typeof value !== "object") return false;
-		return value instanceof Attribute;
-	}
-};
-
-//#endregion
-//#region src/casts.ts
-const builtinCasts = {
-	string: {
-		get: (value) => value == null ? value : String(value),
-		set: (value) => value == null ? value : String(value)
-	},
-	number: {
-		get: (value) => value == null ? value : Number(value),
-		set: (value) => value == null ? value : Number(value)
-	},
-	boolean: {
-		get: (value) => value == null ? value : Boolean(value),
-		set: (value) => value == null ? value : Boolean(value)
-	},
-	date: {
-		get: (value) => {
-			if (value == null || value instanceof Date) return value;
-			return new Date(String(value));
-		},
-		set: (value) => {
-			if (value == null || value instanceof Date) return value;
-			return new Date(String(value));
-		}
-	},
-	json: {
-		get: (value) => {
-			if (value == null || typeof value !== "string") return value;
-			try {
-				return JSON.parse(value);
-			} catch {
-				return value;
-			}
-		},
-		set: (value) => {
-			if (value == null || typeof value === "string") return value;
-			return JSON.stringify(value);
-		}
-	},
-	array: {
-		get: (value) => {
-			if (Array.isArray(value)) return value;
-			if (typeof value === "string") try {
-				const parsed = JSON.parse(value);
-				return Array.isArray(parsed) ? parsed : [parsed];
-			} catch {
-				return [value];
-			}
-			if (value == null) return value;
-			return [value];
-		},
-		set: (value) => {
-			if (value == null) return value;
-			return Array.isArray(value) ? value : [value];
-		}
-	}
-};
-function resolveCast(definition) {
-	if (typeof definition === "string") return builtinCasts[definition];
-	return definition;
-}
-
-//#endregion
 //#region src/Exceptions/ArkormException.ts
 var ArkormException = class extends Error {
 	code;
@@ -136,119 +57,1066 @@ var ArkormException = class extends Error {
 };
 
 //#endregion
-//#region src/database/ForeignKeyBuilder.ts
-/**
-* The ForeignKeyBuilder class provides a fluent interface for defining 
-* foreign key constraints in a migration. It allows you to specify 
-* the referenced table and column, as well as actions to take on 
-* delete and aliases for the relation.
-*
-* @author Legacy (3m1n3nc3)
-* @since 0.2.2
-*/
-var ForeignKeyBuilder = class {
-	foreignKey;
-	constructor(foreignKey) {
-		this.foreignKey = foreignKey;
+//#region src/Exceptions/UnsupportedAdapterFeatureException.ts
+var UnsupportedAdapterFeatureException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "UNSUPPORTED_ADAPTER_FEATURE",
+			...context
+		});
+		this.name = "UnsupportedAdapterFeatureException";
 	}
-	/**
-	* Defines the referenced table and column for this foreign key constraint.
-	* 
-	* @param table 
-	* @param column 
-	* @returns 
-	*/
-	references(table, column) {
-		this.foreignKey.referencesTable = table;
-		this.foreignKey.referencesColumn = column;
-		return this;
+};
+
+//#endregion
+//#region src/adapters/KyselyDatabaseAdapter.ts
+var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
+	capabilities = {
+		transactions: true,
+		returning: true,
+		insertMany: true,
+		updateMany: true,
+		deleteMany: true,
+		exists: true,
+		relationLoads: false,
+		relationAggregates: false,
+		relationFilters: false,
+		rawWhere: false
+	};
+	constructor(db) {
+		this.db = db;
+	}
+	resolveTable(target) {
+		if (target.table && target.table.trim().length > 0) return target.table;
+		throw new ArkormException("Kysely adapter requires a concrete target table.", {
+			operation: "adapter.table",
+			model: target.modelName,
+			meta: { target }
+		});
 	}
-	/**
-	* Defines the action to take when a referenced record is deleted, such 
-	* as "CASCADE", "SET NULL", or "RESTRICT".
-	* 
-	* @param action 
-	* @returns 
-	*/
-	onDelete(action) {
-		this.foreignKey.onDelete = action;
-		return this;
+	resolvePrimaryKey(target) {
+		return this.mapColumn(target, target.primaryKey || "id");
 	}
-	/**
-	* Defines an alias for the relation represented by this foreign key, which 
-	* can be used in the ORM for more intuitive access to related models.
-	* 
-	* @param name 
-	* @returns 
-	*/
-	alias(name) {
-		this.foreignKey.relationAlias = name;
-		return this;
+	mapColumn(target, column) {
+		return target.columns?.[column] ?? column;
 	}
-	/**
-	* Defines an alias for the inverse relation represented by this foreign key.
-	* 
-	* @param name 
-	* @returns 
-	*/
-	inverseAlias(name) {
-		this.foreignKey.inverseRelationAlias = name;
-		return this;
+	reverseColumnMap(target) {
+		return Object.entries(target.columns ?? {}).reduce((all, [attribute, column]) => {
+			all[column] = attribute;
+			return all;
+		}, {});
 	}
-	/**
-	* Defines an alias for the foreign key field itself, which can be 
-	* used in the ORM for more intuitive access to the foreign key value.
-	* 
-	* @param fieldName 
-	* @returns 
-	*/
-	as(fieldName) {
-		this.foreignKey.fieldAlias = fieldName;
-		return this;
+	mapRow(target, row) {
+		if (!row) return null;
+		const reverseMap = this.reverseColumnMap(target);
+		return Object.entries(row).reduce((mapped, [key, value]) => {
+			mapped[reverseMap[key] ?? key] = value;
+			return mapped;
+		}, {});
+	}
+	mapRows(target, rows) {
+		return rows.map((row) => this.mapRow(target, row));
+	}
+	mapValues(target, values) {
+		return Object.entries(values).reduce((mapped, [key, value]) => {
+			mapped[this.mapColumn(target, key)] = value;
+			return mapped;
+		}, {});
+	}
+	buildSelectList(target, columns) {
+		if (!columns || columns.length === 0) return sql.raw("*");
+		return sql.join(columns.map(({ column, alias }) => {
+			const mappedColumn = this.mapColumn(target, column);
+			const resultAlias = alias ?? column;
+			if (mappedColumn === resultAlias) return sql.ref(mappedColumn);
+			return sql`${sql.ref(mappedColumn)} as ${sql.id(resultAlias)}`;
+		}));
+	}
+	buildOrderBy(target, orderBy) {
+		if (!orderBy || orderBy.length === 0) return sql``;
+		return sql` order by ${sql.join(orderBy.map(({ column, direction }) => {
+			return sql`${sql.ref(this.mapColumn(target, column))} ${sql.raw(direction === "desc" ? "desc" : "asc")}`;
+		}), sql`, `)}`;
+	}
+	buildConditionValueList(value) {
+		if (Array.isArray(value)) return value;
+		return typeof value === "undefined" ? [] : [value];
+	}
+	buildComparisonCondition(target, condition) {
+		const column = sql.ref(this.mapColumn(target, condition.column));
+		if (condition.operator === "is-null") return sql`${column} is null`;
+		if (condition.operator === "is-not-null") return sql`${column} is not null`;
+		if (condition.operator === "in") {
+			const values = this.buildConditionValueList(condition.value);
+			if (values.length === 0) return sql`1 = 0`;
+			return sql`${column} in (${sql.join(values)})`;
+		}
+		if (condition.operator === "not-in") {
+			const values = this.buildConditionValueList(condition.value);
+			if (values.length === 0) return sql`1 = 1`;
+			return sql`${column} not in (${sql.join(values)})`;
+		}
+		if (condition.operator === "contains") return sql`${column} like ${`%${String(condition.value ?? "")}%`}`;
+		if (condition.operator === "starts-with") return sql`${column} like ${`${String(condition.value ?? "")}%`}`;
+		if (condition.operator === "ends-with") return sql`${column} like ${`%${String(condition.value ?? "")}`}`;
+		return sql`${column} ${condition.operator === "!=" ? sql.raw("!=") : sql.raw(condition.operator)} ${condition.value}`;
+	}
+	buildWhereCondition(target, condition) {
+		if (!condition) return sql`1 = 1`;
+		if (condition.type === "comparison") return this.buildComparisonCondition(target, condition);
+		if (condition.type === "group") {
+			const group = condition;
+			const conditions = group.conditions.map((entry) => {
+				return this.buildWhereCondition(target, entry);
+			});
+			if (conditions.length === 0) return sql`1 = 1`;
+			const separator = group.operator === "or" ? sql` or ` : sql` and `;
+			return sql`(${sql.join(conditions, separator)})`;
+		}
+		if (condition.type === "not") {
+			const notCondition = condition;
+			return sql`not (${this.buildWhereCondition(target, notCondition.condition)})`;
+		}
+		throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the Kysely adapter.", {
+			operation: "adapter.where",
+			meta: {
+				feature: "rawWhere",
+				sql: condition.sql
+			}
+		});
+	}
+	buildWhereClause(target, condition) {
+		if (!condition) return sql``;
+		return sql` where ${this.buildWhereCondition(target, condition)}`;
+	}
+	buildPaginationClause(spec) {
+		const clauses = [];
+		if (typeof spec.limit === "number") clauses.push(sql` limit ${spec.limit}`);
+		if (typeof spec.offset === "number") clauses.push(sql` offset ${spec.offset}`);
+		if (clauses.length === 0) return sql``;
+		return sql.join(clauses, sql``);
+	}
+	assertNoRelationLoads(spec) {
+		if ("relationLoads" in spec && spec.relationLoads && spec.relationLoads.length > 0) throw new UnsupportedAdapterFeatureException("Kysely adapter relation-load execution is planned for a later phase.", {
+			operation: "adapter.relationLoads",
+			meta: { feature: "relationLoads" }
+		});
 	}
+	async select(spec) {
+		this.assertNoRelationLoads(spec);
+		const result = await sql`
+            select ${this.buildSelectList(spec.target, spec.columns)}
+            from ${sql.table(this.resolveTable(spec.target))}
+            ${this.buildWhereClause(spec.target, spec.where)}
+            ${this.buildOrderBy(spec.target, spec.orderBy)}
+            ${this.buildPaginationClause(spec)}
+        `.execute(this.db);
+		return this.mapRows(spec.target, result.rows);
+	}
+	async selectOne(spec) {
+		return (await this.select({
+			...spec,
+			limit: spec.limit ?? 1
+		}))[0] ?? null;
+	}
+	async insert(spec) {
+		const values = this.mapValues(spec.target, spec.values);
+		const columns = Object.keys(values);
+		const result = columns.length === 0 ? await sql`
+                insert into ${sql.table(this.resolveTable(spec.target))}
+                default values
+                returning *
+            `.execute(this.db) : await sql`
+                insert into ${sql.table(this.resolveTable(spec.target))} (${sql.join(columns.map((column) => sql.id(column)), sql`, `)})
+                values (${sql.join(columns.map((column) => values[column]), sql`, `)})
+                returning *
+            `.execute(this.db);
+		return this.mapRow(spec.target, result.rows[0]);
+	}
+	async insertMany(spec) {
+		if (spec.values.length === 0) return 0;
+		const rows = spec.values.map((row) => this.mapValues(spec.target, row));
+		const columns = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
+		if (columns.length === 0) return (await sql`
+                insert into ${sql.table(this.resolveTable(spec.target))}
+                default values
+                ${spec.ignoreDuplicates ? sql` on conflict do nothing` : sql``}
+                returning ${sql.id(this.resolvePrimaryKey(spec.target))}
+            `.execute(this.db)).rows.length;
+		const values = sql.join(rows.map((row) => {
+			return sql`(${sql.join(columns.map((column) => row[column] ?? null), sql`, `)})`;
+		}), sql`, `);
+		return (await sql`
+            insert into ${sql.table(this.resolveTable(spec.target))} (${sql.join(columns.map((column) => sql.id(column)), sql`, `)})
+            values ${values}
+            ${spec.ignoreDuplicates ? sql` on conflict do nothing` : sql``}
+            returning ${sql.id(this.resolvePrimaryKey(spec.target))}
+        `.execute(this.db)).rows.length;
+	}
+	async update(spec) {
+		const values = this.mapValues(spec.target, spec.values);
+		const assignments = Object.entries(values).map(([column, value]) => {
+			return sql`${sql.id(column)} = ${value}`;
+		});
+		if (assignments.length === 0) return await this.selectOne({
+			target: spec.target,
+			where: spec.where,
+			limit: 1
+		});
+		const result = await sql`
+            update ${sql.table(this.resolveTable(spec.target))}
+            set ${sql.join(assignments, sql`, `)}
+            ${this.buildWhereClause(spec.target, spec.where)}
+            returning *
+        `.execute(this.db);
+		return this.mapRow(spec.target, result.rows[0]);
+	}
+	async updateMany(spec) {
+		const values = this.mapValues(spec.target, spec.values);
+		const assignments = Object.entries(values).map(([column, value]) => {
+			return sql`${sql.id(column)} = ${value}`;
+		});
+		if (assignments.length === 0) return 0;
+		return (await sql`
+            update ${sql.table(this.resolveTable(spec.target))}
+            set ${sql.join(assignments, sql`, `)}
+            ${this.buildWhereClause(spec.target, spec.where)}
+            returning ${sql.id(this.resolvePrimaryKey(spec.target))}
+        `.execute(this.db)).rows.length;
+	}
+	async delete(spec) {
+		const result = await sql`
+            delete from ${sql.table(this.resolveTable(spec.target))}
+            ${this.buildWhereClause(spec.target, spec.where)}
+            returning *
+        `.execute(this.db);
+		return this.mapRow(spec.target, result.rows[0]);
+	}
+	async deleteMany(spec) {
+		return (await sql`
+            delete from ${sql.table(this.resolveTable(spec.target))}
+            ${this.buildWhereClause(spec.target, spec.where)}
+            returning ${sql.id(this.resolvePrimaryKey(spec.target))}
+        `.execute(this.db)).rows.length;
+	}
+	async count(spec) {
+		const result = await sql`
+            select count(*)::int as count
+            from ${sql.table(this.resolveTable(spec.target))}
+            ${this.buildWhereClause(spec.target, spec.where)}
+        `.execute(this.db);
+		return Number(result.rows[0]?.count ?? 0);
+	}
+	async exists(spec) {
+		const result = await sql`
+            select exists(
+                select 1
+                from ${sql.table(this.resolveTable(spec.target))}
+                ${this.buildWhereClause(spec.target, spec.where)}
+                limit 1
+            ) as exists
+        `.execute(this.db);
+		return Boolean(result.rows[0]?.exists);
+	}
+	async transaction(callback, context = {}) {
+		let transactionBuilder = this.db.transaction();
+		if (context.readOnly !== void 0) transactionBuilder = transactionBuilder.setAccessMode(context.readOnly ? "read only" : "read write");
+		if (context.isolationLevel) transactionBuilder = transactionBuilder.setIsolationLevel(context.isolationLevel);
+		return await transactionBuilder.execute(async (transaction) => {
+			return await callback(new KyselyDatabaseAdapter(transaction));
+		});
+	}
+};
+const createKyselyAdapter = (db) => {
+	return new KyselyDatabaseAdapter(db);
 };
 
 //#endregion
-//#region src/database/TableBuilder.ts
-const PRISMA_ENUM_MEMBER_REGEX$1 = /^[A-Za-z][A-Za-z0-9_]*$/;
-const normalizeEnumMember = (columnName, value) => {
-	const normalized = value.trim();
-	if (!normalized) throw new Error(`Enum column [${columnName}] must define only non-empty values.`);
-	if (!PRISMA_ENUM_MEMBER_REGEX$1.test(normalized)) throw new Error(`Enum column [${columnName}] contains invalid Prisma enum value [${normalized}].`);
-	return normalized;
+//#region src/Exceptions/MissingDelegateException.ts
+var MissingDelegateException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "MISSING_DELEGATE",
+			...context
+		});
+		this.name = "MissingDelegateException";
+	}
 };
-const normalizeEnumMembers = (columnName, values) => {
-	const normalizedValues = values.map((value) => normalizeEnumMember(columnName, value));
-	const seen = /* @__PURE__ */ new Set();
-	for (const value of normalizedValues) {
-		if (seen.has(value)) throw new Error(`Enum column [${columnName}] contains duplicate enum value [${value}].`);
-		seen.add(value);
+
+//#endregion
+//#region src/helpers/runtime-module-loader.ts
+var RuntimeModuleLoader = class {
+	static async load(filePath) {
+		const resolvedPath = resolve(filePath);
+		return await createJiti(pathToFileURL(resolvedPath).href, {
+			interopDefault: false,
+			tsconfigPaths: true
+		}).import(resolvedPath);
 	}
-	return normalizedValues;
 };
-/**
-* The EnumBuilder class provides a fluent interface for configuring enum columns
-* after they are defined on a table.
-*
-* @author Legacy (3m1n3nc3)
-* @since 0.2.3
-*/
-var EnumBuilder = class {
-	tableBuilder;
-	columnName;
-	constructor(tableBuilder, columnName) {
-		this.tableBuilder = tableBuilder;
-		this.columnName = columnName;
+
+//#endregion
+//#region src/helpers/runtime-config.ts
+const resolveDefaultStubsPath = () => {
+	let current = path.dirname(fileURLToPath(import.meta.url));
+	while (true) {
+		const packageJsonPath = path.join(current, "package.json");
+		const stubsPath = path.join(current, "stubs");
+		if (existsSync(packageJsonPath) && existsSync(stubsPath)) return stubsPath;
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
 	}
-	/**
-	* Defines the Prisma enum name for this column.
-	*
-	* @param name
-	* @returns
-	*/
-	enumName(name) {
-		this.tableBuilder.enumName(name, this.columnName);
-		return this;
+	return path.join(process.cwd(), "stubs");
+};
+const baseConfig = {
+	paths: {
+		stubs: resolveDefaultStubsPath(),
+		seeders: path.join(process.cwd(), "database", "seeders"),
+		models: path.join(process.cwd(), "src", "models"),
+		migrations: path.join(process.cwd(), "database", "migrations"),
+		factories: path.join(process.cwd(), "database", "factories"),
+		buildOutput: path.join(process.cwd(), "dist")
+	},
+	outputExt: "ts"
+};
+const userConfig = {
+	...baseConfig,
+	paths: { ...baseConfig.paths ?? {} }
+};
+let runtimeConfigLoaded = false;
+let runtimeConfigLoadingPromise;
+let runtimeClientResolver;
+let runtimePaginationURLDriverFactory;
+let runtimePaginationCurrentPageResolver;
+const transactionClientStorage = new AsyncLocalStorage();
+const mergePathConfig = (paths) => {
+	const defaults = baseConfig.paths ?? {};
+	const current = userConfig.paths ?? {};
+	const incoming = Object.entries(paths ?? {}).reduce((all, [key, value]) => {
+		if (typeof value === "string" && value.trim().length > 0) all[key] = path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+		return all;
+	}, {});
+	return {
+		...defaults,
+		...current,
+		...incoming
+	};
+};
+/**
+* Define the ArkORM runtime configuration. This function can be used to provide.
+* 
+* @param config The ArkORM configuration object.
+* @returns The same configuration object.
+*/
+const defineConfig = (config) => {
+	return config;
+};
+/**
+* Get the user-provided ArkORM configuration. 
+* 
+* @returns The user-provided ArkORM configuration object.  
+*/
+const getUserConfig = (key) => {
+	if (key) return userConfig[key];
+	return userConfig;
+};
+/**
+* Configure the ArkORM runtime with the provided Prisma client resolver and 
+* delegate mapping resolver.
+* 
+* @param prisma 
+* @param mapping 
+*/
+const configureArkormRuntime = (prisma, options = {}) => {
+	const nextConfig = {
+		...userConfig,
+		prisma,
+		paths: mergePathConfig(options.paths)
+	};
+	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
+	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
+	Object.assign(userConfig, { ...nextConfig });
+	runtimeClientResolver = prisma;
+	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
+	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+};
+/**
+* Reset the ArkORM runtime configuration. 
+* This is primarily intended for testing purposes.
+*/
+const resetArkormRuntimeForTests = () => {
+	Object.assign(userConfig, {
+		...baseConfig,
+		paths: { ...baseConfig.paths ?? {} }
+	});
+	runtimeConfigLoaded = false;
+	runtimeConfigLoadingPromise = void 0;
+	runtimeClientResolver = void 0;
+	runtimePaginationURLDriverFactory = void 0;
+	runtimePaginationCurrentPageResolver = void 0;
+};
+/**
+* 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. 
+* This function checks for a default export and falls back to the module itself, then validates
+* the configuration object and applies it to the runtime if valid.
+* 
+* @param imported 
+* @returns 
+*/
+const resolveAndApplyConfig = (imported) => {
+	const config = imported?.default ?? imported;
+	if (!config || typeof config !== "object" || !config.prisma) return;
+	configureArkormRuntime(config.prisma, {
+		pagination: config.pagination,
+		paths: config.paths,
+		outputExt: config.outputExt
+	});
+	runtimeConfigLoaded = true;
+};
+/**
+* Dynamically import a configuration file. 
+* A cache-busting query parameter is appended to ensure the latest version is loaded.
+* 
+* @param configPath 
+* @returns A promise that resolves to the imported configuration module.   
+*/
+const importConfigFile = (configPath) => {
+	return RuntimeModuleLoader.load(configPath);
+};
+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;
+		try {
+			resolveAndApplyConfig(require(configPath));
+			return true;
+		} catch {
+			continue;
+		}
+	}
+	return false;
+};
+/**
+* Load the ArkORM configuration by searching for configuration files in the 
+* current working directory.
+* @returns 
+*/
+const loadArkormConfig = async () => {
+	if (runtimeConfigLoaded) return;
+	if (runtimeConfigLoadingPromise) return await runtimeConfigLoadingPromise;
+	if (loadRuntimeConfigSync()) return;
+	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;
+			try {
+				resolveAndApplyConfig(await importConfigFile(configPath));
+				return;
+			} catch {
+				continue;
+			}
+		}
+		runtimeConfigLoaded = true;
+	})();
+	await runtimeConfigLoadingPromise;
+};
+/**
+* Ensure that the ArkORM configuration is loaded. 
+* This function can be called to trigger the loading process if it hasn't already been initiated.
+* If the configuration is already loaded, it will return immediately.
+* 
+* @returns 
+*/
+const ensureArkormConfigLoading = () => {
+	if (runtimeConfigLoaded) return;
+	if (!runtimeConfigLoadingPromise) loadArkormConfig();
+};
+const getDefaultStubsPath = () => {
+	return resolveDefaultStubsPath();
+};
+/**
+* Get the runtime Prisma client. 
+* This function will trigger the loading of the ArkORM configuration if 
+* it hasn't already been loaded.
+* 
+* @returns 
+*/
+const getRuntimePrismaClient = () => {
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionClient) return activeTransactionClient;
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return resolveClient(runtimeClientResolver);
+};
+const getActiveTransactionClient = () => {
+	return transactionClientStorage.getStore();
+};
+const isTransactionCapableClient = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.$transaction === "function";
+};
+const runArkormTransaction = async (callback, options = {}) => {
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionClient) return await callback(activeTransactionClient);
+	const client = getRuntimePrismaClient();
+	if (!client) throw new ArkormException("Cannot start a transaction without a configured Prisma client.", {
+		code: "CLIENT_NOT_CONFIGURED",
+		operation: "transaction"
+	});
+	if (!isTransactionCapableClient(client)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the current adapter.", {
+		code: "TRANSACTION_NOT_SUPPORTED",
+		operation: "transaction"
+	});
+	return await client.$transaction(async (transactionClient) => {
+		return await transactionClientStorage.run(transactionClient, async () => {
+			return await callback(transactionClient);
+		});
+	}, options);
+};
+/**
+* Get the configured pagination URL driver factory from runtime config.
+*
+* @returns
+*/
+const getRuntimePaginationURLDriverFactory = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimePaginationURLDriverFactory;
+};
+/**
+* Get the configured current-page resolver from runtime config.
+*
+* @returns
+*/
+const getRuntimePaginationCurrentPageResolver = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimePaginationCurrentPageResolver;
+};
+/**
+* Check if a given value is a Prisma delegate-like object 
+* by verifying the presence of common delegate methods.
+* 
+* @param value The value to check.
+* @returns True if the value is a Prisma delegate-like object, false otherwise.    
+*/
+const isDelegateLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return [
+		"findMany",
+		"findFirst",
+		"create",
+		"update",
+		"delete",
+		"count"
+	].every((method) => typeof candidate[method] === "function");
+};
+loadArkormConfig();
+
+//#endregion
+//#region src/helpers/prisma.ts
+/**
+* Create an adapter to convert a Prisma client instance into a format 
+* compatible with ArkORM's expectations.
+* 
+* @param prisma The Prisma client instance to adapt.
+* @param mapping An optional mapping of Prisma delegate names to ArkORM delegate names.
+* @returns A record of adapted Prisma delegates compatible with ArkORM.
+*/
+function createPrismaAdapter(prisma) {
+	return Object.entries(prisma).reduce((accumulator, [key, value]) => {
+		if (!isDelegateLike(value)) return accumulator;
+		accumulator[key] = value;
+		return accumulator;
+	}, {});
+}
+/**
+* Create a delegate mapping record for Model.setClient() from a Prisma client.
+*
+* @param prisma The Prisma client instance.
+* @param mapping Optional mapping of Arkormˣ delegate names to Prisma delegate names.
+* @returns A delegate map keyed by Arkormˣ delegate names.
+*/
+function createPrismaDelegateMap(prisma, mapping = {}) {
+	const delegates = createPrismaAdapter(prisma);
+	if (Object.keys(mapping).length === 0) return delegates;
+	return Object.entries(mapping).reduce((accumulator, [arkormDelegate, prismaDelegate]) => {
+		const resolved = delegates[prismaDelegate];
+		if (!resolved) return accumulator;
+		accumulator[arkormDelegate] = resolved;
+		return accumulator;
+	}, {});
+}
+/**
+* Infer the Prisma delegate name for a given model name using a simple convention.
+* 
+* @param modelName The name of the model to infer the delegate name for.
+* @returns The inferred Prisma delegate name.
+*/
+function inferDelegateName(modelName) {
+	return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}s`;
+}
+
+//#endregion
+//#region src/adapters/PrismaDatabaseAdapter.ts
+var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
+	capabilities;
+	delegates;
+	constructor(prisma, mapping = {}) {
+		this.prisma = prisma;
+		this.mapping = mapping;
+		this.delegates = Object.entries(prisma).reduce((accumulator, [key, value]) => {
+			if (!isDelegateLike(value)) return accumulator;
+			accumulator[key] = value;
+			return accumulator;
+		}, {});
+		this.capabilities = {
+			transactions: this.hasTransactionSupport(prisma),
+			insertMany: Object.values(this.delegates).some((delegate) => typeof delegate.createMany === "function"),
+			updateMany: Object.values(this.delegates).some((delegate) => typeof delegate.updateMany === "function"),
+			deleteMany: false,
+			exists: true,
+			relationLoads: false,
+			relationAggregates: false,
+			relationFilters: false,
+			rawWhere: false,
+			returning: false
+		};
+	}
+	hasTransactionSupport(client) {
+		return Boolean(client) && typeof client.$transaction === "function";
+	}
+	normalizeCandidate(value) {
+		return value.trim();
+	}
+	unique(values) {
+		return [...new Set(values.filter(Boolean))];
+	}
+	toQuerySelect(columns) {
+		if (!columns || columns.length === 0) return void 0;
+		return columns.reduce((select, column) => {
+			select[column.column] = true;
+			return select;
+		}, {});
+	}
+	toQueryOrderBy(orderBy) {
+		if (!orderBy || orderBy.length === 0) return void 0;
+		return orderBy.map((entry) => ({ [entry.column]: entry.direction }));
+	}
+	toComparisonWhere(condition) {
+		if (condition.operator === "is-null") return { [condition.column]: null };
+		if (condition.operator === "is-not-null") return { [condition.column]: { not: null } };
+		if (condition.operator === "=") return { [condition.column]: condition.value };
+		if (condition.operator === "!=") return { [condition.column]: { not: condition.value } };
+		if (condition.operator === ">") return { [condition.column]: { gt: condition.value } };
+		if (condition.operator === ">=") return { [condition.column]: { gte: condition.value } };
+		if (condition.operator === "<") return { [condition.column]: { lt: condition.value } };
+		if (condition.operator === "<=") return { [condition.column]: { lte: condition.value } };
+		if (condition.operator === "in") return { [condition.column]: { in: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+		if (condition.operator === "not-in") return { [condition.column]: { notIn: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+		if (condition.operator === "contains") return { [condition.column]: { contains: condition.value } };
+		if (condition.operator === "starts-with") return { [condition.column]: { startsWith: condition.value } };
+		return { [condition.column]: { endsWith: condition.value } };
+	}
+	toQueryWhere(condition) {
+		if (!condition) return void 0;
+		if (condition.type === "comparison") return this.toComparisonWhere(condition);
+		if (condition.type === "group") {
+			const group = condition;
+			const grouped = group.conditions.map((entry) => this.toQueryWhere(entry)).filter((entry) => Boolean(entry));
+			if (grouped.length === 0) return void 0;
+			return group.operator === "and" ? { AND: grouped } : { OR: grouped };
+		}
+		if (condition.type === "not") {
+			const notCondition = condition;
+			const nested = this.toQueryWhere(notCondition.condition);
+			if (!nested) return void 0;
+			return { NOT: nested };
+		}
+		throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the Prisma compatibility adapter.", {
+			operation: "adapter.where",
+			meta: {
+				feature: "rawWhere",
+				sql: condition.sql
+			}
+		});
+	}
+	buildFindArgs(spec) {
+		return {
+			include: this.toQueryInclude(spec.relationLoads),
+			where: this.toQueryWhere(spec.where),
+			orderBy: this.toQueryOrderBy(spec.orderBy),
+			select: this.toQuerySelect(spec.columns),
+			skip: spec.offset,
+			take: spec.limit
+		};
+	}
+	toQueryInclude(relationLoads) {
+		if (!relationLoads || relationLoads.length === 0) return void 0;
+		return relationLoads.reduce((include, plan) => {
+			const nestedInclude = this.toQueryInclude(plan.relationLoads);
+			const nestedSelect = this.toQuerySelect(plan.columns);
+			const nestedWhere = this.toQueryWhere(plan.constraint);
+			const nestedOrderBy = this.toQueryOrderBy(plan.orderBy);
+			if (!nestedInclude && !nestedSelect && !nestedWhere && !nestedOrderBy && plan.offset === void 0 && plan.limit === void 0) {
+				include[plan.relation] = true;
+				return include;
+			}
+			include[plan.relation] = {
+				where: nestedWhere,
+				orderBy: nestedOrderBy,
+				select: nestedSelect,
+				include: nestedInclude,
+				skip: plan.offset,
+				take: plan.limit
+			};
+			return include;
+		}, {});
+	}
+	resolveDelegate(target) {
+		const tableName = target.table ? this.normalizeCandidate(target.table) : "";
+		const singularTableName = tableName ? `${str(tableName).singular()}` : "";
+		const camelTableName = tableName ? `${str(tableName).camel()}` : "";
+		const camelSingularTableName = tableName ? `${str(tableName).camel().singular()}` : "";
+		const candidates = this.unique([
+			target.table ? this.mapping[target.table] : "",
+			tableName,
+			singularTableName ? this.mapping[singularTableName] : "",
+			singularTableName,
+			camelTableName ? this.mapping[camelTableName] : "",
+			camelTableName,
+			camelSingularTableName ? this.mapping[camelSingularTableName] : "",
+			camelSingularTableName,
+			target.modelName ? this.mapping[target.modelName] : "",
+			target.modelName ? this.normalizeCandidate(target.modelName) : "",
+			target.modelName ? inferDelegateName(target.modelName) : "",
+			target.modelName ? this.mapping[inferDelegateName(target.modelName)] : ""
+		]);
+		const resolved = candidates.map((candidate) => this.delegates[candidate]).find(Boolean);
+		if (resolved) return resolved;
+		throw new MissingDelegateException("Prisma delegate could not be resolved for adapter target.", {
+			operation: "getDelegate",
+			model: target.modelName,
+			delegate: target.table,
+			meta: {
+				target,
+				candidates
+			}
+		});
+	}
+	async select(spec) {
+		return await this.resolveDelegate(spec.target).findMany(this.buildFindArgs(spec));
+	}
+	async selectOne(spec) {
+		return await this.resolveDelegate(spec.target).findFirst(this.buildFindArgs(spec));
+	}
+	async insert(spec) {
+		return await this.resolveDelegate(spec.target).create({ data: spec.values });
+	}
+	async insertMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		if (typeof delegate.createMany === "function") {
+			const result = await delegate.createMany({
+				data: spec.values,
+				skipDuplicates: spec.ignoreDuplicates
+			});
+			if (typeof result === "number") return result;
+			return typeof result?.count === "number" ? result.count : spec.values.length;
+		}
+		let inserted = 0;
+		for (const values of spec.values) try {
+			await delegate.create({ data: values });
+			inserted += 1;
+		} catch (error) {
+			if (!spec.ignoreDuplicates) throw error;
+		}
+		return spec.ignoreDuplicates ? inserted : spec.values.length;
+	}
+	async update(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		if (!where) return null;
+		return await delegate.update({
+			where,
+			data: spec.values
+		});
+	}
+	async updateMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		if (typeof delegate.updateMany === "function") {
+			const result = await delegate.updateMany({
+				where,
+				data: spec.values
+			});
+			if (typeof result === "number") return result;
+			return typeof result?.count === "number" ? result.count : 0;
+		}
+		const rows = await delegate.findMany({ where });
+		await Promise.all(rows.map(async (row) => {
+			await delegate.update({
+				where: row,
+				data: spec.values
+			});
+		}));
+		return rows.length;
+	}
+	async delete(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		if (!where) return null;
+		return await delegate.delete({ where });
+	}
+	async deleteMany(spec) {
+		const delegate = this.resolveDelegate(spec.target);
+		const where = this.toQueryWhere(spec.where);
+		const rows = await delegate.findMany({ where });
+		await Promise.all(rows.map(async (row) => {
+			await delegate.delete({ where: row });
+		}));
+		return rows.length;
+	}
+	async count(spec) {
+		return await this.resolveDelegate(spec.target).count({ where: this.toQueryWhere(spec.where) });
+	}
+	async exists(spec) {
+		return await this.selectOne({
+			...spec,
+			limit: 1
+		}) != null;
+	}
+	async loadRelations(_spec) {
+		throw new UnsupportedAdapterFeatureException("Relation batch loading is not supported by the Prisma compatibility adapter yet.", {
+			operation: "adapter.loadRelations",
+			meta: { feature: "relationLoads" }
+		});
+	}
+	async transaction(callback, context = {}) {
+		if (!this.hasTransactionSupport(this.prisma)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the Prisma compatibility adapter.", {
+			operation: "adapter.transaction",
+			meta: { feature: "transactions" }
+		});
+		return await this.prisma.$transaction(async (transactionClient) => {
+			return await callback(new PrismaDatabaseAdapter(transactionClient, this.mapping));
+		}, {
+			isolationLevel: context.isolationLevel,
+			maxWait: context.maxWait,
+			timeout: context.timeout
+		});
+	}
+};
+const createPrismaDatabaseAdapter = (prisma, mapping = {}) => {
+	return new PrismaDatabaseAdapter(prisma, mapping);
+};
+const createPrismaCompatibilityAdapter = createPrismaDatabaseAdapter;
+
+//#endregion
+//#region src/Attribute.ts
+var Attribute = class Attribute {
+	get;
+	set;
+	constructor(options = {}) {
+		this.get = options.get;
+		this.set = options.set;
+	}
+	static make(options) {
+		return new Attribute(options);
+	}
+	static isAttribute(value) {
+		if (!value || typeof value !== "object") return false;
+		return value instanceof Attribute;
+	}
+};
+
+//#endregion
+//#region src/casts.ts
+const builtinCasts = {
+	string: {
+		get: (value) => value == null ? value : String(value),
+		set: (value) => value == null ? value : String(value)
+	},
+	number: {
+		get: (value) => value == null ? value : Number(value),
+		set: (value) => value == null ? value : Number(value)
+	},
+	boolean: {
+		get: (value) => value == null ? value : Boolean(value),
+		set: (value) => value == null ? value : Boolean(value)
+	},
+	date: {
+		get: (value) => {
+			if (value == null || value instanceof Date) return value;
+			return new Date(String(value));
+		},
+		set: (value) => {
+			if (value == null || value instanceof Date) return value;
+			return new Date(String(value));
+		}
+	},
+	json: {
+		get: (value) => {
+			if (value == null || typeof value !== "string") return value;
+			try {
+				return JSON.parse(value);
+			} catch {
+				return value;
+			}
+		},
+		set: (value) => {
+			if (value == null || typeof value === "string") return value;
+			return JSON.stringify(value);
+		}
+	},
+	array: {
+		get: (value) => {
+			if (Array.isArray(value)) return value;
+			if (typeof value === "string") try {
+				const parsed = JSON.parse(value);
+				return Array.isArray(parsed) ? parsed : [parsed];
+			} catch {
+				return [value];
+			}
+			if (value == null) return value;
+			return [value];
+		},
+		set: (value) => {
+			if (value == null) return value;
+			return Array.isArray(value) ? value : [value];
+		}
+	}
+};
+function resolveCast(definition) {
+	if (typeof definition === "string") return builtinCasts[definition];
+	return definition;
+}
+
+//#endregion
+//#region src/database/ForeignKeyBuilder.ts
+/**
+* The ForeignKeyBuilder class provides a fluent interface for defining 
+* foreign key constraints in a migration. It allows you to specify 
+* the referenced table and column, as well as actions to take on 
+* delete and aliases for the relation.
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.2.2
+*/
+var ForeignKeyBuilder = class {
+	foreignKey;
+	constructor(foreignKey) {
+		this.foreignKey = foreignKey;
+	}
+	/**
+	* Defines the referenced table and column for this foreign key constraint.
+	* 
+	* @param table 
+	* @param column 
+	* @returns 
+	*/
+	references(table, column) {
+		this.foreignKey.referencesTable = table;
+		this.foreignKey.referencesColumn = column;
+		return this;
+	}
+	/**
+	* Defines the action to take when a referenced record is deleted, such 
+	* as "CASCADE", "SET NULL", or "RESTRICT".
+	* 
+	* @param action 
+	* @returns 
+	*/
+	onDelete(action) {
+		this.foreignKey.onDelete = action;
+		return this;
+	}
+	/**
+	* Defines an alias for the relation represented by this foreign key, which 
+	* can be used in the ORM for more intuitive access to related models.
+	* 
+	* @param name 
+	* @returns 
+	*/
+	alias(name) {
+		this.foreignKey.relationAlias = name;
+		return this;
+	}
+	/**
+	* Defines an alias for the inverse relation represented by this foreign key.
+	* 
+	* @param name 
+	* @returns 
+	*/
+	inverseAlias(name) {
+		this.foreignKey.inverseRelationAlias = name;
+		return this;
+	}
+	/**
+	* Defines an alias for the foreign key field itself, which can be 
+	* used in the ORM for more intuitive access to the foreign key value.
+	* 
+	* @param fieldName 
+	* @returns 
+	*/
+	as(fieldName) {
+		this.foreignKey.fieldAlias = fieldName;
+		return this;
+	}
+};
+
+//#endregion
+//#region src/database/TableBuilder.ts
+const PRISMA_ENUM_MEMBER_REGEX$1 = /^[A-Za-z][A-Za-z0-9_]*$/;
+const normalizeEnumMember = (columnName, value) => {
+	const normalized = value.trim();
+	if (!normalized) throw new Error(`Enum column [${columnName}] must define only non-empty values.`);
+	if (!PRISMA_ENUM_MEMBER_REGEX$1.test(normalized)) throw new Error(`Enum column [${columnName}] contains invalid Prisma enum value [${normalized}].`);
+	return normalized;
+};
+const normalizeEnumMembers = (columnName, values) => {
+	const normalizedValues = values.map((value) => normalizeEnumMember(columnName, value));
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of normalizedValues) {
+		if (seen.has(value)) throw new Error(`Enum column [${columnName}] contains duplicate enum value [${value}].`);
+		seen.add(value);
+	}
+	return normalizedValues;
+};
+/**
+* The EnumBuilder class provides a fluent interface for configuring enum columns
+* after they are defined on a table.
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.2.3
+*/
+var EnumBuilder = class {
+	tableBuilder;
+	columnName;
+	constructor(tableBuilder, columnName) {
+		this.tableBuilder = tableBuilder;
+		this.columnName = columnName;
+	}
+	/**
+	* Defines the Prisma enum name for this column.
+	*
+	* @param name
+	* @returns
+	*/
+	enumName(name) {
+		this.tableBuilder.enumName(name, this.columnName);
+		return this;
 	}
 	/**
 	* Marks the enum column as nullable.
@@ -952,272 +1820,34 @@ const buildFieldLine = (column) => {
 	return `  ${column.name} ${scalar}${nullable}${primary}${unique}${defaultSuffix}${updatedAt}${mapped}`;
 };
 /**
-* Build a Prisma enum block string based on an enum name and its values, validating that 
-* at least one value is provided.
-* 
-* @param enumName      The name of the enum to create.
-* @param values        The array of values for the enum.
-* @returns             The Prisma enum block string.
-*/
-const buildEnumBlock = (enumName, values) => {
-	if (values.length === 0) throw new ArkormException(`Enum [${enumName}] must define at least one value.`);
-	return `enum ${enumName} {\n${values.map((value) => `  ${value}`).join("\n")}\n}`;
-};
-/**
-* Find the Prisma enum block in a schema string that corresponds to a given enum 
-* name, returning its details if found.
-* 
-* @param schema        The Prisma schema string to search for the enum block.
-* @param enumName      The name of the enum to find in the schema.
-* @returns 
-*/
-const findEnumBlock = (schema, enumName) => {
-	const candidates = [...schema.matchAll(PRISMA_ENUM_REGEX)];
-	for (const match of candidates) {
-		const block = match[0];
-		const matchedEnumName = match[1];
-		const start = match.index ?? 0;
-		const end = start + block.length;
-		if (matchedEnumName === enumName) return {
-			enumName: matchedEnumName,
-			block,
-			start,
-			end
-		};
-	}
-	return null;
-};
-/**
-* Ensure that Prisma enum blocks exist in the schema for any enum columns defined in a 
-* create or alter table operation, adding them if necessary and validating against 
-* existing blocks.
-* 
-* @param schema    The current Prisma schema string to check and modify.
-* @param columns   The array of schema column definitions to check for enum types and ensure corresponding blocks exist for.
-* @returns 
-*/
-const ensureEnumBlocks = (schema, columns) => {
-	let nextSchema = schema;
-	for (const column of columns) {
-		if (column.type !== "enum") continue;
-		const enumName = resolveEnumName(column);
-		const enumValues = column.enumValues ?? [];
-		const existing = findEnumBlock(nextSchema, enumName);
-		if (existing) {
-			const existingValues = validateEnumValues(column, enumName, extractEnumBlockValues(existing.block));
-			if (enumValues.length === 0) {
-				validateEnumDefaultValue(column, enumName, existingValues);
-				continue;
-			}
-			const normalizedEnumValues = validateEnumValues(column, enumName, enumValues);
-			if (existingValues.join("|") !== normalizedEnumValues.join("|")) throw new ArkormException(`Prisma enum [${enumName}] already exists with different values.`);
-			validateEnumDefaultValue(column, enumName, existingValues);
-			continue;
-		}
-		if (enumValues.length === 0) throw new ArkormException(`Prisma enum [${enumName}] was not found for column [${column.name}].`);
-		const normalizedEnumValues = validateEnumValues(column, enumName, enumValues);
-		validateEnumDefaultValue(column, enumName, normalizedEnumValues);
-		const block = buildEnumBlock(enumName, normalizedEnumValues);
-		nextSchema = `${nextSchema.trimEnd()}\n\n${block}\n`;
-	}
-	return nextSchema;
-};
-/**
-* Build a Prisma model-level @@index definition line.
-* 
-* @param index     The schema index definition to convert to a Prisma \@\@index line.
-* @returns 
-*/
-const buildIndexLine = (index) => {
-	return `  @@index([${index.columns.join(", ")}]${typeof index.name === "string" && index.name.trim().length > 0 ? `, name: "${index.name.replace(/"/g, "\\\"")}"` : ""})`;
-};
-/**
-* Derive a relation field name from a foreign key column name by applying 
-* common conventions, such as removing "Id" suffixes and converting to camelCase.
-* 
-* @param columnName    The name of the foreign key column.
-* @returns             The derived relation field name.
-*/
-const deriveRelationFieldName = (columnName) => {
-	const trimmed = columnName.trim();
-	if (!trimmed) return "relation";
-	if (trimmed.endsWith("Id") && trimmed.length > 2) {
-		const root = trimmed.slice(0, -2);
-		return `${root.charAt(0).toLowerCase()}${root.slice(1)}`;
-	}
-	if (trimmed.endsWith("_id") && trimmed.length > 3) return trimmed.slice(0, -3).replace(/_([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
-	return `${trimmed.charAt(0).toLowerCase()}${trimmed.slice(1)}`;
-};
-/**
-* Derive a relation name for both sides of a relation based on the 
-* source and target model names, using an explicit alias if provided or a 
-* convention of combining the full source model name with the target model name.
-* 
-* @param sourceModelName    The name of the source model in the relation.
-* @param targetModelName    The name of the target model in the relation.
-* @param explicitAlias      An optional explicit alias for the relation.
-* @returns                  The derived or explicit relation alias.
-*/
-const deriveRelationAlias = (sourceModelName, targetModelName, explicitAlias) => {
-	if (explicitAlias && explicitAlias.trim().length > 0) return explicitAlias.trim();
-	return [sourceModelName, targetModelName].sort((left, right) => left.localeCompare(right)).join("");
-};
-const deriveInverseRelationAlias = deriveRelationAlias;
-const deriveSingularFieldName = (modelName) => {
-	if (!modelName) return "item";
-	return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}`;
-};
-const deriveCollectionFieldName = (modelName) => {
-	if (!modelName) return "items";
-	const camel = `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}`;
-	if (camel.endsWith("s")) return `${camel}es`;
-	return `${camel}s`;
-};
-const resolveForeignKeyColumn = (columns, foreignKey) => {
-	return columns.find((column) => column.name === foreignKey.column);
-};
-const isOneToOneForeignKey = (column) => {
-	return Boolean(column?.unique || column?.primary);
-};
-/** 
-* Format a SchemaForeignKeyAction value as a Prisma onDelete action string.
-* 
-* @param action    The foreign key action to format.
-* @returns         The corresponding Prisma onDelete action string.
-*/
-const formatRelationAction = (action) => {
-	if (action === "cascade") return "Cascade";
-	if (action === "restrict") return "Restrict";
-	if (action === "setNull") return "SetNull";
-	if (action === "setDefault") return "SetDefault";
-	return "NoAction";
-};
-/**
-* Build a Prisma relation field line based on a SchemaForeignKey 
-* definition, including relation name and onDelete action.
-* 
-* @param foreignKey    The foreign key definition to convert to a relation line.
-* @returns             The corresponding Prisma schema line for the relation field.
-*/
-const buildRelationLine = (sourceModelName, foreignKey, columns = []) => {
-	if (!foreignKey.referencesTable.trim()) throw new ArkormException(`Foreign key [${foreignKey.column}] must define a referenced table.`);
-	if (!foreignKey.referencesColumn.trim()) throw new ArkormException(`Foreign key [${foreignKey.column}] must define a referenced column.`);
-	const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
-	const fieldName = foreignKey.fieldAlias?.trim() || deriveRelationFieldName(foreignKey.column);
-	const targetModel = toModelName(foreignKey.referencesTable);
-	const relationName = deriveRelationAlias(sourceModelName, targetModel, foreignKey.relationAlias?.trim());
-	const optional = sourceColumn?.nullable ? "?" : "";
-	const onDelete = foreignKey.onDelete ? `, onDelete: ${formatRelationAction(foreignKey.onDelete)}` : "";
-	return `  ${fieldName} ${targetModel}${optional} @relation("${relationName.replace(/"/g, "\\\"")}", fields: [${foreignKey.column}], references: [${foreignKey.referencesColumn}]${onDelete})`;
-};
-/**
-* Build a Prisma relation field line for the inverse side of a relation, based 
-* on the source and target model names and the foreign key definition, using 
-* naming conventions and any explicit inverse alias provided.
-* 
-* @param sourceModelName   The name of the source model in the relation.
-* @param targetModelName   The name of the target model in the relation.
-* @param foreignKey        The foreign key definition for the relation.
-* @returns                 The Prisma schema line for the inverse relation field.
-*/
-const buildInverseRelationLine = (sourceModelName, targetModelName, foreignKey, columns = []) => {
-	const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
-	const fieldName = isOneToOneForeignKey(sourceColumn) ? deriveSingularFieldName(sourceModelName) : deriveCollectionFieldName(sourceModelName);
-	const relationName = deriveRelationAlias(sourceModelName, targetModelName, foreignKey.relationAlias?.trim());
-	return `  ${fieldName} ${isOneToOneForeignKey(sourceColumn) ? `${sourceModelName}?` : `${sourceModelName}[]`} @relation("${relationName.replace(/"/g, "\\\"")}")`;
-};
-/**
-* Inject a line into the body of a Prisma model block if it does not already 
-* exist, using a provided existence check function to determine if the line 
-* is already present.
-* 
-* @param bodyLines The lines of the model block body to modify.
-* @param line      The line to inject if it does not already exist.
-* @param exists    A function that checks if a given line already exists in the body.
-* @returns 
-*/
-const injectLineIntoModelBody = (bodyLines, line, exists) => {
-	if (bodyLines.some(exists)) return bodyLines;
-	const insertIndex = Math.max(1, bodyLines.length - 1);
-	bodyLines.splice(insertIndex, 0, line);
-	return bodyLines;
-};
-/**
-* Apply inverse relation definitions to a Prisma schema string based on the 
-* foreign keys defined in a create or alter table operation, ensuring that 
-* related models have corresponding relation fields for bi-directional navigation.
-* 
-* @param schema The Prisma schema string to modify.
-* @param sourceModelName The name of the source model in the relation.
-* @param foreignKeys An array of foreign key definitions to process.
-* @returns The updated Prisma schema string with inverse relations applied.
-*/
-const applyInverseRelations = (schema, sourceModelName, foreignKeys, columns = []) => {
-	let nextSchema = schema;
-	for (const foreignKey of foreignKeys) {
-		const targetModel = findModelBlock(nextSchema, foreignKey.referencesTable);
-		if (!targetModel) continue;
-		const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
-		const inverseLine = buildInverseRelationLine(sourceModelName, targetModel.modelName, foreignKey, columns);
-		const targetBodyLines = targetModel.block.split("\n");
-		const fieldName = isOneToOneForeignKey(sourceColumn) ? deriveSingularFieldName(sourceModelName) : deriveCollectionFieldName(sourceModelName);
-		const fieldRegex = new RegExp(`^\\s*${escapeRegex(fieldName)}\\s+`);
-		injectLineIntoModelBody(targetBodyLines, inverseLine, (line) => fieldRegex.test(line));
-		const updatedTarget = targetBodyLines.join("\n");
-		nextSchema = `${nextSchema.slice(0, targetModel.start)}${updatedTarget}${nextSchema.slice(targetModel.end)}`;
-	}
-	return nextSchema;
-};
-/**
-* Build a Prisma model block string based on a SchemaTableCreateOperation, including 
-* all fields and any necessary mapping.
+* Build a Prisma enum block string based on an enum name and its values, validating that 
+* at least one value is provided.
 * 
-* @param operation The schema table create operation to convert.
-* @returns         The corresponding Prisma model block string.
+* @param enumName      The name of the enum to create.
+* @param values        The array of values for the enum.
+* @returns             The Prisma enum block string.
 */
-const buildModelBlock = (operation) => {
-	const modelName = toModelName(operation.table);
-	const mapped = operation.table !== modelName.toLowerCase();
-	const fields = operation.columns.map(buildFieldLine);
-	const relations = (operation.foreignKeys ?? []).map((foreignKey) => buildRelationLine(modelName, foreignKey, operation.columns));
-	const metadata = [...(operation.indexes ?? []).map(buildIndexLine), ...mapped ? [`  @@map("${str(operation.table).snake()}")`] : []];
-	return `model ${modelName} {\n${(metadata.length > 0 ? [
-		...fields,
-		...relations,
-		"",
-		...metadata
-	] : [...fields, ...relations]).join("\n")}\n}`;
+const buildEnumBlock = (enumName, values) => {
+	if (values.length === 0) throw new ArkormException(`Enum [${enumName}] must define at least one value.`);
+	return `enum ${enumName} {\n${values.map((value) => `  ${value}`).join("\n")}\n}`;
 };
 /**
-* Find the Prisma model block in a schema string that corresponds to a given 
-* table name, using both explicit mapping and naming conventions.
+* Find the Prisma enum block in a schema string that corresponds to a given enum 
+* name, returning its details if found.
 * 
-* @param schema 
-* @param table 
+* @param schema        The Prisma schema string to search for the enum block.
+* @param enumName      The name of the enum to find in the schema.
 * @returns 
 */
-const findModelBlock = (schema, table) => {
-	const candidates = [...schema.matchAll(PRISMA_MODEL_REGEX)];
-	const explicitMapRegex = new RegExp(`@@map\\("${escapeRegex(table)}"\\)`);
+const findEnumBlock = (schema, enumName) => {
+	const candidates = [...schema.matchAll(PRISMA_ENUM_REGEX)];
 	for (const match of candidates) {
 		const block = match[0];
-		const modelName = match[1];
+		const matchedEnumName = match[1];
 		const start = match.index ?? 0;
 		const end = start + block.length;
-		if (explicitMapRegex.test(block)) return {
-			modelName,
-			block,
-			start,
-			end
-		};
-		if (modelName.toLowerCase() === table.toLowerCase()) return {
-			modelName,
-			block,
-			start,
-			end
-		};
-		if (modelName.toLowerCase() === toModelName(table).toLowerCase()) return {
-			modelName,
+		if (matchedEnumName === enumName) return {
+			enumName: matchedEnumName,
 			block,
 			start,
 			end
@@ -1226,600 +1856,543 @@ const findModelBlock = (schema, table) => {
 	return null;
 };
 /**
-* Apply a create table operation to a Prisma schema string, adding a new model 
-* block for the specified table and fields.
-* 
-* @param schema    The current Prisma schema string.
-* @param operation The schema table create operation to apply.
-* @returns         The updated Prisma schema string with the new model block.
-*/
-const applyCreateTableOperation = (schema, operation) => {
-	if (findModelBlock(schema, operation.table)) throw new ArkormException(`Prisma model for table [${operation.table}] already exists.`);
-	const schemaWithEnums = ensureEnumBlocks(schema, operation.columns);
-	const block = buildModelBlock(operation);
-	return applyInverseRelations(`${schemaWithEnums.trimEnd()}\n\n${block}\n`, toModelName(operation.table), operation.foreignKeys ?? [], operation.columns);
-};
-/**
-* Apply an alter table operation to a Prisma schema string, modifying the model 
-* block for the specified table by adding and removing fields as needed.
+* Ensure that Prisma enum blocks exist in the schema for any enum columns defined in a 
+* create or alter table operation, adding them if necessary and validating against 
+* existing blocks.
 * 
-* @param schema    The current Prisma schema string.
-* @param operation The schema table alter operation to apply.
-* @returns         The updated Prisma schema string with the modified model block.
+* @param schema    The current Prisma schema string to check and modify.
+* @param columns   The array of schema column definitions to check for enum types and ensure corresponding blocks exist for.
+* @returns 
 */
-const applyAlterTableOperation = (schema, operation) => {
-	const model = findModelBlock(schema, operation.table);
-	if (!model) throw new ArkormException(`Prisma model for table [${operation.table}] was not found.`);
-	const schemaWithEnums = ensureEnumBlocks(schema, operation.addColumns);
-	const refreshedModel = findModelBlock(schemaWithEnums, operation.table);
-	if (!refreshedModel) throw new ArkormException(`Prisma model for table [${operation.table}] was not found.`);
-	let block = refreshedModel.block;
-	const bodyLines = block.split("\n");
-	operation.dropColumns.forEach((column) => {
-		const columnRegex = new RegExp(`^\\s*${escapeRegex(column)}\\s+`);
-		for (let index = 0; index < bodyLines.length; index += 1) if (columnRegex.test(bodyLines[index])) {
-			bodyLines.splice(index, 1);
-			return;
+const ensureEnumBlocks = (schema, columns) => {
+	let nextSchema = schema;
+	for (const column of columns) {
+		if (column.type !== "enum") continue;
+		const enumName = resolveEnumName(column);
+		const enumValues = column.enumValues ?? [];
+		const existing = findEnumBlock(nextSchema, enumName);
+		if (existing) {
+			const existingValues = validateEnumValues(column, enumName, extractEnumBlockValues(existing.block));
+			if (enumValues.length === 0) {
+				validateEnumDefaultValue(column, enumName, existingValues);
+				continue;
+			}
+			const normalizedEnumValues = validateEnumValues(column, enumName, enumValues);
+			if (existingValues.join("|") !== normalizedEnumValues.join("|")) throw new ArkormException(`Prisma enum [${enumName}] already exists with different values.`);
+			validateEnumDefaultValue(column, enumName, existingValues);
+			continue;
 		}
-	});
-	operation.addColumns.forEach((column) => {
-		const fieldLine = buildFieldLine(column);
-		const columnRegex = new RegExp(`^\\s*${escapeRegex(column.name)}\\s+`);
-		if (bodyLines.some((line) => columnRegex.test(line))) return;
-		const defaultInsertIndex = Math.max(1, bodyLines.length - 1);
-		const afterInsertIndex = typeof column.after === "string" && column.after.length > 0 ? bodyLines.findIndex((line) => new RegExp(`^\\s*${escapeRegex(column.after)}\\s+`).test(line)) : -1;
-		const insertIndex = afterInsertIndex > 0 ? Math.min(afterInsertIndex + 1, defaultInsertIndex) : defaultInsertIndex;
-		bodyLines.splice(insertIndex, 0, fieldLine);
-	});
-	(operation.addIndexes ?? []).forEach((index) => {
-		const indexLine = buildIndexLine(index);
-		if (bodyLines.some((line) => line.trim() === indexLine.trim())) return;
-		const insertIndex = Math.max(1, bodyLines.length - 1);
-		bodyLines.splice(insertIndex, 0, indexLine);
-	});
-	for (const foreignKey of operation.addForeignKeys ?? []) {
-		const relationLine = buildRelationLine(model.modelName, foreignKey, operation.addColumns);
-		const relationRegex = new RegExp(`^\\s*${escapeRegex(foreignKey.fieldAlias?.trim() || deriveRelationFieldName(foreignKey.column))}\\s+`);
-		injectLineIntoModelBody(bodyLines, relationLine, (line) => relationRegex.test(line));
+		if (enumValues.length === 0) throw new ArkormException(`Prisma enum [${enumName}] was not found for column [${column.name}].`);
+		const normalizedEnumValues = validateEnumValues(column, enumName, enumValues);
+		validateEnumDefaultValue(column, enumName, normalizedEnumValues);
+		const block = buildEnumBlock(enumName, normalizedEnumValues);
+		nextSchema = `${nextSchema.trimEnd()}\n\n${block}\n`;
 	}
-	block = bodyLines.join("\n");
-	return applyInverseRelations(`${schemaWithEnums.slice(0, refreshedModel.start)}${block}${schemaWithEnums.slice(refreshedModel.end)}`, model.modelName, operation.addForeignKeys ?? [], operation.addColumns);
-};
-/**
-* Apply a drop table operation to a Prisma schema string, removing the model block
-* for the specified table.
-*/
-const applyDropTableOperation = (schema, operation) => {
-	const model = findModelBlock(schema, operation.table);
-	if (!model) return schema;
-	const before = schema.slice(0, model.start).trimEnd();
-	const after = schema.slice(model.end).trimStart();
-	return `${before}${before && after ? "\n\n" : ""}${after}`;
+	return nextSchema;
 };
 /**
-* The SchemaBuilder class provides a fluent interface for defining 
-* database schema operations in a migration, such as creating, altering, and 
-* dropping tables.
+* Build a Prisma model-level @@index definition line.
 * 
-* @param schema        The current Prisma schema string.
-* @param operations    The list of schema operations to apply.
-* @returns             The updated Prisma schema string after applying all operations.
+* @param index     The schema index definition to convert to a Prisma \@\@index line.
+* @returns 
 */
-const applyOperationsToPrismaSchema = (schema, operations) => {
-	return operations.reduce((current, operation) => {
-		if (operation.type === "createTable") return applyCreateTableOperation(current, operation);
-		if (operation.type === "alterTable") return applyAlterTableOperation(current, operation);
-		return applyDropTableOperation(current, operation);
-	}, schema);
+const buildIndexLine = (index) => {
+	return `  @@index([${index.columns.join(", ")}]${typeof index.name === "string" && index.name.trim().length > 0 ? `, name: "${index.name.replace(/"/g, "\\\"")}"` : ""})`;
 };
 /**
-* Run a Prisma CLI command using npx, capturing and throwing any errors that occur.
+* Derive a relation field name from a foreign key column name by applying 
+* common conventions, such as removing "Id" suffixes and converting to camelCase.
 * 
-* @param args The arguments to pass to the Prisma CLI command.
-* @param cwd The current working directory to run the command in.
-* @returns void
+* @param columnName    The name of the foreign key column.
+* @returns             The derived relation field name.
 */
-const runPrismaCommand = (args, cwd) => {
-	const command = spawnSync("npx", ["prisma", ...args], {
-		cwd,
-		encoding: "utf-8"
-	});
-	if (command.status === 0) return;
-	const errorOutput = [command.stdout, command.stderr].filter(Boolean).join("\n").trim();
-	throw new ArkormException(errorOutput ? `Prisma command failed: prisma ${args.join(" ")}\n${errorOutput}` : `Prisma command failed: prisma ${args.join(" ")}`);
+const deriveRelationFieldName = (columnName) => {
+	const trimmed = columnName.trim();
+	if (!trimmed) return "relation";
+	if (trimmed.endsWith("Id") && trimmed.length > 2) {
+		const root = trimmed.slice(0, -2);
+		return `${root.charAt(0).toLowerCase()}${root.slice(1)}`;
+	}
+	if (trimmed.endsWith("_id") && trimmed.length > 3) return trimmed.slice(0, -3).replace(/_([a-zA-Z0-9])/g, (_, letter) => letter.toUpperCase());
+	return `${trimmed.charAt(0).toLowerCase()}${trimmed.slice(1)}`;
 };
 /**
-* Generate a new migration file with a given name and options, including 
-* writing the file to disk if specified.
+* Derive a relation name for both sides of a relation based on the 
+* source and target model names, using an explicit alias if provided or a 
+* convention of combining the full source model name with the target model name.
 * 
-* @param name 
-* @returns 
+* @param sourceModelName    The name of the source model in the relation.
+* @param targetModelName    The name of the target model in the relation.
+* @param explicitAlias      An optional explicit alias for the relation.
+* @returns                  The derived or explicit relation alias.
 */
-const resolveMigrationClassName = (name) => {
-	const cleaned = name.replace(/[^a-zA-Z0-9]+/g, " ").trim();
-	if (!cleaned) return "GeneratedMigration";
-	return `${cleaned.split(/\s+/g).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("")}Migration`;
+const deriveRelationAlias = (sourceModelName, targetModelName, explicitAlias) => {
+	if (explicitAlias && explicitAlias.trim().length > 0) return explicitAlias.trim();
+	return [sourceModelName, targetModelName].sort((left, right) => left.localeCompare(right)).join("");
 };
-/**
-* Pad a number with leading zeros to ensure it is at least two digits, for 
-* use in migration timestamps.
-* 
-* @param value 
-* @returns 
-*/
-const pad = (value) => String(value).padStart(2, "0");
-/**
-* Create a timestamp string in the format YYYYMMDDHHMMSS for use in migration 
-* file names, based on the current date and time or a provided date.
-* 
-* @param date 
-* @returns 
-*/
-const createMigrationTimestamp = (date = /* @__PURE__ */ new Date()) => {
-	return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+const deriveInverseRelationAlias = deriveRelationAlias;
+const deriveSingularFieldName = (modelName) => {
+	if (!modelName) return "item";
+	return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}`;
 };
-/**
-* Convert a migration name to a slug suitable for use in a file name, by 
-* lowercasing and replacing non-alphanumeric characters with underscores.
+const deriveCollectionFieldName = (modelName) => {
+	if (!modelName) return "items";
+	const camel = `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}`;
+	if (camel.endsWith("s")) return `${camel}es`;
+	return `${camel}s`;
+};
+const resolveForeignKeyColumn = (columns, foreignKey) => {
+	return columns.find((column) => column.name === foreignKey.column);
+};
+const isOneToOneForeignKey = (column) => {
+	return Boolean(column?.unique || column?.primary);
+};
+/** 
+* Format a SchemaForeignKeyAction value as a Prisma onDelete action string.
 * 
-* @param name 
-* @returns 
+* @param action    The foreign key action to format.
+* @returns         The corresponding Prisma onDelete action string.
 */
-const toMigrationFileSlug = (name) => {
-	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "migration";
+const formatRelationAction = (action) => {
+	if (action === "cascade") return "Cascade";
+	if (action === "restrict") return "Restrict";
+	if (action === "setNull") return "SetNull";
+	if (action === "setDefault") return "SetDefault";
+	return "NoAction";
 };
 /**
-* Build the source code for a new migration file based on a given class 
-* name, using a template with empty up and down methods.
+* Build a Prisma relation field line based on a SchemaForeignKey 
+* definition, including relation name and onDelete action.
 * 
-* @param className 
-* @returns 
+* @param foreignKey    The foreign key definition to convert to a relation line.
+* @returns             The corresponding Prisma schema line for the relation field.
 */
-const buildMigrationSource = (className, extension = "ts") => {
-	if (extension === "js") return [
-		"import { Migration } from 'arkormx'",
-		"",
-		`export default class ${className} extends Migration {`,
-		"    /**",
-		"     * @param {import('arkormx').SchemaBuilder} schema",
-		"     * @returns {Promise<void>}",
-		"     */",
-		"    async up (schema) {",
-		"    }",
-		"",
-		"    /**",
-		"     * @param {import('arkormx').SchemaBuilder} schema",
-		"     * @returns {Promise<void>}",
-		"     */",
-		"    async down (schema) {",
-		"    }",
-		"}",
-		""
-	].join("\n");
-	return [
-		"import { Migration, SchemaBuilder } from 'arkormx'",
-		"",
-		`export default class ${className} extends Migration {`,
-		"    public async up (schema: SchemaBuilder): Promise<void> {",
-		"    }",
-		"",
-		"    public async down (schema: SchemaBuilder): Promise<void> {",
-		"    }",
-		"}",
-		""
-	].join("\n");
+const buildRelationLine = (sourceModelName, foreignKey, columns = []) => {
+	if (!foreignKey.referencesTable.trim()) throw new ArkormException(`Foreign key [${foreignKey.column}] must define a referenced table.`);
+	if (!foreignKey.referencesColumn.trim()) throw new ArkormException(`Foreign key [${foreignKey.column}] must define a referenced column.`);
+	const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
+	const fieldName = foreignKey.fieldAlias?.trim() || deriveRelationFieldName(foreignKey.column);
+	const targetModel = toModelName(foreignKey.referencesTable);
+	const relationName = deriveRelationAlias(sourceModelName, targetModel, foreignKey.relationAlias?.trim());
+	const optional = sourceColumn?.nullable ? "?" : "";
+	const onDelete = foreignKey.onDelete ? `, onDelete: ${formatRelationAction(foreignKey.onDelete)}` : "";
+	return `  ${fieldName} ${targetModel}${optional} @relation("${relationName.replace(/"/g, "\\\"")}", fields: [${foreignKey.column}], references: [${foreignKey.referencesColumn}]${onDelete})`;
 };
 /**
-* Generate a new migration file with a given name and options, including 
-* writing the file to disk if specified, and return the details of the generated file.
+* Build a Prisma relation field line for the inverse side of a relation, based 
+* on the source and target model names and the foreign key definition, using 
+* naming conventions and any explicit inverse alias provided.
 * 
-* @param name 
-* @param options 
-* @returns 
+* @param sourceModelName   The name of the source model in the relation.
+* @param targetModelName   The name of the target model in the relation.
+* @param foreignKey        The foreign key definition for the relation.
+* @returns                 The Prisma schema line for the inverse relation field.
 */
-const generateMigrationFile = (name, options = {}) => {
-	const timestamp = createMigrationTimestamp(/* @__PURE__ */ new Date());
-	const fileSlug = toMigrationFileSlug(name);
-	const className = resolveMigrationClassName(name);
-	const extension = options.extension ?? "ts";
-	const directory = options.directory ?? join(process.cwd(), "database", "migrations");
-	const fileName = `${timestamp}_${fileSlug}.${extension}`;
-	const filePath = join(directory, fileName);
-	const content = buildMigrationSource(className, extension);
-	if (options.write ?? true) {
-		if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
-		if (existsSync(filePath)) throw new ArkormException(`Migration file already exists: ${filePath}`);
-		writeFileSync(filePath, content);
-	}
-	return {
-		fileName,
-		filePath,
-		className,
-		content
-	};
+const buildInverseRelationLine = (sourceModelName, targetModelName, foreignKey, columns = []) => {
+	const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
+	const fieldName = isOneToOneForeignKey(sourceColumn) ? deriveSingularFieldName(sourceModelName) : deriveCollectionFieldName(sourceModelName);
+	const relationName = deriveRelationAlias(sourceModelName, targetModelName, foreignKey.relationAlias?.trim());
+	return `  ${fieldName} ${isOneToOneForeignKey(sourceColumn) ? `${sourceModelName}?` : `${sourceModelName}[]`} @relation("${relationName.replace(/"/g, "\\\"")}")`;
 };
 /**
-* Get the list of schema operations that would be performed by a given migration class when run in a specified direction (up or down), without actually applying them.
+* Inject a line into the body of a Prisma model block if it does not already 
+* exist, using a provided existence check function to determine if the line 
+* is already present.
 * 
-* @param migration The migration class or instance to analyze.
-* @param direction The direction of the migration to plan for ('up' or 'down').
-* @returns         A promise that resolves to an array of schema operations that would be performed.   
+* @param bodyLines The lines of the model block body to modify.
+* @param line      The line to inject if it does not already exist.
+* @param exists    A function that checks if a given line already exists in the body.
+* @returns 
 */
-const getMigrationPlan = async (migration, direction = "up") => {
-	const instance = typeof migration === "function" ? new migration() : migration;
-	const schema = new SchemaBuilder();
-	if (direction === "up") await instance.up(schema);
-	else await instance.down(schema);
-	return schema.getOperations();
+const injectLineIntoModelBody = (bodyLines, line, exists) => {
+	if (bodyLines.some(exists)) return bodyLines;
+	const insertIndex = Math.max(1, bodyLines.length - 1);
+	bodyLines.splice(insertIndex, 0, line);
+	return bodyLines;
 };
 /**
-* Apply the schema operations defined in a migration to a Prisma schema 
-* file, updating the file on disk if specified, and return the updated 
-* schema and list of operations applied.
+* Apply inverse relation definitions to a Prisma schema string based on the 
+* foreign keys defined in a create or alter table operation, ensuring that 
+* related models have corresponding relation fields for bi-directional navigation.
 * 
-* @param migration The migration class or instance to apply.
-* @param options   Options for applying the migration, including schema path and write flag.
-* @returns         A promise that resolves to an object containing the updated schema, schema path, and list of operations applied.
+* @param schema The Prisma schema string to modify.
+* @param sourceModelName The name of the source model in the relation.
+* @param foreignKeys An array of foreign key definitions to process.
+* @returns The updated Prisma schema string with inverse relations applied.
 */
-const applyMigrationToPrismaSchema = 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, "up");
-	const schema = applyOperationsToPrismaSchema(source, operations);
-	if (options.write ?? true) writeFileSync(schemaPath, schema);
-	return {
-		schema,
-		schemaPath,
-		operations
-	};
+const applyInverseRelations = (schema, sourceModelName, foreignKeys, columns = []) => {
+	let nextSchema = schema;
+	for (const foreignKey of foreignKeys) {
+		const targetModel = findModelBlock(nextSchema, foreignKey.referencesTable);
+		if (!targetModel) continue;
+		const sourceColumn = resolveForeignKeyColumn(columns, foreignKey);
+		const inverseLine = buildInverseRelationLine(sourceModelName, targetModel.modelName, foreignKey, columns);
+		const targetBodyLines = targetModel.block.split("\n");
+		const fieldName = isOneToOneForeignKey(sourceColumn) ? deriveSingularFieldName(sourceModelName) : deriveCollectionFieldName(sourceModelName);
+		const fieldRegex = new RegExp(`^\\s*${escapeRegex(fieldName)}\\s+`);
+		injectLineIntoModelBody(targetBodyLines, inverseLine, (line) => fieldRegex.test(line));
+		const updatedTarget = targetBodyLines.join("\n");
+		nextSchema = `${nextSchema.slice(0, targetModel.start)}${updatedTarget}${nextSchema.slice(targetModel.end)}`;
+	}
+	return nextSchema;
 };
 /**
-* 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.
+* Build a Prisma model block string based on a SchemaTableCreateOperation, including 
+* all fields and any necessary mapping.
+* 
+* @param operation The schema table create operation to convert.
+* @returns         The corresponding Prisma model block string.
 */
-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,
-		operations
-	};
+const buildModelBlock = (operation) => {
+	const modelName = toModelName(operation.table);
+	const mapped = operation.table !== modelName.toLowerCase();
+	const fields = operation.columns.map(buildFieldLine);
+	const relations = (operation.foreignKeys ?? []).map((foreignKey) => buildRelationLine(modelName, foreignKey, operation.columns));
+	const metadata = [...(operation.indexes ?? []).map(buildIndexLine), ...mapped ? [`  @@map("${str(operation.table).snake()}")`] : []];
+	return `model ${modelName} {\n${(metadata.length > 0 ? [
+		...fields,
+		...relations,
+		"",
+		...metadata
+	] : [...fields, ...relations]).join("\n")}\n}`;
 };
 /**
-* Run a migration by applying its schema operations to a Prisma schema 
-* file, optionally generating Prisma client code and running migrations after 
-* applying the schema changes.
+* Find the Prisma model block in a schema string that corresponds to a given 
+* table name, using both explicit mapping and naming conventions.
 * 
-* @param migration The migration class or instance to run.
-* @param options   Options for running the migration, including schema path, write flag, and Prisma commands.
-* @returns         A promise that resolves to an object containing the schema path and list of operations applied.
+* @param schema 
+* @param table 
+* @returns 
 */
-const runMigrationWithPrisma = async (migration, options = {}) => {
-	const cwd = options.cwd ?? process.cwd();
-	const applied = await applyMigrationToPrismaSchema(migration, {
-		schemaPath: options.schemaPath ?? join(cwd, "prisma", "schema.prisma"),
-		write: options.write
-	});
-	const shouldGenerate = options.runGenerate ?? true;
-	const shouldMigrate = options.runMigrate ?? true;
-	const mode = options.migrateMode ?? "dev";
-	if (shouldGenerate) runPrismaCommand(["generate"], cwd);
-	if (shouldMigrate) if (mode === "deploy") runPrismaCommand(["migrate", "deploy"], cwd);
-	else runPrismaCommand([
-		"migrate",
-		"dev",
-		"--name",
-		options.migrationName ?? `arkorm_${createMigrationTimestamp()}`
-	], cwd);
-	return {
-		schemaPath: applied.schemaPath,
-		operations: applied.operations
-	};
-};
-
-//#endregion
-//#region src/helpers/runtime-module-loader.ts
-var RuntimeModuleLoader = class {
-	static async load(filePath) {
-		const resolvedPath = resolve(filePath);
-		return await createJiti(pathToFileURL(resolvedPath).href, {
-			interopDefault: false,
-			tsconfigPaths: true
-		}).import(resolvedPath);
-	}
-};
-
-//#endregion
-//#region src/Exceptions/UnsupportedAdapterFeatureException.ts
-var UnsupportedAdapterFeatureException = class extends ArkormException {
-	constructor(message, context = {}) {
-		super(message, {
-			code: "UNSUPPORTED_ADAPTER_FEATURE",
-			...context
-		});
-		this.name = "UnsupportedAdapterFeatureException";
-	}
-};
-
-//#endregion
-//#region src/helpers/runtime-config.ts
-const resolveDefaultStubsPath = () => {
-	let current = path.dirname(fileURLToPath(import.meta.url));
-	while (true) {
-		const packageJsonPath = path.join(current, "package.json");
-		const stubsPath = path.join(current, "stubs");
-		if (existsSync$1(packageJsonPath) && existsSync$1(stubsPath)) return stubsPath;
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
+const findModelBlock = (schema, table) => {
+	const candidates = [...schema.matchAll(PRISMA_MODEL_REGEX)];
+	const explicitMapRegex = new RegExp(`@@map\\("${escapeRegex(table)}"\\)`);
+	for (const match of candidates) {
+		const block = match[0];
+		const modelName = match[1];
+		const start = match.index ?? 0;
+		const end = start + block.length;
+		if (explicitMapRegex.test(block)) return {
+			modelName,
+			block,
+			start,
+			end
+		};
+		if (modelName.toLowerCase() === table.toLowerCase()) return {
+			modelName,
+			block,
+			start,
+			end
+		};
+		if (modelName.toLowerCase() === toModelName(table).toLowerCase()) return {
+			modelName,
+			block,
+			start,
+			end
+		};
 	}
-	return path.join(process.cwd(), "stubs");
-};
-const baseConfig = {
-	paths: {
-		stubs: resolveDefaultStubsPath(),
-		seeders: path.join(process.cwd(), "database", "seeders"),
-		models: path.join(process.cwd(), "src", "models"),
-		migrations: path.join(process.cwd(), "database", "migrations"),
-		factories: path.join(process.cwd(), "database", "factories"),
-		buildOutput: path.join(process.cwd(), "dist")
-	},
-	outputExt: "ts"
-};
-const userConfig = {
-	...baseConfig,
-	paths: { ...baseConfig.paths ?? {} }
-};
-let runtimeConfigLoaded = false;
-let runtimeConfigLoadingPromise;
-let runtimeClientResolver;
-let runtimePaginationURLDriverFactory;
-let runtimePaginationCurrentPageResolver;
-const transactionClientStorage = new AsyncLocalStorage();
-const mergePathConfig = (paths) => {
-	const defaults = baseConfig.paths ?? {};
-	const current = userConfig.paths ?? {};
-	const incoming = Object.entries(paths ?? {}).reduce((all, [key, value]) => {
-		if (typeof value === "string" && value.trim().length > 0) all[key] = path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
-		return all;
-	}, {});
-	return {
-		...defaults,
-		...current,
-		...incoming
-	};
+	return null;
 };
 /**
-* Define the ArkORM runtime configuration. This function can be used to provide.
+* Apply a create table operation to a Prisma schema string, adding a new model 
+* block for the specified table and fields.
 * 
-* @param config The ArkORM configuration object.
-* @returns The same configuration object.
+* @param schema    The current Prisma schema string.
+* @param operation The schema table create operation to apply.
+* @returns         The updated Prisma schema string with the new model block.
 */
-const defineConfig = (config) => {
-	return config;
+const applyCreateTableOperation = (schema, operation) => {
+	if (findModelBlock(schema, operation.table)) throw new ArkormException(`Prisma model for table [${operation.table}] already exists.`);
+	const schemaWithEnums = ensureEnumBlocks(schema, operation.columns);
+	const block = buildModelBlock(operation);
+	return applyInverseRelations(`${schemaWithEnums.trimEnd()}\n\n${block}\n`, toModelName(operation.table), operation.foreignKeys ?? [], operation.columns);
 };
 /**
-* Get the user-provided ArkORM configuration. 
+* Apply an alter table operation to a Prisma schema string, modifying the model 
+* block for the specified table by adding and removing fields as needed.
 * 
-* @returns The user-provided ArkORM configuration object.  
+* @param schema    The current Prisma schema string.
+* @param operation The schema table alter operation to apply.
+* @returns         The updated Prisma schema string with the modified model block.
 */
-const getUserConfig = (key) => {
-	if (key) return userConfig[key];
-	return userConfig;
+const applyAlterTableOperation = (schema, operation) => {
+	const model = findModelBlock(schema, operation.table);
+	if (!model) throw new ArkormException(`Prisma model for table [${operation.table}] was not found.`);
+	const schemaWithEnums = ensureEnumBlocks(schema, operation.addColumns);
+	const refreshedModel = findModelBlock(schemaWithEnums, operation.table);
+	if (!refreshedModel) throw new ArkormException(`Prisma model for table [${operation.table}] was not found.`);
+	let block = refreshedModel.block;
+	const bodyLines = block.split("\n");
+	operation.dropColumns.forEach((column) => {
+		const columnRegex = new RegExp(`^\\s*${escapeRegex(column)}\\s+`);
+		for (let index = 0; index < bodyLines.length; index += 1) if (columnRegex.test(bodyLines[index])) {
+			bodyLines.splice(index, 1);
+			return;
+		}
+	});
+	operation.addColumns.forEach((column) => {
+		const fieldLine = buildFieldLine(column);
+		const columnRegex = new RegExp(`^\\s*${escapeRegex(column.name)}\\s+`);
+		if (bodyLines.some((line) => columnRegex.test(line))) return;
+		const defaultInsertIndex = Math.max(1, bodyLines.length - 1);
+		const afterInsertIndex = typeof column.after === "string" && column.after.length > 0 ? bodyLines.findIndex((line) => new RegExp(`^\\s*${escapeRegex(column.after)}\\s+`).test(line)) : -1;
+		const insertIndex = afterInsertIndex > 0 ? Math.min(afterInsertIndex + 1, defaultInsertIndex) : defaultInsertIndex;
+		bodyLines.splice(insertIndex, 0, fieldLine);
+	});
+	(operation.addIndexes ?? []).forEach((index) => {
+		const indexLine = buildIndexLine(index);
+		if (bodyLines.some((line) => line.trim() === indexLine.trim())) return;
+		const insertIndex = Math.max(1, bodyLines.length - 1);
+		bodyLines.splice(insertIndex, 0, indexLine);
+	});
+	for (const foreignKey of operation.addForeignKeys ?? []) {
+		const relationLine = buildRelationLine(model.modelName, foreignKey, operation.addColumns);
+		const relationRegex = new RegExp(`^\\s*${escapeRegex(foreignKey.fieldAlias?.trim() || deriveRelationFieldName(foreignKey.column))}\\s+`);
+		injectLineIntoModelBody(bodyLines, relationLine, (line) => relationRegex.test(line));
+	}
+	block = bodyLines.join("\n");
+	return applyInverseRelations(`${schemaWithEnums.slice(0, refreshedModel.start)}${block}${schemaWithEnums.slice(refreshedModel.end)}`, model.modelName, operation.addForeignKeys ?? [], operation.addColumns);
 };
 /**
-* Configure the ArkORM runtime with the provided Prisma client resolver and 
-* delegate mapping resolver.
+* Apply a drop table operation to a Prisma schema string, removing the model block
+* for the specified table.
+*/
+const applyDropTableOperation = (schema, operation) => {
+	const model = findModelBlock(schema, operation.table);
+	if (!model) return schema;
+	const before = schema.slice(0, model.start).trimEnd();
+	const after = schema.slice(model.end).trimStart();
+	return `${before}${before && after ? "\n\n" : ""}${after}`;
+};
+/**
+* The SchemaBuilder class provides a fluent interface for defining 
+* database schema operations in a migration, such as creating, altering, and 
+* dropping tables.
 * 
-* @param prisma 
-* @param mapping 
+* @param schema        The current Prisma schema string.
+* @param operations    The list of schema operations to apply.
+* @returns             The updated Prisma schema string after applying all operations.
 */
-const configureArkormRuntime = (prisma, options = {}) => {
-	const nextConfig = {
-		...userConfig,
-		prisma,
-		paths: mergePathConfig(options.paths)
-	};
-	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
-	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
-	Object.assign(userConfig, { ...nextConfig });
-	runtimeClientResolver = prisma;
-	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
-	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+const applyOperationsToPrismaSchema = (schema, operations) => {
+	return operations.reduce((current, operation) => {
+		if (operation.type === "createTable") return applyCreateTableOperation(current, operation);
+		if (operation.type === "alterTable") return applyAlterTableOperation(current, operation);
+		return applyDropTableOperation(current, operation);
+	}, schema);
 };
 /**
-* Reset the ArkORM runtime configuration. 
-* This is primarily intended for testing purposes.
+* Run a Prisma CLI command using npx, capturing and throwing any errors that occur.
+* 
+* @param args The arguments to pass to the Prisma CLI command.
+* @param cwd The current working directory to run the command in.
+* @returns void
 */
-const resetArkormRuntimeForTests = () => {
-	Object.assign(userConfig, {
-		...baseConfig,
-		paths: { ...baseConfig.paths ?? {} }
+const runPrismaCommand = (args, cwd) => {
+	const command = spawnSync("npx", ["prisma", ...args], {
+		cwd,
+		encoding: "utf-8"
 	});
-	runtimeConfigLoaded = false;
-	runtimeConfigLoadingPromise = void 0;
-	runtimeClientResolver = void 0;
-	runtimePaginationURLDriverFactory = void 0;
-	runtimePaginationCurrentPageResolver = void 0;
+	if (command.status === 0) return;
+	const errorOutput = [command.stdout, command.stderr].filter(Boolean).join("\n").trim();
+	throw new ArkormException(errorOutput ? `Prisma command failed: prisma ${args.join(" ")}\n${errorOutput}` : `Prisma command failed: prisma ${args.join(" ")}`);
 };
 /**
-* 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.
+* Generate a new migration file with a given name and options, including 
+* writing the file to disk if specified.
 * 
-* @param resolver 
+* @param name 
 * @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;
+const resolveMigrationClassName = (name) => {
+	const cleaned = name.replace(/[^a-zA-Z0-9]+/g, " ").trim();
+	if (!cleaned) return "GeneratedMigration";
+	return `${cleaned.split(/\s+/g).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("")}Migration`;
 };
 /**
-* Resolve and apply the ArkORM configuration from an imported module. 
-* This function checks for a default export and falls back to the module itself, then validates
-* the configuration object and applies it to the runtime if valid.
+* Pad a number with leading zeros to ensure it is at least two digits, for 
+* use in migration timestamps.
 * 
-* @param imported 
+* @param value 
 * @returns 
 */
-const resolveAndApplyConfig = (imported) => {
-	const config = imported?.default ?? imported;
-	if (!config || typeof config !== "object" || !config.prisma) return;
-	configureArkormRuntime(config.prisma, {
-		pagination: config.pagination,
-		paths: config.paths,
-		outputExt: config.outputExt
-	});
-	runtimeConfigLoaded = true;
-};
+const pad = (value) => String(value).padStart(2, "0");
 /**
-* Dynamically import a configuration file. 
-* A cache-busting query parameter is appended to ensure the latest version is loaded.
+* Create a timestamp string in the format YYYYMMDDHHMMSS for use in migration 
+* file names, based on the current date and time or a provided date.
 * 
-* @param configPath 
-* @returns A promise that resolves to the imported configuration module.   
+* @param date 
+* @returns 
 */
-const importConfigFile = (configPath) => {
-	return RuntimeModuleLoader.load(configPath);
-};
-const loadRuntimeConfigSync = () => {
-	const require = createRequire(import.meta.url);
-	const syncConfigPaths = [path.join(process.cwd(), "arkormx.config.cjs")];
-	for (const configPath of syncConfigPaths) {
-		if (!existsSync$1(configPath)) continue;
-		try {
-			resolveAndApplyConfig(require(configPath));
-			return true;
-		} catch {
-			continue;
-		}
-	}
-	return false;
+const createMigrationTimestamp = (date = /* @__PURE__ */ new Date()) => {
+	return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
 };
 /**
-* Load the ArkORM configuration by searching for configuration files in the 
-* current working directory.
+* Convert a migration name to a slug suitable for use in a file name, by 
+* lowercasing and replacing non-alphanumeric characters with underscores.
+* 
+* @param name 
 * @returns 
-*/
-const loadArkormConfig = async () => {
-	if (runtimeConfigLoaded) return;
-	if (runtimeConfigLoadingPromise) return await runtimeConfigLoadingPromise;
-	if (loadRuntimeConfigSync()) return;
-	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$1(configPath)) continue;
-			try {
-				resolveAndApplyConfig(await importConfigFile(configPath));
-				return;
-			} catch {
-				continue;
-			}
-		}
-		runtimeConfigLoaded = true;
-	})();
-	await runtimeConfigLoadingPromise;
+*/
+const toMigrationFileSlug = (name) => {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "migration";
 };
 /**
-* Ensure that the ArkORM configuration is loaded. 
-* This function can be called to trigger the loading process if it hasn't already been initiated.
-* If the configuration is already loaded, it will return immediately.
+* Build the source code for a new migration file based on a given class 
+* name, using a template with empty up and down methods.
 * 
+* @param className 
 * @returns 
 */
-const ensureArkormConfigLoading = () => {
-	if (runtimeConfigLoaded) return;
-	if (!runtimeConfigLoadingPromise) loadArkormConfig();
-};
-const getDefaultStubsPath = () => {
-	return resolveDefaultStubsPath();
+const buildMigrationSource = (className, extension = "ts") => {
+	if (extension === "js") return [
+		"import { Migration } from 'arkormx'",
+		"",
+		`export default class ${className} extends Migration {`,
+		"    /**",
+		"     * @param {import('arkormx').SchemaBuilder} schema",
+		"     * @returns {Promise<void>}",
+		"     */",
+		"    async up (schema) {",
+		"    }",
+		"",
+		"    /**",
+		"     * @param {import('arkormx').SchemaBuilder} schema",
+		"     * @returns {Promise<void>}",
+		"     */",
+		"    async down (schema) {",
+		"    }",
+		"}",
+		""
+	].join("\n");
+	return [
+		"import { Migration, SchemaBuilder } from 'arkormx'",
+		"",
+		`export default class ${className} extends Migration {`,
+		"    public async up (schema: SchemaBuilder): Promise<void> {",
+		"    }",
+		"",
+		"    public async down (schema: SchemaBuilder): Promise<void> {",
+		"    }",
+		"}",
+		""
+	].join("\n");
 };
 /**
-* Get the runtime Prisma client. 
-* This function will trigger the loading of the ArkORM configuration if 
-* it hasn't already been loaded.
+* Generate a new migration file with a given name and options, including 
+* writing the file to disk if specified, and return the details of the generated file.
 * 
+* @param name 
+* @param options 
 * @returns 
 */
-const getRuntimePrismaClient = () => {
-	const activeTransactionClient = transactionClientStorage.getStore();
-	if (activeTransactionClient) return activeTransactionClient;
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return resolveClient(runtimeClientResolver);
-};
-const getActiveTransactionClient = () => {
-	return transactionClientStorage.getStore();
-};
-const isTransactionCapableClient = (value) => {
-	if (!value || typeof value !== "object") return false;
-	return typeof value.$transaction === "function";
+const generateMigrationFile = (name, options = {}) => {
+	const timestamp = createMigrationTimestamp(/* @__PURE__ */ new Date());
+	const fileSlug = toMigrationFileSlug(name);
+	const className = resolveMigrationClassName(name);
+	const extension = options.extension ?? "ts";
+	const directory = options.directory ?? join(process.cwd(), "database", "migrations");
+	const fileName = `${timestamp}_${fileSlug}.${extension}`;
+	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);
+	}
+	return {
+		fileName,
+		filePath,
+		className,
+		content
+	};
 };
-const runArkormTransaction = async (callback, options = {}) => {
-	const activeTransactionClient = transactionClientStorage.getStore();
-	if (activeTransactionClient) return await callback(activeTransactionClient);
-	const client = getRuntimePrismaClient();
-	if (!client) throw new ArkormException("Cannot start a transaction without a configured Prisma client.", {
-		code: "CLIENT_NOT_CONFIGURED",
-		operation: "transaction"
-	});
-	if (!isTransactionCapableClient(client)) throw new UnsupportedAdapterFeatureException("Transactions are not supported by the current adapter.", {
-		code: "TRANSACTION_NOT_SUPPORTED",
-		operation: "transaction"
-	});
-	return await client.$transaction(async (transactionClient) => {
-		return await transactionClientStorage.run(transactionClient, async () => {
-			return await callback(transactionClient);
-		});
-	}, options);
+/**
+* Get the list of schema operations that would be performed by a given migration class when run in a specified direction (up or down), without actually applying them.
+* 
+* @param migration The migration class or instance to analyze.
+* @param direction The direction of the migration to plan for ('up' or 'down').
+* @returns         A promise that resolves to an array of schema operations that would be performed.   
+*/
+const getMigrationPlan = async (migration, direction = "up") => {
+	const instance = typeof migration === "function" ? new migration() : migration;
+	const schema = new SchemaBuilder();
+	if (direction === "up") await instance.up(schema);
+	else await instance.down(schema);
+	return schema.getOperations();
 };
 /**
-* Get the configured pagination URL driver factory from runtime config.
-*
-* @returns
+* Apply the schema operations defined in a migration to a Prisma schema 
+* file, updating the file on disk if specified, and return the updated 
+* schema and list of operations applied.
+* 
+* @param migration The migration class or instance to apply.
+* @param options   Options for applying the migration, including schema path and write flag.
+* @returns         A promise that resolves to an object containing the updated schema, schema path, and list of operations applied.
 */
-const getRuntimePaginationURLDriverFactory = () => {
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimePaginationURLDriverFactory;
+const applyMigrationToPrismaSchema = async (migration, options = {}) => {
+	const schemaPath = options.schemaPath ?? join(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 operations = await getMigrationPlan(migration, "up");
+	const schema = applyOperationsToPrismaSchema(source, operations);
+	if (options.write ?? true) writeFileSync$1(schemaPath, schema);
+	return {
+		schema,
+		schemaPath,
+		operations
+	};
 };
 /**
-* Get the configured current-page resolver from runtime config.
+* Apply the rollback (down) operations defined in a migration to a Prisma schema file.
 *
-* @returns
+* @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 getRuntimePaginationCurrentPageResolver = () => {
-	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
-	return runtimePaginationCurrentPageResolver;
+const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) => {
+	const schemaPath = options.schemaPath ?? join(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 operations = await getMigrationPlan(migration, "down");
+	const schema = applyOperationsToPrismaSchema(source, operations);
+	if (options.write ?? true) writeFileSync$1(schemaPath, schema);
+	return {
+		schema,
+		schemaPath,
+		operations
+	};
 };
 /**
-* Check if a given value is a Prisma delegate-like object 
-* by verifying the presence of common delegate methods.
+* Run a migration by applying its schema operations to a Prisma schema 
+* file, optionally generating Prisma client code and running migrations after 
+* applying the schema changes.
 * 
-* @param value The value to check.
-* @returns True if the value is a Prisma delegate-like object, false otherwise.    
+* @param migration The migration class or instance to run.
+* @param options   Options for running the migration, including schema path, write flag, and Prisma commands.
+* @returns         A promise that resolves to an object containing the schema path and list of operations applied.
 */
-const isDelegateLike = (value) => {
-	if (!value || typeof value !== "object") return false;
-	const candidate = value;
-	return [
-		"findMany",
-		"findFirst",
-		"create",
-		"update",
-		"delete",
-		"count"
-	].every((method) => typeof candidate[method] === "function");
+const runMigrationWithPrisma = async (migration, options = {}) => {
+	const cwd = options.cwd ?? process.cwd();
+	const applied = await applyMigrationToPrismaSchema(migration, {
+		schemaPath: options.schemaPath ?? join(cwd, "prisma", "schema.prisma"),
+		write: options.write
+	});
+	const shouldGenerate = options.runGenerate ?? true;
+	const shouldMigrate = options.runMigrate ?? true;
+	const mode = options.migrateMode ?? "dev";
+	if (shouldGenerate) runPrismaCommand(["generate"], cwd);
+	if (shouldMigrate) if (mode === "deploy") runPrismaCommand(["migrate", "deploy"], cwd);
+	else runPrismaCommand([
+		"migrate",
+		"dev",
+		"--name",
+		options.migrationName ?? `arkorm_${createMigrationTimestamp()}`
+	], cwd);
+	return {
+		schemaPath: applied.schemaPath,
+		operations: applied.operations
+	};
 };
-loadArkormConfig();
 
 //#endregion
 //#region src/cli/CliApp.ts
@@ -1849,7 +2422,7 @@ var CliApp = class {
 	*/
 	ensureDirectory(filePath) {
 		const dir = dirname$1(filePath);
-		if (!existsSync$1(dir)) mkdirSync$1(dir, { recursive: true });
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 	}
 	/**
 	* Convert absolute paths under current working directory into relative display paths.
@@ -1898,13 +2471,13 @@ var CliApp = class {
 	* @returns
 	*/
 	resolveRuntimeDirectoryPath(directoryPath) {
-		if (existsSync$1(directoryPath)) return directoryPath;
+		if (existsSync(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$1(buildOutput, relativeSource);
-		return existsSync$1(mappedDirectory) ? mappedDirectory : directoryPath;
+		return existsSync(mappedDirectory) ? mappedDirectory : directoryPath;
 	}
 	/**
 	* Resolve a script file path for runtime execution.
@@ -1934,7 +2507,7 @@ var CliApp = class {
 				} else candidates.push(mappedFile);
 			}
 		}
-		const runtimeMatch = candidates.find((path) => existsSync$1(path));
+		const runtimeMatch = candidates.find((path) => existsSync(path));
 		if (runtimeMatch) return runtimeMatch;
 		return filePath;
 	}
@@ -1946,14 +2519,14 @@ var CliApp = class {
 	* @param replacements
 	*/
 	generateFile(stubPath, outputPath, replacements, options) {
-		if (existsSync$1(outputPath) && !options?.force) {
+		if (existsSync(outputPath) && !options?.force) {
 			this.command.error(`Error: ${this.formatPathForLog(outputPath)} already exists.`);
 			process.exit(1);
-		} else if (existsSync$1(outputPath) && options?.force) rmSync$1(outputPath);
-		let content = readFileSync$1(stubPath, "utf-8");
+		} else if (existsSync(outputPath) && options?.force) rmSync(outputPath);
+		let content = readFileSync(stubPath, "utf-8");
 		for (const [key, value] of Object.entries(replacements)) content = content.replace(new RegExp(`{{${key}}}`, "g"), value);
 		this.ensureDirectory(outputPath);
-		writeFileSync$1(outputPath, content);
+		writeFileSync(outputPath, content);
 		return outputPath;
 	}
 	/**
@@ -2091,18 +2664,18 @@ var CliApp = class {
 	*/
 	ensurePrismaModelEntry(modelName, delegateName) {
 		const schemaPath = join$1(process.cwd(), "prisma", "schema.prisma");
-		if (!existsSync$1(schemaPath)) return {
+		if (!existsSync(schemaPath)) return {
 			path: schemaPath,
 			updated: false
 		};
-		const source = readFileSync$1(schemaPath, "utf-8");
+		const source = readFileSync(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$1(schemaPath, applyCreateTableOperation(source, {
+		writeFileSync(schemaPath, applyCreateTableOperation(source, {
 			type: "createTable",
 			table: delegateName,
 			columns: [{
@@ -2479,17 +3052,17 @@ var CliApp = class {
 	syncModelsFromPrisma(options = {}) {
 		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");
+		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 prismaEnums = this.parsePrismaEnums(schema);
 		const prismaModels = this.parsePrismaModels(schema);
-		const modelFiles = readdirSync$1(modelsDir).filter((file) => file.endsWith(".ts"));
+		const modelFiles = readdirSync(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 source = readFileSync(filePath, "utf-8");
 			const classMatch = source.match(/export\s+class\s+(\w+)\s+extends\s+Model<'([^']+)'>/);
 			if (!classMatch) {
 				skipped.push(filePath);
@@ -2507,7 +3080,7 @@ var CliApp = class {
 				skipped.push(filePath);
 				return;
 			}
-			writeFileSync$1(filePath, synced.content);
+			writeFileSync(filePath, synced.content);
 			updated.push(filePath);
 		});
 		return {
@@ -2544,18 +3117,18 @@ var InitCommand = class extends Command {
 		const stubsDir = typeof stubs === "string" && stubs.trim().length > 0 ? stubs : getDefaultStubsPath();
 		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")) {
+		const stubPath = existsSync(preferredStubPath) ? preferredStubPath : legacyStubPath;
+		if (existsSync(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$1(outputDir) && this.option("force")) copyFileSync(outputDir, outputDir.replace(/\.js$/, `.backup.${Date.now()}.js`));
-		if (!existsSync$1(stubPath)) {
+		if (existsSync(outputDir) && this.option("force")) copyFileSync(outputDir, outputDir.replace(/\.js$/, `.backup.${Date.now()}.js`));
+		if (!existsSync(stubPath)) {
 			this.error(`Error: Missing config stub at ${preferredStubPath} (or ${legacyStubPath})`);
 			process.exit(1);
 		}
-		writeFileSync$1(outputDir, readFileSync$1(stubPath, "utf-8"));
+		writeFileSync(outputDir, readFileSync(stubPath, "utf-8"));
 		this.success("Arkormˣ initialized successfully!");
 	}
 };
@@ -2697,13 +3270,13 @@ const buildMigrationIdentity = (filePath, className) => {
 	return `${fileName.slice(0, fileName.length - extname(fileName).length)}:${className}`;
 };
 const computeMigrationChecksum = (filePath) => {
-	const source = readFileSync(filePath, "utf-8");
+	const source = readFileSync$1(filePath, "utf-8");
 	return createHash("sha256").update(source).digest("hex");
 };
 const readAppliedMigrationsState = (stateFilePath) => {
-	if (!existsSync(stateFilePath)) return { ...DEFAULT_STATE };
+	if (!existsSync$1(stateFilePath)) return { ...DEFAULT_STATE };
 	try {
-		const parsed = JSON.parse(readFileSync(stateFilePath, "utf-8"));
+		const parsed = JSON.parse(readFileSync$1(stateFilePath, "utf-8"));
 		if (!Array.isArray(parsed.migrations)) return { ...DEFAULT_STATE };
 		return {
 			version: 1,
@@ -2720,8 +3293,8 @@ const readAppliedMigrationsState = (stateFilePath) => {
 };
 const writeAppliedMigrationsState = (stateFilePath, state) => {
 	const directory = dirname(stateFilePath);
-	if (!existsSync(directory)) mkdirSync(directory, { recursive: true });
-	writeFileSync(stateFilePath, JSON.stringify(state, null, 2));
+	if (!existsSync$1(directory)) mkdirSync$1(directory, { recursive: true });
+	writeFileSync$1(stateFilePath, JSON.stringify(state, null, 2));
 };
 const isMigrationApplied = (state, identity, checksum) => {
 	const matched = state.migrations.find((migration) => migration.id === identity);
@@ -2767,10 +3340,24 @@ const markMigrationRun = (state, run) => {
 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];
+	return runs.map((run, index) => ({
+		run,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	})[0]?.run;
 };
 const getLatestAppliedMigrations = (state, steps) => {
-	return [...state.migrations].sort((left, right) => right.appliedAt.localeCompare(left.appliedAt)).slice(0, Math.max(0, steps));
+	return state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
 };
 
 //#endregion
@@ -2822,7 +3409,7 @@ var MigrateCommand = class extends Command {
 		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)}`);
+		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 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.");
@@ -2890,7 +3477,7 @@ var MigrateCommand = class extends Command {
 	* @param migrationsDir The directory to load migration classes from.
 	*/
 	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)));
+		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();
 	}
 	/**
@@ -2912,7 +3499,7 @@ var MigrateCommand = class extends Command {
 			`${base}Migration.js`,
 			`${base}Migration.mjs`,
 			`${base}Migration.cjs`
-		].map((file) => join(migrationsDir, file)).find((file) => existsSync(file));
+		].map((file) => join(migrationsDir, file)).find((file) => existsSync$1(file));
 		if (!target) return [[void 0, name]];
 		const runtimeTarget = this.app.resolveRuntimeScriptPath(target);
 		return (await this.loadMigrationClassesFromFile(runtimeTarget)).map((cls) => [cls, runtimeTarget]);
@@ -2959,7 +3546,7 @@ var MigrateRollbackCommand = class extends Command {
 		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)}`);
+		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);
@@ -3005,7 +3592,7 @@ var MigrateRollbackCommand = class extends Command {
 		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)));
+		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) {
@@ -3039,11 +3626,11 @@ var MigrationHistoryCommand = class extends Command {
 		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)) {
+			if (!existsSync$1(stateFilePath)) {
 				this.success(`No migration state file found at ${this.app.formatPathForLog(stateFilePath)}`);
 				return;
 			}
-			rmSync(stateFilePath);
+			rmSync$1(stateFilePath);
 			this.success(`Deleted migration state file: ${this.app.formatPathForLog(stateFilePath)}`);
 			return;
 		}
@@ -3172,7 +3759,7 @@ var SeedCommand = class extends Command {
 		this.app.command = this;
 		const configuredSeedersDir = this.app.getConfig("paths")?.seeders ?? join(process.cwd(), "database", "seeders");
 		const seedersDir = this.app.resolveRuntimeDirectoryPath(configuredSeedersDir);
-		if (!existsSync(seedersDir)) return void this.error(`ERROR: Seeders directory not found: ${this.app.formatPathForLog(configuredSeedersDir)}`);
+		if (!existsSync$1(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();
@@ -3186,7 +3773,7 @@ var SeedCommand = class extends Command {
 	* @returns 
 	*/
 	async loadAllSeeders(seedersDir) {
-		const files = readdirSync(seedersDir).filter((file) => /\.(ts|js|mjs|cjs)$/i.test(file)).map((file) => this.app.resolveRuntimeScriptPath(join(seedersDir, file)));
+		const files = readdirSync$1(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();
 	}
 	/**
@@ -3207,7 +3794,7 @@ var SeedCommand = class extends Command {
 			`${base}Seeder.js`,
 			`${base}Seeder.mjs`,
 			`${base}Seeder.cjs`
-		].map((file) => join(seedersDir, file)).find((file) => existsSync(file));
+		].map((file) => join(seedersDir, file)).find((file) => existsSync$1(file));
 		if (!target) return [];
 		const runtimeTarget = this.app.resolveRuntimeScriptPath(target);
 		return await this.loadSeederClassesFromFile(runtimeTarget);
@@ -3377,18 +3964,6 @@ const defineFactory = (model, definition) => {
 	return new InlineFactory(model, definition);
 };
 
-//#endregion
-//#region src/Exceptions/MissingDelegateException.ts
-var MissingDelegateException = class extends ArkormException {
-	constructor(message, context = {}) {
-		super(message, {
-			code: "MISSING_DELEGATE",
-			...context
-		});
-		this.name = "MissingDelegateException";
-	}
-};
-
 //#endregion
 //#region src/Exceptions/ModelNotFoundException.ts
 /**
@@ -3451,55 +4026,59 @@ var ScopeNotDefinedException = class extends ArkormException {
 };
 
 //#endregion
-//#region src/Exceptions/UniqueConstraintResolutionException.ts
-var UniqueConstraintResolutionException = class extends ArkormException {
-	constructor(message, context = {}) {
-		super(message, {
-			code: "UNIQUE_CONSTRAINT_RESOLUTION_FAILED",
-			...context
-		});
-		this.name = "UniqueConstraintResolutionException";
-	}
-};
-
-//#endregion
-//#region src/helpers/prisma.ts
-/**
-* Create an adapter to convert a Prisma client instance into a format 
-* compatible with ArkORM's expectations.
-* 
-* @param prisma The Prisma client instance to adapt.
-* @param mapping An optional mapping of Prisma delegate names to ArkORM delegate names.
-* @returns A record of adapted Prisma delegates compatible with ArkORM.
-*/
-function createPrismaAdapter(prisma) {
-	return Object.entries(prisma).reduce((accumulator, [key, value]) => {
-		if (!isDelegateLike(value)) return accumulator;
-		accumulator[key] = value;
-		return accumulator;
-	}, {});
-}
-/**
-* Create a delegate mapping record for Model.setClient() from a Prisma client.
-*
-* @param prisma The Prisma client instance.
-* @param mapping Optional mapping of Arkormˣ delegate names to Prisma delegate names.
-* @returns A delegate map keyed by Arkormˣ delegate names.
-*/
-function createPrismaDelegateMap(prisma) {
-	return createPrismaAdapter(prisma);
-}
-/**
-* Infer the Prisma delegate name for a given model name using a simple convention.
-* 
-* @param modelName The name of the model to infer the delegate name for.
-* @returns The inferred Prisma delegate name.
-*/
-function inferDelegateName(modelName) {
-	return `${modelName.charAt(0).toLowerCase()}${modelName.slice(1)}s`;
-}
-
-//#endregion
+//#region src/Exceptions/UniqueConstraintResolutionException.ts
+var UniqueConstraintResolutionException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "UNIQUE_CONSTRAINT_RESOLUTION_FAILED",
+			...context
+		});
+		this.name = "UniqueConstraintResolutionException";
+	}
+};
+
+//#endregion
+//#region src/relationship/RelationTableLoader.ts
+var RelationTableLoader = class {
+	constructor(adapter) {
+		this.adapter = adapter;
+	}
+	async selectRows(spec) {
+		return await this.adapter.select({
+			target: { table: spec.table },
+			where: spec.where,
+			columns: spec.columns,
+			orderBy: spec.orderBy,
+			limit: spec.limit,
+			offset: spec.offset
+		});
+	}
+	async selectRow(spec) {
+		return await this.adapter.selectOne({
+			target: { table: spec.table },
+			where: spec.where,
+			columns: spec.columns,
+			orderBy: spec.orderBy,
+			limit: spec.limit ?? 1,
+			offset: spec.offset
+		});
+	}
+	async selectColumnValues(spec) {
+		return (await this.selectRows({
+			...spec.lookup,
+			columns: [{ column: spec.column }]
+		})).map((row) => row[spec.column]);
+	}
+	async selectColumnValue(spec) {
+		return (await this.selectRow({
+			...spec.lookup,
+			columns: [{ column: spec.column }],
+			limit: 1
+		}))?.[spec.column] ?? null;
+	}
+};
+
+//#endregion
 //#region src/relationship/Relation.ts
 /**
 * Base class for all relationship types. Not meant to be used directly.
@@ -3509,6 +4088,17 @@ function inferDelegateName(modelName) {
 */
 var Relation = class {
 	constraint = null;
+	getRelationAdapter() {
+		const adapter = this.getRelatedModel().getAdapter();
+		if (!adapter) throw new UnsupportedAdapterFeatureException("Relationship resolution requires a configured adapter.", { operation: "relation.adapter" });
+		return adapter;
+	}
+	getRelatedModel() {
+		return this.related;
+	}
+	createRelationTableLoader() {
+		return new RelationTableLoader(this.getRelationAdapter());
+	}
 	/**
 	* Apply a constraint to the relationship query.
 	* 
@@ -3725,9 +4315,31 @@ var BelongsToManyRelation = class extends Relation {
 	*/
 	async getQuery() {
 		const parentValue = this.parent.getAttribute(this.parentKey);
-		const ids = (await this.related.getDelegate(this.throughDelegate).findMany({ where: { [this.foreignPivotKey]: parentValue } })).map((row) => row[this.relatedPivotKey]);
+		const ids = await this.createRelationTableLoader().selectColumnValues({
+			lookup: {
+				table: this.throughDelegate,
+				where: {
+					type: "comparison",
+					column: this.foreignPivotKey,
+					operator: "=",
+					value: parentValue
+				}
+			},
+			column: this.relatedPivotKey
+		});
 		return this.applyConstraint(this.related.query().where({ [this.relatedKey]: { in: ids } }));
 	}
+	getMetadata() {
+		return {
+			type: "belongsToMany",
+			relatedModel: this.related,
+			throughTable: this.throughDelegate,
+			foreignPivotKey: this.foreignPivotKey,
+			relatedPivotKey: this.relatedPivotKey,
+			parentKey: this.parentKey,
+			relatedKey: this.relatedKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -3794,6 +4406,14 @@ var BelongsToRelation = class extends SingleResultRelation {
 		const foreignValue = this.parent.getAttribute(this.foreignKey);
 		return this.applyConstraint(this.related.query().where({ [this.ownerKey]: foreignValue }));
 	}
+	getMetadata() {
+		return {
+			type: "belongsTo",
+			relatedModel: this.related,
+			foreignKey: this.foreignKey,
+			ownerKey: this.ownerKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -3829,6 +4449,14 @@ var HasManyRelation = class extends Relation {
 		const localValue = this.parent.getAttribute(this.localKey);
 		return this.applyConstraint(this.related.query().where({ [this.foreignKey]: localValue }));
 	}
+	getMetadata() {
+		return {
+			type: "hasMany",
+			relatedModel: this.related,
+			foreignKey: this.foreignKey,
+			localKey: this.localKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -3866,9 +4494,31 @@ var HasManyThroughRelation = class extends Relation {
 	*/
 	async getQuery() {
 		const localValue = this.parent.getAttribute(this.localKey);
-		const keys = (await this.related.getDelegate(this.throughDelegate).findMany({ where: { [this.firstKey]: localValue } })).map((row) => row[this.secondLocalKey]);
+		const keys = await this.createRelationTableLoader().selectColumnValues({
+			lookup: {
+				table: this.throughDelegate,
+				where: {
+					type: "comparison",
+					column: this.firstKey,
+					operator: "=",
+					value: localValue
+				}
+			},
+			column: this.secondLocalKey
+		});
 		return this.applyConstraint(this.related.query().where({ [this.secondKey]: { in: keys } }));
 	}
+	getMetadata() {
+		return {
+			type: "hasManyThrough",
+			relatedModel: this.related,
+			throughTable: this.throughDelegate,
+			firstKey: this.firstKey,
+			secondKey: this.secondKey,
+			localKey: this.localKey,
+			secondLocalKey: this.secondLocalKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -3902,6 +4552,14 @@ var HasOneRelation = class extends SingleResultRelation {
 		const localValue = this.parent.getAttribute(this.localKey);
 		return this.applyConstraint(this.related.query().where({ [this.foreignKey]: localValue }));
 	}
+	getMetadata() {
+		return {
+			type: "hasOne",
+			relatedModel: this.related,
+			foreignKey: this.foreignKey,
+			localKey: this.localKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -3937,9 +4595,31 @@ var HasOneThroughRelation = class extends SingleResultRelation {
 	*/
 	async getQuery() {
 		const localValue = this.parent.getAttribute(this.localKey);
-		const intermediate = await this.related.getDelegate(this.throughDelegate).findFirst({ where: { [this.firstKey]: localValue } });
-		if (!intermediate) return this.applyConstraint(this.related.query().where({ [this.secondKey]: { in: [] } }));
-		return this.applyConstraint(this.related.query().where({ [this.secondKey]: intermediate[this.secondLocalKey] }));
+		const intermediateKey = await this.createRelationTableLoader().selectColumnValue({
+			lookup: {
+				table: this.throughDelegate,
+				where: {
+					type: "comparison",
+					column: this.firstKey,
+					operator: "=",
+					value: localValue
+				}
+			},
+			column: this.secondLocalKey
+		});
+		if (intermediateKey == null) return this.applyConstraint(this.related.query().where({ [this.secondKey]: { in: [] } }));
+		return this.applyConstraint(this.related.query().where({ [this.secondKey]: intermediateKey }));
+	}
+	getMetadata() {
+		return {
+			type: "hasOneThrough",
+			relatedModel: this.related,
+			throughTable: this.throughDelegate,
+			firstKey: this.firstKey,
+			secondKey: this.secondKey,
+			localKey: this.localKey,
+			secondLocalKey: this.secondLocalKey
+		};
 	}
 	/**
 	* Fetches the related models for this relationship.
@@ -3980,6 +4660,16 @@ var MorphManyRelation = class extends Relation {
 			[`${this.morphName}Type`]: type
 		}));
 	}
+	getMetadata() {
+		return {
+			type: "morphMany",
+			relatedModel: this.related,
+			morphName: this.morphName,
+			morphIdColumn: `${this.morphName}Id`,
+			morphTypeColumn: `${this.morphName}Type`,
+			localKey: this.localKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -4017,6 +4707,16 @@ var MorphOneRelation = class extends SingleResultRelation {
 			[`${this.morphName}Type`]: type
 		}));
 	}
+	getMetadata() {
+		return {
+			type: "morphOne",
+			relatedModel: this.related,
+			morphName: this.morphName,
+			morphIdColumn: `${this.morphName}Id`,
+			morphTypeColumn: `${this.morphName}Type`,
+			localKey: this.localKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -4054,12 +4754,42 @@ var MorphToManyRelation = class extends Relation {
 	async getQuery() {
 		const parentValue = this.parent.getAttribute(this.parentKey);
 		const morphType = this.parent.constructor.name;
-		const ids = (await this.related.getDelegate(this.throughDelegate).findMany({ where: {
-			[`${this.morphName}Id`]: parentValue,
-			[`${this.morphName}Type`]: morphType
-		} })).map((row) => row[this.relatedPivotKey]);
+		const ids = await this.createRelationTableLoader().selectColumnValues({
+			lookup: {
+				table: this.throughDelegate,
+				where: {
+					type: "group",
+					operator: "and",
+					conditions: [{
+						type: "comparison",
+						column: `${this.morphName}Id`,
+						operator: "=",
+						value: parentValue
+					}, {
+						type: "comparison",
+						column: `${this.morphName}Type`,
+						operator: "=",
+						value: morphType
+					}]
+				}
+			},
+			column: this.relatedPivotKey
+		});
 		return this.applyConstraint(this.related.query().where({ [this.relatedKey]: { in: ids } }));
 	}
+	getMetadata() {
+		return {
+			type: "morphToMany",
+			relatedModel: this.related,
+			throughTable: this.throughDelegate,
+			morphName: this.morphName,
+			morphIdColumn: `${this.morphName}Id`,
+			morphTypeColumn: `${this.morphName}Type`,
+			relatedPivotKey: this.relatedPivotKey,
+			parentKey: this.parentKey,
+			relatedKey: this.relatedKey
+		};
+	}
 	/**
 	* Fetches the related models for this relationship.
 	* 
@@ -4261,7 +4991,13 @@ var Paginator = class {
 * @since 0.1.0
 */
 var QueryBuilder = class QueryBuilder {
-	args = {};
+	queryWhere;
+	legacyWhere;
+	queryRelationLoads;
+	queryOrderBy;
+	querySelect;
+	offsetValue;
+	limitValue;
 	eagerLoads = {};
 	includeTrashed = false;
 	onlyTrashedRecords = false;
@@ -4271,12 +5007,11 @@ var QueryBuilder = class QueryBuilder {
 	/**
 	* Creates a new QueryBuilder instance.
 	* 
-	* @param delegate 
 	* @param model 
 	*/
-	constructor(delegate, model) {
-		this.delegate = delegate;
+	constructor(model, adapter) {
 		this.model = model;
+		this.adapter = adapter;
 	}
 	resolvePaginationPage(page, options) {
 		if (typeof page !== "undefined") return Number.isFinite(page) ? Math.max(1, page) : 1;
@@ -4450,11 +5185,26 @@ var QueryBuilder = class QueryBuilder {
 		return this.clone().where(this.buildComparisonWhere(key, operator, value)).first();
 	}
 	addLogicalWhere(operator, where) {
-		if (!this.args.where) {
-			this.args.where = where;
+		const condition = this.tryBuildQueryCondition(where);
+		if (!this.legacyWhere && condition) {
+			if (!this.queryWhere) {
+				this.queryWhere = condition;
+				return this;
+			}
+			this.queryWhere = {
+				type: "group",
+				operator: operator === "AND" ? "and" : "or",
+				conditions: [this.queryWhere, condition]
+			};
+			return this;
+		}
+		const existingWhere = this.legacyWhere ?? this.toDelegateWhere(this.queryWhere);
+		this.queryWhere = void 0;
+		if (!existingWhere) {
+			this.legacyWhere = where;
 			return this;
 		}
-		this.args.where = { [operator]: [this.args.where, where] };
+		this.legacyWhere = { [operator]: [existingWhere, where] };
 		return this;
 	}
 	buildComparisonWhere(key, operator, value) {
@@ -4498,7 +5248,12 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	orderBy(orderBy) {
 		this.randomOrderEnabled = false;
-		this.args.orderBy = orderBy;
+		const normalized = this.normalizeQueryOrderBy(orderBy);
+		if (!normalized) throw new UnsupportedAdapterFeatureException("Order clauses must use Arkorm-normalizable column directions.", {
+			operation: "orderBy",
+			model: this.model.name
+		});
+		this.queryOrderBy = normalized;
 		return this;
 	}
 	/**
@@ -4518,7 +5273,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	reorder(column, direction = "asc") {
-		this.args.orderBy = void 0;
+		this.queryOrderBy = void 0;
 		this.randomOrderEnabled = false;
 		if (!column) return this;
 		return this.orderBy({ [column]: direction });
@@ -4548,7 +5303,13 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	include(include) {
-		this.args.include = include;
+		const normalized = this.normalizeRelationLoads(include);
+		if (normalized === null) throw new UnsupportedAdapterFeatureException("Include clauses could not be normalized into Arkorm relation load plans.", {
+			operation: "include",
+			model: this.model.name,
+			meta: { feature: "relationLoads" }
+		});
+		this.queryRelationLoads = normalized;
 		return this;
 	}
 	/**
@@ -4560,14 +5321,6 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	with(relations) {
 		const relationMap = this.normalizeWith(relations);
-		const names = Object.keys(relationMap);
-		this.args.include = {
-			...this.args.include || {},
-			...names.reduce((accumulator, name) => {
-				accumulator[name] = true;
-				return accumulator;
-			}, {})
-		};
 		Object.entries(relationMap).forEach(([name, constraint]) => {
 			this.eagerLoads[name] = constraint;
 		});
@@ -4880,7 +5633,12 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	select(select) {
-		this.args.select = select;
+		const normalized = this.normalizeQuerySelect(select);
+		if (normalized === null) throw new UnsupportedAdapterFeatureException("Select clauses must use Arkorm-normalizable column projections.", {
+			operation: "select",
+			model: this.model.name
+		});
+		this.querySelect = normalized;
 		return this;
 	}
 	/**
@@ -4891,7 +5649,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	skip(skip) {
-		this.args.skip = skip;
+		this.offsetValue = skip;
 		return this;
 	}
 	/**
@@ -4910,7 +5668,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	take(take) {
-		this.args.take = take;
+		this.limitValue = take;
 		return this;
 	}
 	/**
@@ -4941,16 +5699,13 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	async get() {
 		const relationCache = /* @__PURE__ */ new WeakMap();
-		const rows = await this.delegate.findMany(this.buildFindArgs());
+		const rows = await this.executeReadRows();
 		const normalizedRows = this.randomOrderEnabled ? this.shuffleRows(rows) : rows;
 		const models = await this.model.hydrateManyRetrieved(normalizedRows);
 		let filteredModels = models;
-		if (this.hasRelationFilters()) if (this.hasOrRelationFilters() && this.args.where) {
+		if (this.hasRelationFilters()) if (this.hasOrRelationFilters() && this.hasBaseWhereConstraints()) {
 			const baseIds = new Set(models.map((model) => this.getModelId(model)).filter((id) => id != null));
-			const allRows = await this.delegate.findMany({
-				...this.args,
-				where: this.buildSoftDeleteOnlyWhere()
-			});
+			const allRows = await this.executeReadRows(this.buildSoftDeleteOnlyWhere(), true);
 			const allModels = this.model.hydrateMany(allRows);
 			filteredModels = await this.filterModelsByRelationConstraints(allModels, relationCache, baseIds);
 		} else filteredModels = await this.filterModelsByRelationConstraints(models, relationCache);
@@ -4969,7 +5724,7 @@ var QueryBuilder = class QueryBuilder {
 	async first() {
 		if (this.hasRelationFilters() || this.hasRelationAggregates()) return (await this.get()).all()[0] ?? null;
 		if (this.randomOrderEnabled) {
-			const rows = await this.delegate.findMany(this.buildFindArgs());
+			const rows = await this.executeReadRows();
 			if (rows.length === 0) return null;
 			const row = this.shuffleRows(rows)[0];
 			if (!row) return null;
@@ -4977,7 +5732,7 @@ var QueryBuilder = class QueryBuilder {
 			await model.load(this.eagerLoads);
 			return model;
 		}
-		const row = await this.delegate.findFirst(this.buildFindArgs());
+		const row = await this.executeReadRow();
 		if (!row) return null;
 		const model = await this.model.hydrateRetrieved(row);
 		await model.load(this.eagerLoads);
@@ -4993,11 +5748,12 @@ var QueryBuilder = class QueryBuilder {
 		if (!model) throw new ModelNotFoundException(this.model.name, "Record not found.");
 		return model;
 	}
-	async find(value, key = "id") {
-		return this.where({ [key]: value }).first();
+	async find(value, key) {
+		const resolvedKey = key ?? this.model.getPrimaryKey();
+		return this.where({ [resolvedKey]: value }).first();
 	}
 	async findOr(value, keyOrCallback, maybeCallback) {
-		const key = typeof keyOrCallback === "string" ? keyOrCallback : "id";
+		const key = typeof keyOrCallback === "string" ? keyOrCallback : this.model.getPrimaryKey();
 		const callback = typeof keyOrCallback === "function" ? keyOrCallback : maybeCallback;
 		if (!callback) throw new QueryConstraintException("findOr requires a fallback callback.", {
 			operation: "findOr",
@@ -5014,7 +5770,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async value(column) {
-		const row = await this.delegate.findFirst(this.buildFindArgs());
+		const row = await this.executeReadRow();
 		if (!row) return null;
 		return row[column] ?? null;
 	}
@@ -5037,7 +5793,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async pluck(column, key) {
-		const rows = await this.delegate.findMany(this.buildFindArgs());
+		const rows = await this.executeReadRows();
 		if (!key) return new ArkormCollection(rows.map((row) => row[column]));
 		return new ArkormCollection(rows.sort((leftRow, rightRow) => String(leftRow[key]).localeCompare(String(rightRow[key]))).map((row) => row[column]));
 	}
@@ -5048,7 +5804,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	async create(data) {
-		const created = await this.delegate.create({ data });
+		const created = await this.executeInsertRow(data);
 		return this.model.hydrate(created);
 	}
 	/**
@@ -5070,14 +5826,11 @@ var QueryBuilder = class QueryBuilder {
 	async insert(values) {
 		const payloads = this.normalizeInsertPayloads(values);
 		if (payloads.length === 0) return true;
-		const delegate = this.delegate;
-		if (typeof delegate.createMany === "function") {
-			await delegate.createMany({ data: payloads });
+		if (payloads.length === 1) {
+			await this.executeInsertRow(payloads[0]);
 			return true;
 		}
-		await Promise.all(payloads.map(async (payload) => {
-			await this.delegate.create({ data: payload });
-		}));
+		await this.executeInsertManyRows(payloads);
 		return true;
 	}
 	/**
@@ -5089,22 +5842,7 @@ var QueryBuilder = class QueryBuilder {
 	async insertOrIgnore(values) {
 		const payloads = this.normalizeInsertPayloads(values);
 		if (payloads.length === 0) return 0;
-		const delegate = this.delegate;
-		if (typeof delegate.createMany === "function") {
-			const result = await delegate.createMany({
-				data: payloads,
-				skipDuplicates: true
-			});
-			return this.resolveAffectedCount(result, payloads.length);
-		}
-		let inserted = 0;
-		for (const payload of payloads) try {
-			await this.delegate.create({ data: payload });
-			inserted += 1;
-		} catch {
-			continue;
-		}
-		return inserted;
+		return await this.executeInsertManyRows(payloads, true);
 	}
 	/**
 	* Insert a record and return its primary key value.
@@ -5114,8 +5852,8 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async insertGetId(values, sequence) {
-		const created = await this.delegate.create({ data: values });
-		const key = sequence ?? "id";
+		const created = await this.executeInsertRow(values);
+		const key = sequence ?? this.model.getPrimaryKey();
 		if (!(key in created)) throw new UniqueConstraintResolutionException(`Inserted record does not contain key [${key}].`, {
 			operation: "insertGetId",
 			model: this.model.name,
@@ -5162,10 +5900,7 @@ var QueryBuilder = class QueryBuilder {
 			model: this.model.name
 		});
 		const uniqueWhere = await this.resolveUniqueWhere(where);
-		const updated = await this.delegate.update({
-			where: uniqueWhere,
-			data
-		});
+		const updated = await this.executeUpdateRow(uniqueWhere, data);
 		return this.model.hydrate(updated);
 	}
 	/**
@@ -5180,16 +5915,7 @@ var QueryBuilder = class QueryBuilder {
 			operation: "updateFrom",
 			model: this.model.name
 		});
-		const delegate = this.delegate;
-		if (typeof delegate.updateMany === "function") {
-			const result = await delegate.updateMany({
-				where,
-				data
-			});
-			return this.resolveAffectedCount(result, 0);
-		}
-		await this.update(data);
-		return 1;
+		return await this.executeUpdateManyRows(where, data);
 	}
 	/**
 	* Insert a record when no match exists, otherwise update the matching record.
@@ -5199,13 +5925,13 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async updateOrInsert(attributes, values = {}) {
-		const exists = await this.delegate.findFirst({ where: attributes }) != null;
+		const exists = await this.clone().where(attributes).first() != null;
 		const resolvedValues = typeof values === "function" ? await values(exists) : values;
 		if (!exists) {
-			await this.delegate.create({ data: {
+			await this.executeInsertRow({
 				...attributes,
 				...resolvedValues
-			} });
+			});
 			return true;
 		}
 		return await this.clone().where(attributes).update(resolvedValues) != null;
@@ -5249,9 +5975,53 @@ var QueryBuilder = class QueryBuilder {
 			model: this.model.name
 		});
 		const uniqueWhere = await this.resolveUniqueWhere(where);
-		const deleted = await this.delegate.delete({ where: uniqueWhere });
+		const deleted = await this.executeDeleteRow(uniqueWhere);
 		return this.model.hydrate(deleted);
 	}
+	tryBuildInsertSpec(values) {
+		return {
+			target: this.buildQueryTarget(),
+			values
+		};
+	}
+	tryBuildInsertManySpec(values) {
+		return {
+			target: this.buildQueryTarget(),
+			values
+		};
+	}
+	tryBuildInsertOrIgnoreManySpec(values) {
+		return {
+			...this.tryBuildInsertManySpec(values),
+			ignoreDuplicates: true
+		};
+	}
+	tryBuildUpdateSpec(where, values) {
+		const condition = this.tryBuildQueryCondition(where);
+		if (!condition) return null;
+		return {
+			target: this.buildQueryTarget(),
+			where: condition,
+			values
+		};
+	}
+	tryBuildUpdateManySpec(where, values) {
+		const condition = this.tryBuildQueryCondition(where);
+		if (condition === null) return null;
+		return {
+			target: this.buildQueryTarget(),
+			where: condition,
+			values
+		};
+	}
+	tryBuildDeleteSpec(where) {
+		const condition = this.tryBuildQueryCondition(where);
+		if (!condition) return null;
+		return {
+			target: this.buildQueryTarget(),
+			where: condition
+		};
+	}
 	/**
 	* Counts the number of records matching the current query constraints.
 	* 
@@ -5259,7 +6029,7 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	async count() {
 		if (this.hasRelationFilters()) return (await this.get()).all().length;
-		return this.delegate.count({ where: this.buildWhere() });
+		return this.executeReadCount();
 	}
 	/**
 	* Determines if any records exist for the current query constraints.
@@ -5268,7 +6038,7 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	async exists() {
 		if (this.hasRelationFilters()) return await this.count() > 0;
-		return await this.delegate.findFirst(this.buildFindArgs()) != null;
+		return await this.executeReadExists();
 	}
 	/**
 	* Determines if no records exist for the current query constraints.
@@ -5345,7 +6115,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async min(column) {
-		const rows = await this.delegate.findMany(this.buildFindArgs());
+		const rows = await this.executeReadRows();
 		if (rows.length === 0) return null;
 		const values = rows.map((row) => row[column]).filter((value) => value != null);
 		if (values.length === 0) return null;
@@ -5358,7 +6128,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async max(column) {
-		const rows = await this.delegate.findMany(this.buildFindArgs());
+		const rows = await this.executeReadRows();
 		if (rows.length === 0) return null;
 		const values = rows.map((row) => row[column]).filter((value) => value != null);
 		if (values.length === 0) return null;
@@ -5371,7 +6141,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async sum(column) {
-		return (await this.delegate.findMany(this.buildFindArgs())).reduce((total, row) => {
+		return (await this.executeReadRows()).reduce((total, row) => {
 			const value = row[column];
 			const numeric = typeof value === "number" ? value : Number(value);
 			return Number.isFinite(numeric) ? total + numeric : total;
@@ -5384,7 +6154,7 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	async avg(column) {
-		const values = (await this.delegate.findMany(this.buildFindArgs())).map((row) => {
+		const values = (await this.executeReadRows()).map((row) => {
 			const value = row[column];
 			return typeof value === "number" ? value : Number(value);
 		}).filter((value) => Number.isFinite(value));
@@ -5399,13 +6169,16 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	whereRaw(sql, bindings = []) {
-		const delegate = this.delegate;
-		if (typeof delegate.applyRawWhere !== "function") throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
+		if (!this.adapter?.capabilities?.rawWhere) throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
 			operation: "whereRaw",
 			model: this.model.name,
 			meta: { feature: "rawWhere" }
 		});
-		this.args.where = delegate.applyRawWhere(this.buildWhere(), sql, bindings);
+		this.appendQueryCondition("AND", {
+			type: "raw",
+			sql,
+			bindings
+		});
 		return this;
 	}
 	/**
@@ -5416,14 +6189,17 @@ var QueryBuilder = class QueryBuilder {
 	* @returns
 	*/
 	orWhereRaw(sql, bindings = []) {
-		const delegate = this.delegate;
-		if (typeof delegate.applyRawWhere !== "function") throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
+		if (!this.adapter?.capabilities?.rawWhere) throw new UnsupportedAdapterFeatureException("Raw where clauses are not supported by the current adapter.", {
 			operation: "orWhereRaw",
 			model: this.model.name,
 			meta: { feature: "rawWhere" }
 		});
-		const rawWhere = delegate.applyRawWhere(void 0, sql, bindings);
-		return this.orWhere(rawWhere);
+		this.appendQueryCondition("OR", {
+			type: "raw",
+			sql,
+			bindings
+		});
+		return this;
 	}
 	/**
 	* Paginates the query results and returns a LengthAwarePaginator instance 
@@ -5474,13 +6250,14 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	clone() {
-		const builder = new QueryBuilder(this.delegate, this.model);
-		builder.args.where = this.args.where;
-		builder.args.include = this.args.include;
-		builder.args.orderBy = this.args.orderBy;
-		builder.args.select = this.args.select;
-		builder.args.skip = this.args.skip;
-		builder.args.take = this.args.take;
+		const builder = new QueryBuilder(this.model, this.adapter);
+		builder.queryWhere = this.queryWhere;
+		builder.legacyWhere = this.legacyWhere;
+		builder.queryRelationLoads = this.queryRelationLoads ? this.cloneRelationLoads(this.queryRelationLoads) : void 0;
+		builder.queryOrderBy = this.queryOrderBy ? [...this.queryOrderBy] : void 0;
+		builder.querySelect = this.querySelect ? [...this.querySelect] : void 0;
+		builder.offsetValue = this.offsetValue;
+		builder.limitValue = this.limitValue;
 		builder.includeTrashed = this.includeTrashed;
 		builder.onlyTrashedRecords = this.onlyTrashedRecords;
 		builder.randomOrderEnabled = this.randomOrderEnabled;
@@ -5509,6 +6286,424 @@ var QueryBuilder = class QueryBuilder {
 		}, {});
 		return relations;
 	}
+	buildQueryTarget() {
+		const metadata = this.model.getModelMetadata();
+		return {
+			model: this.model,
+			modelName: this.model.name,
+			table: metadata.table,
+			primaryKey: metadata.primaryKey,
+			columns: metadata.columns,
+			softDelete: metadata.softDelete
+		};
+	}
+	hasBaseWhereConstraints() {
+		return this.queryWhere != null || this.legacyWhere != null;
+	}
+	normalizeQuerySelect(select) {
+		if (Array.isArray(select) || typeof select !== "object" || !select) return null;
+		const entries = Object.entries(select);
+		if (entries.some(([, value]) => value !== true && value !== false && value !== void 0)) return null;
+		const columns = entries.filter(([, value]) => value === true).map(([column]) => ({ column }));
+		return columns.length > 0 ? columns : [];
+	}
+	normalizeQueryOrderBy(orderBy) {
+		return (Array.isArray(orderBy) ? orderBy : [orderBy]).reduce((accumulator, clause) => {
+			if (!accumulator) return null;
+			if (!clause || typeof clause !== "object" || Array.isArray(clause)) return null;
+			const entries = Object.entries(clause);
+			for (const [column, direction] of entries) {
+				if (direction !== "asc" && direction !== "desc") return null;
+				accumulator.push({
+					column,
+					direction
+				});
+			}
+			return accumulator;
+		}, []);
+	}
+	cloneRelationLoads(plans) {
+		return plans.map((plan) => {
+			return {
+				relation: plan.relation,
+				constraint: plan.constraint,
+				orderBy: plan.orderBy ? [...plan.orderBy] : void 0,
+				limit: plan.limit,
+				offset: plan.offset,
+				columns: plan.columns ? [...plan.columns] : void 0,
+				relationLoads: plan.relationLoads ? this.cloneRelationLoads(plan.relationLoads) : void 0
+			};
+		});
+	}
+	normalizeRelationLoadSelect(select) {
+		if (Array.isArray(select) || typeof select !== "object" || !select) return null;
+		const entries = Object.entries(select);
+		if (entries.some(([, value]) => value !== true && value !== false && value !== void 0)) return null;
+		return entries.filter(([, value]) => value === true).map(([column]) => ({ column }));
+	}
+	normalizeRelationLoadOrderBy(orderBy) {
+		const clauses = Array.isArray(orderBy) ? orderBy : [orderBy];
+		const normalized = [];
+		for (const clause of clauses) {
+			if (!clause || typeof clause !== "object" || Array.isArray(clause)) return null;
+			for (const [column, direction] of Object.entries(clause)) {
+				if (direction !== "asc" && direction !== "desc") return null;
+				normalized.push({
+					column,
+					direction
+				});
+			}
+		}
+		return normalized;
+	}
+	normalizeRelationLoads(include) {
+		if (Array.isArray(include) || typeof include !== "object" || !include) return null;
+		const plans = [];
+		for (const [relation, value] of Object.entries(include)) {
+			if (value === false || value === void 0) continue;
+			if (value === true) {
+				plans.push({ relation });
+				continue;
+			}
+			if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+			const options = value;
+			const constraint = options.where === void 0 ? void 0 : this.tryBuildQueryCondition(options.where);
+			const orderBy = options.orderBy === void 0 ? void 0 : this.normalizeRelationLoadOrderBy(options.orderBy);
+			const columns = options.select === void 0 ? void 0 : this.normalizeRelationLoadSelect(options.select);
+			const relationLoads = options.include === void 0 ? void 0 : this.normalizeRelationLoads(options.include);
+			if (constraint === null || orderBy === null || columns === null || relationLoads === null) return null;
+			if (options.skip !== void 0 && typeof options.skip !== "number" || options.take !== void 0 && typeof options.take !== "number") return null;
+			plans.push({
+				relation,
+				constraint,
+				orderBy,
+				limit: options.take,
+				offset: options.skip,
+				columns,
+				relationLoads
+			});
+		}
+		return plans;
+	}
+	appendQueryCondition(operator, condition) {
+		if (!this.queryWhere) {
+			this.queryWhere = condition;
+			return;
+		}
+		this.queryWhere = {
+			type: "group",
+			operator: operator === "AND" ? "and" : "or",
+			conditions: [this.queryWhere, condition]
+		};
+	}
+	toDelegateWhere(condition) {
+		if (!condition) return void 0;
+		if (condition.type === "comparison") {
+			if (condition.operator === "is-null") return { [condition.column]: null };
+			if (condition.operator === "is-not-null") return { [condition.column]: { not: null } };
+			if (condition.operator === "=") return { [condition.column]: condition.value };
+			if (condition.operator === "!=") return { [condition.column]: { not: condition.value } };
+			if (condition.operator === ">") return { [condition.column]: { gt: condition.value } };
+			if (condition.operator === ">=") return { [condition.column]: { gte: condition.value } };
+			if (condition.operator === "<") return { [condition.column]: { lt: condition.value } };
+			if (condition.operator === "<=") return { [condition.column]: { lte: condition.value } };
+			if (condition.operator === "in") return { [condition.column]: { in: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+			if (condition.operator === "not-in") return { [condition.column]: { notIn: Array.isArray(condition.value) ? condition.value : [condition.value] } };
+			if (condition.operator === "contains") return { [condition.column]: { contains: condition.value } };
+			if (condition.operator === "starts-with") return { [condition.column]: { startsWith: condition.value } };
+			return { [condition.column]: { endsWith: condition.value } };
+		}
+		if (condition.type === "group") {
+			const conditions = condition.conditions.map((entry) => this.toDelegateWhere(entry)).filter((entry) => Boolean(entry));
+			if (conditions.length === 0) return void 0;
+			return { [condition.operator === "and" ? "AND" : "OR"]: conditions };
+		}
+		if (condition.type === "not") {
+			const nested = this.toDelegateWhere(condition.condition);
+			if (!nested) return void 0;
+			return { NOT: nested };
+		}
+	}
+	buildSoftDeleteQueryCondition() {
+		const softDeleteConfig = this.model.getSoftDeleteConfig();
+		if (!softDeleteConfig.enabled || this.includeTrashed) return void 0;
+		return {
+			type: "comparison",
+			column: softDeleteConfig.column,
+			operator: this.onlyTrashedRecords ? "is-not-null" : "is-null"
+		};
+	}
+	buildQueryWhereCondition(softDeleteOnly = false) {
+		if (this.legacyWhere) {
+			const fallbackWhere = softDeleteOnly ? this.buildSoftDeleteOnlyWhere() : this.buildWhere();
+			return this.tryBuildQueryCondition(fallbackWhere);
+		}
+		const softDeleteCondition = this.buildSoftDeleteQueryCondition();
+		if (softDeleteOnly) return softDeleteCondition;
+		if (!this.queryWhere) return softDeleteCondition;
+		if (!softDeleteCondition) return this.queryWhere;
+		return {
+			type: "group",
+			operator: "and",
+			conditions: [this.queryWhere, softDeleteCondition]
+		};
+	}
+	tryBuildQuerySelectColumns() {
+		return this.querySelect;
+	}
+	tryBuildQueryOrderBy() {
+		return this.queryOrderBy;
+	}
+	tryBuildFieldCondition(column, value) {
+		if (value === null) return {
+			type: "comparison",
+			column,
+			operator: "is-null"
+		};
+		if (value instanceof Date || typeof value !== "object") return {
+			type: "comparison",
+			column,
+			operator: "=",
+			value
+		};
+		if (Array.isArray(value)) return null;
+		const clause = value;
+		const conditions = [];
+		for (const [operator, operand] of Object.entries(clause)) {
+			if (operator === "equals") {
+				conditions.push({
+					type: "comparison",
+					column,
+					operator: operand === null ? "is-null" : "=",
+					value: operand
+				});
+				continue;
+			}
+			if (operator === "not") {
+				if (operand && typeof operand === "object" && !Array.isArray(operand)) return null;
+				conditions.push({
+					type: "comparison",
+					column,
+					operator: operand === null ? "is-not-null" : "!=",
+					value: operand
+				});
+				continue;
+			}
+			if (operator === "in" || operator === "notIn") {
+				if (!Array.isArray(operand)) return null;
+				conditions.push({
+					type: "comparison",
+					column,
+					operator: operator === "in" ? "in" : "not-in",
+					value: operand
+				});
+				continue;
+			}
+			if (operator === "gt" || operator === "gte" || operator === "lt" || operator === "lte") {
+				const comparison = {
+					type: "comparison",
+					column,
+					operator: operator === "gt" ? ">" : operator === "gte" ? ">=" : operator === "lt" ? "<" : "<=",
+					value: operand
+				};
+				conditions.push(comparison);
+				continue;
+			}
+			if (operator === "contains" || operator === "startsWith" || operator === "endsWith") {
+				conditions.push({
+					type: "comparison",
+					column,
+					operator: operator === "startsWith" ? "starts-with" : operator === "endsWith" ? "ends-with" : "contains",
+					value: operand
+				});
+				continue;
+			}
+			return null;
+		}
+		if (conditions.length === 0) return null;
+		return conditions.length === 1 ? conditions[0] ?? null : {
+			type: "group",
+			operator: "and",
+			conditions
+		};
+	}
+	tryBuildQueryCondition(where) {
+		if (!where) return void 0;
+		if (Array.isArray(where) || typeof where !== "object") return null;
+		const conditions = [];
+		for (const [key, value] of Object.entries(where)) {
+			if (key === "AND" || key === "OR") {
+				if (!Array.isArray(value)) return null;
+				const nested = value.map((entry) => this.tryBuildQueryCondition(entry)).filter((entry) => entry !== void 0);
+				if (nested.some((entry) => entry == null)) return null;
+				if (nested.length > 0) conditions.push({
+					type: "group",
+					operator: key === "AND" ? "and" : "or",
+					conditions: nested
+				});
+				continue;
+			}
+			if (key === "NOT") {
+				const nested = Array.isArray(value) ? value.map((entry) => this.tryBuildQueryCondition(entry)).filter((entry) => entry !== void 0) : [this.tryBuildQueryCondition(value)].filter((entry) => entry !== void 0);
+				if (nested.some((entry) => entry == null)) return null;
+				if (nested.length === 0) continue;
+				conditions.push({
+					type: "not",
+					condition: nested.length === 1 ? nested[0] : {
+						type: "group",
+						operator: "and",
+						conditions: nested
+					}
+				});
+				continue;
+			}
+			const condition = this.tryBuildFieldCondition(key, value);
+			if (!condition) return null;
+			conditions.push(condition);
+		}
+		if (conditions.length === 0) return void 0;
+		return conditions.length === 1 ? conditions[0] ?? void 0 : {
+			type: "group",
+			operator: "and",
+			conditions
+		};
+	}
+	tryBuildSelectSpec(where, softDeleteOnly = false) {
+		const columns = this.tryBuildQuerySelectColumns();
+		const orderBy = this.tryBuildQueryOrderBy();
+		const condition = this.buildQueryWhereCondition(softDeleteOnly);
+		if (columns === null || orderBy === null || condition === null) return null;
+		return {
+			target: this.buildQueryTarget(),
+			columns,
+			where: condition,
+			orderBy,
+			limit: this.limitValue,
+			offset: this.offsetValue,
+			relationLoads: this.queryRelationLoads
+		};
+	}
+	tryBuildAggregateSpec() {
+		const condition = this.buildQueryWhereCondition(false);
+		if (condition === null) return null;
+		return {
+			target: this.buildQueryTarget(),
+			where: condition,
+			aggregate: { type: "count" }
+		};
+	}
+	requireAdapter() {
+		if (!this.adapter) throw new UnsupportedAdapterFeatureException("Query execution requires a configured database adapter.", {
+			operation: "query.execute",
+			model: this.model.name,
+			meta: { feature: "adapter" }
+		});
+		return this.adapter;
+	}
+	async executeReadRows(whereOverride, useWhereOverride = false) {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildSelectSpec(useWhereOverride ? whereOverride : this.buildWhere(), useWhereOverride);
+		if (!spec) throw new UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+			operation: "query.select",
+			model: this.model.name
+		});
+		return await adapter.select(spec);
+	}
+	async executeReadRow() {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildSelectSpec(this.buildWhere());
+		if (!spec) throw new UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+			operation: "query.selectOne",
+			model: this.model.name
+		});
+		return await adapter.selectOne(spec);
+	}
+	async executeReadCount() {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildAggregateSpec();
+		if (!spec) throw new UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm aggregate specification.", {
+			operation: "query.count",
+			model: this.model.name
+		});
+		return await adapter.count(spec);
+	}
+	async executeReadExists() {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildSelectSpec(this.buildWhere());
+		if (!spec) throw new UnsupportedAdapterFeatureException("Query shape could not be compiled into an Arkorm select specification.", {
+			operation: "query.exists",
+			model: this.model.name
+		});
+		if (typeof adapter.exists === "function") return await adapter.exists({
+			...spec,
+			limit: 1
+		});
+		return await adapter.selectOne({
+			...spec,
+			limit: 1
+		}) != null;
+	}
+	async executeInsertRow(values) {
+		return await this.requireAdapter().insert(this.tryBuildInsertSpec(values));
+	}
+	async executeInsertManyRows(values, ignoreDuplicates = false) {
+		const adapter = this.requireAdapter();
+		if (typeof adapter.insertMany === "function") return await adapter.insertMany(ignoreDuplicates ? this.tryBuildInsertOrIgnoreManySpec(values) : this.tryBuildInsertManySpec(values));
+		let inserted = 0;
+		for (const value of values) try {
+			await adapter.insert(this.tryBuildInsertSpec(value));
+			inserted += 1;
+		} catch (error) {
+			if (!ignoreDuplicates) throw error;
+		}
+		return inserted;
+	}
+	async executeUpdateRow(where, values) {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildUpdateSpec(where, values);
+		if (!spec) throw new UnsupportedAdapterFeatureException("Update could not be compiled into an Arkorm update specification.", {
+			operation: "query.update",
+			model: this.model.name
+		});
+		const updated = await adapter.update(spec);
+		if (!updated) throw new ModelNotFoundException(this.model.name, "Record not found for update operation.", { operation: "update" });
+		return updated;
+	}
+	async executeUpdateManyRows(where, values) {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildUpdateManySpec(where, values);
+		if (!spec) throw new UnsupportedAdapterFeatureException("Update-many could not be compiled into an Arkorm update specification.", {
+			operation: "query.updateMany",
+			model: this.model.name
+		});
+		if (typeof adapter.updateMany === "function") return await adapter.updateMany(spec);
+		const rows = await adapter.select({
+			target: spec.target,
+			where: spec.where
+		});
+		let updated = 0;
+		for (const row of rows) {
+			const rowWhere = this.tryBuildQueryCondition(row);
+			if (!rowWhere) continue;
+			if (await adapter.update({
+				target: spec.target,
+				where: rowWhere,
+				values: spec.values
+			})) updated += 1;
+		}
+		return updated;
+	}
+	async executeDeleteRow(where) {
+		const adapter = this.requireAdapter();
+		const spec = this.tryBuildDeleteSpec(where);
+		if (!spec) throw new UnsupportedAdapterFeatureException("Delete could not be compiled into an Arkorm delete specification.", {
+			operation: "query.delete",
+			model: this.model.name
+		});
+		const deleted = await adapter.delete(spec);
+		if (!deleted) throw new ModelNotFoundException(this.model.name, "Record not found for delete operation.", { operation: "delete" });
+		return deleted;
+	}
 	/**
 	* Builds the where clause for the query, taking into account soft delete 
 	* settings if applicable.
@@ -5516,24 +6711,19 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	buildWhere() {
+		const baseWhere = this.legacyWhere ?? this.toDelegateWhere(this.queryWhere);
 		const softDeleteConfig = this.model.getSoftDeleteConfig();
-		if (!softDeleteConfig.enabled) return this.args.where;
-		if (this.includeTrashed) return this.args.where;
+		if (!softDeleteConfig.enabled) return baseWhere;
+		if (this.includeTrashed) return baseWhere;
 		const softDeleteClause = this.onlyTrashedRecords ? { [softDeleteConfig.column]: { not: null } } : { [softDeleteConfig.column]: null };
-		if (!this.args.where) return softDeleteClause;
-		return { AND: [this.args.where, softDeleteClause] };
+		if (!baseWhere) return softDeleteClause;
+		return { AND: [baseWhere, softDeleteClause] };
 	}
 	/**
 	* Builds the arguments for the findMany delegate method, including the where clause.
 	* 
 	* @returns 
 	*/
-	buildFindArgs() {
-		return {
-			...this.args,
-			where: this.buildWhere()
-		};
-	}
 	/**
 	* Resolves a unique where clause for update and delete operations. 
 	* 
@@ -5542,18 +6732,29 @@ var QueryBuilder = class QueryBuilder {
 	*/
 	async resolveUniqueWhere(where) {
 		if (this.isUniqueWhere(where)) return where;
-		const row = await this.delegate.findFirst({ where });
+		const condition = this.tryBuildQueryCondition(where);
+		if (!condition) throw new UniqueConstraintResolutionException("Unable to resolve a unique identifier for update/delete operation from the current query shape.", {
+			operation: "resolveUniqueWhere",
+			model: this.model.name,
+			meta: { where }
+		});
+		const row = await this.requireAdapter().selectOne({
+			target: this.buildQueryTarget(),
+			columns: [{ column: this.model.getPrimaryKey() }],
+			where: condition,
+			limit: 1
+		});
 		if (!row) throw new ModelNotFoundException(this.model.name, "Record not found for update/delete operation.", {
 			operation: "resolveUniqueWhere",
 			meta: { where }
 		});
-		const record = row;
-		if (!Object.prototype.hasOwnProperty.call(record, "id")) throw new UniqueConstraintResolutionException("Unable to resolve a unique identifier for update/delete operation. Include an id in the query constraints.", {
+		const primaryKey = this.model.getPrimaryKey();
+		if (!Object.prototype.hasOwnProperty.call(row, primaryKey)) throw new UniqueConstraintResolutionException(`Unable to resolve a unique identifier for update/delete operation. Include [${primaryKey}] in the query constraints.`, {
 			operation: "resolveUniqueWhere",
 			model: this.model.name,
 			meta: { where }
 		});
-		return { id: record.id };
+		return { [primaryKey]: row[primaryKey] };
 	}
 	/**
 	* Checks if the provided where clause is already a unique 
@@ -5563,7 +6764,8 @@ var QueryBuilder = class QueryBuilder {
 	* @returns 
 	*/
 	isUniqueWhere(where) {
-		return Object.keys(where).length === 1 && Object.prototype.hasOwnProperty.call(where, "id");
+		const primaryKey = this.model.getPrimaryKey();
+		return Object.keys(where).length === 1 && Object.prototype.hasOwnProperty.call(where, primaryKey);
 	}
 	shuffleRows(rows) {
 		const shuffled = [...rows];
@@ -5603,7 +6805,7 @@ var QueryBuilder = class QueryBuilder {
 	getModelId(model) {
 		const readable = model;
 		if (typeof readable.getAttribute !== "function") return null;
-		const id = readable.getAttribute("id");
+		const id = readable.getAttribute(this.model.getPrimaryKey());
 		if (typeof id === "number" || typeof id === "string") return id;
 		return null;
 	}
@@ -5742,8 +6944,12 @@ var Model = class Model {
 	static lifecycleStates = /* @__PURE__ */ new WeakMap();
 	static eventsSuppressed = 0;
 	static factoryClass;
+	static adapter;
 	static client;
 	static delegate;
+	static table;
+	static primaryKey = "id";
+	static columns = {};
 	static softDeletes = false;
 	static deletedAtColumn = "deletedAt";
 	static globalScopes = {};
@@ -5787,6 +6993,37 @@ var Model = class Model {
 	static setClient(client) {
 		this.client = client;
 	}
+	static setAdapter(adapter) {
+		this.adapter = adapter;
+	}
+	static getTable() {
+		return this.table || this.delegate || `${str(this.name).camel().plural()}`;
+	}
+	static getPrimaryKey() {
+		return this.primaryKey || "id";
+	}
+	static getColumnMap() {
+		return { ...this.columns };
+	}
+	static getColumnName(attribute) {
+		return this.getColumnMap()[attribute] ?? attribute;
+	}
+	static getModelMetadata() {
+		return {
+			table: this.getTable(),
+			primaryKey: this.getPrimaryKey(),
+			columns: this.getColumnMap(),
+			softDelete: this.getSoftDeleteConfig()
+		};
+	}
+	static getRelationMetadata(name) {
+		const resolver = this.prototype[name];
+		if (typeof resolver !== "function") return null;
+		const instance = new this({});
+		const relation = resolver.call(instance);
+		if (!(relation instanceof Relation)) return null;
+		return relation.getMetadata();
+	}
 	static setFactory(factoryClass) {
 		this.factoryClass = factoryClass;
 	}
@@ -5960,7 +7197,7 @@ var Model = class Model {
 	*/
 	static getDelegate(delegate) {
 		ensureArkormConfigLoading();
-		const key = delegate || this.delegate || `${str(this.name).camel().plural()}`;
+		const key = delegate || this.delegate || this.getTable();
 		const candidates = [
 			key,
 			`${str(key).camel()}`,
@@ -5983,6 +7220,13 @@ var Model = class Model {
 		});
 		return resolved;
 	}
+	static getAdapter() {
+		ensureArkormConfigLoading();
+		if (this.adapter) return this.adapter;
+		const client = getActiveTransactionClient() ?? this.client ?? getRuntimePrismaClient();
+		if (!client || typeof client !== "object") return void 0;
+		return createPrismaCompatibilityAdapter(client);
+	}
 	/**
 	* Get a new query builder instance for the model.
 	* 
@@ -5991,7 +7235,8 @@ var Model = class Model {
 	*/
 	static query() {
 		Model.ensureModelBooted(this);
-		let builder = new QueryBuilder(this.getDelegate(), this);
+		const modelStatic = this;
+		let builder = new QueryBuilder(modelStatic, modelStatic.getAdapter());
 		const modelClass = this;
 		if (!Model.areGlobalScopesSuppressed(modelClass)) {
 			modelClass.ensureOwnGlobalScopes();
@@ -6142,10 +7387,11 @@ var Model = class Model {
 	* @returns 
 	*/
 	async save() {
-		const identifier = this.getAttribute("id");
+		const constructor = this.constructor;
+		const primaryKey = constructor.getPrimaryKey();
+		const identifier = this.getAttribute(primaryKey);
 		const payload = this.getRawAttributes();
 		const previousOriginal = this.getOriginal();
-		const constructor = this.constructor;
 		if (identifier == null) {
 			await Model.dispatchEvent(constructor, "saving", this);
 			await Model.dispatchEvent(constructor, "creating", this);
@@ -6159,7 +7405,7 @@ var Model = class Model {
 		}
 		await Model.dispatchEvent(constructor, "saving", this);
 		await Model.dispatchEvent(constructor, "updating", this);
-		const model = await constructor.query().where({ id: identifier }).update(payload);
+		const model = await constructor.query().where({ [primaryKey]: identifier }).update(payload);
 		this.fill(model.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncOriginal();
@@ -6184,21 +7430,22 @@ var Model = class Model {
 	* @returns 
 	*/
 	async delete() {
-		const identifier = this.getAttribute("id");
-		if (identifier == null) throw new ArkormException("Cannot delete a model without an id.");
-		const previousOriginal = this.getOriginal();
 		const constructor = this.constructor;
+		const primaryKey = constructor.getPrimaryKey();
+		const identifier = this.getAttribute(primaryKey);
+		if (identifier == null) throw new ArkormException(primaryKey === "id" ? "Cannot delete a model without an id." : `Cannot delete a model without a [${primaryKey}] value.`);
+		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "deleting", this);
 		const softDeleteConfig = constructor.getSoftDeleteConfig();
 		if (softDeleteConfig.enabled) {
-			const model = await constructor.query().where({ id: identifier }).update({ [softDeleteConfig.column]: /* @__PURE__ */ new Date() });
+			const model = await constructor.query().where({ [primaryKey]: identifier }).update({ [softDeleteConfig.column]: /* @__PURE__ */ new Date() });
 			this.fill(model.getRawAttributes());
 			this.syncChanges(previousOriginal);
 			this.syncOriginal();
 			await Model.dispatchEvent(constructor, "deleted", this);
 			return this;
 		}
-		const deleted = await constructor.query().where({ id: identifier }).delete();
+		const deleted = await constructor.query().where({ [primaryKey]: identifier }).delete();
 		this.fill(deleted.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncOriginal();
@@ -6220,13 +7467,14 @@ var Model = class Model {
 	* @returns 
 	*/
 	async forceDelete() {
-		const identifier = this.getAttribute("id");
-		if (identifier == null) throw new ArkormException("Cannot force delete a model without an id.");
-		const previousOriginal = this.getOriginal();
 		const constructor = this.constructor;
+		const primaryKey = constructor.getPrimaryKey();
+		const identifier = this.getAttribute(primaryKey);
+		if (identifier == null) throw new ArkormException(primaryKey === "id" ? "Cannot force delete a model without an id." : `Cannot force delete a model without a [${primaryKey}] value.`);
+		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "forceDeleting", this);
 		await Model.dispatchEvent(constructor, "deleting", this);
-		const deleted = await constructor.query().withTrashed().where({ id: identifier }).delete();
+		const deleted = await constructor.query().withTrashed().where({ [primaryKey]: identifier }).delete();
 		this.fill(deleted.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncOriginal();
@@ -6248,14 +7496,15 @@ var Model = class Model {
 	* @returns 
 	*/
 	async restore() {
-		const identifier = this.getAttribute("id");
-		if (identifier == null) throw new ArkormException("Cannot restore a model without an id.");
 		const constructor = this.constructor;
+		const primaryKey = constructor.getPrimaryKey();
+		const identifier = this.getAttribute(primaryKey);
+		if (identifier == null) throw new ArkormException(primaryKey === "id" ? "Cannot restore a model without an id." : `Cannot restore a model without a [${primaryKey}] value.`);
 		const softDeleteConfig = constructor.getSoftDeleteConfig();
 		if (!softDeleteConfig.enabled) return this;
 		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "restoring", this);
-		const model = await constructor.query().withTrashed().where({ id: identifier }).update({ [softDeleteConfig.column]: null });
+		const model = await constructor.query().withTrashed().where({ [primaryKey]: identifier }).update({ [softDeleteConfig.column]: null });
 		this.fill(model.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncOriginal();
@@ -6367,8 +7616,9 @@ var Model = class Model {
 	is(model) {
 		if (!(model instanceof Model)) return false;
 		if (this.constructor !== model.constructor) return false;
-		const identifier = this.getAttribute("id");
-		const otherIdentifier = model.getAttribute("id");
+		const primaryKey = this.constructor.getPrimaryKey();
+		const identifier = this.getAttribute(primaryKey);
+		const otherIdentifier = model.getAttribute(primaryKey);
 		if (identifier == null || otherIdentifier == null) return false;
 		return identifier === otherIdentifier;
 	}
@@ -6407,8 +7657,9 @@ var Model = class Model {
 	* @param localKey 
 	* @returns 
 	*/
-	hasOne(related, foreignKey, localKey = "id") {
-		return new HasOneRelation(this, related, foreignKey, localKey);
+	hasOne(related, foreignKey, localKey) {
+		const constructor = this.constructor;
+		return new HasOneRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a has many relationship.
@@ -6418,8 +7669,9 @@ var Model = class Model {
 	* @param localKey 
 	* @returns 
 	*/
-	hasMany(related, foreignKey, localKey = "id") {
-		return new HasManyRelation(this, related, foreignKey, localKey);
+	hasMany(related, foreignKey, localKey) {
+		const constructor = this.constructor;
+		return new HasManyRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a belongs to relationship.
@@ -6429,8 +7681,8 @@ var Model = class Model {
 	* @param ownerKey 
 	* @returns 
 	*/
-	belongsTo(related, foreignKey, ownerKey = "id") {
-		return new BelongsToRelation(this, related, foreignKey, ownerKey);
+	belongsTo(related, foreignKey, ownerKey) {
+		return new BelongsToRelation(this, related, foreignKey, ownerKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Define a belongs to many relationship.
@@ -6443,8 +7695,9 @@ var Model = class Model {
 	* @param relatedKey 
 	* @returns 
 	*/
-	belongsToMany(related, throughDelegate, foreignPivotKey, relatedPivotKey, parentKey = "id", relatedKey = "id") {
-		return new BelongsToManyRelation(this, related, throughDelegate, foreignPivotKey, relatedPivotKey, parentKey, relatedKey);
+	belongsToMany(related, throughDelegate, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+		const constructor = this.constructor;
+		return new BelongsToManyRelation(this, related, throughDelegate, foreignPivotKey, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Define a has one through relationship.
@@ -6457,8 +7710,9 @@ var Model = class Model {
 	* @param secondLocalKey 
 	* @returns 
 	*/
-	hasOneThrough(related, throughDelegate, firstKey, secondKey, localKey = "id", secondLocalKey = "id") {
-		return new HasOneThroughRelation(this, related, throughDelegate, firstKey, secondKey, localKey, secondLocalKey);
+	hasOneThrough(related, throughDelegate, firstKey, secondKey, localKey, secondLocalKey = "id") {
+		const constructor = this.constructor;
+		return new HasOneThroughRelation(this, related, throughDelegate, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
 	}
 	/**
 	* Define a has many through relationship.
@@ -6471,8 +7725,9 @@ var Model = class Model {
 	* @param secondLocalKey 
 	* @returns 
 	*/
-	hasManyThrough(related, throughDelegate, firstKey, secondKey, localKey = "id", secondLocalKey = "id") {
-		return new HasManyThroughRelation(this, related, throughDelegate, firstKey, secondKey, localKey, secondLocalKey);
+	hasManyThrough(related, throughDelegate, firstKey, secondKey, localKey, secondLocalKey = "id") {
+		const constructor = this.constructor;
+		return new HasManyThroughRelation(this, related, throughDelegate, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
 	}
 	/**
 	* Define a polymorphic one to one relationship.
@@ -6482,8 +7737,9 @@ var Model = class Model {
 	* @param localKey 
 	* @returns 
 	*/
-	morphOne(related, morphName, localKey = "id") {
-		return new MorphOneRelation(this, related, morphName, localKey);
+	morphOne(related, morphName, localKey) {
+		const constructor = this.constructor;
+		return new MorphOneRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a polymorphic one to many relationship.
@@ -6493,8 +7749,9 @@ var Model = class Model {
 	* @param localKey 
 	* @returns 
 	*/
-	morphMany(related, morphName, localKey = "id") {
-		return new MorphManyRelation(this, related, morphName, localKey);
+	morphMany(related, morphName, localKey) {
+		const constructor = this.constructor;
+		return new MorphManyRelation(this, related, morphName, localKey ?? constructor.getPrimaryKey());
 	}
 	/**
 	* Define a polymorphic many to many relationship.
@@ -6507,8 +7764,9 @@ var Model = class Model {
 	* @param relatedKey 
 	* @returns 
 	*/
-	morphToMany(related, throughDelegate, morphName, relatedPivotKey, parentKey = "id", relatedKey = "id") {
-		return new MorphToManyRelation(this, related, throughDelegate, morphName, relatedPivotKey, parentKey, relatedKey);
+	morphToMany(related, throughDelegate, morphName, relatedPivotKey, parentKey, relatedKey) {
+		const constructor = this.constructor;
+		return new MorphToManyRelation(this, related, throughDelegate, morphName, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
 	}
 	/**
 	* Resolve a get mutator method for a given attribute key, if it exists.
@@ -6758,4 +8016,4 @@ var Model = class Model {
 };
 
 //#endregion
-export { ArkormCollection, ArkormException, Attribute, CliApp, EnumBuilder, ForeignKeyBuilder, InitCommand, InlineFactory, 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, QueryBuilder, QueryConstraintException, RelationResolutionException, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, ScopeNotDefinedException, SeedCommand, Seeder, TableBuilder, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToPrismaSchema, applyMigrationToPrismaSchema, applyOperationsToPrismaSchema, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildRelationLine, computeMigrationChecksum, configureArkormRuntime, createMigrationTimestamp, createPrismaAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, 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, 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, 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, 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 };