arkormx 2.0.6 → 2.0.8

package/dist/MorphToManyRelation-DWmrAkT8.mjs

@@ -0,0 +1,4459 @@
+import { Collection } from "@h3ravel/collect.js";
+import { AsyncLocalStorage } from "async_hooks";
+import { createJiti } from "jiti";
+import { pathToFileURL } from "node:url";
+import { dirname, extname, join, resolve } from "node:path";
+import { createRequire } from "module";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readFileSync as readFileSync$1, rmSync as rmSync$1, writeFileSync as writeFileSync$1 } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { str } from "@h3ravel/support";
+
+//#region src/Exceptions/ArkormException.ts
+var ArkormException = class extends Error {
+	code;
+	operation;
+	model;
+	delegate;
+	relation;
+	scope;
+	meta;
+	constructor(message, context = {}) {
+		super(message, context.cause === void 0 ? void 0 : { cause: context.cause });
+		this.name = "ArkormException";
+		this.code = context.code;
+		this.operation = context.operation;
+		this.model = context.model;
+		this.delegate = context.delegate;
+		this.relation = context.relation;
+		this.scope = context.scope;
+		this.meta = context.meta;
+	}
+	getContext() {
+		return {
+			code: this.code,
+			operation: this.operation,
+			model: this.model,
+			delegate: this.delegate,
+			relation: this.relation,
+			scope: this.scope,
+			meta: this.meta,
+			cause: this.cause
+		};
+	}
+	toJSON() {
+		return {
+			name: this.name,
+			message: this.message,
+			...this.getContext()
+		};
+	}
+};
+
+//#endregion
+//#region src/Collection.ts
+var ArkormCollection = class extends Collection {};
+
+//#endregion
+//#region src/Exceptions/RelationResolutionException.ts
+var RelationResolutionException = class extends ArkormException {
+	constructor(message, context = {}) {
+		super(message, {
+			code: "RELATION_RESOLUTION_FAILED",
+			...context
+		});
+		this.name = "RelationResolutionException";
+	}
+};
+
+//#endregion
+//#region src/relationship/RelationTableLoader.ts
+/**
+* Utility class responsible for loading data from relation tables, which are used to 
+* manage relationships between models in Arkorm. 
+* 
+* @author Legacy (3m1n3nc3)
+* @since 2.0.0-next.0
+*/
+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/SetBasedEagerLoader.ts
+/**
+* Utility class responsible for performing set-based eager loading of relationships for 
+* a collection of models.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 2.0.0-next.2
+*/
+var SetBasedEagerLoader = class SetBasedEagerLoader {
+	constructor(models, relations) {
+		this.models = models;
+		this.relations = relations;
+	}
+	/**
+	* Performs eager loading of all specified relationships for the set of models. 
+	* 
+	* @returns 
+	*/
+	async load() {
+		if (this.models.length === 0) return;
+		const relationTree = this.buildRelationTree(this.relations);
+		await Promise.all(Array.from(relationTree.entries()).map(async ([name, node]) => {
+			await this.loadRelationNode(name, node);
+		}));
+	}
+	async loadRelationNode(name, node) {
+		await this.loadRelation(name, node.constraint);
+		if (node.children.size === 0) return;
+		const relatedModels = this.collectLoadedRelationModels(name);
+		if (relatedModels.length === 0) return;
+		await new SetBasedEagerLoader(relatedModels, this.relationTreeToMap(node.children)).load();
+	}
+	/**
+	* Loads a specific relationship for the set of models based on the relationship name 
+	* and an optional constraint.
+	* 
+	* @param name          The name of the relationship to load.
+	* @param constraint    An optional constraint to apply to the query.
+	* @returns             A promise that resolves when the relationship is loaded.
+	*/
+	async loadRelation(name, constraint) {
+		const resolver = this.resolveRelationResolver(name);
+		if (!resolver) return;
+		const metadata = resolver.call(this.models[0]).getMetadata();
+		switch (metadata.type) {
+			case "belongsTo":
+				await this.loadBelongsTo(name, resolver, metadata, constraint);
+				return;
+			case "belongsToMany":
+				await this.loadBelongsToMany(name, metadata, constraint);
+				return;
+			case "hasMany":
+				await this.loadHasMany(name, metadata, constraint);
+				return;
+			case "hasOne":
+				await this.loadHasOne(name, resolver, metadata, constraint);
+				return;
+			case "hasManyThrough":
+				await this.loadHasManyThrough(name, metadata, constraint);
+				return;
+			case "hasOneThrough":
+				await this.loadHasOneThrough(name, resolver, metadata, constraint);
+				return;
+			default: await this.loadIndividually(name, resolver, constraint);
+		}
+	}
+	/**
+	* Resolves the relation resolver function for a given relationship name by inspecting 
+	* the first model in the set.
+	* 
+	* @param name  The name of the relationship to resolve.
+	* @returns     The relation resolver function or null if not found.
+	*/
+	resolveRelationResolver(name) {
+		const resolver = this.models[0][name];
+		if (typeof resolver !== "function") {
+			const modelName = this.models[0].constructor?.name ?? "Model";
+			throw new RelationResolutionException(`Relation [${name}] is not defined on the model.`, {
+				operation: "eagerLoad",
+				model: modelName,
+				relation: name
+			});
+		}
+		return resolver;
+	}
+	buildRelationTree(relations) {
+		const tree = /* @__PURE__ */ new Map();
+		Object.entries(relations).forEach(([path, constraint]) => {
+			const segments = path.split(".").map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+			if (segments.length === 0) return;
+			let current = tree;
+			segments.forEach((segment, index) => {
+				const existing = current.get(segment) ?? {
+					constraint: void 0,
+					children: /* @__PURE__ */ new Map()
+				};
+				if (index === segments.length - 1 && constraint) existing.constraint = constraint;
+				current.set(segment, existing);
+				current = existing.children;
+			});
+		});
+		return tree;
+	}
+	relationTreeToMap(tree, prefix = "") {
+		return Array.from(tree.entries()).reduce((all, [name, node]) => {
+			const path = prefix ? `${prefix}.${name}` : name;
+			all[path] = node.constraint;
+			Object.assign(all, this.relationTreeToMap(node.children, path));
+			return all;
+		}, {});
+	}
+	collectLoadedRelationModels(name) {
+		return this.models.reduce((all, model) => {
+			const loaded = model.getAttribute(name);
+			if (loaded instanceof ArkormCollection) {
+				loaded.all().forEach((item) => {
+					if (this.isEagerLoadableModel(item)) all.push(item);
+				});
+				return all;
+			}
+			if (this.isEagerLoadableModel(loaded)) all.push(loaded);
+			return all;
+		}, []);
+	}
+	isEagerLoadableModel(value) {
+		return typeof value === "object" && value !== null && typeof value.getAttribute === "function" && typeof value.setLoadedRelation === "function";
+	}
+	/**
+	* Loads a "belongs to" relationship for the set of models.
+	* 
+	* @param name          The name of the relationship to load.
+	* @param resolver      The relation resolver function.
+	* @param metadata      The metadata for the relationship.
+	* @param constraint    An optional constraint to apply to the query.
+	* @returns             A promise that resolves when the relationship is loaded.
+	*/
+	async loadBelongsTo(name, resolver, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.foreignKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.ownerKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByOwnerKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.ownerKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (!relatedByOwnerKey.has(lookupKey)) relatedByOwnerKey.set(lookupKey, related);
+		});
+		this.models.forEach((model) => {
+			const foreignValue = model.getAttribute(metadata.foreignKey);
+			const relationValue = foreignValue == null ? void 0 : relatedByOwnerKey.get(this.toLookupKey(foreignValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
+	}
+	/**
+	* Loads a "has many" relationship for the set of models. 
+	* 
+	* @param name 
+	* @param metadata 
+	* @param constraint 
+	* @returns 
+	*/
+	async loadHasMany(name, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByForeignKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.foreignKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			const bucket = relatedByForeignKey.get(lookupKey) ?? [];
+			bucket.push(related);
+			relatedByForeignKey.set(lookupKey, bucket);
+		});
+		this.models.forEach((model) => {
+			const localValue = model.getAttribute(metadata.localKey);
+			const related = localValue == null ? [] : relatedByForeignKey.get(this.toLookupKey(localValue)) ?? [];
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models. 
+	* 
+	* @param name 
+	* @param metadata 
+	* @param constraint 
+	* @returns 
+	*/
+	async loadBelongsToMany(name, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.parentKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		const pivotRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: this.buildBelongsToManyPivotWhere(metadata, parentKeys),
+			columns: this.getBelongsToManyPivotColumns(metadata).map((column) => ({ column }))
+		});
+		const relatedIds = this.collectUniqueRowValues(pivotRows, metadata.relatedPivotKey);
+		if (relatedIds.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.relatedKey, relatedIds);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.relatedKey);
+			if (relatedValue == null) return;
+			relatedByKey.set(this.toLookupKey(relatedValue), related);
+		});
+		const relatedKeysByParent = /* @__PURE__ */ new Map();
+		const pivotByParentAndRelated = /* @__PURE__ */ new Map();
+		pivotRows.forEach((row) => {
+			const parentValue = row[metadata.foreignPivotKey];
+			const relatedValue = row[metadata.relatedPivotKey];
+			if (parentValue == null || relatedValue == null) return;
+			const bucket = relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? [];
+			bucket.push(relatedValue);
+			relatedKeysByParent.set(this.toLookupKey(parentValue), bucket);
+			pivotByParentAndRelated.set(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`, row);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.parentKey);
+			const related = (parentValue == null ? [] : relatedKeysByParent.get(this.toLookupKey(parentValue)) ?? []).reduce((all, relatedValue) => {
+				const candidate = relatedByKey.get(this.toLookupKey(relatedValue));
+				if (candidate) all.push(this.attachBelongsToManyPivot(metadata, candidate, pivotByParentAndRelated.get(`${this.toLookupKey(parentValue)}:${this.toLookupKey(relatedValue)}`)));
+				return all;
+			}, []);
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+	}
+	buildBelongsToManyPivotWhere(metadata, parentKeys) {
+		const baseCondition = {
+			type: "comparison",
+			column: metadata.foreignPivotKey,
+			operator: "in",
+			value: parentKeys
+		};
+		if (!metadata.pivotWhere) return baseCondition;
+		return {
+			type: "group",
+			operator: "and",
+			conditions: [baseCondition, metadata.pivotWhere]
+		};
+	}
+	getBelongsToManyPivotColumns(metadata) {
+		return [
+			metadata.foreignPivotKey,
+			metadata.relatedPivotKey,
+			...metadata.pivotColumns ?? []
+		].filter((column, index, all) => all.indexOf(column) === index);
+	}
+	shouldAttachBelongsToManyPivot(metadata) {
+		return Boolean(metadata.pivotModel) || Boolean(metadata.pivotCreatedAtColumn) || Boolean(metadata.pivotUpdatedAtColumn) || (metadata.pivotColumns?.length ?? 0) > 0 || Boolean(metadata.pivotAccessor);
+	}
+	createBelongsToManyPivotRecord(metadata, row) {
+		const attributes = this.getBelongsToManyPivotColumns(metadata).reduce((all, column) => {
+			all[column] = row[column];
+			return all;
+		}, {});
+		if (!metadata.pivotModel) return attributes;
+		if (typeof metadata.pivotModel.hydrate === "function") return metadata.pivotModel.hydrate(attributes);
+		return new metadata.pivotModel(attributes);
+	}
+	attachBelongsToManyPivot(metadata, related, row) {
+		if (!row || !this.shouldAttachBelongsToManyPivot(metadata)) return related;
+		const rawReader = related;
+		if (typeof rawReader.getRawAttributes !== "function" || typeof rawReader.setAttribute !== "function") return related;
+		const cloned = metadata.relatedModel.hydrate(rawReader.getRawAttributes());
+		cloned.setAttribute(metadata.pivotAccessor ?? "pivot", this.createBelongsToManyPivotRecord(metadata, row));
+		return cloned;
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	* 
+	* @param name 
+	* @param resolver 
+	* @param metadata 
+	* @param constraint 
+	* @returns 
+	*/
+	async loadHasOne(name, resolver, metadata, constraint) {
+		const keys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (keys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.foreignKey, keys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByForeignKey = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const value = this.readModelAttribute(related, metadata.foreignKey);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (!relatedByForeignKey.has(lookupKey)) relatedByForeignKey.set(lookupKey, related);
+		});
+		this.models.forEach((model) => {
+			const localValue = model.getAttribute(metadata.localKey);
+			const relationValue = localValue == null ? void 0 : relatedByForeignKey.get(this.toLookupKey(localValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
+	}
+	/**
+	* Loads a "has many through" relationship for the set of models.
+	* 
+	* @param name 
+	* @param metadata 
+	* @param constraint 
+	* @returns 
+	*/
+	async loadHasManyThrough(name, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		const throughRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: {
+				type: "comparison",
+				column: metadata.firstKey,
+				operator: "in",
+				value: parentKeys
+			}
+		});
+		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
+		if (intermediateKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, new ArkormCollection([]));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByIntermediate = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
+			if (relatedValue == null) return;
+			const bucket = relatedByIntermediate.get(this.toLookupKey(relatedValue)) ?? [];
+			bucket.push(related);
+			relatedByIntermediate.set(this.toLookupKey(relatedValue), bucket);
+		});
+		const intermediateByParent = /* @__PURE__ */ new Map();
+		throughRows.forEach((row) => {
+			const parentValue = row[metadata.firstKey];
+			const intermediateValue = row[metadata.secondLocalKey];
+			if (parentValue == null || intermediateValue == null) return;
+			const bucket = intermediateByParent.get(this.toLookupKey(parentValue)) ?? [];
+			bucket.push(intermediateValue);
+			intermediateByParent.set(this.toLookupKey(parentValue), bucket);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.localKey);
+			const related = (parentValue == null ? [] : intermediateByParent.get(this.toLookupKey(parentValue)) ?? []).flatMap((intermediateValue) => relatedByIntermediate.get(this.toLookupKey(intermediateValue)) ?? []);
+			model.setLoadedRelation(name, new ArkormCollection(related));
+		});
+	}
+	/**
+	* Loads a "has one through" relationship for the set of models.
+	* 
+	* @param name 
+	* @param resolver 
+	* @param metadata 
+	* @param constraint 
+	* @returns 
+	*/
+	async loadHasOneThrough(name, resolver, metadata, constraint) {
+		const parentKeys = this.collectUniqueKeys((model) => model.getAttribute(metadata.localKey));
+		if (parentKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		const throughRows = await this.createRelationTableLoader().selectRows({
+			table: metadata.throughTable,
+			where: {
+				type: "comparison",
+				column: metadata.firstKey,
+				operator: "in",
+				value: parentKeys
+			}
+		});
+		const intermediateKeys = this.collectUniqueRowValues(throughRows, metadata.secondLocalKey);
+		if (intermediateKeys.length === 0) {
+			this.models.forEach((model) => {
+				model.setLoadedRelation(name, this.resolveSingleDefault(resolver, model));
+			});
+			return;
+		}
+		let query = metadata.relatedModel.query().whereIn(metadata.secondKey, intermediateKeys);
+		query = this.applyConstraint(query, constraint);
+		const relatedModels = (await query.get()).all();
+		const relatedByIntermediate = /* @__PURE__ */ new Map();
+		relatedModels.forEach((related) => {
+			const relatedValue = this.readModelAttribute(related, metadata.secondKey);
+			if (relatedValue == null) return;
+			const lookupKey = this.toLookupKey(relatedValue);
+			if (!relatedByIntermediate.has(lookupKey)) relatedByIntermediate.set(lookupKey, related);
+		});
+		const intermediateByParent = /* @__PURE__ */ new Map();
+		throughRows.forEach((row) => {
+			const parentValue = row[metadata.firstKey];
+			const intermediateValue = row[metadata.secondLocalKey];
+			if (parentValue == null || intermediateValue == null) return;
+			const lookupKey = this.toLookupKey(parentValue);
+			if (!intermediateByParent.has(lookupKey)) intermediateByParent.set(lookupKey, intermediateValue);
+		});
+		this.models.forEach((model) => {
+			const parentValue = model.getAttribute(metadata.localKey);
+			const intermediateValue = parentValue == null ? void 0 : intermediateByParent.get(this.toLookupKey(parentValue));
+			const relationValue = intermediateValue == null ? void 0 : relatedByIntermediate.get(this.toLookupKey(intermediateValue));
+			model.setLoadedRelation(name, relationValue ?? this.resolveSingleDefault(resolver, model));
+		});
+	}
+	/**
+	* Fallback method to load relationships individually for each model when the 
+	* relationship type is not supported for set-based loading.
+	* 
+	* @param name 
+	* @param resolver 
+	* @param constraint 
+	*/
+	async loadIndividually(name, resolver, constraint) {
+		await Promise.all(this.models.map(async (model) => {
+			const relation = resolver.call(model);
+			if (constraint) relation.constrain(constraint);
+			model.setLoadedRelation(name, await relation.getResults());
+		}));
+	}
+	/**
+	* Applies an eager load constraint to a query if provided.
+	* 
+	* @param query 
+	* @param constraint 
+	* @returns 
+	*/
+	applyConstraint(query, constraint) {
+		if (!constraint) return query;
+		return constraint(query) ?? query;
+	}
+	/**
+	* Collects unique values from the set of models based on a resolver function, which 
+	* is used to extract the value from each model.
+	* 
+	* @param resolve   A function that takes a model and returns the value to be collected.
+	* @returns         An array of unique values.
+	*/
+	collectUniqueKeys(resolve) {
+		const seen = /* @__PURE__ */ new Set();
+		const values = [];
+		this.models.forEach((model) => {
+			const value = resolve(model);
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (seen.has(lookupKey)) return;
+			seen.add(lookupKey);
+			values.push(value);
+		});
+		return values;
+	}
+	/**
+	* Collects unique values from an array of database rows based on a specified key, which 
+	* is used to extract the value from each row.
+	* 
+	* @param rows  An array of database rows.
+	* @param key   The key to extract values from each row.
+	* @returns     An array of unique values.
+	*/
+	collectUniqueRowValues(rows, key) {
+		const seen = /* @__PURE__ */ new Set();
+		const values = [];
+		rows.forEach((row) => {
+			const value = row[key];
+			if (value == null) return;
+			const lookupKey = this.toLookupKey(value);
+			if (seen.has(lookupKey)) return;
+			seen.add(lookupKey);
+			values.push(value);
+		});
+		return values;
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	* 
+	* @returns 
+	*/
+	createRelationTableLoader() {
+		return new RelationTableLoader(this.resolveAdapter());
+	}
+	/**
+	* Loads a "belongs to many" relationship for the set of models.
+	* 
+	* @returns 
+	*/
+	resolveAdapter() {
+		const adapter = this.models[0].constructor.getAdapter?.();
+		if (!adapter) throw new Error("Set-based eager loading requires a configured adapter.");
+		return adapter;
+	}
+	/**
+	* Reads an attribute value from a model using the getAttribute method, which is used 
+	* to access model attributes in a way that is compatible with Arkorm's internal model structure.
+	* 
+	* @param model The model to read the attribute from.
+	* @param key The name of the attribute to read.
+	* @returns 
+	*/
+	readModelAttribute(model, key) {
+		return model.getAttribute?.(key);
+	}
+	/**
+	* Resolves the default result for a relationship when no related models are found. 
+	* 
+	* @param resolver 
+	* @param model 
+	* @returns 
+	*/
+	resolveSingleDefault(resolver, model) {
+		return resolver.call(model).resolveDefaultResult?.() ?? null;
+	}
+	/**
+	* Generates a unique lookup key for a given value, which is used to store and retrieve 
+	* values in maps during the eager loading process.
+	* 
+	* @param value     The value to generate a lookup key for.
+	* @returns         A unique string representing the value.
+	*/
+	toLookupKey(value) {
+		if (value instanceof Date) return `date:${value.toISOString()}`;
+		return `${typeof value}:${String(value)}`;
+	}
+};
+
+//#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-module-loader.ts
+var RuntimeModuleLoader = class {
+	static async load(filePath) {
+		const resolvedPath = resolve(filePath);
+		return await createJiti(pathToFileURL(resolvedPath).href, {
+			interopDefault: false,
+			tsconfigPaths: true,
+			sourceMaps: true
+		}).import(resolvedPath, { default: true });
+	}
+};
+
+//#endregion
+//#region src/helpers/migration-history.ts
+const createEmptyAppliedMigrationsState = () => ({
+	version: 1,
+	migrations: [],
+	runs: []
+});
+const supportsDatabaseMigrationState = (adapter) => {
+	return typeof adapter?.readAppliedMigrationsState === "function" && typeof adapter?.writeAppliedMigrationsState === "function";
+};
+const resolveMigrationStateFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
+	return join(cwd, ".arkormx", "migrations.applied.json");
+};
+const buildMigrationIdentity = (filePath, className) => {
+	const fileName = filePath.split("/").pop()?.split("\\").pop() ?? filePath;
+	return `${fileName.slice(0, fileName.length - extname(fileName).length)}:${className}`;
+};
+const computeMigrationChecksum = (filePath) => {
+	const source = readFileSync$1(filePath, "utf-8");
+	return createHash("sha256").update(source).digest("hex");
+};
+const readAppliedMigrationsState = (stateFilePath) => {
+	if (!existsSync$1(stateFilePath)) return createEmptyAppliedMigrationsState();
+	try {
+		const parsed = JSON.parse(readFileSync$1(stateFilePath, "utf-8"));
+		if (!Array.isArray(parsed.migrations)) return createEmptyAppliedMigrationsState();
+		return {
+			version: 1,
+			migrations: parsed.migrations.filter((migration) => {
+				return typeof migration?.id === "string" && typeof migration?.file === "string" && typeof migration?.className === "string" && typeof migration?.appliedAt === "string" && (migration?.checksum === void 0 || typeof migration?.checksum === "string");
+			}),
+			runs: Array.isArray(parsed.runs) ? parsed.runs.filter((run) => {
+				return typeof run?.id === "string" && typeof run?.appliedAt === "string" && Array.isArray(run?.migrationIds) && run.migrationIds.every((item) => typeof item === "string");
+			}) : []
+		};
+	} catch {
+		return createEmptyAppliedMigrationsState();
+	}
+};
+const readAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) return await adapter.readAppliedMigrationsState();
+	return readAppliedMigrationsState(stateFilePath);
+};
+const writeAppliedMigrationsState = (stateFilePath, state) => {
+	const directory = dirname(stateFilePath);
+	if (!existsSync$1(directory)) mkdirSync$1(directory, { recursive: true });
+	writeFileSync$1(stateFilePath, JSON.stringify(state, null, 2));
+};
+const writeAppliedMigrationsStateToStore = async (adapter, stateFilePath, state) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(state);
+		return;
+	}
+	writeAppliedMigrationsState(stateFilePath, state);
+};
+const deleteAppliedMigrationsStateFromStore = async (adapter, stateFilePath) => {
+	if (supportsDatabaseMigrationState(adapter)) {
+		await adapter.writeAppliedMigrationsState(createEmptyAppliedMigrationsState());
+		return "database";
+	}
+	if (!existsSync$1(stateFilePath)) return "missing-file";
+	writeAppliedMigrationsState(stateFilePath, createEmptyAppliedMigrationsState());
+	return "file";
+};
+const isMigrationApplied = (state, identity, checksum) => {
+	const matched = state.migrations.find((migration) => migration.id === identity);
+	if (!matched) return false;
+	if (checksum && matched.checksum) return matched.checksum === checksum;
+	if (checksum && !matched.checksum) return false;
+	return true;
+};
+const findAppliedMigration = (state, identity) => {
+	return state.migrations.find((migration) => migration.id === identity);
+};
+const markMigrationApplied = (state, entry) => {
+	const next = state.migrations.filter((migration) => migration.id !== entry.id);
+	next.push(entry);
+	return {
+		version: 1,
+		migrations: next,
+		runs: state.runs ?? []
+	};
+};
+const removeAppliedMigration = (state, identity) => {
+	return {
+		version: 1,
+		migrations: state.migrations.filter((migration) => migration.id !== identity),
+		runs: (state.runs ?? []).map((run) => ({
+			...run,
+			migrationIds: run.migrationIds.filter((id) => id !== identity)
+		})).filter((run) => run.migrationIds.length > 0)
+	};
+};
+const buildMigrationRunId = () => {
+	return `run_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+};
+const markMigrationRun = (state, run) => {
+	const nextRuns = (state.runs ?? []).filter((existing) => existing.id !== run.id);
+	nextRuns.push(run);
+	return {
+		version: 1,
+		migrations: state.migrations,
+		runs: nextRuns
+	};
+};
+const getLastMigrationRun = (state) => {
+	const runs = state.runs ?? [];
+	if (runs.length === 0) return void 0;
+	return runs.map((run, index) => ({
+		run,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.run.appliedAt.localeCompare(left.run.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	})[0]?.run;
+};
+const getLatestAppliedMigrations = (state, steps) => {
+	return state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = right.migration.appliedAt.localeCompare(left.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return right.index - left.index;
+	}).slice(0, Math.max(0, steps)).map((entry) => entry.migration);
+};
+
+//#endregion
+//#region src/helpers/PrimaryKeyGenerationPlanner.ts
+var PrimaryKeyGenerationPlanner = class {
+	static plan(column) {
+		if (!column.primary || column.default !== void 0) return void 0;
+		if (column.type === "uuid" || column.type === "string") return {
+			strategy: "uuid",
+			prismaDefault: "@default(uuid())",
+			databaseDefault: column.type === "uuid" ? "gen_random_uuid()" : "gen_random_uuid()::text",
+			runtimeFactory: "uuid"
+		};
+	}
+	static generate(generation) {
+		if (generation?.runtimeFactory === "uuid") return randomUUID();
+	}
+};
+
+//#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.
+	*
+	* @returns
+	*/
+	nullable() {
+		this.tableBuilder.nullable(this.columnName);
+		return this;
+	}
+	/**
+	* Marks the enum column as unique.
+	*
+	* @returns
+	*/
+	unique() {
+		this.tableBuilder.unique(this.columnName);
+		return this;
+	}
+	/**
+	* Sets a default value for the enum column.
+	*
+	* @param value
+	* @returns
+	*/
+	default(value) {
+		this.tableBuilder.default(value, this.columnName);
+		return this;
+	}
+	/**
+	* Positions the enum column after another column when supported.
+	*
+	* @param referenceColumn
+	* @returns
+	*/
+	after(referenceColumn) {
+		this.tableBuilder.after(referenceColumn, this.columnName);
+		return this;
+	}
+	/**
+	* Maps the enum column to a custom database column name.
+	*
+	* @param name
+	* @returns
+	*/
+	map(name) {
+		this.tableBuilder.map(name, this.columnName);
+		return this;
+	}
+};
+/**
+* The TableBuilder class provides a fluent interface for defining 
+* the structure of a database table in a migration, including columns to add or drop.
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var TableBuilder = class {
+	columns = [];
+	dropColumnNames = [];
+	indexes = [];
+	foreignKeys = [];
+	latestColumnName;
+	/**
+	* Defines a primary key column in the table.
+	* 
+	* @param columnNameOrOptions 
+	* @param options 
+	* @returns 
+	*/
+	primary(columnNameOrOptions, options) {
+		const config = typeof columnNameOrOptions === "string" ? {
+			columnName: columnNameOrOptions,
+			...options ?? {}
+		} : columnNameOrOptions ?? {};
+		const column = this.resolveColumn(config.columnName);
+		column.primary = true;
+		if (typeof config.autoIncrement === "boolean") column.autoIncrement = config.autoIncrement;
+		if (Object.prototype.hasOwnProperty.call(config, "default")) column.default = config.default;
+		column.primaryKeyGeneration = PrimaryKeyGenerationPlanner.plan(column);
+		return this;
+	}
+	/**
+	* Defines an auto-incrementing primary key column.
+	* 
+	* @param name  The name of the primary key column.
+	* @default 'id'
+	* @returns     The current TableBuilder instance for chaining.
+	*/
+	id(name = "id", type = "id") {
+		return this.column(name, type, { primary: true });
+	}
+	/**
+	* Defines a UUID column in the table.
+	* 
+	* @param name      The name of the UUID column.
+	* @param options   Additional options for the UUID column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	uuid(name, options = {}) {
+		return this.column(name, "uuid", options);
+	}
+	/**
+	* Defines an enum column in the table.
+	*
+	* @param name      The name of the enum column.
+	* @param values    Either an array of string values for the enum or the name of an existing enum to reuse.
+	* @param options   Additional options for the enum column.
+	* @returns
+	*/
+	enum(name, valuesOrEnumName, options = {}) {
+		const isEnumReuse = typeof valuesOrEnumName === "string";
+		if (!isEnumReuse && valuesOrEnumName.length === 0) throw new Error(`Enum column [${name}] must define at least one value.`);
+		const normalizedEnumValues = isEnumReuse ? void 0 : normalizeEnumMembers(name, valuesOrEnumName);
+		const enumName = isEnumReuse ? valuesOrEnumName.trim() : options.enumName?.trim();
+		if (isEnumReuse && !enumName) throw new Error(`Enum column [${name}] must define an enum name.`);
+		this.column(name, "enum", {
+			...options,
+			enumName,
+			enumValues: normalizedEnumValues
+		});
+		return new EnumBuilder(this, name);
+	}
+	/**
+	* Defines a string column in the table.
+	* 
+	* @param name      The name of the string column.
+	* @param options   Additional options for the string column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	string(name, options = {}) {
+		return this.column(name, "string", options);
+	}
+	/**
+	* Defines a text column in the table.
+	* 
+	* @param name      The name of the text column.
+	* @param options   Additional options for the text column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	text(name, options = {}) {
+		return this.column(name, "text", options);
+	}
+	/**
+	* Defines an integer column in the table.
+	* 
+	* @param name      The name of the integer column.
+	* @param options   Additional options for the integer column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	integer(name, options = {}) {
+		return this.column(name, "integer", options);
+	}
+	/**
+	* Defines a big integer column in the table.
+	* 
+	* @param name      The name of the big integer column.
+	* @param options   Additional options for the big integer column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	bigInteger(name, options = {}) {
+		return this.column(name, "bigInteger", options);
+	}
+	/**
+	* Defines a float column in the table.
+	* 
+	* @param name      The name of the float column.
+	* @param options   Additional options for the float column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	float(name, options = {}) {
+		return this.column(name, "float", options);
+	}
+	/**
+	* Marks a column as unique in the table.
+	* 
+	* @param name Optional explicit column name. 
+	* When omitted, applies to the latest defined column.
+	* @returns The current TableBuilder instance for chaining.
+	*/
+	unique(name) {
+		const column = this.resolveColumn(name);
+		column.unique = true;
+		return this;
+	}
+	/**
+	* Defines a boolean column in the table.
+	* 
+	* @param name      The name of the boolean column. 
+	* @param options   Additional options for the boolean column.
+	* @returns         The current TableBuilder instance for chaining.
+	*/
+	boolean(name, options = {}) {
+		return this.column(name, "boolean", options);
+	}
+	/**
+	* Defines a JSON column in the table.
+	* 
+	* @param name      The name of the JSON column.
+	* @param options   Additional options for the JSON column.
+	* @returns 
+	*/
+	json(name, options = {}) {
+		return this.column(name, "json", options);
+	}
+	/**
+	* Defines a date column in the table.
+	* 
+	* @param name      The name of the date column.
+	* @param options   Additional options for the date column.
+	* @returns 
+	*/
+	date(name, options = {}) {
+		return this.column(name, "date", options);
+	}
+	/**
+	* Defines colonns for a polymorphic relationship in the table.
+	* 
+	* @param name    The base name for the polymorphic relationship columns.
+	* @returns 
+	*/
+	morphs(name, nullable = false) {
+		this.string(`${name}Type`, { nullable });
+		this.integer(`${name}Id`, { nullable });
+		return this;
+	}
+	/**
+	* Defines nullable columns for a polymorphic relationship in the table.
+	* 
+	* @param name  The base name for the polymorphic relationship columns.
+	* @returns 
+	*/
+	nullableMorphs(name) {
+		return this.morphs(name, true);
+	}
+	/**
+	* Defines a timestamp column in the table.
+	* 
+	* @param name      The name of the timestamp column.
+	* @param options   Additional options for the timestamp column.
+	* @returns 
+	*/
+	timestamp(name, options = {}) {
+		return this.column(name, "timestamp", options);
+	}
+	/**
+	* Defines both createdAt and updatedAt timestamp columns in the table.
+	* 
+	* @returns 
+	*/
+	timestamps() {
+		this.timestamp("createdAt", {
+			nullable: false,
+			default: "now()"
+		});
+		this.timestamp("updatedAt", {
+			nullable: false,
+			updatedAt: true
+		});
+		return this;
+	}
+	/**
+	* Defines a soft delete timestamp column in the table.
+	* 
+	* @param column    The name of the soft delete column.
+	* @returns 
+	*/
+	softDeletes(column = "deletedAt") {
+		this.timestamp(column, { nullable: true });
+		return this;
+	}
+	/**
+	* Defines a column to be dropped from the table in an alterTable operation.
+	* 
+	* @param name   The name of the column to drop.
+	* @returns 
+	*/
+	dropColumn(name) {
+		this.dropColumnNames.push(name);
+		return this;
+	}
+	/**
+	* Marks a column as nullable.
+	* 
+	* @param columnName Optional explicit column name. When omitted, applies to the latest defined column.
+	* @returns          The current TableBuilder instance for chaining.
+	*/
+	nullable(columnName) {
+		const column = this.resolveColumn(columnName);
+		column.nullable = true;
+		return this;
+	}
+	/**
+	* Sets the Prisma enum name for an enum column.
+	*
+	* @param name       The enum name to assign.
+	* @param columnName Optional explicit target column name. When omitted, applies to the latest defined column.
+	* @returns          The current TableBuilder instance for chaining.
+	*/
+	enumName(name, columnName) {
+		const column = this.resolveColumn(columnName);
+		if (column.type !== "enum") throw new Error(`Column [${column.name}] is not an enum column.`);
+		const enumName = name.trim();
+		if (!enumName) throw new Error(`Enum column [${column.name}] must define an enum name.`);
+		column.enumName = enumName;
+		return this;
+	}
+	/**
+	* Sets a default value for a column.
+	*
+	* @param value      The default scalar value or Prisma expression (e.g. 'now()').
+	* @param columnName Optional explicit column name. When omitted, applies to the latest defined column.
+	* @returns          The current TableBuilder instance for chaining.
+	*/
+	default(value, columnName) {
+		const column = this.resolveColumn(columnName);
+		column.default = value;
+		return this;
+	}
+	/**
+	* Sets the column position to appear after another column when possible.
+	* 
+	* @param referenceColumn The column that the target column should be placed after.
+	* @param columnName      Optional explicit target column name. When omitted, applies to the latest defined column.
+	* @returns               The current TableBuilder instance for chaining.
+	*/
+	after(referenceColumn, columnName) {
+		const column = this.resolveColumn(columnName);
+		column.after = referenceColumn;
+		return this;
+	}
+	/**
+	* Maps the column to a custom database column name.
+	* 
+	* @param name       The custom database column name.
+	* @param columnName Optional explicit target column name. When omitted, applies to the latest defined column.
+	* @returns          The current TableBuilder instance for chaining.
+	*/
+	map(name, columnName) {
+		const column = this.resolveColumn(columnName);
+		column.map = name;
+		return this;
+	}
+	/**
+	* Defines an index on one or more columns.
+	* 
+	* @param columns Optional target columns. When omitted, applies to the latest defined column.
+	* @param name    Optional index name.
+	* @returns       The current TableBuilder instance for chaining.
+	*/
+	index(columns, name) {
+		const columnList = Array.isArray(columns) ? columns : typeof columns === "string" ? [columns] : [this.resolveColumn().name];
+		this.indexes.push({
+			columns: [...columnList],
+			name
+		});
+		return this;
+	}
+	/**
+	* Defines a foreign key relation for an existing column.
+	*
+	* @param column The local foreign key column name.
+	* @returns A fluent foreign key builder.
+	*/
+	foreignKey(column) {
+		const entry = {
+			column,
+			referencesTable: "",
+			referencesColumn: "id"
+		};
+		this.foreignKeys.push(entry);
+		return new ForeignKeyBuilder(entry);
+	}
+	/**
+	* Defines a foreign key relation for a column, using a 
+	* conventional naming pattern.
+	* 
+	* @param column 
+	* @returns 
+	*/
+	foreign(column) {
+		const columnName = this.resolveColumn(column).name;
+		return this.foreignKey(column ?? columnName);
+	}
+	/**
+	* Returns a deep copy of the defined columns for the table.
+	* 
+	* @returns 
+	*/
+	getColumns() {
+		return this.columns.map((column) => ({
+			...column,
+			enumValues: column.enumValues ? [...column.enumValues] : void 0
+		}));
+	}
+	/**
+	* Returns a copy of the defined column names to be dropped from the table.
+	* 
+	* @returns 
+	*/
+	getDropColumns() {
+		return [...this.dropColumnNames];
+	}
+	/**
+	* Returns a deep copy of the defined indexes for the table.
+	* 
+	* @returns
+	*/
+	getIndexes() {
+		return this.indexes.map((index) => ({
+			...index,
+			columns: [...index.columns]
+		}));
+	}
+	/**
+	* Returns a deep copy of the defined foreign keys for the table.
+	*
+	* @returns
+	*/
+	getForeignKeys() {
+		return this.foreignKeys.map((foreignKey) => ({ ...foreignKey }));
+	}
+	/**
+	* Defines a column in the table with the given name.
+	* 
+	* @param name      The name of the column.
+	* @param type      The type of the column.
+	* @param options   Additional options for the column.
+	* @returns 
+	*/
+	column(name, type, options) {
+		this.columns.push({
+			name,
+			type,
+			enumName: options.enumName,
+			enumValues: options.enumValues ? [...options.enumValues] : void 0,
+			map: options.map,
+			nullable: options.nullable,
+			unique: options.unique,
+			primary: options.primary,
+			autoIncrement: options.autoIncrement,
+			after: options.after,
+			default: options.default,
+			updatedAt: options.updatedAt,
+			primaryKeyGeneration: options.primaryKeyGeneration
+		});
+		const column = this.columns[this.columns.length - 1];
+		column.primaryKeyGeneration = PrimaryKeyGenerationPlanner.plan(column);
+		this.latestColumnName = name;
+		return this;
+	}
+	/**
+	* Resolve a target column by name or fallback to the latest defined column.
+	* 
+	* @param columnName 
+	* @returns 
+	*/
+	resolveColumn(columnName) {
+		const targetName = columnName ?? this.latestColumnName;
+		if (!targetName) throw new Error("No column available for this operation.");
+		const column = this.columns.find((item) => item.name === targetName);
+		if (!column) throw new Error(`Column [${targetName}] was not found in the table definition.`);
+		return column;
+	}
+};
+
+//#endregion
+//#region src/database/SchemaBuilder.ts
+/**
+* The SchemaBuilder class provides methods for defining the operations to be 
+* performed in a migration, such as creating, altering, or dropping tables. 
+*
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var SchemaBuilder = class {
+	operations = [];
+	/**
+	* Defines a new table to be created in the migration.
+	* 
+	* @param table     The name of the table to create.
+	* @param callback  A callback function to define the table's columns and structure.
+	* @returns         The current SchemaBuilder instance for chaining.
+	*/
+	createTable(table, callback) {
+		const builder = new TableBuilder();
+		callback(builder);
+		this.operations.push({
+			type: "createTable",
+			table,
+			columns: builder.getColumns(),
+			indexes: builder.getIndexes(),
+			foreignKeys: builder.getForeignKeys()
+		});
+		return this;
+	}
+	/**
+	* Defines alterations to an existing table in the migration.
+	* 
+	* @param table     The name of the table to alter.
+	* @param callback  A callback function to define the alterations to the table's columns and structure.
+	* @returns         The current SchemaBuilder instance for chaining.
+	*/
+	alterTable(table, callback) {
+		const builder = new TableBuilder();
+		callback(builder);
+		this.operations.push({
+			type: "alterTable",
+			table,
+			addColumns: builder.getColumns(),
+			dropColumns: builder.getDropColumns(),
+			addIndexes: builder.getIndexes(),
+			addForeignKeys: builder.getForeignKeys()
+		});
+		return this;
+	}
+	/**
+	* Defines a table to be dropped in the migration.
+	* 
+	* @param table The name of the table to drop.
+	* @returns     The current SchemaBuilder instance for chaining.
+	*/
+	dropTable(table) {
+		this.operations.push({
+			type: "dropTable",
+			table
+		});
+		return this;
+	}
+	/**
+	* Returns a deep copy of the defined schema operations for the migration/
+	* 
+	* @returns An array of schema operations for the migration.
+	*/
+	getOperations() {
+		return this.operations.map((operation) => {
+			if (operation.type === "createTable") return {
+				...operation,
+				columns: operation.columns.map((column) => ({
+					...column,
+					enumValues: column.enumValues ? [...column.enumValues] : void 0
+				})),
+				indexes: operation.indexes.map((index) => ({
+					...index,
+					columns: [...index.columns]
+				})),
+				foreignKeys: operation.foreignKeys.map((foreignKey) => ({ ...foreignKey }))
+			};
+			if (operation.type === "alterTable") return {
+				...operation,
+				addColumns: operation.addColumns.map((column) => ({
+					...column,
+					enumValues: column.enumValues ? [...column.enumValues] : void 0
+				})),
+				dropColumns: [...operation.dropColumns],
+				addIndexes: operation.addIndexes.map((index) => ({
+					...index,
+					columns: [...index.columns]
+				})),
+				addForeignKeys: operation.addForeignKeys.map((foreignKey) => ({ ...foreignKey }))
+			};
+			return { ...operation };
+		});
+	}
+};
+
+//#endregion
+//#region src/helpers/migrations.ts
+const PRISMA_MODEL_REGEX = /model\s+(\w+)\s*\{[\s\S]*?\n\}/g;
+const PRISMA_ENUM_REGEX = /enum\s+(\w+)\s*\{[\s\S]*?\n\}/g;
+const PRISMA_ENUM_MEMBER_REGEX = /^[A-Za-z][A-Za-z0-9_]*$/;
+/**
+* Convert a table name to a PascalCase model name, with basic singularization.
+* 
+* @param tableName The name of the table to convert.
+* @returns The corresponding PascalCase model name.
+*/
+const toModelName = (tableName) => {
+	const normalized = tableName.replace(/[^a-zA-Z0-9]+/g, " ").trim();
+	const parts = (normalized.endsWith("s") && normalized.length > 1 ? normalized.slice(0, -1) : normalized).split(/\s+/g).filter(Boolean);
+	if (parts.length === 0) return "GeneratedModel";
+	return parts.map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+};
+/**
+* Escape special characters in a string for use in a regular expression.
+* 
+* @param value 
+* @returns 
+*/
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Convert a SchemaColumn definition to a Prisma field type string, including modifiers.
+* 
+* @param column 
+* @returns 
+*/
+const resolvePrismaType = (column) => {
+	if (column.type === "id") return "Int";
+	if (column.type === "enum") return resolveEnumName(column);
+	if (column.type === "uuid") return "String";
+	if (column.type === "string" || column.type === "text") return "String";
+	if (column.type === "integer") return "Int";
+	if (column.type === "bigInteger") return "BigInt";
+	if (column.type === "float") return "Float";
+	if (column.type === "boolean") return "Boolean";
+	if (column.type === "json") return "Json";
+	return "DateTime";
+};
+const resolveEnumName = (column) => {
+	if (column.type !== "enum") throw new ArkormException(`Column [${column.name}] is not an enum column.`);
+	if (column.enumName && column.enumName.trim().length > 0) return column.enumName.trim();
+	throw new ArkormException(`Enum column [${column.name}] must define an enum name.`);
+};
+/** 
+* Format a default value for inclusion in a Prisma schema field definition, based on its type.
+* 
+* @param value 
+* @returns 
+*/
+const formatDefaultValue = (value) => {
+	if (value == null) return void 0;
+	if (value === "now()") return "@default(now())";
+	if (typeof value === "string") return `@default("${value.replace(/"/g, "\\\"")}")`;
+	if (typeof value === "number" || typeof value === "bigint") return `@default(${value})`;
+	if (typeof value === "boolean") return `@default(${value ? "true" : "false"})`;
+};
+/**
+* Format a default value for an enum column as a Prisma @default attribute, validating that it is a non-empty string.
+* 
+* @param value 
+* @returns 
+*/
+const formatEnumDefaultValue = (value) => {
+	if (value == null) return void 0;
+	if (typeof value !== "string" || value.trim().length === 0) throw new ArkormException("Enum default values must be provided as non-empty strings.");
+	return `@default(${value.trim()})`;
+};
+/**
+* Normalize an enum value by ensuring it is a non-empty string and trimming whitespace.
+* 
+* @param value 
+* @returns 
+*/
+const normalizeEnumValue = (value) => {
+	if (typeof value !== "string" || value.trim().length === 0) throw new ArkormException("Enum values must be provided as non-empty strings.");
+	const normalized = value.trim();
+	if (!PRISMA_ENUM_MEMBER_REGEX.test(normalized)) throw new ArkormException(`Enum value [${normalized}] is not a valid Prisma enum member name.`);
+	return normalized;
+};
+/**
+* Extract the enum values from a Prisma enum block string.
+* 
+* @param block 
+* @returns 
+*/
+const extractEnumBlockValues = (block) => {
+	return block.split("\n").slice(1, -1).map((line) => line.trim()).filter(Boolean);
+};
+const validateEnumValues = (column, enumName, enumValues) => {
+	const normalizedValues = enumValues.map(normalizeEnumValue);
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of normalizedValues) {
+		if (seen.has(value)) throw new ArkormException(`Prisma enum [${enumName}] for column [${column.name}] contains duplicate value [${value}].`);
+		seen.add(value);
+	}
+	return normalizedValues;
+};
+/**
+* Validate that a default value for an enum column is included in the defined enum values.
+* 
+* @param column 
+* @param enumName 
+* @param enumValues 
+* @returns 
+*/
+const validateEnumDefaultValue = (column, enumName, enumValues) => {
+	if (column.default == null) return;
+	const normalizedDefault = normalizeEnumValue(column.default);
+	if (enumValues.includes(normalizedDefault)) return;
+	throw new ArkormException(`Enum default value [${normalizedDefault}] is not defined in Prisma enum [${enumName}] for column [${column.name}].`);
+};
+/**
+* Build a single line of a Prisma model field definition based on a SchemaColumn, including type and modifiers.
+* 
+* @param column 
+* @returns 
+*/
+const buildFieldLine = (column) => {
+	if (column.type === "id") {
+		const primary = column.primary === false ? "" : " @id";
+		const mapped = typeof column.map === "string" && column.map.trim().length > 0 ? ` @map("${column.map.replace(/"/g, "\\\"")}")` : "";
+		const configuredDefault = formatDefaultValue(column.default);
+		const shouldAutoIncrement = column.autoIncrement ?? column.primary !== false;
+		const defaultSuffix = configuredDefault ? ` ${configuredDefault}` : shouldAutoIncrement && primary ? " @default(autoincrement())" : "";
+		return `  ${column.name} Int${primary}${defaultSuffix}${mapped}`;
+	}
+	const scalar = resolvePrismaType(column);
+	const nullable = column.nullable ? "?" : "";
+	const unique = column.unique ? " @unique" : "";
+	const primary = column.primary ? " @id" : "";
+	const mapped = typeof column.map === "string" && column.map.trim().length > 0 ? ` @map("${column.map.replace(/"/g, "\\\"")}")` : "";
+	const updatedAt = column.updatedAt ? " @updatedAt" : "";
+	const defaultValue = column.type === "enum" ? formatEnumDefaultValue(column.default) : column.primaryKeyGeneration?.prismaDefault ?? formatDefaultValue(column.default);
+	const defaultSuffix = defaultValue ? ` ${defaultValue}` : "";
+	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.
+* 
+* @param operation The schema table create operation to convert.
+* @returns         The corresponding Prisma model 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}`;
+};
+/**
+* Find the Prisma model block in a schema string that corresponds to a given 
+* table name, using both explicit mapping and naming conventions.
+* 
+* @param schema 
+* @param table 
+* @returns 
+*/
+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 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.
+* 
+* @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 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);
+};
+/**
+* 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 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 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);
+};
+/**
+* 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 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(" ")}`);
+};
+/**
+* Generate a new migration file with a given name and options, including 
+* writing the file to disk if specified.
+* 
+* @param name 
+* @returns 
+*/
+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`;
+};
+/**
+* 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())}`;
+};
+/**
+* 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 toMigrationFileSlug = (name) => {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "migration";
+};
+/**
+* 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 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");
+};
+/**
+* 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 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
+	};
+};
+/**
+* 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();
+};
+const supportsDatabaseMigrationExecution = (adapter) => {
+	return typeof adapter?.executeSchemaOperations === "function";
+};
+const supportsDatabaseReset = (adapter) => {
+	return typeof adapter?.resetDatabase === "function";
+};
+const stripPrismaSchemaModelsAndEnums = (schema) => {
+	const stripped = schema.replace(PRISMA_MODEL_REGEX, "").replace(PRISMA_ENUM_REGEX, "").replace(/\n{3,}/g, "\n\n").trimEnd();
+	return stripped.length > 0 ? `${stripped}\n` : "";
+};
+const applyMigrationToDatabase = async (adapter, migration) => {
+	if (!supportsDatabaseMigrationExecution(adapter)) throw new ArkormException("The configured adapter does not support database-backed migration execution.");
+	const operations = await getMigrationPlan(migration, "up");
+	await adapter.executeSchemaOperations(operations);
+	return { operations };
+};
+const applyMigrationRollbackToDatabase = async (adapter, migration) => {
+	if (!supportsDatabaseMigrationExecution(adapter)) throw new ArkormException("The configured adapter does not support database-backed migration execution.");
+	const operations = await getMigrationPlan(migration, "down");
+	await adapter.executeSchemaOperations(operations);
+	return { operations };
+};
+/**
+* Apply the schema operations defined in a migration to a Prisma schema 
+* file, updating the file on disk if specified, and return the updated 
+* 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 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
+	};
+};
+/**
+* Apply the rollback (down) operations defined in a migration to a Prisma schema file.
+*
+* @param migration The migration class or instance to rollback.
+* @param options   Options for applying the rollback, including schema path and write flag.
+* @returns         A promise that resolves to an object containing the updated schema, schema path, and rollback operations applied.
+*/
+const applyMigrationRollbackToPrismaSchema = async (migration, options = {}) => {
+	const schemaPath = options.schemaPath ?? join(process.cwd(), "prisma", "schema.prisma");
+	if (!existsSync$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
+	};
+};
+/**
+* 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 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 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/column-mappings.ts
+let cachedColumnMappingsPath;
+let cachedColumnMappingsState;
+const resolvePersistedMetadataFeatures = (features) => {
+	return {
+		persistedColumnMappings: features?.persistedColumnMappings !== false,
+		persistedEnums: features?.persistedEnums !== false
+	};
+};
+const createEmptyPersistedColumnMappingsState = () => ({
+	version: 1,
+	tables: {}
+});
+const resolveColumnMappingsFilePath = (cwd, configuredPath) => {
+	if (configuredPath && configuredPath.trim().length > 0) return resolve(configuredPath);
+	return join(cwd, ".arkormx", "column-mappings.json");
+};
+const normalizePersistedEnumValues = (values) => {
+	if (!Array.isArray(values)) return [];
+	return values.filter((value) => typeof value === "string" && value.trim().length > 0);
+};
+const normalizeLegacyTableColumns = (columns) => {
+	return Object.entries(columns).reduce((mapped, [attribute, column]) => {
+		if (attribute.trim().length === 0) return mapped;
+		if (typeof column !== "string" || column.trim().length === 0) return mapped;
+		mapped[attribute] = column;
+		return mapped;
+	}, {});
+};
+const normalizePersistedTableMetadata = (table) => {
+	if (!table || typeof table !== "object" || Array.isArray(table)) return {
+		columns: {},
+		enums: {}
+	};
+	const candidate = table;
+	if (!(Object.prototype.hasOwnProperty.call(candidate, "columns") || Object.prototype.hasOwnProperty.call(candidate, "enums") || Object.prototype.hasOwnProperty.call(candidate, "primaryKeyGeneration") || Object.prototype.hasOwnProperty.call(candidate, "timestampColumns"))) return {
+		columns: normalizeLegacyTableColumns(candidate),
+		enums: {}
+	};
+	return {
+		columns: normalizeLegacyTableColumns(candidate.columns ?? {}),
+		enums: Object.entries(candidate.enums ?? {}).reduce((all, [columnName, values]) => {
+			if (columnName.trim().length === 0) return all;
+			const normalizedValues = normalizePersistedEnumValues(values);
+			if (normalizedValues.length > 0) all[columnName] = normalizedValues;
+			return all;
+		}, {}),
+		primaryKeyGeneration: normalizePersistedPrimaryKeyGeneration(candidate.primaryKeyGeneration),
+		timestampColumns: normalizePersistedTimestampColumns(candidate.timestampColumns)
+	};
+};
+const normalizePersistedPrimaryKeyGeneration = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const candidate = value;
+	if (candidate.strategy !== "uuid" || typeof candidate.column !== "string" || candidate.column.trim().length === 0) return void 0;
+	return {
+		column: candidate.column,
+		strategy: "uuid",
+		prismaDefault: typeof candidate.prismaDefault === "string" && candidate.prismaDefault.trim().length > 0 ? candidate.prismaDefault : void 0,
+		databaseDefault: typeof candidate.databaseDefault === "string" && candidate.databaseDefault.trim().length > 0 ? candidate.databaseDefault : void 0,
+		runtimeFactory: candidate.runtimeFactory === "uuid" ? "uuid" : void 0
+	};
+};
+const normalizePersistedTimestampColumns = (value) => {
+	if (!Array.isArray(value)) return void 0;
+	const columns = value.reduce((all, entry) => {
+		if (!entry || typeof entry !== "object" || Array.isArray(entry)) return all;
+		const candidate = entry;
+		if (typeof candidate.column !== "string" || candidate.column.trim().length === 0) return all;
+		const normalized = { column: candidate.column };
+		if (candidate.default === "now()") normalized.default = "now()";
+		if (candidate.updatedAt === true) normalized.updatedAt = true;
+		if (!normalized.default && !normalized.updatedAt) return all;
+		all.push(normalized);
+		return all;
+	}, []);
+	return columns.length > 0 ? columns : void 0;
+};
+const normalizePersistedColumnMappingsState = (state) => {
+	return {
+		version: 1,
+		tables: Object.entries(state?.tables ?? {}).reduce((all, [tableName, tableMetadata]) => {
+			if (tableName.trim().length === 0) return all;
+			const normalized = normalizePersistedTableMetadata(tableMetadata);
+			if (Object.keys(normalized.columns).length > 0 || Object.keys(normalized.enums).length > 0 || normalized.primaryKeyGeneration || normalized.timestampColumns?.length) all[tableName] = normalized;
+			return all;
+		}, {})
+	};
+};
+const buildPersistedFeatureDisabledError = (feature, table) => {
+	return new ArkormException(`Table [${table}] requires ${feature === "persistedColumnMappings" ? "persisted column mappings" : "persisted enum metadata"}, but ${feature === "persistedColumnMappings" ? "features.persistedColumnMappings" : "features.persistedEnums"} is disabled in arkormx.config.*.`, {
+		operation: "metadata.persisted",
+		meta: {
+			feature,
+			table
+		}
+	});
+};
+const assertPersistedTableMetadataEnabled = (table, metadata, features, strict) => {
+	if (!strict) return;
+	if (!features.persistedColumnMappings && Object.keys(metadata.columns).length > 0) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+	if (!features.persistedEnums && Object.keys(metadata.enums).length > 0) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+};
+const buildEnumUnionType = (values) => {
+	return values.map((value) => {
+		return `'${value.replace(/'/g, String.raw`\'`)}'`;
+	}).join(" | ");
+};
+const resetPersistedColumnMappingsCache = () => {
+	cachedColumnMappingsPath = void 0;
+	cachedColumnMappingsState = void 0;
+};
+const readPersistedColumnMappingsState = (filePath) => {
+	if (cachedColumnMappingsPath === filePath && cachedColumnMappingsState) return cachedColumnMappingsState;
+	if (!existsSync$1(filePath)) {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+	try {
+		const normalized = normalizePersistedColumnMappingsState(JSON.parse(readFileSync$1(filePath, "utf-8")));
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = normalized;
+		return normalized;
+	} catch {
+		const empty = createEmptyPersistedColumnMappingsState();
+		cachedColumnMappingsPath = filePath;
+		cachedColumnMappingsState = empty;
+		return empty;
+	}
+};
+const writePersistedColumnMappingsState = (filePath, state) => {
+	const normalized = normalizePersistedColumnMappingsState(state);
+	const directory = dirname(filePath);
+	if (!existsSync$1(directory)) mkdirSync$1(directory, { recursive: true });
+	writeFileSync$1(filePath, JSON.stringify(normalized, null, 2));
+	cachedColumnMappingsPath = filePath;
+	cachedColumnMappingsState = normalized;
+};
+const deletePersistedColumnMappingsState = (filePath) => {
+	if (existsSync$1(filePath)) rmSync$1(filePath, { force: true });
+	resetPersistedColumnMappingsCache();
+};
+const getPersistedTableMetadata = (table, options = {}) => {
+	const metadata = readPersistedColumnMappingsState(resolveColumnMappingsFilePath(options.cwd ?? process.cwd(), options.configuredPath)).tables[table] ?? {
+		columns: {},
+		enums: {}
+	};
+	assertPersistedTableMetadataEnabled(table, metadata, options.features ?? resolvePersistedMetadataFeatures(), options.strict ?? false);
+	return {
+		columns: { ...metadata.columns },
+		enums: Object.entries(metadata.enums).reduce((all, [columnName, values]) => {
+			all[columnName] = [...values];
+			return all;
+		}, {}),
+		primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+		timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+	};
+};
+const getPersistedColumnMap = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).columns;
+};
+const getPersistedEnumMap = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).enums;
+};
+const getPersistedPrimaryKeyGeneration = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).primaryKeyGeneration;
+};
+const getPersistedTimestampColumns = (table, options = {}) => {
+	return getPersistedTableMetadata(table, options).timestampColumns ?? [];
+};
+const applyMappedColumn = (tableColumns, column, features, table) => {
+	if (typeof column.map === "string" && column.map.trim().length > 0 && column.map !== column.name) {
+		if (!features.persistedColumnMappings) throw buildPersistedFeatureDisabledError("persistedColumnMappings", table);
+		tableColumns[column.name] = column.map;
+		return;
+	}
+	delete tableColumns[column.name];
+};
+const applyEnumColumn = (tableEnums, column, features, table) => {
+	const values = column.enumValues ?? [];
+	if (column.type === "enum" && values.length > 0) {
+		if (!features.persistedEnums) throw buildPersistedFeatureDisabledError("persistedEnums", table);
+		tableEnums[column.name] = [...values];
+		return;
+	}
+	delete tableEnums[column.name];
+};
+const removePersistedColumnMetadata = (tableMetadata, columnName) => {
+	delete tableMetadata.columns[columnName];
+	delete tableMetadata.enums[columnName];
+	Object.entries(tableMetadata.columns).forEach(([attribute, mappedColumn]) => {
+		if (mappedColumn === columnName) delete tableMetadata.columns[attribute];
+	});
+	if (tableMetadata.primaryKeyGeneration?.column === columnName) delete tableMetadata.primaryKeyGeneration;
+	if (tableMetadata.timestampColumns) {
+		tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((column) => column.column !== columnName);
+		if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+	}
+};
+const applyPrimaryKeyGeneration = (tableMetadata, column) => {
+	if (!column.primary || !column.primaryKeyGeneration) {
+		if (tableMetadata.primaryKeyGeneration?.column === column.name) delete tableMetadata.primaryKeyGeneration;
+		return;
+	}
+	tableMetadata.primaryKeyGeneration = {
+		column: column.name,
+		...column.primaryKeyGeneration
+	};
+};
+const applyTimestampColumn = (tableMetadata, column) => {
+	if (column.type !== "timestamp" || column.default !== "now()" && column.updatedAt !== true) {
+		if (tableMetadata.timestampColumns) {
+			tableMetadata.timestampColumns = tableMetadata.timestampColumns.filter((entry) => entry.column !== column.name);
+			if (tableMetadata.timestampColumns.length === 0) delete tableMetadata.timestampColumns;
+		}
+		return;
+	}
+	const nextColumn = {
+		column: column.name,
+		...column.default === "now()" ? { default: "now()" } : {},
+		...column.updatedAt ? { updatedAt: true } : {}
+	};
+	tableMetadata.timestampColumns = [...(tableMetadata.timestampColumns ?? []).filter((entry) => entry.column !== column.name), nextColumn];
+};
+const applyOperationsToPersistedColumnMappingsState = (state, operations, features = resolvePersistedMetadataFeatures()) => {
+	const nextTables = Object.entries(state.tables).reduce((all, [table, metadata]) => {
+		all[table] = {
+			columns: { ...metadata.columns },
+			enums: Object.entries(metadata.enums).reduce((nextEnums, [columnName, values]) => {
+				nextEnums[columnName] = [...values];
+				return nextEnums;
+			}, {}),
+			primaryKeyGeneration: metadata.primaryKeyGeneration ? { ...metadata.primaryKeyGeneration } : void 0,
+			timestampColumns: metadata.timestampColumns?.map((column) => ({ ...column }))
+		};
+		return all;
+	}, {});
+	operations.forEach((operation) => {
+		if (operation.type === "createTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.columns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		if (operation.type === "alterTable") {
+			const tableMetadata = nextTables[operation.table] ?? {
+				columns: {},
+				enums: {}
+			};
+			operation.addColumns.forEach((column) => {
+				applyMappedColumn(tableMetadata.columns, column, features, operation.table);
+				applyEnumColumn(tableMetadata.enums, column, features, operation.table);
+				applyPrimaryKeyGeneration(tableMetadata, column);
+				applyTimestampColumn(tableMetadata, column);
+			});
+			operation.dropColumns.forEach((columnName) => {
+				removePersistedColumnMetadata(tableMetadata, columnName);
+			});
+			if (Object.keys(tableMetadata.columns).length > 0 || Object.keys(tableMetadata.enums).length > 0 || tableMetadata.primaryKeyGeneration || tableMetadata.timestampColumns?.length) nextTables[operation.table] = tableMetadata;
+			else delete nextTables[operation.table];
+			return;
+		}
+		delete nextTables[operation.table];
+	});
+	return {
+		version: 1,
+		tables: nextTables
+	};
+};
+const rebuildPersistedColumnMappingsState = async (state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const availableByIdentity = new Map(availableMigrations.map(([migrationClass, file]) => [buildMigrationIdentity(file, migrationClass.name), migrationClass]));
+	let nextState = createEmptyPersistedColumnMappingsState();
+	const orderedMigrations = state.migrations.map((migration, index) => ({
+		migration,
+		index
+	})).sort((left, right) => {
+		const appliedAtOrder = left.migration.appliedAt.localeCompare(right.migration.appliedAt);
+		if (appliedAtOrder !== 0) return appliedAtOrder;
+		return left.index - right.index;
+	});
+	for (const { migration } of orderedMigrations) {
+		const migrationClass = availableByIdentity.get(migration.id);
+		if (!migrationClass) throw new ArkormException(`Unable to rebuild persisted column mappings because migration [${migration.id}] could not be resolved from the current migration files.`, {
+			operation: "migration.columnMappings",
+			meta: {
+				migrationId: migration.id,
+				file: migration.file,
+				className: migration.className
+			}
+		});
+		const operations = await getMigrationPlan(migrationClass, "up");
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+	return nextState;
+};
+const syncPersistedColumnMappingsFromState = async (cwd, state, availableMigrations, features = resolvePersistedMetadataFeatures()) => {
+	const filePath = resolveColumnMappingsFilePath(cwd);
+	const nextState = await rebuildPersistedColumnMappingsState(state, availableMigrations, features);
+	if (Object.keys(nextState.tables).length === 0) {
+		deletePersistedColumnMappingsState(filePath);
+		return;
+	}
+	writePersistedColumnMappingsState(filePath, nextState);
+};
+const validatePersistedMetadataFeaturesForMigrations = async (migrations, features = resolvePersistedMetadataFeatures()) => {
+	let nextState = createEmptyPersistedColumnMappingsState();
+	for (const [migrationClass] of migrations) {
+		const operations = await getMigrationPlan(migrationClass, "up");
+		nextState = applyOperationsToPersistedColumnMappingsState(nextState, operations, features);
+	}
+};
+const getPersistedEnumTsType = (values) => {
+	return buildEnumUnionType(values);
+};
+
+//#endregion
+//#region src/helpers/runtime-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;
+	}
+	return path.join(process.cwd(), "stubs");
+};
+const baseConfig = {
+	naming: { modelTableCase: "snake" },
+	features: {
+		persistedColumnMappings: true,
+		persistedEnums: true
+	},
+	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,
+	naming: { ...baseConfig.naming ?? {} },
+	features: { ...baseConfig.features ?? {} },
+	paths: { ...baseConfig.paths ?? {} }
+};
+let runtimeConfigLoaded = false;
+let runtimeConfigLoadingPromise;
+let runtimeClientResolver;
+let runtimeAdapter;
+let runtimePaginationURLDriverFactory;
+let runtimePaginationCurrentPageResolver;
+let runtimeDebugHandler;
+const transactionClientStorage = new AsyncLocalStorage();
+const transactionAdapterStorage = new AsyncLocalStorage();
+const defaultDebugHandler = (event) => {
+	const prefix = `[arkorm:${event.adapter}] ${event.operation}${event.target ? ` [${event.target}]` : ""}`;
+	const payload = {
+		phase: event.phase,
+		durationMs: event.durationMs,
+		inspection: event.inspection ?? void 0,
+		meta: event.meta,
+		error: event.error
+	};
+	if (event.phase === "error") {
+		console.error(prefix, payload);
+		return;
+	}
+	console.debug(prefix, payload);
+};
+const resolveDebugHandler = (debug) => {
+	if (debug === true) return defaultDebugHandler;
+	return typeof debug === "function" ? debug : void 0;
+};
+const mergeNamingConfig = (naming) => {
+	const defaults = baseConfig.naming ?? {};
+	const current = userConfig.naming ?? {};
+	return {
+		...defaults,
+		...current,
+		...naming ?? {}
+	};
+};
+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
+	};
+};
+/**
+* Merge the feature configuration from the base defaults, user configuration, and provided options.
+* 
+* @param features 
+* @returns 
+*/
+const mergeFeatureConfig = (features) => {
+	const defaults = baseConfig.features ?? {};
+	const current = userConfig.features ?? {};
+	return {
+		...defaults,
+		...current,
+		...features ?? {}
+	};
+};
+/**
+* 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;
+};
+/**
+* Bind a database adapter instance to an array of models that support adapter binding.
+* 
+* @param adapter 
+* @param models 
+* @returns 
+*/
+const bindAdapterToModels = (adapter, models) => {
+	models.forEach((model) => {
+		model.setAdapter(adapter);
+	});
+	return adapter;
+};
+/**
+* Get the user-provided ArkORM configuration. 
+* 
+* @param key Optional specific configuration key to retrieve. If omitted, the entire configuration object is returned.
+* @returns The user-provided ArkORM configuration object.  
+*/
+const getUserConfig = (key) => {
+	if (key) return userConfig[key];
+	return userConfig;
+};
+/**
+* Configure the ArkORM runtime with the provided runtime client resolver and
+* adapter-first options.
+* 
+* @param client 
+* @param options
+*/
+const configureArkormRuntime = (client, options = {}) => {
+	const resolvedClient = client ?? options.client;
+	const nextConfig = {
+		...userConfig,
+		naming: mergeNamingConfig(options.naming),
+		features: mergeFeatureConfig(options.features),
+		paths: mergePathConfig(options.paths)
+	};
+	nextConfig.client = resolvedClient;
+	nextConfig.prisma = resolvedClient;
+	if (options.pagination !== void 0) nextConfig.pagination = options.pagination;
+	if (options.adapter !== void 0) nextConfig.adapter = options.adapter;
+	if (options.boot !== void 0) nextConfig.boot = options.boot;
+	if (options.debug !== void 0) nextConfig.debug = options.debug;
+	if (options.outputExt !== void 0) nextConfig.outputExt = options.outputExt;
+	Object.assign(userConfig, { ...nextConfig });
+	runtimeClientResolver = resolvedClient;
+	runtimeAdapter = options.adapter;
+	runtimePaginationURLDriverFactory = nextConfig.pagination?.urlDriver;
+	runtimePaginationCurrentPageResolver = nextConfig.pagination?.resolveCurrentPage;
+	runtimeDebugHandler = resolveDebugHandler(nextConfig.debug);
+	const bootClient = resolveClient(resolvedClient);
+	options.boot?.({
+		client: bootClient,
+		prisma: bootClient,
+		bindAdapter: bindAdapterToModels
+	});
+};
+/**
+* Reset the ArkORM runtime configuration. 
+* This is primarily intended for testing purposes.
+*/
+const resetArkormRuntimeForTests = () => {
+	Object.assign(userConfig, {
+		...baseConfig,
+		naming: { ...baseConfig.naming ?? {} },
+		features: { ...baseConfig.features ?? {} },
+		paths: { ...baseConfig.paths ?? {} }
+	});
+	runtimeConfigLoaded = false;
+	runtimeConfigLoadingPromise = void 0;
+	runtimeClientResolver = void 0;
+	runtimeAdapter = void 0;
+	runtimePaginationURLDriverFactory = void 0;
+	runtimePaginationCurrentPageResolver = void 0;
+	runtimeDebugHandler = void 0;
+	resetPersistedColumnMappingsCache();
+};
+/**
+* Resolve a runtime 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") return;
+	const runtimeClient = config.client ?? config.prisma;
+	configureArkormRuntime(runtimeClient, {
+		client: runtimeClient,
+		adapter: config.adapter,
+		boot: config.boot,
+		debug: config.debug,
+		naming: config.naming,
+		features: config.features,
+		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 compatibility client.
+* This function will trigger the loading of the ArkORM configuration if 
+* it hasn't already been loaded.
+* 
+* @returns 
+*/
+const getRuntimeClient = () => {
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionClient) return activeTransactionClient;
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return resolveClient(runtimeClientResolver);
+};
+/**
+* @deprecated Use getRuntimeClient instead.
+*/
+const getRuntimePrismaClient = getRuntimeClient;
+const getRuntimeAdapter = () => {
+	const activeTransactionAdapter = transactionAdapterStorage.getStore();
+	if (activeTransactionAdapter) return activeTransactionAdapter;
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimeAdapter;
+};
+const getActiveTransactionClient = () => {
+	return transactionClientStorage.getStore();
+};
+const getActiveTransactionAdapter = () => {
+	return transactionAdapterStorage.getStore();
+};
+const isTransactionCapableClient = (value) => {
+	if (!value || typeof value !== "object") return false;
+	return typeof value.$transaction === "function";
+};
+const runArkormTransaction = async (callback, options = {}, preferredAdapter) => {
+	const activeTransactionAdapter = transactionAdapterStorage.getStore();
+	const activeTransactionClient = transactionClientStorage.getStore();
+	if (activeTransactionAdapter || activeTransactionClient) return await callback({
+		adapter: activeTransactionAdapter,
+		client: activeTransactionClient
+	});
+	const adapter = preferredAdapter ?? getRuntimeAdapter();
+	if (adapter) return await adapter.transaction(async (transactionAdapter) => {
+		return await transactionAdapterStorage.run(transactionAdapter, async () => {
+			return await callback({
+				adapter: transactionAdapter,
+				client: transactionClientStorage.getStore()
+			});
+		});
+	}, options);
+	const client = getRuntimeClient();
+	if (!client) throw new ArkormException("Cannot start a transaction without a configured runtime client or adapter.", {
+		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({ client: 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;
+};
+const getRuntimeDebugHandler = () => {
+	if (!runtimeConfigLoaded) loadRuntimeConfigSync();
+	return runtimeDebugHandler;
+};
+const emitRuntimeDebugEvent = (event) => {
+	getRuntimeDebugHandler()?.(event);
+};
+/**
+* Check if a given value matches Arkorm's query-schema contract
+* by verifying the presence of common delegate methods.
+* 
+* @param value The value to check.
+* @returns True if the value matches the query-schema contract, false otherwise.
+*/
+const isQuerySchemaLike = (value) => {
+	if (!value || typeof value !== "object") return false;
+	const candidate = value;
+	return [
+		"findMany",
+		"findFirst",
+		"create",
+		"update",
+		"delete",
+		"count"
+	].every((method) => typeof candidate[method] === "function");
+};
+/**
+* @deprecated Use isQuerySchemaLike instead.
+*/
+const isDelegateLike = isQuerySchemaLike;
+loadArkormConfig();
+
+//#endregion
+//#region src/URLDriver.ts
+/**
+* URLDriver builds pagination URLs from paginator options.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var URLDriver = class URLDriver {
+	static DEFAULT_PAGE_NAME = "page";
+	path;
+	query;
+	fragment;
+	pageName;
+	constructor(options = {}) {
+		this.path = options.path ?? "/";
+		this.query = options.query ?? {};
+		this.fragment = options.fragment ?? "";
+		this.pageName = options.pageName ?? URLDriver.DEFAULT_PAGE_NAME;
+	}
+	getPageName() {
+		return this.pageName;
+	}
+	url(page) {
+		const targetPage = Math.max(1, page);
+		const [basePath, pathQuery = ""] = this.path.split("?");
+		const search = new URLSearchParams(pathQuery);
+		Object.entries(this.query).forEach(([key, value]) => {
+			if (value == null) {
+				search.delete(key);
+				return;
+			}
+			search.set(key, String(value));
+		});
+		search.set(this.pageName, String(targetPage));
+		const queryString = search.toString();
+		const normalizedFragment = this.fragment.replace(/^#/, "");
+		if (!queryString && !normalizedFragment) return basePath;
+		if (!normalizedFragment) return `${basePath}?${queryString}`;
+		if (!queryString) return `${basePath}#${normalizedFragment}`;
+		return `${basePath}?${queryString}#${normalizedFragment}`;
+	}
+};
+
+//#endregion
+//#region src/Paginator.ts
+/**
+* The LengthAwarePaginator class encapsulates paginated results with full
+* metadata including the total result count and last page.
+* 
+* @template T The type of the data being paginated.
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var LengthAwarePaginator = class {
+	data;
+	meta;
+	urlDriver;
+	/**
+	* Creates a new LengthAwarePaginator instance.
+	* 
+	* @param data          The collection of data being paginated.
+	* @param total         The total number of items.
+	* @param perPage       The number of items per page.
+	* @param currentPage   The current page number.
+	* @param options       URL generation options.
+	*/
+	constructor(data, total, perPage, currentPage, options = {}) {
+		const lastPage = Math.max(1, Math.ceil(total / perPage));
+		const from = total === 0 ? null : (currentPage - 1) * perPage + 1;
+		const to = total === 0 ? null : Math.min(currentPage * perPage, total);
+		this.data = data;
+		const urlDriverFactory = getRuntimePaginationURLDriverFactory();
+		this.urlDriver = urlDriverFactory ? urlDriverFactory(options) : new URLDriver(options);
+		this.meta = {
+			total,
+			perPage,
+			currentPage,
+			lastPage,
+			from,
+			to
+		};
+	}
+	getPageName() {
+		return this.urlDriver.getPageName();
+	}
+	url(page) {
+		return this.urlDriver.url(page);
+	}
+	nextPageUrl() {
+		if (this.meta.currentPage >= this.meta.lastPage) return null;
+		return this.url(this.meta.currentPage + 1);
+	}
+	previousPageUrl() {
+		if (this.meta.currentPage <= 1) return null;
+		return this.url(this.meta.currentPage - 1);
+	}
+	firstPageUrl() {
+		return this.url(1);
+	}
+	lastPageUrl() {
+		return this.url(this.meta.lastPage);
+	}
+	/**
+	* Converts the paginator instance to a JSON-serializable object.
+	* 
+	* @returns 
+	*/
+	toJSON() {
+		return {
+			data: this.data,
+			meta: this.meta,
+			links: {
+				first: this.firstPageUrl(),
+				last: this.lastPageUrl(),
+				prev: this.previousPageUrl(),
+				next: this.nextPageUrl()
+			}
+		};
+	}
+};
+/**
+* The Paginator class encapsulates simple pagination results without total count.
+*
+* @template T The type of the data being paginated.
+*/
+var Paginator = class {
+	data;
+	meta;
+	urlDriver;
+	/**
+	* Creates a new simple Paginator instance.
+	*
+	* @param data          The collection of data being paginated.
+	* @param perPage       The number of items per page.
+	* @param currentPage   The current page number.
+	* @param hasMorePages  Indicates whether additional pages exist.
+	* @param options       URL generation options.
+	*/
+	constructor(data, perPage, currentPage, hasMorePages, options = {}) {
+		const count = data.all().length;
+		const from = count === 0 ? null : (currentPage - 1) * perPage + 1;
+		const to = count === 0 ? null : (from ?? 1) + count - 1;
+		this.data = data;
+		const urlDriverFactory = getRuntimePaginationURLDriverFactory();
+		this.urlDriver = urlDriverFactory ? urlDriverFactory(options) : new URLDriver(options);
+		this.meta = {
+			perPage,
+			currentPage,
+			from,
+			to,
+			hasMorePages
+		};
+	}
+	getPageName() {
+		return this.urlDriver.getPageName();
+	}
+	url(page) {
+		return this.urlDriver.url(page);
+	}
+	nextPageUrl() {
+		if (!this.meta.hasMorePages) return null;
+		return this.url(this.meta.currentPage + 1);
+	}
+	previousPageUrl() {
+		if (this.meta.currentPage <= 1) return null;
+		return this.url(this.meta.currentPage - 1);
+	}
+	toJSON() {
+		return {
+			data: this.data,
+			meta: this.meta,
+			links: {
+				prev: this.previousPageUrl(),
+				next: this.nextPageUrl()
+			}
+		};
+	}
+};
+
+//#endregion
+//#region src/relationship/Relation.ts
+/**
+* Base class for all relationship types. Not meant to be used directly.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+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.
+	* 
+	* @param constraint The constraint function to apply to the query.
+	* @returns The current relation instance.
+	*/
+	constrain(constraint) {
+		if (!this.constraint) {
+			this.constraint = constraint;
+			return this;
+		}
+		const previousConstraint = this.constraint;
+		this.constraint = (query) => {
+			const constrained = previousConstraint(query) ?? query;
+			return constraint(constrained) ?? constrained;
+		};
+		return this;
+	}
+	/**
+	* Add a where clause to the relationship query.
+	*
+	* @param where
+	* @returns
+	*/
+	where(where) {
+		return this.constrain((query) => query.where(where));
+	}
+	/**
+	* Add a strongly-typed where key clause to the relationship query.
+	*
+	* @param key
+	* @param value
+	* @returns
+	*/
+	whereKey(key, value) {
+		return this.constrain((query) => query.whereKey(key, value));
+	}
+	/**
+	* Add a strongly-typed where in clause to the relationship query.
+	*
+	* @param key
+	* @param values
+	* @returns
+	*/
+	whereIn(key, values) {
+		return this.constrain((query) => query.whereIn(key, values));
+	}
+	/**
+	* Add a string contains clause to the relationship query.
+	*
+	* @param key
+	* @param value
+	* @returns
+	*/
+	whereLike(key, value) {
+		return this.constrain((query) => query.whereLike(key, value));
+	}
+	/**
+	* Add a string starts-with clause to the relationship query.
+	*
+	* @param key
+	* @param value
+	* @returns
+	*/
+	whereStartsWith(key, value) {
+		return this.constrain((query) => query.whereStartsWith(key, value));
+	}
+	/**
+	* Add a string ends-with clause to the relationship query.
+	*
+	* @param key
+	* @param value
+	* @returns
+	*/
+	whereEndsWith(key, value) {
+		return this.constrain((query) => query.whereEndsWith(key, value));
+	}
+	/**
+	* Add an order by clause to the relationship query.
+	*
+	* @param orderBy
+	* @returns
+	*/
+	orderBy(orderBy) {
+		return this.constrain((query) => query.orderBy(orderBy));
+	}
+	/**
+	* Add an include clause to the relationship query.
+	*
+	* @param include
+	* @returns
+	*/
+	include(include) {
+		return this.constrain((query) => query.include(include));
+	}
+	/**
+	* Add eager loading relations to the relationship query.
+	*
+	* @param relations
+	* @returns
+	*/
+	with(relations) {
+		return this.constrain((query) => query.with(relations));
+	}
+	/**
+	* Add a select clause to the relationship query.
+	*
+	* @param select
+	* @returns
+	*/
+	select(select) {
+		return this.constrain((query) => query.select(select));
+	}
+	/**
+	* Add a skip clause to the relationship query.
+	*
+	* @param skip
+	* @returns
+	*/
+	skip(skip) {
+		return this.constrain((query) => query.skip(skip));
+	}
+	/**
+	* Add a take clause to the relationship query.
+	*
+	* @param take
+	* @returns
+	*/
+	take(take) {
+		return this.constrain((query) => query.take(take));
+	}
+	/**
+	* Include soft-deleted records in the relationship query.
+	*
+	* @returns
+	*/
+	withTrashed() {
+		return this.constrain((query) => query.withTrashed());
+	}
+	/**
+	* Limit relationship query to only soft-deleted records.
+	*
+	* @returns
+	*/
+	onlyTrashed() {
+		return this.constrain((query) => query.onlyTrashed());
+	}
+	/**
+	* Exclude soft-deleted records from the relationship query.
+	*
+	* @returns
+	*/
+	withoutTrashed() {
+		return this.constrain((query) => query.withoutTrashed());
+	}
+	/**
+	* Apply a scope to the relationship query.
+	*
+	* @param name
+	* @param args
+	* @returns
+	*/
+	scope(name, ...args) {
+		return this.constrain((query) => query.scope(name, ...args));
+	}
+	/**
+	* Apply the defined constraint to the given query, if any.
+	* 
+	* @param query The query builder instance to apply the constraint to.
+	* 
+	* @returns The query builder instance with the constraint applied, if any.
+	*/
+	applyConstraint(query) {
+		if (!this.constraint) return query;
+		return this.constraint(query) ?? query;
+	}
+	/**
+	* Execute the relationship query and return relation results.
+	*
+	* @returns
+	*/
+	async get() {
+		return this.getResults();
+	}
+	/**
+	* Execute the relationship query and return the first related model.
+	*
+	* @returns
+	*/
+	async first() {
+		const results = await this.getResults();
+		if (results instanceof ArkormCollection) return results.all()[0] ?? null;
+		return results;
+	}
+	/**
+	* Count records that match the relationship query.
+	*
+	* @returns
+	*/
+	async count() {
+		return (await this.getQuery()).count();
+	}
+	/**
+	* Determine whether the relationship query has any matching records.
+	*
+	* @returns
+	*/
+	async exists() {
+		return (await this.getQuery()).exists();
+	}
+	/**
+	* Determine whether the relationship query has no matching records.
+	*
+	* @returns
+	*/
+	async doesntExist() {
+		return !await this.exists();
+	}
+};
+
+//#endregion
+//#region src/relationship/BelongsToManyRelation.ts
+/**
+* Defines a many-to-many relationship.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var BelongsToManyRelation = class BelongsToManyRelation extends Relation {
+	static queryDecorationMarker = Symbol("belongsToManyQueryDecoration");
+	pivotColumns = /* @__PURE__ */ new Set();
+	pivotAccessor = "pivot";
+	pivotCreatedAtColumn;
+	pivotUpdatedAtColumn;
+	pivotWhere;
+	pivotModel;
+	shouldAttachPivot = false;
+	constructor(parent, related, throughTable, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
+		super();
+		this.parent = parent;
+		this.related = related;
+		this.throughTable = throughTable;
+		this.foreignPivotKey = foreignPivotKey;
+		this.relatedPivotKey = relatedPivotKey;
+		this.parentKey = parentKey;
+		this.relatedKey = relatedKey;
+	}
+	/**
+	* Specifies additional pivot columns to include on the related models.
+	* 
+	* @param columns   The pivot columns to include on the related models. 
+	* @returns 
+	*/
+	withPivot(...columns) {
+		columns.flat().forEach((column) => {
+			if (typeof column !== "string" || column.trim().length === 0) return;
+			this.pivotColumns.add(column.trim());
+		});
+		this.shouldAttachPivot = true;
+		return this;
+	}
+	/**
+	* Specifies that the pivot table contains timestamp columns and optionally 
+	* allows customizing the names of those columns.
+	* 
+	* @param createdAtColumn    The name of the "created at" timestamp column.
+	* @param updatedAtColumn    The name of the "updated at" timestamp column.
+	* @returns                  The current instance of the relationship.
+	*/
+	withTimestamps(createdAtColumn = "createdAt", updatedAtColumn = "updatedAt") {
+		this.pivotCreatedAtColumn = createdAtColumn;
+		this.pivotUpdatedAtColumn = updatedAtColumn;
+		return this.withPivot(createdAtColumn, updatedAtColumn);
+	}
+	/**
+	* Specifies a custom accessor name for the pivot attributes on the related models. 
+	* By default, pivot attributes are accessible via the `pivot` property on the 
+	* related models.
+	* 
+	* @param accessor    The custom accessor name for the pivot attributes.
+	* @returns           The current instance of the relationship.
+	*/
+	as(accessor) {
+		const normalized = accessor.trim();
+		if (normalized.length === 0) return this;
+		this.pivotAccessor = normalized;
+		this.shouldAttachPivot = true;
+		return this;
+	}
+	/**
+	* Specifies a custom pivot model to use for the pivot records. The pivot model can 
+	* be used to define custom behavior or methods on the pivot records, as well as to 
+	* specify a custom hydration method for the pivot records.
+	* 
+	* @param pivotModel    The custom pivot model to use.
+	* @returns             The current instance of the relationship.
+	*/
+	using(pivotModel) {
+		this.pivotModel = pivotModel;
+		this.shouldAttachPivot = true;
+		return this;
+	}
+	wherePivot(column, operatorOrValue, value) {
+		const normalizedColumn = column.trim();
+		if (normalizedColumn.length === 0) return this;
+		if (arguments.length === 2) return this.addPivotWhere(this.makePivotComparison(normalizedColumn, "=", operatorOrValue));
+		return this.addPivotWhere(this.makePivotComparison(normalizedColumn, operatorOrValue, value));
+	}
+	/**
+	* Adds a "pivot column in" condition to the relationship query.
+	* 
+	* @param column 
+	* @param values 
+	* @returns 
+	*/
+	wherePivotNotIn(column, values) {
+		return this.addPivotWhere(this.makePivotComparison(column, "not-in", values));
+	}
+	/**
+	* Adds a "pivot column between" condition to the relationship query.
+	* 
+	* @param column 
+	* @param range 
+	* @returns 
+	*/
+	wherePivotBetween(column, range) {
+		return this.addPivotWhere({
+			type: "group",
+			operator: "and",
+			conditions: [this.makePivotComparison(column, ">=", range[0]), this.makePivotComparison(column, "<=", range[1])]
+		});
+	}
+	/**
+	* Adds a "pivot column not between" condition to the relationship query.
+	* 
+	* @param column 
+	* @param range 
+	* @returns 
+	*/
+	wherePivotNotBetween(column, range) {
+		return this.addPivotWhere({
+			type: "not",
+			condition: {
+				type: "group",
+				operator: "and",
+				conditions: [this.makePivotComparison(column, ">=", range[0]), this.makePivotComparison(column, "<=", range[1])]
+			}
+		});
+	}
+	/**
+	* Adds a "pivot column is null" condition to the relationship query.
+	* 
+	* @param column 
+	* @returns 
+	*/
+	wherePivotNull(column) {
+		return this.addPivotWhere(this.makePivotComparison(column, "is-null"));
+	}
+	/**
+	* Adds a "pivot column is not null" condition to the relationship query.
+	* 
+	* @param column 
+	* @returns 
+	*/
+	wherePivotNotNull(column) {
+		return this.addPivotWhere(this.makePivotComparison(column, "is-not-null"));
+	}
+	addPivotWhere(condition) {
+		if (!this.pivotWhere) {
+			this.pivotWhere = condition;
+			return this;
+		}
+		this.pivotWhere = {
+			type: "group",
+			operator: "and",
+			conditions: [this.pivotWhere, condition]
+		};
+		return this;
+	}
+	makePivotComparison(column, operator, value) {
+		const normalizedColumn = column.trim();
+		if (operator === "is-null" || operator === "is-not-null") return {
+			type: "comparison",
+			column: normalizedColumn,
+			operator
+		};
+		return {
+			type: "comparison",
+			column: normalizedColumn,
+			operator,
+			value
+		};
+	}
+	buildPivotWhere(parentValue) {
+		const baseCondition = {
+			type: "comparison",
+			column: this.foreignPivotKey,
+			operator: "=",
+			value: parentValue
+		};
+		if (!this.pivotWhere) return baseCondition;
+		return {
+			type: "group",
+			operator: "and",
+			conditions: [baseCondition, this.pivotWhere]
+		};
+	}
+	buildPivotTarget() {
+		return {
+			table: this.throughTable,
+			primaryKey: this.relatedPivotKey
+		};
+	}
+	buildRelatedPivotCondition(relatedValues) {
+		const normalizedValues = relatedValues.filter((value) => value != null);
+		if (normalizedValues.length === 0) return null;
+		if (normalizedValues.length === 1) return {
+			type: "comparison",
+			column: this.relatedPivotKey,
+			operator: "=",
+			value: normalizedValues[0]
+		};
+		return {
+			type: "comparison",
+			column: this.relatedPivotKey,
+			operator: "in",
+			value: normalizedValues
+		};
+	}
+	buildPivotMutationWhere(relatedValues = []) {
+		const baseCondition = this.buildPivotWhere(this.resolveParentPivotValue());
+		const relatedCondition = this.buildRelatedPivotCondition(relatedValues);
+		if (!relatedCondition) return baseCondition;
+		return {
+			type: "group",
+			operator: "and",
+			conditions: [baseCondition, relatedCondition]
+		};
+	}
+	normalizeIdentifierValue(value) {
+		if (typeof value === "string" && /^-?\d+$/.test(value)) return Number(value);
+		return value;
+	}
+	isPlainObject(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+	}
+	isModelLike(value) {
+		return this.isPlainObject(value) && typeof value.getAttribute === "function";
+	}
+	normalizeRelatedItems(related) {
+		return Array.isArray(related) ? related : [related];
+	}
+	normalizeSyncEntries(related, pivotAttributes = {}) {
+		if (Array.isArray(related)) return related.map((item) => ({
+			related: item,
+			attributes: { ...pivotAttributes }
+		}));
+		if (this.isPlainObject(related) && !this.isModelLike(related)) return Object.entries(related).map(([key, attributes]) => ({
+			related: this.normalizeIdentifierValue(key),
+			attributes: this.isPlainObject(attributes) ? attributes : {}
+		}));
+		return [{
+			related,
+			attributes: { ...pivotAttributes }
+		}];
+	}
+	resolveParentPivotValue() {
+		return this.parent.getAttribute(this.parentKey);
+	}
+	resolveRelatedPivotValue(related) {
+		if (related && typeof related === "object" && "getAttribute" in related) return related.getAttribute(this.relatedKey);
+		return related;
+	}
+	buildPivotInsertValues(related, attributes = {}) {
+		const values = {
+			...attributes,
+			[this.foreignPivotKey]: this.resolveParentPivotValue(),
+			[this.relatedPivotKey]: this.resolveRelatedPivotValue(related)
+		};
+		if (this.pivotCreatedAtColumn && !(this.pivotCreatedAtColumn in values)) values[this.pivotCreatedAtColumn] = /* @__PURE__ */ new Date();
+		if (this.pivotUpdatedAtColumn && !(this.pivotUpdatedAtColumn in values)) values[this.pivotUpdatedAtColumn] = /* @__PURE__ */ new Date();
+		return values;
+	}
+	attachPivotToSingleResult(related, pivotRow) {
+		if (!this.shouldAttachPivotAttributes()) return related;
+		related.setAttribute(this.pivotAccessor, this.createPivotRecord(pivotRow));
+		return related;
+	}
+	async insertPivotRow(values, adapter = this.getRelationAdapter()) {
+		await adapter.insert({
+			target: this.buildPivotTarget(),
+			values
+		});
+	}
+	async selectPivotRows(where, adapter = this.getRelationAdapter()) {
+		return await adapter.select({
+			target: this.buildPivotTarget(),
+			where
+		});
+	}
+	async deletePivotRows(where, adapter = this.getRelationAdapter()) {
+		if (typeof adapter.deleteMany === "function") return await adapter.deleteMany({
+			target: this.buildPivotTarget(),
+			where
+		});
+		const rows = await this.selectPivotRows(where, adapter);
+		await Promise.all(rows.map(async (row) => {
+			await adapter.delete({
+				target: this.buildPivotTarget(),
+				where: {
+					type: "group",
+					operator: "and",
+					conditions: Object.entries(row).map(([column, value]) => ({
+						type: "comparison",
+						column,
+						operator: "=",
+						value
+					}))
+				}
+			});
+		}));
+		return rows.length;
+	}
+	buildPivotUpdateValues(attributes = {}) {
+		const values = { ...attributes };
+		if (this.pivotUpdatedAtColumn && !(this.pivotUpdatedAtColumn in values)) values[this.pivotUpdatedAtColumn] = /* @__PURE__ */ new Date();
+		return values;
+	}
+	async updatePivotRows(related, attributes, adapter = this.getRelationAdapter()) {
+		const values = this.buildPivotUpdateValues(attributes);
+		if (Object.keys(values).length === 0) return 0;
+		const where = this.buildPivotMutationWhere([this.resolveRelatedPivotValue(related)]);
+		if (typeof adapter.updateMany === "function") return await adapter.updateMany({
+			target: this.buildPivotTarget(),
+			where,
+			values
+		});
+		const rows = await this.selectPivotRows(where, adapter);
+		await Promise.all(rows.map(async (row) => {
+			await adapter.update({
+				target: this.buildPivotTarget(),
+				where: {
+					type: "group",
+					operator: "and",
+					conditions: Object.entries(row).map(([column, value]) => ({
+						type: "comparison",
+						column,
+						operator: "=",
+						value
+					}))
+				},
+				values
+			});
+		}));
+		return rows.length;
+	}
+	/**
+	* Creates a new instance of the related model with the given attributes and attaches 
+	* pivot attributes if pivot attributes should be included.
+	* 
+	* @param attributes    The attributes to initialize the related model with.
+	* @returns             A new instance of the related model.
+	*/
+	make(attributes = {}) {
+		return this.related.hydrate(attributes);
+	}
+	/**
+	* Creates a new related model record with the given attributes, creates a pivot record 
+	* with the given pivot attributes, and attaches pivot attributes if pivot attributes 
+	* should be included.
+	* 
+	* @param attributes        The attributes to initialize the related model with.
+	* @param pivotAttributes   The attributes to initialize the pivot record with.
+	* @returns                 A new instance of the related model with pivot attributes attached.
+	*/
+	async create(attributes = {}, pivotAttributes = {}) {
+		const related = await this.related.query().create(attributes);
+		const pivotRow = this.buildPivotInsertValues(related, pivotAttributes);
+		await this.insertPivotRow(pivotRow);
+		return this.attachPivotToSingleResult(related, pivotRow);
+	}
+	/**
+	* Saves a related model record, creates a pivot record with the given pivot attributes 
+	* if the related model was not previously persisted, and attaches pivot attributes if 
+	* pivot attributes should be included.
+	* 
+	* @param related           The related model instance to save.
+	* @param pivotAttributes   The attributes to initialize the pivot record with.
+	* @returns                 A new instance of the related model with pivot attributes attached.
+	*/
+	async save(related, pivotAttributes = {}) {
+		const saveable = related;
+		let persisted = related;
+		if (typeof saveable.save === "function") try {
+			persisted = await saveable.save();
+		} catch (error) {
+			if (!(typeof error === "object" && error !== null && "code" in error && error.code === "MODEL_NOT_FOUND")) throw error;
+			const attributes = typeof saveable.getRawAttributes === "function" ? saveable.getRawAttributes() : {};
+			persisted = await this.related.query().create(attributes);
+		}
+		const pivotRow = this.buildPivotInsertValues(persisted, pivotAttributes);
+		await this.insertPivotRow(pivotRow);
+		return this.attachPivotToSingleResult(persisted, pivotRow);
+	}
+	/**
+	* Attaches one or more related model records to the parent model by creating pivot 
+	* records with the given pivot attributes if pivot attributes should be included.
+	* 
+	* @param related           The related model instance(s) to attach.
+	* @param pivotAttributes   The attributes to initialize the pivot record with.
+	* @returns                 The number of related model records attached.
+	*/
+	async attach(related, pivotAttributes = {}) {
+		const items = Array.isArray(related) ? related : [related];
+		await Promise.all(items.map(async (item) => {
+			await this.insertPivotRow(this.buildPivotInsertValues(item, pivotAttributes));
+		}));
+		return items.length;
+	}
+	/**
+	* Detaches one or more related model records from the parent model by deleting
+	* matching pivot rows. When no related value is provided, all matching pivot rows
+	* for the parent are removed.
+	*
+	* @param related
+	* @returns
+	*/
+	async detach(related) {
+		const where = related === void 0 ? this.buildPivotWhere(this.resolveParentPivotValue()) : this.buildPivotMutationWhere(this.normalizeRelatedItems(related).map((item) => this.resolveRelatedPivotValue(item)));
+		return await this.deletePivotRows(where);
+	}
+	/**
+	* Synchronizes the pivot table so only the provided related values remain attached.
+	* Existing matching rows can receive updated pivot attributes during the operation.
+	*
+	* @param related
+	* @param pivotAttributes
+	* @returns
+	*/
+	async sync(related, pivotAttributes = {}) {
+		return await this.getRelationAdapter().transaction(async (transaction) => {
+			const existingRows = await this.selectPivotRows(this.buildPivotWhere(this.resolveParentPivotValue()), transaction);
+			const desiredEntries = /* @__PURE__ */ new Map();
+			this.normalizeSyncEntries(related, pivotAttributes).forEach((entry) => {
+				const relatedValue = this.resolveRelatedPivotValue(entry.related);
+				if (relatedValue == null) return;
+				desiredEntries.set(String(relatedValue), {
+					related: relatedValue,
+					attributes: entry.attributes
+				});
+			});
+			let detached = 0;
+			let attached = 0;
+			let updated = 0;
+			const existingKeys = /* @__PURE__ */ new Set();
+			for (const row of existingRows) {
+				const relatedValue = row[this.relatedPivotKey];
+				if (relatedValue == null) continue;
+				const relatedKey = String(relatedValue);
+				existingKeys.add(relatedKey);
+				if (!desiredEntries.has(relatedKey)) detached += await this.deletePivotRows(this.buildPivotMutationWhere([relatedValue]), transaction);
+			}
+			for (const [relatedKey, entry] of desiredEntries) {
+				if (!existingKeys.has(relatedKey)) {
+					await this.insertPivotRow(this.buildPivotInsertValues(entry.related, entry.attributes), transaction);
+					attached += 1;
+					continue;
+				}
+				if (Object.keys(entry.attributes).length === 0) continue;
+				updated += await this.updatePivotRows(entry.related, entry.attributes, transaction);
+			}
+			return {
+				attached,
+				detached,
+				updated
+			};
+		});
+	}
+	shouldAttachPivotAttributes() {
+		return this.shouldAttachPivot || this.pivotColumns.size > 0 || Boolean(this.pivotCreatedAtColumn) || Boolean(this.pivotUpdatedAtColumn) || Boolean(this.pivotModel);
+	}
+	getPivotColumnSelection() {
+		return [
+			this.foreignPivotKey,
+			this.relatedPivotKey,
+			...this.pivotColumns
+		].filter((column, index, all) => all.indexOf(column) === index);
+	}
+	/**
+	* Creates a pivot record from a row of data.
+	* 
+	* @param row   The row of data containing pivot attributes.
+	* @returns     The pivot record.
+	*/
+	createPivotRecord(row) {
+		const attributes = this.getPivotColumnSelection().reduce((all, column) => {
+			all[column] = row[column];
+			return all;
+		}, {});
+		if (!this.pivotModel) return attributes;
+		if (typeof this.pivotModel.hydrate === "function") return this.pivotModel.hydrate(attributes);
+		return new this.pivotModel(attributes);
+	}
+	/**
+	* Attaches pivot attributes to the related models if pivot attributes should be included.
+	* 
+	* @param results 
+	* @param pivotRows 
+	* @returns 
+	*/
+	attachPivotToResults(results, pivotRows) {
+		if (!this.shouldAttachPivotAttributes()) return results;
+		const pivotByRelatedKey = /* @__PURE__ */ new Map();
+		pivotRows.forEach((row) => {
+			const relatedValue = row[this.relatedPivotKey];
+			if (relatedValue == null) return;
+			pivotByRelatedKey.set(String(relatedValue), row);
+		});
+		results.all().forEach((related) => {
+			const model = related;
+			const relatedValue = model.getAttribute(this.relatedKey);
+			if (relatedValue == null) return;
+			const pivotRow = pivotByRelatedKey.get(String(relatedValue));
+			if (!pivotRow) return;
+			model.setAttribute(this.pivotAccessor, this.createPivotRecord(pivotRow));
+		});
+		return results;
+	}
+	attachPivotToModel(model, pivotRows) {
+		if (!model) return model;
+		return this.attachPivotToResults(new ArkormCollection([model]), pivotRows).all()[0] ?? null;
+	}
+	decorateQueryBuilder(query, pivotRows) {
+		const decorated = query;
+		if (decorated[BelongsToManyRelation.queryDecorationMarker]) return query;
+		const originalGet = query.get.bind(query);
+		const originalFirst = query.first.bind(query);
+		const originalPaginate = query.paginate.bind(query);
+		const originalSimplePaginate = query.simplePaginate.bind(query);
+		const originalClone = query.clone.bind(query);
+		decorated.get = (async () => {
+			const results = await originalGet();
+			return this.attachPivotToResults(results, pivotRows);
+		});
+		decorated.first = (async () => {
+			const result = await originalFirst();
+			return this.attachPivotToModel(result, pivotRows);
+		});
+		decorated.paginate = (async (perPage = 15, page, options = {}) => {
+			const paginator = await originalPaginate(perPage, page, options);
+			return new LengthAwarePaginator(this.attachPivotToResults(paginator.data, pivotRows), paginator.meta.total, paginator.meta.perPage, paginator.meta.currentPage, options);
+		});
+		decorated.simplePaginate = (async (perPage = 15, page, options = {}) => {
+			const paginator = await originalSimplePaginate(perPage, page, options);
+			return new Paginator(this.attachPivotToResults(paginator.data, pivotRows), paginator.meta.perPage, paginator.meta.currentPage, paginator.meta.hasMorePages, options);
+		});
+		decorated.clone = (() => {
+			return this.decorateQueryBuilder(originalClone(), pivotRows);
+		});
+		decorated[BelongsToManyRelation.queryDecorationMarker] = true;
+		return query;
+	}
+	async loadPivotRowsForParent() {
+		const parentValue = this.resolveParentPivotValue();
+		return await this.createRelationTableLoader().selectRows({
+			table: this.throughTable,
+			where: this.buildPivotWhere(parentValue),
+			columns: this.getPivotColumnSelection().map((column) => ({ column }))
+		});
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const pivotRows = await this.loadPivotRowsForParent();
+		const ids = pivotRows.map((row) => row[this.relatedPivotKey]);
+		return this.decorateQueryBuilder(this.applyConstraint(this.related.query().where({ [this.relatedKey]: { in: ids } })), pivotRows);
+	}
+	getMetadata() {
+		const shouldAttachPivot = this.shouldAttachPivotAttributes();
+		return {
+			type: "belongsToMany",
+			relatedModel: this.related,
+			throughTable: this.throughTable,
+			foreignPivotKey: this.foreignPivotKey,
+			relatedPivotKey: this.relatedPivotKey,
+			parentKey: this.parentKey,
+			relatedKey: this.relatedKey,
+			pivotAccessor: shouldAttachPivot ? this.pivotAccessor : void 0,
+			pivotColumns: [...this.pivotColumns],
+			pivotCreatedAtColumn: this.pivotCreatedAtColumn,
+			pivotUpdatedAtColumn: this.pivotUpdatedAtColumn,
+			pivotWhere: this.pivotWhere,
+			pivotModel: this.pivotModel
+		};
+	}
+	/**
+	* Fetches the related models for this relationship.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return (await this.getQuery()).get();
+	}
+};
+
+//#endregion
+//#region src/relationship/SingleResultRelation.ts
+/**
+* Base class for relationships that resolve to a single related model.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 1.3.0
+*/
+var SingleResultRelation = class extends Relation {
+	defaultValue;
+	constructor(parent, related) {
+		super();
+		this.parent = parent;
+		this.related = related;
+	}
+	/**
+	* Defines a default value to return when the relationship does not find a related model.
+	* 
+	* @param value     The default value or a callback that returns the default value.
+	* @returns         The current instance for method chaining.
+	*/
+	withDefault(value = {}) {
+		this.defaultValue = value;
+		return this;
+	}
+	resolveDefaultResult() {
+		if (typeof this.defaultValue === "undefined") return null;
+		const resolved = typeof this.defaultValue === "function" ? this.defaultValue(this.parent) : this.defaultValue;
+		if (resolved instanceof this.related) return resolved;
+		return this.related.hydrate(resolved);
+	}
+};
+
+//#endregion
+//#region src/relationship/BelongsToRelation.ts
+/**
+* Defines an inverse one-to-one or many relationship.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var BelongsToRelation = class extends SingleResultRelation {
+	constructor(parent, related, foreignKey, ownerKey) {
+		super(parent, related);
+		this.foreignKey = foreignKey;
+		this.ownerKey = ownerKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return await (await this.getQuery()).first() ?? this.resolveDefaultResult();
+	}
+};
+
+//#endregion
+//#region src/relationship/HasManyRelation.ts
+/**
+* Defines a one-to-many relationship.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var HasManyRelation = class extends Relation {
+	constructor(parent, related, foreignKey, localKey) {
+		super();
+		this.parent = parent;
+		this.related = related;
+		this.foreignKey = foreignKey;
+		this.localKey = localKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return (await this.getQuery()).get();
+	}
+};
+
+//#endregion
+//#region src/relationship/HasManyThroughRelation.ts
+/**
+* Defines a has-many-through relationship, which provides a convenient way to access 
+* distant relations via an intermediate relation. 
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var HasManyThroughRelation = class extends Relation {
+	constructor(parent, related, throughTable, firstKey, secondKey, localKey, secondLocalKey) {
+		super();
+		this.parent = parent;
+		this.related = related;
+		this.throughTable = throughTable;
+		this.firstKey = firstKey;
+		this.secondKey = secondKey;
+		this.localKey = localKey;
+		this.secondLocalKey = secondLocalKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const localValue = this.parent.getAttribute(this.localKey);
+		const keys = await this.createRelationTableLoader().selectColumnValues({
+			lookup: {
+				table: this.throughTable,
+				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.throughTable,
+			firstKey: this.firstKey,
+			secondKey: this.secondKey,
+			localKey: this.localKey,
+			secondLocalKey: this.secondLocalKey
+		};
+	}
+	/**
+	* Fetches the related models for this relationship.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return (await this.getQuery()).get();
+	}
+};
+
+//#endregion
+//#region src/relationship/HasOneRelation.ts
+/**
+* Represents a "has one" relationship between two models.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var HasOneRelation = class extends SingleResultRelation {
+	constructor(parent, related, foreignKey, localKey) {
+		super(parent, related);
+		this.foreignKey = foreignKey;
+		this.localKey = localKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return await (await this.getQuery()).first() ?? this.resolveDefaultResult();
+	}
+};
+
+//#endregion
+//#region src/relationship/HasOneThroughRelation.ts
+/**
+* Represents a "has one through" relationship, where the parent model is related 
+* to exactly one instance of the related model through an intermediate model.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var HasOneThroughRelation = class extends SingleResultRelation {
+	constructor(parent, related, throughTable, firstKey, secondKey, localKey, secondLocalKey) {
+		super(parent, related);
+		this.throughTable = throughTable;
+		this.firstKey = firstKey;
+		this.secondKey = secondKey;
+		this.localKey = localKey;
+		this.secondLocalKey = secondLocalKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const localValue = this.parent.getAttribute(this.localKey);
+		const intermediateKey = await this.createRelationTableLoader().selectColumnValue({
+			lookup: {
+				table: this.throughTable,
+				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.throughTable,
+			firstKey: this.firstKey,
+			secondKey: this.secondKey,
+			localKey: this.localKey,
+			secondLocalKey: this.secondLocalKey
+		};
+	}
+	/**
+	* Fetches the related models for this relationship.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return await (await this.getQuery()).first() ?? this.resolveDefaultResult();
+	}
+};
+
+//#endregion
+//#region src/relationship/MorphManyRelation.ts
+/**
+* Defines a polymorphic one-to-many relationship. 
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var MorphManyRelation = class extends Relation {
+	constructor(parent, related, morphName, localKey) {
+		super();
+		this.parent = parent;
+		this.related = related;
+		this.morphName = morphName;
+		this.localKey = localKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const id = this.parent.getAttribute(this.localKey);
+		const type = this.parent.constructor.name;
+		return this.applyConstraint(this.related.query().where({
+			[`${this.morphName}Id`]: id,
+			[`${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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return (await this.getQuery()).get();
+	}
+};
+
+//#endregion
+//#region src/relationship/MorphOneRelation.ts
+/**
+* Defines a polymorphic one-to-one relationship.
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var MorphOneRelation = class extends SingleResultRelation {
+	constructor(parent, related, morphName, localKey) {
+		super(parent, related);
+		this.morphName = morphName;
+		this.localKey = localKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const id = this.parent.getAttribute(this.localKey);
+		const type = this.parent.constructor.name;
+		return this.applyConstraint(this.related.query().where({
+			[`${this.morphName}Id`]: id,
+			[`${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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return await (await this.getQuery()).first() ?? this.resolveDefaultResult();
+	}
+};
+
+//#endregion
+//#region src/relationship/MorphToManyRelation.ts
+/**
+* Defines a polymorphic many-to-many relationship.  
+* 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var MorphToManyRelation = class extends Relation {
+	constructor(parent, related, throughTable, morphName, relatedPivotKey, parentKey, relatedKey) {
+		super();
+		this.parent = parent;
+		this.related = related;
+		this.throughTable = throughTable;
+		this.morphName = morphName;
+		this.relatedPivotKey = relatedPivotKey;
+		this.parentKey = parentKey;
+		this.relatedKey = relatedKey;
+	}
+	/**
+	* Build the relationship query.
+	*
+	* @returns
+	*/
+	async getQuery() {
+		const parentValue = this.parent.getAttribute(this.parentKey);
+		const morphType = this.parent.constructor.name;
+		const ids = await this.createRelationTableLoader().selectColumnValues({
+			lookup: {
+				table: this.throughTable,
+				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.throughTable,
+			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.
+	* 
+	* @returns 
+	*/
+	async getResults() {
+		return (await this.getQuery()).get();
+	}
+};
+
+//#endregion
+export { PRISMA_ENUM_MEMBER_REGEX as $, getLastMigrationRun as $t, isDelegateLike as A, getMigrationPlan as At, getPersistedEnumMap as B, toMigrationFileSlug as Bt, getRuntimeAdapter as C, escapeRegex as Ct, getRuntimePaginationURLDriverFactory as D, formatEnumDefaultValue as Dt, getRuntimePaginationCurrentPageResolver as E, formatDefaultValue as Et, runArkormTransaction as F, runMigrationWithPrisma as Ft, readPersistedColumnMappingsState as G, ForeignKeyBuilder as Gt, getPersistedPrimaryKeyGeneration as H, SchemaBuilder as Ht, applyOperationsToPersistedColumnMappingsState as I, runPrismaCommand as It, resolveColumnMappingsFilePath as J, buildMigrationRunId as Jt, rebuildPersistedColumnMappingsState as K, PrimaryKeyGenerationPlanner as Kt, createEmptyPersistedColumnMappingsState as L, stripPrismaSchemaModelsAndEnums as Lt, isTransactionCapableClient as M, resolveEnumName as Mt, loadArkormConfig as N, resolveMigrationClassName as Nt, getRuntimePrismaClient as O, formatRelationAction as Ot, resetArkormRuntimeForTests as P, resolvePrismaType as Pt, writePersistedColumnMappingsState as Q, findAppliedMigration as Qt, deletePersistedColumnMappingsState as R, supportsDatabaseMigrationExecution as Rt, getDefaultStubsPath as S, deriveSingularFieldName as St, getRuntimeDebugHandler as T, findModelBlock as Tt, getPersistedTableMetadata as U, EnumBuilder as Ut, getPersistedEnumTsType as V, toModelName as Vt, getPersistedTimestampColumns as W, TableBuilder as Wt, syncPersistedColumnMappingsFromState as X, createEmptyAppliedMigrationsState as Xt, resolvePersistedMetadataFeatures as Y, computeMigrationChecksum as Yt, validatePersistedMetadataFeaturesForMigrations as Z, deleteAppliedMigrationsStateFromStore as Zt, defineConfig as _, ArkormException as _n, createMigrationTimestamp as _t, HasOneRelation as a, readAppliedMigrationsStateFromStore as an, applyMigrationRollbackToDatabase as at, getActiveTransactionAdapter as b, deriveRelationAlias as bt, BelongsToRelation as c, supportsDatabaseMigrationState as cn, applyMigrationToPrismaSchema as ct, Relation as d, RuntimeModuleLoader as dn, buildFieldLine as dt, getLatestAppliedMigrations as en, PRISMA_ENUM_REGEX as et, LengthAwarePaginator as f, UnsupportedAdapterFeatureException as fn, buildIndexLine as ft, configureArkormRuntime as g, ArkormCollection as gn, buildRelationLine as gt, bindAdapterToModels as h, RelationResolutionException as hn, buildModelBlock as ht, HasOneThroughRelation as i, readAppliedMigrationsState as in, applyDropTableOperation as it, isQuerySchemaLike as j, pad as jt, getUserConfig as k, generateMigrationFile as kt, SingleResultRelation as l, writeAppliedMigrationsState as ln, applyOperationsToPrismaSchema as lt, URLDriver as m, RelationTableLoader as mn, buildMigrationSource as mt, MorphOneRelation as n, markMigrationApplied as nn, applyAlterTableOperation as nt, HasManyThroughRelation as o, removeAppliedMigration as on, applyMigrationRollbackToPrismaSchema as ot, Paginator as p, SetBasedEagerLoader as pn, buildInverseRelationLine as pt, resetPersistedColumnMappingsCache as q, buildMigrationIdentity as qt, MorphManyRelation as r, markMigrationRun as rn, applyCreateTableOperation as rt, HasManyRelation as s, resolveMigrationStateFilePath as sn, applyMigrationToDatabase as st, MorphToManyRelation as t, isMigrationApplied as tn, PRISMA_MODEL_REGEX as tt, BelongsToManyRelation as u, writeAppliedMigrationsStateToStore as un, buildEnumBlock as ut, emitRuntimeDebugEvent as v, deriveCollectionFieldName as vt, getRuntimeClient as w, findEnumBlock as wt, getActiveTransactionClient as x, deriveRelationFieldName as xt, ensureArkormConfigLoading as y, deriveInverseRelationAlias as yt, getPersistedColumnMap as z, supportsDatabaseReset as zt };