arkormx 2.4.4 → 2.4.6

package/dist/index.mjs

@@ -9,6 +9,7 @@ import { str } from "@h3ravel/support";
 import { sql } from "kysely";
 import { Logger } from "@h3ravel/shared";
 import { Command } from "@h3ravel/musket";
+import { AsyncLocalStorage } from "node:async_hooks";
 
 //#region src/Exceptions/QueryExecutionException.ts
 var QueryExecutionException = class extends ArkormException {
@@ -3528,6 +3529,9 @@ var Seeder = class Seeder {
 	static {
 		this[SEEDER_BRAND] = true;
 	}
+	static {
+		this.executionReport = new AsyncLocalStorage();
+	}
 	/**
 	* Runs one or more seeders.
 	* 
@@ -3537,6 +3541,19 @@ var Seeder = class Seeder {
 		await Seeder.runSeeders(...seeders);
 	}
 	/**
+	* Run seeders and return every seeder class executed, including nested calls.
+	* 
+	* @param seeders 
+	* @returns 
+	*/
+	static async runWithReport(...seeders) {
+		const report = [];
+		await this.executionReport.run(report, async () => {
+			await this.runSeeders(...seeders);
+		});
+		return report;
+	}
+	/**
 	* Converts a SeederInput into a Seeder instance. 
 	* 
 	* @param input     The SeederInput to convert.
@@ -3560,7 +3577,11 @@ var Seeder = class Seeder {
 			all.push(current);
 			return all;
 		}, []);
-		for (const seeder of queue) await this.toSeederInstance(seeder).run();
+		for (const seeder of queue) {
+			const instance = this.toSeederInstance(seeder);
+			this.executionReport.getStore()?.push(instance.constructor.name);
+			await instance.run();
+		}
 	}
 };
 
@@ -3593,9 +3614,10 @@ var SeedCommand = class extends Command {
 		if (seederDirs.length === 0 && getRegisteredSeeders().length === 0) return void this.error(`ERROR: Seeders directory not found: ${this.app.formatPathForLog(configuredSeedersDir)}`);
 		const classes = this.option("all") ? await this.loadAllSeeders(seederDirs) : await this.loadNamedSeeder(seederDirs, this.argument("name") ?? "DatabaseSeeder");
 		if (classes.length === 0) return void this.error("ERROR: No seeder classes found to run.");
-		for (const SeederClassItem of classes) await new SeederClassItem().run();
+		const executedSeeders = [];
+		for (const SeederClassItem of classes) executedSeeders.push(...await Seeder.runWithReport(new SeederClassItem()));
 		this.success("Database seeding completed");
-		classes.forEach((cls) => this.success(this.app.splitLogger("Seeded", cls.name)));
+		executedSeeders.forEach((name) => this.success(this.app.splitLogger("Seeded", name)));
 	}
 	/**
 	* Load all seeder classes from the specified directory.
@@ -3664,191 +3686,42 @@ var logo_default = String.raw`
 `;
 
 //#endregion
-//#region src/database/factories.ts
-/**
-* Base class for defining model factories. 
-* Not meant to be used directly.
-* 
-* @template TModel The type of model the factory creates.
-* @template TAttributes The type of attributes used to create the model.
-* @author Legacy (3m1n3nc3)
-* @since 0.1.0
-*/
-var ModelFactory = class ModelFactory {
-	constructor() {
-		this.amount = 1;
-		this.sequence = 0;
-		this.states = [];
-	}
-	/**
-	* Set the number of models to create.
-	* 
-	* @param amount 
-	* @returns 
-	*/
-	count(amount) {
-		this.amount = Math.max(1, Math.floor(amount));
-		return this;
-	}
-	/**
-	* Define a state transformation for the factory. 
-	* States are applied in the order they were defined.
-	* 
-	* @param resolver A function that takes the current attributes and sequence number, and returns the transformed attributes.
-	* @returns The factory instance for chaining.
-	*/
-	state(resolver) {
-		this.states.push(resolver);
-		return this;
-	}
-	/**
-	* Create a new model instance without saving it to the database.
-	* 
-	* @param overrides 
-	* @returns 
-	*/
-	make(overrides = {}) {
-		const attributes = this.buildAttributes(overrides);
-		return new this.model(attributes);
-	}
-	/**
-	* Create a new model instance from an async factory definition without
-	* saving it to the database.
-	*
-	* @param overrides
-	* @returns
-	*/
-	async makeAsync(overrides = {}) {
-		const attributes = await this.buildAttributesAsync(overrides);
-		return new this.model(attributes);
-	}
-	/**
-	* Create multiple model instances without saving them to the database.
-	* 
-	* @param amount 
-	* @param overrides 
-	* @returns 
-	*/
-	makeMany(amount = this.amount, overrides = {}) {
-		const total = Math.max(1, Math.floor(amount));
-		return Array.from({ length: total }, () => this.make(overrides));
-	}
-	/**
-	* Create multiple model instances from async factory definitions without
-	* saving them to the database.
-	*
-	* @param amount
-	* @param overrides
-	* @returns
-	*/
-	async makeManyAsync(amount = this.amount, overrides = {}) {
-		const total = Math.max(1, Math.floor(amount));
-		const models = [];
-		for (let index = 0; index < total; index++) models.push(await this.makeAsync(overrides));
-		return models;
-	}
-	/**
-	* Create a new model instance and save it to the database.
-	* 
-	* @param overrides 
-	* @returns 
-	*/
-	async create(overrides = {}) {
-		const model = await this.makeAsync(overrides);
-		if (typeof model.save !== "function") throw new Error("Factory model does not support save().");
-		return await model.save();
-	}
-	/**
-	* Create multiple model instances and save them to the database.
-	* 
-	* @param amount 
-	* @param overrides 
-	* @returns 
-	*/
-	async createMany(amount = this.amount, overrides = {}) {
-		const models = await this.makeManyAsync(amount, overrides);
-		return await Promise.all(models.map(async (model) => {
-			if (typeof model.save !== "function") throw new Error("Factory model does not support save().");
-			return await model.save();
-		}));
-	}
-	/**
-	* Build the attributes for a model instance, applying the factory 
-	* definition and any defined states, and merging in any overrides.
-	* 
-	* @param overrides 
-	* @returns 
-	*/
-	buildAttributes(overrides) {
-		const sequence = this.sequence;
-		this.sequence += 1;
-		let resolved = this.definition(sequence);
-		if (ModelFactory.isPromiseLike(resolved)) {
-			this.sequence = sequence;
-			throw new Error("This factory has an async definition. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
-		}
-		for (const state of this.states) {
-			resolved = state(resolved, sequence);
-			if (ModelFactory.isPromiseLike(resolved)) {
-				this.sequence = sequence;
-				throw new Error("This factory has an async state. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
-			}
-		}
-		return {
-			...resolved,
-			...overrides
-		};
-	}
-	/**
-	* Build attributes for async and sync factory definitions.
-	*
-	* @param overrides
-	* @returns
-	*/
-	async buildAttributesAsync(overrides) {
-		const sequence = this.sequence;
-		this.sequence += 1;
-		let resolved = await this.definition(sequence);
-		for (const state of this.states) resolved = await state(resolved, sequence);
-		return {
-			...resolved,
-			...overrides
-		};
-	}
-	static isPromiseLike(value) {
-		return typeof value?.then === "function";
-	}
+//#region src/helpers/runtime-compatibility.ts
+const isObjectLike = (value) => {
+	return Boolean(value) && typeof value === "object";
 };
-/**
-* A helper class for defining factories using an inline definition 
-* function, without needing to create a separate factory class.
-* 
-* @template TModel
-* @template TAttributes 
-* @author Legacy (3m1n3nc3)
-* @since 0.1.0
-*/
-var InlineFactory = class extends ModelFactory {
-	constructor(model, resolver) {
-		super();
-		this.resolver = resolver;
-		this.model = model;
-	}
-	definition(sequence) {
-		return this.resolver(sequence);
-	}
+const isCompatibilityClient = (value) => {
+	return Boolean(value) && typeof value === "object";
 };
-/**
-* Define a factory for a given model using an inline definition function.
-* 
-* @template TModel         The type of model the factory creates.
-* @template TAttributes    The type of attributes used to create the model.
-* @param model             The model constructor.
-* @param definition        The factory definition function.
-* @returns                 A new instance of the model factory.
-*/
-const defineFactory = (model, definition) => {
-	return new InlineFactory(model, definition);
+const getCompatibilitySources = (preferredClient) => {
+	const activeTransactionClient = getActiveTransactionClient();
+	const runtimeClient = getRuntimeClient();
+	return activeTransactionClient ? [
+		activeTransactionClient,
+		preferredClient,
+		runtimeClient
+	] : [preferredClient, runtimeClient];
+};
+const getRuntimeCompatibilityAdapter = (preferredClient) => {
+	const client = getCompatibilitySources(preferredClient).find((source) => isCompatibilityClient(source));
+	if (!client) return void 0;
+	return createPrismaCompatibilityAdapter(client);
+};
+const resolveRuntimeCompatibilityQuerySchema = (candidates, preferredClient) => {
+	return getCompatibilitySources(preferredClient).flatMap((source) => {
+		if (!isObjectLike(source)) return [];
+		return candidates.map((candidate) => source[candidate]);
+	}).find((candidate) => isQuerySchemaLike(candidate));
+};
+const resolveRuntimeCompatibilityQuerySchemaOrThrow = (key, candidates, modelName, preferredClient) => {
+	const resolved = resolveRuntimeCompatibilityQuerySchema(candidates, preferredClient);
+	if (!resolved) throw new MissingDelegateException(`Database delegate [${key}] is not configured.`, {
+		operation: "getDelegate",
+		model: modelName,
+		delegate: key,
+		meta: { candidates }
+	});
+	return resolved;
 };
 
 //#endregion
@@ -4757,6 +4630,11 @@ var QueryBuilder = class QueryBuilder {
 		const resolvedKey = key ?? this.model.getPrimaryKey();
 		return this.where({ [resolvedKey]: value }).first();
 	}
+	async findOrFail(value, key) {
+		const model = await this.find(value, key);
+		if (!model) throw new ModelNotFoundException(this.model.name, "Record not found.");
+		return model;
+	}
 	async findOr(value, keyOrCallback, maybeCallback) {
 		const key = typeof keyOrCallback === "string" ? keyOrCallback : this.model.getPrimaryKey();
 		const callback = typeof keyOrCallback === "function" ? keyOrCallback : maybeCallback;
@@ -6319,164 +6197,6 @@ var QueryBuilder = class QueryBuilder {
 	}
 };
 
-//#endregion
-//#region src/helpers/runtime-compatibility.ts
-const isObjectLike = (value) => {
-	return Boolean(value) && typeof value === "object";
-};
-const isCompatibilityClient = (value) => {
-	return Boolean(value) && typeof value === "object";
-};
-const getCompatibilitySources = (preferredClient) => {
-	const activeTransactionClient = getActiveTransactionClient();
-	const runtimeClient = getRuntimeClient();
-	return activeTransactionClient ? [
-		activeTransactionClient,
-		preferredClient,
-		runtimeClient
-	] : [preferredClient, runtimeClient];
-};
-const getRuntimeCompatibilityAdapter = (preferredClient) => {
-	const client = getCompatibilitySources(preferredClient).find((source) => isCompatibilityClient(source));
-	if (!client) return void 0;
-	return createPrismaCompatibilityAdapter(client);
-};
-const resolveRuntimeCompatibilityQuerySchema = (candidates, preferredClient) => {
-	return getCompatibilitySources(preferredClient).flatMap((source) => {
-		if (!isObjectLike(source)) return [];
-		return candidates.map((candidate) => source[candidate]);
-	}).find((candidate) => isQuerySchemaLike(candidate));
-};
-const resolveRuntimeCompatibilityQuerySchemaOrThrow = (key, candidates, modelName, preferredClient) => {
-	const resolved = resolveRuntimeCompatibilityQuerySchema(candidates, preferredClient);
-	if (!resolved) throw new MissingDelegateException(`Database delegate [${key}] is not configured.`, {
-		operation: "getDelegate",
-		model: modelName,
-		delegate: key,
-		meta: { candidates }
-	});
-	return resolved;
-};
-
-//#endregion
-//#region src/DB.ts
-const defaultSoftDeleteConfig = {
-	enabled: false,
-	column: "deletedAt"
-};
-var DB = class DB {
-	constructor(adapter) {
-		this.scopedAdapter = adapter;
-	}
-	static setAdapter(adapter) {
-		this.adapter = adapter;
-	}
-	static getAdapter() {
-		const runtimeAdapter = getRuntimeAdapter();
-		if (runtimeAdapter) return runtimeAdapter;
-		if (this.adapter) return this.adapter;
-		return getRuntimeCompatibilityAdapter();
-	}
-	getAdapter() {
-		return this.scopedAdapter ?? DB.getAdapter();
-	}
-	static table(table, options = {}) {
-		return new DB().table(table, options);
-	}
-	table(table, options = {}) {
-		return DB.createTableModel(table, options, this.getAdapter()).query();
-	}
-	static async raw(sql, bindings = []) {
-		return await new DB().raw(sql, bindings);
-	}
-	async raw(sql, bindings = []) {
-		const adapter = this.getAdapter();
-		if (!adapter) throw new ArkormException("Raw queries require a configured database adapter.", {
-			code: "ADAPTER_NOT_CONFIGURED",
-			operation: "db.raw"
-		});
-		if (!adapter.rawQuery) throw new UnsupportedAdapterFeatureException("Raw queries are not supported by the current adapter.", {
-			operation: "db.raw",
-			meta: { feature: "rawQuery" }
-		});
-		const rows = await adapter.rawQuery({
-			sql,
-			bindings
-		});
-		return ArkormCollection.make(rows);
-	}
-	static async transaction(callback, context) {
-		return await new DB().transaction(callback, context);
-	}
-	async transaction(callback, context) {
-		const adapter = this.getAdapter();
-		if (!adapter) throw new ArkormException("DB transactions require a configured database adapter.", {
-			code: "ADAPTER_NOT_CONFIGURED",
-			operation: "db.transaction"
-		});
-		return await adapter.transaction(async (transactionAdapter) => {
-			return await callback(new DB(transactionAdapter));
-		}, context);
-	}
-	static createTableModel(table, options, adapter) {
-		const primaryKey = options.primaryKey ?? "id";
-		const resolvedAdapter = options.adapter ?? adapter ?? DB.getAdapter();
-		const persistedMetadata = DB.resolvePersistedTableMetadata(table, options, resolvedAdapter);
-		const columns = {
-			...persistedMetadata.columns,
-			...options.columns ?? {}
-		};
-		const softDelete = options.softDelete ?? defaultSoftDeleteConfig;
-		const primaryKeyGeneration = options.primaryKeyGeneration ? { ...options.primaryKeyGeneration } : persistedMetadata.primaryKeyGeneration?.column === primaryKey ? {
-			strategy: persistedMetadata.primaryKeyGeneration.strategy,
-			prismaDefault: persistedMetadata.primaryKeyGeneration.prismaDefault,
-			databaseDefault: persistedMetadata.primaryKeyGeneration.databaseDefault,
-			runtimeFactory: persistedMetadata.primaryKeyGeneration.runtimeFactory
-		} : void 0;
-		const timestampColumns = options.timestampColumns?.map((column) => ({ ...column })) ?? persistedMetadata.timestampColumns?.map((column) => ({ ...column }));
-		const buildMetadata = () => {
-			return {
-				table,
-				primaryKey,
-				columns: { ...columns },
-				softDelete: { ...softDelete },
-				primaryKeyGeneration,
-				timestampColumns
-			};
-		};
-		const modelStatic = {
-			query: () => new QueryBuilder(modelStatic, modelStatic.getAdapter()),
-			hydrate: (attributes) => ({ ...attributes }),
-			hydrateMany: (attributes) => attributes.map((attribute) => ({ ...attribute })),
-			hydrateRetrieved: async (attributes) => ({ ...attributes }),
-			hydrateManyRetrieved: async (attributes) => attributes.map((attribute) => ({ ...attribute })),
-			getAdapter: () => resolvedAdapter,
-			getColumnMap: () => ({ ...columns }),
-			getColumnName: (attribute) => columns[attribute] ?? attribute,
-			getModelMetadata: () => buildMetadata(),
-			getPrimaryKey: () => primaryKey,
-			getRelationMetadata: () => null,
-			setAdapter: () => {},
-			getSoftDeleteConfig: () => ({ ...softDelete }),
-			getTable: () => table
-		};
-		return modelStatic;
-	}
-	static resolvePersistedTableMetadata(table, options, adapter) {
-		if (options.persistedMetadata === false) return {
-			columns: {},
-			enums: {}
-		};
-		const persistedMetadataOptions = typeof options.persistedMetadata === "object" ? options.persistedMetadata : {};
-		return getPersistedTableMetadata(table, {
-			cwd: persistedMetadataOptions.cwd,
-			configuredPath: persistedMetadataOptions.configuredPath,
-			features: resolvePersistedMetadataFeatures(getUserConfig("features")),
-			strict: persistedMetadataOptions.strict ?? (Boolean(adapter) && !(adapter instanceof PrismaDatabaseAdapter))
-		});
-	}
-};
-
 //#endregion
 //#region src/Model.ts
 /**
@@ -7719,6 +7439,552 @@ var Model = class Model {
 	}
 };
 
+//#endregion
+//#region src/database/factories.ts
+/**
+* Base class for defining model factories. 
+* Not meant to be used directly.
+* 
+* @template TModel The type of model the factory creates.
+* @template TAttributes The type of attributes used to create the model.
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var ModelFactory = class ModelFactory {
+	constructor() {
+		this.amount = 1;
+		this.sequence = 0;
+		this.states = [];
+		this.configured = false;
+		this.afterMakingCallbacks = [];
+		this.afterCreatingCallbacks = [];
+		this.hasRelations = [];
+		this.forRelations = [];
+		this.attachedRelations = [];
+		this.recyclePool = /* @__PURE__ */ new Map();
+		this.recycleOffsets = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Configure states and lifecycle callbacks for each new factory instance.
+	*/
+	configure() {}
+	/**
+	* Set the number of models to create.
+	* 
+	* @param amount 
+	* @returns 
+	*/
+	count(amount) {
+		this.ensureConfigured();
+		this.amount = Math.max(1, Math.floor(amount));
+		return this;
+	}
+	/**
+	* Define a state transformation for the factory. 
+	* States are applied in the order they were defined.
+	* 
+	* @param resolver A function that takes the current attributes and sequence number, and returns the transformed attributes.
+	* @returns The factory instance for chaining.
+	*/
+	state(resolver) {
+		this.ensureConfigured();
+		this.states.push(resolver);
+		return this;
+	}
+	/**
+	* Register a callback that runs after a model is made.
+	* 
+	* @param callback 
+	* @returns 
+	*/
+	afterMaking(callback) {
+		this.ensureConfigured();
+		this.afterMakingCallbacks.push(callback);
+		return this;
+	}
+	/**
+	* Register a callback that runs after a model is persisted.
+	* 
+	* @param callback 
+	* @returns 
+	*/
+	afterCreating(callback) {
+		this.ensureConfigured();
+		this.afterCreatingCallbacks.push(callback);
+		return this;
+	}
+	/**
+	* Create a new model instance without saving it to the database.
+	* 
+	* @param overrides 
+	* @returns 
+	*/
+	make(overrides = {}) {
+		this.ensureConfigured();
+		const attributes = this.buildAttributes(overrides);
+		const model = new this.model(attributes);
+		this.runCallbacksSync(this.afterMakingCallbacks, model, "afterMaking");
+		return model;
+	}
+	/**
+	* Create a new model instance from an async factory definition without
+	* saving it to the database.
+	*
+	* @param overrides
+	* @returns
+	*/
+	async makeAsync(overrides = {}) {
+		this.ensureConfigured();
+		const attributes = await this.buildAttributesAsync(overrides);
+		const model = new this.model(attributes);
+		await this.runCallbacks(this.afterMakingCallbacks, model);
+		return model;
+	}
+	/**
+	* Create multiple model instances without saving them to the database.
+	* 
+	* @param amount 
+	* @param overrides 
+	* @returns 
+	*/
+	makeMany(amount = this.amount, overrides = {}) {
+		const total = Math.max(1, Math.floor(amount));
+		return Array.from({ length: total }, () => this.make(overrides));
+	}
+	/**
+	* Create multiple model instances from async factory definitions without
+	* saving them to the database.
+	*
+	* @param amount
+	* @param overrides
+	* @returns
+	*/
+	async makeManyAsync(amount = this.amount, overrides = {}) {
+		const total = Math.max(1, Math.floor(amount));
+		const models = [];
+		for (let index = 0; index < total; index++) models.push(await this.makeAsync(overrides));
+		return models;
+	}
+	/**
+	* Create a new model instance and save it to the database.
+	* 
+	* @param overrides 
+	* @returns 
+	*/
+	async create(overrides = {}) {
+		return await this.createPersisted(overrides);
+	}
+	/**
+	* Create multiple model instances and save them to the database.
+	* 
+	* @param amount 
+	* @param overrides 
+	* @returns 
+	*/
+	async createMany(amount = this.amount, overrides = {}) {
+		this.ensureConfigured();
+		const total = Math.max(1, Math.floor(amount));
+		const models = [];
+		for (let index = 0; index < total; index++) models.push(await this.create(overrides));
+		return models;
+	}
+	/**
+	* Create related models through a has-one or has-many relationship.
+	* 
+	* @param factory 
+	* @param relationship 
+	* @returns 
+	*/
+	has(factory, relationship) {
+		this.ensureConfigured();
+		this.hasRelations.push({
+			factory,
+			relationship
+		});
+		return this;
+	}
+	/**
+	* Associate the created model with a parent model or factory.
+	* 
+	* @param related 
+	* @param relationship 
+	* @returns 
+	*/
+	for(related, relationship) {
+		this.ensureConfigured();
+		this.forRelations.push({
+			related,
+			relationship
+		});
+		return this;
+	}
+	/**
+	* Create or reuse related models and attach them through a many-to-many relationship.
+	* 
+	* @param related 
+	* @param pivot 
+	* @param relationship 
+	* @returns 
+	*/
+	hasAttached(related, pivot = {}, relationship) {
+		this.ensureConfigured();
+		this.attachedRelations.push({
+			related,
+			pivot,
+			relationship
+		});
+		return this;
+	}
+	/**
+	* Reuse existing models when resolving factory-backed relationships.
+	* 
+	* @param models 
+	* @returns 
+	*/
+	recycle(models) {
+		this.ensureConfigured();
+		(Array.isArray(models) ? models : "all" in models ? models.all() : [models]).forEach((model) => {
+			const constructor = model.constructor;
+			const existing = this.recyclePool.get(constructor) ?? [];
+			if (!existing.includes(model)) existing.push(model);
+			this.recyclePool.set(constructor, existing);
+		});
+		return this;
+	}
+	/**
+	* Get the model contgructor
+	* 
+	* @returns 
+	*/
+	getModelConstructor() {
+		return this.model;
+	}
+	/**
+	* Build the attributes for a model instance, applying the factory 
+	* definition and any defined states, and merging in any overrides.
+	* 
+	* @param overrides 
+	* @returns 
+	*/
+	buildAttributes(overrides) {
+		const sequence = this.sequence;
+		this.sequence += 1;
+		let resolved = this.definition(sequence);
+		if (ModelFactory.isPromiseLike(resolved)) {
+			this.sequence = sequence;
+			throw new Error("This factory has an async definition. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
+		}
+		for (const state of this.states) {
+			resolved = state(resolved, sequence);
+			if (ModelFactory.isPromiseLike(resolved)) {
+				this.sequence = sequence;
+				throw new Error("This factory has an async state. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
+			}
+		}
+		const attributes = {
+			...resolved,
+			...overrides
+		};
+		return this.resolveAttributesSync(this.applyBelongsToRelationshipsSync(attributes));
+	}
+	/**
+	* Build attributes for async and sync factory definitions.
+	*
+	* @param overrides
+	* @returns
+	*/
+	async buildAttributesAsync(overrides) {
+		const sequence = this.sequence;
+		this.sequence += 1;
+		let resolved = await this.definition(sequence);
+		for (const state of this.states) resolved = await state(resolved, sequence);
+		const attributes = {
+			...resolved,
+			...overrides
+		};
+		return await this.resolveAttributesAsync(await this.applyBelongsToRelationships(attributes));
+	}
+	ensureConfigured() {
+		if (this.configured) return;
+		this.configured = true;
+		this.configure();
+	}
+	resolveAttributesSync(attributes) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(attributes)) {
+			if (ModelFactory.isFactory(value)) throw new Error("This factory definition creates a related model. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
+			const next = typeof value === "function" ? value(resolved) : value;
+			if (ModelFactory.isPromiseLike(next)) throw new Error("This factory has an async attribute resolver. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
+			resolved[key] = next;
+		}
+		return resolved;
+	}
+	async resolveAttributesAsync(attributes) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(attributes)) {
+			if (ModelFactory.isFactory(value)) {
+				resolved[key] = await this.resolveFactoryKey(value);
+				continue;
+			}
+			resolved[key] = typeof value === "function" ? await value(resolved) : value;
+		}
+		return resolved;
+	}
+	applyBelongsToRelationshipsSync(attributes) {
+		return this.forRelations.reduce((resolved, relation) => {
+			if (relation.related instanceof Model) return this.mergeBelongsToAttribute(resolved, relation.related, relation.relationship);
+			throw new Error("This factory creates a parent model. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.");
+		}, attributes);
+	}
+	async applyBelongsToRelationships(attributes) {
+		let resolved = attributes;
+		for (const relation of this.forRelations) {
+			const related = relation.related instanceof Model ? relation.related : await this.resolveFactoryModel(relation.related);
+			resolved = this.mergeBelongsToAttribute(resolved, related, relation.relationship);
+		}
+		return resolved;
+	}
+	mergeBelongsToAttribute(attributes, related, relationship) {
+		const relationName = relationship ?? `${str(related.constructor.name).camel().singular()}`;
+		const metadata = this.model.getRelationMetadata?.(relationName);
+		if (metadata?.type !== "belongsTo" || !metadata.foreignKey || !metadata.ownerKey) throw new Error(`Factory relationship [${relationName}] is not a belongsTo relation on [${this.model.name}].`);
+		return {
+			...attributes,
+			[metadata.foreignKey]: related.getAttribute(metadata.ownerKey)
+		};
+	}
+	async createPersisted(overrides, persist) {
+		const model = await this.makeAsync(overrides);
+		const persisted = persist ? await persist(model) : await this.saveModel(model);
+		await this.createHasRelations(persisted);
+		await this.createAttachedRelations(persisted);
+		await this.runCallbacks(this.afterCreatingCallbacks, persisted);
+		return persisted;
+	}
+	async saveModel(model) {
+		const saveable = model;
+		const constructor = model?.constructor;
+		const primaryKey = constructor.getPrimaryKey?.() ?? "id";
+		if (saveable.getAttribute?.(primaryKey) != null && constructor.query && saveable.getRawAttributes) return await constructor.query().create(saveable.getRawAttributes());
+		if (typeof saveable.save !== "function") throw new Error("Factory model does not support save().");
+		return await saveable.save();
+	}
+	async createHasRelations(model) {
+		for (const definition of this.hasRelations) {
+			const relationship = definition.relationship ?? `${str(definition.factory.getModelConstructor().name).camel().plural()}`;
+			const relation = this.resolveRelation(model, relationship);
+			definition.factory.inheritRecyclePool(this.recyclePool);
+			for (let index = 0; index < definition.factory.amount; index++) await definition.factory.createPersisted({}, async (related) => await relation.save(related));
+		}
+	}
+	async createAttachedRelations(model) {
+		for (const definition of this.attachedRelations) {
+			const factory = definition.related instanceof ModelFactory ? definition.related : null;
+			const relatedModels = factory ? await factory.inheritRecyclePool(this.recyclePool).createMany() : Array.isArray(definition.related) ? definition.related : [definition.related];
+			const relatedName = factory?.getModelConstructor().name ?? relatedModels[0]?.constructor.name;
+			const relationship = definition.relationship ?? `${str(relatedName ?? "").camel().plural()}`;
+			const relation = this.resolveRelation(model, relationship);
+			if (typeof relation.attach !== "function") throw new Error(`Factory relationship [${relationship}] does not support attach().`);
+			await relation.attach(relatedModels, definition.pivot);
+		}
+	}
+	resolveRelation(model, relationship) {
+		const resolver = model[relationship];
+		if (typeof resolver !== "function") throw new Error(`Factory relationship [${relationship}] is not defined on [${this.model.name}].`);
+		return resolver.call(model);
+	}
+	async resolveFactoryKey(factory) {
+		const model = await this.resolveFactoryModel(factory);
+		const primaryKey = model.constructor.getPrimaryKey?.() ?? "id";
+		return model.getAttribute(primaryKey);
+	}
+	async resolveFactoryModel(factory) {
+		factory.inheritRecyclePool(this.recyclePool);
+		return factory.takeRecycledModel() ?? await factory.create();
+	}
+	inheritRecyclePool(pool) {
+		pool.forEach((models, constructor) => {
+			const existing = this.recyclePool.get(constructor) ?? [];
+			const inherited = models.filter((model) => !existing.includes(model));
+			this.recyclePool.set(constructor, [...existing, ...inherited]);
+		});
+		return this;
+	}
+	takeRecycledModel() {
+		const constructor = this.model;
+		const models = this.recyclePool.get(constructor);
+		if (!models || models.length === 0) return null;
+		const offset = this.recycleOffsets.get(constructor) ?? 0;
+		this.recycleOffsets.set(constructor, offset + 1);
+		return models[offset % models.length] ?? null;
+	}
+	runCallbacksSync(callbacks, model, callbackName) {
+		callbacks.forEach((callback) => {
+			const result = callback(model);
+			if (ModelFactory.isPromiseLike(result)) throw new Error(`Factory ${callbackName} callback is async. Use makeAsync(), makeManyAsync(), create(), or createMany() instead.`);
+		});
+	}
+	async runCallbacks(callbacks, model) {
+		for (const callback of callbacks) await callback(model);
+	}
+	static isPromiseLike(value) {
+		return typeof value?.then === "function";
+	}
+	static isFactory(value) {
+		return value instanceof ModelFactory;
+	}
+};
+/**
+* A helper class for defining factories using an inline definition 
+* function, without needing to create a separate factory class.
+* 
+* @template TModel
+* @template TAttributes 
+* @author Legacy (3m1n3nc3)
+* @since 0.1.0
+*/
+var InlineFactory = class extends ModelFactory {
+	constructor(model, resolver) {
+		super();
+		this.resolver = resolver;
+		this.model = model;
+	}
+	definition(sequence) {
+		return this.resolver(sequence);
+	}
+};
+/**
+* Define a factory for a given model using an inline definition function.
+* 
+* @template TModel         The type of model the factory creates.
+* @template TAttributes    The type of attributes used to create the model.
+* @param model             The model constructor.
+* @param definition        The factory definition function.
+* @returns                 A new instance of the model factory.
+*/
+const defineFactory = (model, definition) => {
+	return new InlineFactory(model, definition);
+};
+
+//#endregion
+//#region src/DB.ts
+const defaultSoftDeleteConfig = {
+	enabled: false,
+	column: "deletedAt"
+};
+var DB = class DB {
+	constructor(adapter) {
+		this.scopedAdapter = adapter;
+	}
+	static setAdapter(adapter) {
+		this.adapter = adapter;
+	}
+	static getAdapter() {
+		const runtimeAdapter = getRuntimeAdapter();
+		if (runtimeAdapter) return runtimeAdapter;
+		if (this.adapter) return this.adapter;
+		return getRuntimeCompatibilityAdapter();
+	}
+	getAdapter() {
+		return this.scopedAdapter ?? DB.getAdapter();
+	}
+	static table(table, options = {}) {
+		return new DB().table(table, options);
+	}
+	table(table, options = {}) {
+		return DB.createTableModel(table, options, this.getAdapter()).query();
+	}
+	static async raw(sql, bindings = []) {
+		return await new DB().raw(sql, bindings);
+	}
+	async raw(sql, bindings = []) {
+		const adapter = this.getAdapter();
+		if (!adapter) throw new ArkormException("Raw queries require a configured database adapter.", {
+			code: "ADAPTER_NOT_CONFIGURED",
+			operation: "db.raw"
+		});
+		if (!adapter.rawQuery) throw new UnsupportedAdapterFeatureException("Raw queries are not supported by the current adapter.", {
+			operation: "db.raw",
+			meta: { feature: "rawQuery" }
+		});
+		const rows = await adapter.rawQuery({
+			sql,
+			bindings
+		});
+		return ArkormCollection.make(rows);
+	}
+	static async transaction(callback, context) {
+		return await new DB().transaction(callback, context);
+	}
+	async transaction(callback, context) {
+		const adapter = this.getAdapter();
+		if (!adapter) throw new ArkormException("DB transactions require a configured database adapter.", {
+			code: "ADAPTER_NOT_CONFIGURED",
+			operation: "db.transaction"
+		});
+		return await adapter.transaction(async (transactionAdapter) => {
+			return await callback(new DB(transactionAdapter));
+		}, context);
+	}
+	static createTableModel(table, options, adapter) {
+		const primaryKey = options.primaryKey ?? "id";
+		const resolvedAdapter = options.adapter ?? adapter ?? DB.getAdapter();
+		const persistedMetadata = DB.resolvePersistedTableMetadata(table, options, resolvedAdapter);
+		const columns = {
+			...persistedMetadata.columns,
+			...options.columns ?? {}
+		};
+		const softDelete = options.softDelete ?? defaultSoftDeleteConfig;
+		const primaryKeyGeneration = options.primaryKeyGeneration ? { ...options.primaryKeyGeneration } : persistedMetadata.primaryKeyGeneration?.column === primaryKey ? {
+			strategy: persistedMetadata.primaryKeyGeneration.strategy,
+			prismaDefault: persistedMetadata.primaryKeyGeneration.prismaDefault,
+			databaseDefault: persistedMetadata.primaryKeyGeneration.databaseDefault,
+			runtimeFactory: persistedMetadata.primaryKeyGeneration.runtimeFactory
+		} : void 0;
+		const timestampColumns = options.timestampColumns?.map((column) => ({ ...column })) ?? persistedMetadata.timestampColumns?.map((column) => ({ ...column }));
+		const buildMetadata = () => {
+			return {
+				table,
+				primaryKey,
+				columns: { ...columns },
+				softDelete: { ...softDelete },
+				primaryKeyGeneration,
+				timestampColumns
+			};
+		};
+		const modelStatic = {
+			query: () => new QueryBuilder(modelStatic, modelStatic.getAdapter()),
+			hydrate: (attributes) => ({ ...attributes }),
+			hydrateMany: (attributes) => attributes.map((attribute) => ({ ...attribute })),
+			hydrateRetrieved: async (attributes) => ({ ...attributes }),
+			hydrateManyRetrieved: async (attributes) => attributes.map((attribute) => ({ ...attribute })),
+			getAdapter: () => resolvedAdapter,
+			getColumnMap: () => ({ ...columns }),
+			getColumnName: (attribute) => columns[attribute] ?? attribute,
+			getModelMetadata: () => buildMetadata(),
+			getPrimaryKey: () => primaryKey,
+			getRelationMetadata: () => null,
+			setAdapter: () => {},
+			getSoftDeleteConfig: () => ({ ...softDelete }),
+			getTable: () => table
+		};
+		return modelStatic;
+	}
+	static resolvePersistedTableMetadata(table, options, adapter) {
+		if (options.persistedMetadata === false) return {
+			columns: {},
+			enums: {}
+		};
+		const persistedMetadataOptions = typeof options.persistedMetadata === "object" ? options.persistedMetadata : {};
+		return getPersistedTableMetadata(table, {
+			cwd: persistedMetadataOptions.cwd,
+			configuredPath: persistedMetadataOptions.configuredPath,
+			features: resolvePersistedMetadataFeatures(getUserConfig("features")),
+			strict: persistedMetadataOptions.strict ?? (Boolean(adapter) && !(adapter instanceof PrismaDatabaseAdapter))
+		});
+	}
+};
+
 //#endregion
 //#region src/PivotModel.ts
 /**