arkormx 2.11.12 → 2.12.0

package/dist/index.cjs

@@ -1,11 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_relationship = require('./relationship-BIie-GXN.cjs');
+const require_relationship = require('./relationship-BoQDV6gx.cjs');
 let pg = require("pg");
 let node_path = require("node:path");
+let node_fs = require("node:fs");
+let jiti = require("jiti");
+let node_url = require("node:url");
 let module$1 = require("module");
 let fs = require("fs");
 let path = require("path");
-let node_fs = require("node:fs");
 let _h3ravel_support = require("@h3ravel/support");
 let node_async_hooks = require("node:async_hooks");
 let kysely = require("kysely");
@@ -635,6 +637,15 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	mapColumn(target, column) {
 		return target.columns?.[column] ?? column;
 	}
+	buildIdentifierReference(target, reference) {
+		const segments = reference.split(".");
+		if (segments.length === 1) return kysely.sql.ref(this.mapColumn(target, reference));
+		const column = segments.pop();
+		const table = segments.join(".");
+		const mappedTable = this.mapping[table] ?? table;
+		const mappedColumn = mappedTable === (target.table ? this.mapping[target.table] ?? target.table : void 0) ? this.mapColumn(target, column) : column;
+		return this.buildColumnReference(mappedTable, mappedColumn);
+	}
 	reverseColumnMap(target) {
 		return Object.entries(target.columns ?? {}).reduce((all, [attribute, column]) => {
 			all[column] = attribute;
@@ -658,29 +669,31 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 			return mapped;
 		}, {});
 	}
-	buildSelectList(target, columns) {
-		if (!columns || columns.length === 0) return kysely.sql.raw("*");
+	buildSelectList(target, columns, qualifyColumns = false) {
+		const table = this.resolveTable(target);
+		if (!columns || columns.length === 0) return qualifyColumns ? kysely.sql`${kysely.sql.table(table)}.*` : kysely.sql.raw("*");
 		return kysely.sql.join(columns.map(({ column, alias, raw, wildcard, expression }) => {
-			if (wildcard) return kysely.sql.raw("*");
+			if (wildcard) return qualifyColumns ? kysely.sql`${kysely.sql.table(table)}.*` : kysely.sql.raw("*");
 			if (expression) {
 				const compiled = this.buildExpression(target, expression);
 				const resultAlias = alias ?? column;
 				return resultAlias ? kysely.sql`${compiled} as ${kysely.sql.id(resultAlias)}` : compiled;
 			}
 			if (raw) {
-				const rawExpression = kysely.sql.raw(column);
+				const rawExpression = /^[A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)+$/.test(column) ? this.buildIdentifierReference(target, column) : kysely.sql.raw(column);
 				return alias ? kysely.sql`${rawExpression} as ${kysely.sql.id(alias)}` : rawExpression;
 			}
 			const mappedColumn = this.mapColumn(target, column);
 			const resultAlias = alias ?? column;
-			if (mappedColumn === resultAlias) return kysely.sql.ref(mappedColumn);
-			return kysely.sql`${kysely.sql.ref(mappedColumn)} as ${kysely.sql.id(resultAlias)}`;
+			const reference = qualifyColumns ? this.buildColumnReference(table, mappedColumn) : kysely.sql.ref(mappedColumn);
+			if (mappedColumn === resultAlias) return reference;
+			return kysely.sql`${reference} as ${kysely.sql.id(resultAlias)}`;
 		}));
 	}
-	buildOrderBy(target, orderBy) {
+	buildOrderBy(target, orderBy, qualifyColumns = false) {
 		if (!orderBy || orderBy.length === 0) return kysely.sql``;
 		return kysely.sql` order by ${kysely.sql.join(orderBy.map(({ column, direction, expression }) => {
-			return kysely.sql`${expression ? this.buildExpression(target, expression) : kysely.sql.ref(this.mapColumn(target, column))} ${kysely.sql.raw(direction === "desc" ? "desc" : "asc")}`;
+			return kysely.sql`${expression ? this.buildExpression(target, expression) : qualifyColumns ? this.buildColumnReference(this.resolveTable(target), this.mapColumn(target, column)) : kysely.sql.ref(this.mapColumn(target, column))} ${kysely.sql.raw(direction === "desc" ? "desc" : "asc")}`;
 		}), kysely.sql`, `)}`;
 	}
 	buildGroupBy(target, groupBy) {
@@ -735,7 +748,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		return kysely.sql`${kysely.sql.join(parts, kysely.sql``)}`;
 	}
 	buildJoinConstraint(target, constraint) {
-		if (constraint.type === "column") return kysely.sql`${kysely.sql.ref(constraint.first)} ${kysely.sql.raw(constraint.operator)} ${kysely.sql.ref(constraint.second)}`;
+		if (constraint.type === "column") return kysely.sql`${this.buildIdentifierReference(target, constraint.first)} ${kysely.sql.raw(constraint.operator)} ${this.buildIdentifierReference(target, constraint.second)}`;
 		if (constraint.type === "null") return constraint.not ? kysely.sql`${kysely.sql.ref(constraint.column)} is not null` : kysely.sql`${kysely.sql.ref(constraint.column)} is null`;
 		if (constraint.type === "raw") return this.buildRawWhereCondition({
 			type: "raw",
@@ -743,7 +756,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 			bindings: constraint.bindings
 		});
 		if (constraint.type === "nested") return kysely.sql`(${this.buildJoinConstraints(target, constraint.constraints)})`;
-		const column = kysely.sql.ref(constraint.column);
+		const column = this.buildIdentifierReference(target, constraint.column);
 		const operator = constraint.operator;
 		if (operator === "is-null") return kysely.sql`${column} is null`;
 		if (operator === "is-not-null") return kysely.sql`${column} is not null`;
@@ -765,7 +778,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		return typeof value === "undefined" ? [] : [value];
 	}
 	buildComparisonCondition(target, condition) {
-		const column = kysely.sql.ref(this.mapColumn(target, condition.column));
+		const column = this.buildIdentifierReference(target, condition.column);
 		if (condition.operator === "is-null") return kysely.sql`${column} is null`;
 		if (condition.operator === "is-not-null") return kysely.sql`${column} is not null`;
 		if (condition.operator === "in") {
@@ -1198,6 +1211,30 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
             ${this.buildOrderBy(spec.target, spec.orderBy)}
             ${this.buildPaginationClause(spec)}
         `;
+	}
+	buildPartitionedSelectStatement(spec) {
+		const table = this.resolveTable(spec.target);
+		const rankedAlias = "__arkorm_partitioned";
+		const rowAlias = "__arkorm_partition_row";
+		const offset = Math.max(0, spec.perPartitionOffset ?? 0);
+		const upperBound = offset + Math.max(0, spec.perPartitionLimit);
+		const partitionColumns = spec.partitionBy.map((column) => this.buildIdentifierReference(spec.target, column));
+		const orderBy = spec.orderBy && spec.orderBy.length > 0 ? this.buildOrderBy(spec.target, spec.orderBy, true) : kysely.sql` order by ${this.buildColumnReference(table, this.resolvePrimaryKey(spec.target))} asc`;
+		return kysely.sql`
+      select *
+      from (
+        select ${spec.distinct ? kysely.sql`distinct ` : kysely.sql``}${this.buildSelectList(spec.target, spec.columns, true)}
+        ${this.buildRelationAggregateSelectList(spec.target, spec.relationAggregates)},
+        row_number() over (
+          partition by ${kysely.sql.join(partitionColumns, kysely.sql`, `)}${orderBy}
+        ) as ${kysely.sql.id(rowAlias)}
+        from ${kysely.sql.table(table)}
+        ${this.buildJoinClause(spec.target, spec.joins)}
+        ${this.buildCombinedWhereClause(spec.target, spec.where, spec.relationFilters)}
+      ) as ${kysely.sql.table(rankedAlias)}
+      where ${kysely.sql.ref(rowAlias)} > ${offset} and ${kysely.sql.ref(rowAlias)} <= ${upperBound}
+      order by ${kysely.sql.ref(rowAlias)} asc
+    `;
 	}
 	buildCountStatement(spec) {
 		return kysely.sql`
@@ -1299,6 +1336,20 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 			offset: spec.offset
 		});
 	}
+	async selectPerPartition(spec) {
+		if (spec.partitionBy.length === 0) return await this.select(spec);
+		return await this.executeWithDebug("select", spec.target, this.buildPartitionedSelectStatement(spec), (rows) => this.mapRows(spec.target, rows.map((row) => {
+			const { __arkorm_partition_row: _partitionRow, ...attributes } = row;
+			return attributes;
+		})), {
+			where: spec.where,
+			relationFilters: spec.relationFilters,
+			orderBy: spec.orderBy,
+			partitionBy: spec.partitionBy,
+			perPartitionLimit: spec.perPartitionLimit,
+			perPartitionOffset: spec.perPartitionOffset
+		});
+	}
 	/**
 	* Selects a single record from the database matching the specified criteria and returns it as
 	* a database row. If multiple records match the criteria, only the first one is returned.
@@ -2331,6 +2382,92 @@ const createPrismaDatabaseAdapter = (prisma, mapping = {}) => {
 */
 const createPrismaCompatibilityAdapter = createPrismaDatabaseAdapter;
 
+//#endregion
+//#region src/helpers/model-resolver.ts
+const modelExtensions = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs"
+];
+const isModelModule = (value) => typeof value === "object" && value !== null;
+const isModelConstructor = (value) => {
+	if (typeof value !== "function") return false;
+	const candidate = value;
+	return typeof candidate.query === "function" && typeof candidate.hydrate === "function" && typeof candidate.getTable === "function" && typeof candidate.getPrimaryKey === "function";
+};
+const resolveModelExport = (module, modelName) => {
+	if (!isModelModule(module)) return module;
+	return module.default ?? module[modelName] ?? module;
+};
+const resolveRuntimeDirectory = (directory) => {
+	if ((0, node_fs.existsSync)(directory)) return directory;
+	const buildOutput = require_relationship.getUserConfig("paths")?.buildOutput;
+	if (typeof buildOutput !== "string" || buildOutput.trim().length === 0) return directory;
+	const relativeSource = (0, node_path.relative)(process.cwd(), directory);
+	if (!relativeSource || relativeSource.startsWith("..")) return directory;
+	const mappedDirectory = (0, node_path.join)(buildOutput, relativeSource);
+	return (0, node_fs.existsSync)(mappedDirectory) ? mappedDirectory : directory;
+};
+const resolveRuntimeModelPath = (sourcePath) => {
+	const extension = (0, node_path.extname)(sourcePath).toLowerCase();
+	const candidates = [];
+	if (modelExtensions.includes(extension)) candidates.push(sourcePath);
+	else candidates.push(...modelExtensions.map((modelExtension) => `${sourcePath}${modelExtension}`));
+	const buildOutput = require_relationship.getUserConfig("paths")?.buildOutput;
+	if (typeof buildOutput === "string" && buildOutput.trim().length > 0) candidates.slice().forEach((candidate) => {
+		const relativeSource = (0, node_path.relative)(process.cwd(), candidate);
+		if (!relativeSource || relativeSource.startsWith("..")) return;
+		const mappedFile = (0, node_path.join)(buildOutput, relativeSource);
+		const mappedExtension = (0, node_path.extname)(mappedFile).toLowerCase();
+		if ([
+			".ts",
+			".tsx",
+			".mts",
+			".cts"
+		].includes(mappedExtension)) {
+			const base = mappedFile.slice(0, -mappedExtension.length);
+			candidates.push(`${base}.js`, `${base}.mjs`, `${base}.cjs`);
+			return;
+		}
+		candidates.push(mappedFile);
+	});
+	return candidates.find((candidate) => (0, node_fs.existsSync)(candidate)) ?? sourcePath;
+};
+const getModelDirectories = () => {
+	const configured = require_relationship.getUserConfig("paths")?.models;
+	const registered = require_relationship.getRegisteredPaths("models");
+	return [...typeof configured === "string" ? [configured] : [], ...registered].map((directory) => resolveRuntimeDirectory((0, node_path.isAbsolute)(directory) ? directory : (0, node_path.resolve)(directory))).filter((directory, index, all) => all.indexOf(directory) === index);
+};
+const loadModel = (modelName, exportName) => {
+	const jiti$1 = (0, jiti.createJiti)(`${(0, node_url.pathToFileURL)((0, node_path.resolve)(".")).href}/`, {
+		interopDefault: false,
+		tsconfigPaths: true,
+		sourceMaps: true
+	});
+	for (const directory of getModelDirectories()) {
+		const modulePath = resolveRuntimeModelPath((0, node_path.join)(directory, modelName));
+		if (!(0, node_fs.existsSync)(modulePath)) continue;
+		const model = resolveModelExport(jiti$1(modulePath), exportName);
+		if (!isModelConstructor(model)) continue;
+		require_relationship.registerModels(model);
+		return model;
+	}
+};
+function getModel(modelName) {
+	const normalized = modelName.trim();
+	const exportName = normalized.replace(/\\/g, "/").split("/").pop()?.replace(/\.[^.]+$/, "");
+	if (!normalized || !exportName) throw new Error("Model name is required.");
+	const registeredModel = require_relationship.getRegisteredModels().find((model) => model.name === exportName);
+	if (registeredModel) return registeredModel;
+	const model = loadModel(normalized, exportName);
+	if (model) return model;
+	throw new Error(`Model "${modelName}" not found.`);
+}
+
 //#endregion
 //#region src/Arkorm.ts
 var Arkorm = class Arkorm {
@@ -2350,6 +2487,7 @@ var Arkorm = class Arkorm {
 		this.getRegisteredMigrations = Arkorm.getRegisteredMigrations;
 		this.getRegisteredSeeders = Arkorm.getRegisteredSeeders;
 		this.getRegisteredModels = Arkorm.getRegisteredModels;
+		this.getModel = Arkorm.getModel;
 		this.getRegisteredFactories = Arkorm.getRegisteredFactories;
 	}
 	/**
@@ -2477,6 +2615,9 @@ var Arkorm = class Arkorm {
 	static getRegisteredModels() {
 		return require_relationship.getRegisteredModels();
 	}
+	static {
+		this.getModel = getModel;
+	}
 	/**
 	* Get registered factory constructors or instances.
 	*
@@ -3107,6 +3248,58 @@ var CliApp = class {
 			skipped
 		};
 	}
+	resolveModelFiles(modelsDir) {
+		if (!(0, fs.existsSync)(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
+		return (0, fs.readdirSync)(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => (0, path.join)(modelsDir, file));
+	}
+	syncModelRegistryTypes(modelFiles) {
+		const registryDir = (0, path.join)((0, fs.realpathSync)(process.cwd()), ".arkormx");
+		const registryPath = (0, path.join)(registryDir, "models.d.ts");
+		const models = modelFiles.map((filePath) => {
+			const parsed = this.parseModelSyncSource((0, fs.readFileSync)(filePath, "utf-8"));
+			if (!parsed) return null;
+			return {
+				className: parsed.className,
+				importPath: this.resolveModelRegistryImportPath(registryPath, filePath)
+			};
+		}).filter((model) => model !== null).sort((left, right) => left.className.localeCompare(right.className));
+		const importLines = models.map((model) => {
+			return `import type { ${model.className} } from '${model.importPath}'`;
+		});
+		const registryLines = models.map((model) => {
+			return `    ${model.className}: typeof ${model.className}`;
+		});
+		const content = [
+			"/* eslint-disable */",
+			"// This file is generated by `arkorm models:sync`.",
+			...importLines,
+			"",
+			"declare module 'arkormx' {",
+			"  interface ArkormModelRegistry {",
+			...registryLines,
+			"  }",
+			"}",
+			"",
+			"export {}",
+			""
+		].join("\n");
+		if (((0, fs.existsSync)(registryPath) ? (0, fs.readFileSync)(registryPath, "utf-8") : null) === content) return {
+			path: registryPath,
+			updated: false
+		};
+		(0, fs.mkdirSync)(registryDir, { recursive: true });
+		(0, fs.writeFileSync)(registryPath, content);
+		return {
+			path: registryPath,
+			updated: true
+		};
+	}
+	resolveModelRegistryImportPath(registryPath, modelPath) {
+		const realModelPath = (0, fs.realpathSync)(modelPath);
+		const withoutExtension = realModelPath.slice(0, -(0, path.extname)(realModelPath).length);
+		const relativePath = (0, path.relative)((0, path.dirname)(registryPath), withoutExtension).replace(/\\/g, "/");
+		return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+	}
 	applyPersistedFieldMetadata(structure) {
 		const persistedMetadata = require_relationship.getPersistedTableMetadata(structure.table, {
 			features: require_relationship.resolvePersistedMetadataFeatures(this.getConfig("features")),
@@ -3284,8 +3477,7 @@ var CliApp = class {
 	}
 	async syncModels(options = {}) {
 		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", (0, path.join)(process.cwd(), "src", "models"));
-		if (!(0, fs.existsSync)(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
-		const modelFiles = (0, fs.readdirSync)(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => (0, path.join)(modelsDir, file));
+		const modelFiles = this.resolveModelFiles(modelsDir);
 		const adapter = this.getConfig("adapter");
 		if (adapter && typeof adapter.introspectModels === "function") {
 			const sources = modelFiles.reduce((all, filePath) => {
@@ -3302,11 +3494,13 @@ var CliApp = class {
 				const parsed = sources.get(filePath);
 				return parsed ? structuresByTable.get(parsed.table) : void 0;
 			}, /* @__PURE__ */ new Map());
+			const modelTypes = this.syncModelRegistryTypes(modelFiles);
 			return {
 				source: "adapter",
 				modelsDir,
+				modelTypesPath: modelTypes.path,
 				total: modelFiles.length,
-				updated: result.updated,
+				updated: modelTypes.updated ? [...result.updated, modelTypes.path] : result.updated,
 				skipped: result.skipped
 			};
 		}
@@ -3315,6 +3509,19 @@ var CliApp = class {
 			...this.syncModelsFromPrisma(options)
 		};
 	}
+	syncModelRegistry(options = {}) {
+		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", (0, path.join)(process.cwd(), "src", "models"));
+		const modelFiles = this.resolveModelFiles(modelsDir);
+		const modelTypes = this.syncModelRegistryTypes(modelFiles);
+		return {
+			source: "registry",
+			modelsDir,
+			modelTypesPath: modelTypes.path,
+			total: modelFiles.length,
+			updated: modelTypes.updated ? [modelTypes.path] : [],
+			skipped: []
+		};
+	}
 	/**
 	* Sync model attribute declarations in model files based on the Prisma schema.
 	* This method reads the Prisma schema to extract model definitions and their
@@ -3330,21 +3537,22 @@ var CliApp = class {
 		const schemaPath = options.schemaPath ?? (0, path.join)(process.cwd(), "prisma", "schema.prisma");
 		const modelsDir = options.modelsDir ?? this.resolveConfigPath("models", (0, path.join)(process.cwd(), "src", "models"));
 		if (!(0, fs.existsSync)(schemaPath)) throw new Error(`Prisma schema file not found: ${schemaPath}`);
-		if (!(0, fs.existsSync)(modelsDir)) throw new Error(`Models directory not found: ${modelsDir}`);
 		const schema = (0, fs.readFileSync)(schemaPath, "utf-8");
 		const prismaEnums = this.parsePrismaEnums(schema);
 		const prismaModels = this.parsePrismaModels(schema);
-		const modelFiles = (0, fs.readdirSync)(modelsDir).filter((file) => file.endsWith(".ts")).map((file) => (0, path.join)(modelsDir, file));
+		const modelFiles = this.resolveModelFiles(modelsDir);
 		const result = this.syncModelFiles(modelFiles, (filePath, source) => {
 			const parsed = this.parseModelSyncSource(source);
 			if (!parsed) return void 0;
 			return prismaModels.find((model) => model.table === parsed.table) ?? prismaModels.find((model) => model.name === parsed.className);
 		}, prismaEnums);
+		const modelTypes = this.syncModelRegistryTypes(modelFiles);
 		return {
 			schemaPath,
 			modelsDir,
+			modelTypesPath: modelTypes.path,
 			total: modelFiles.length,
-			updated: result.updated,
+			updated: modelTypes.updated ? [...result.updated, modelTypes.path] : result.updated,
 			skipped: result.skipped
 		};
 	}
@@ -3737,6 +3945,7 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
         {--deploy : Use prisma migrate deploy instead of migrate dev (Prisma compatibility driver only)}
         {--skip-generate : Skip prisma generate (Prisma compatibility driver only)}
         {--skip-migrate : Skip prisma migrate command}
+        {--r|registry : Sync the generated model registry type augmentation after a successful migration}
         {--state-file= : Path to applied migration state file}
         {--schema= : Explicit prisma schema path (Prisma compatibility driver only)}
         {--migration-name= : Name for prisma migrate dev (Prisma compatibility driver only)}
@@ -3793,6 +4002,7 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 				this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 				return;
 			}
+			if (!this.syncModelRegistryIfRequested()) return;
 			this.success("No pending migration classes to apply.");
 			return;
 		}
@@ -3851,6 +4061,18 @@ var MigrateCommand = class extends _h3ravel_musket.Command {
 		], process.cwd());
 		this.success(`Applied ${pending.length} migration(s).`);
 		pending.forEach(([_, file]) => this.success(this.app.splitLogger("Migrated", file)));
+		this.syncModelRegistryIfRequested();
+	}
+	syncModelRegistryIfRequested() {
+		if (!this.option("registry") && !this.option("r")) return true;
+		try {
+			const result = this.app.syncModelRegistry();
+			this.success(this.app.splitLogger("Model Types", result.modelTypesPath ?? "none"));
+			return true;
+		} catch (error) {
+			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+			return false;
+		}
 	}
 	/**
 	* Load all migration classes from the specified directory.
@@ -4280,6 +4502,7 @@ var ModelsSyncCommand = class extends _h3ravel_musket.Command {
 		this.signature = `models:sync
         {--schema= : Path to prisma schema file used when adapter introspection is unavailable}
         {--models= : Path to models directory}
+        {--r|registry-only : Only sync the generated model registry type augmentation}
     `;
 		this.description = "Sync model declare attributes from the active adapter when supported";
 	}
@@ -4288,10 +4511,11 @@ var ModelsSyncCommand = class extends _h3ravel_musket.Command {
 		await require_relationship.loadArkormConfig();
 		let result;
 		try {
-			result = await this.app.syncModels({
+			const options = {
 				schemaPath: this.option("schema") ? (0, node_path.resolve)(String(this.option("schema"))) : void 0,
 				modelsDir: this.option("models") ? (0, node_path.resolve)(String(this.option("models"))) : void 0
-			});
+			};
+			result = this.option("registryOnly") || this.option("registry-only") || this.option("r") ? this.app.syncModelRegistry({ modelsDir: options.modelsDir }) : await this.app.syncModels(options);
 		} catch (error) {
 			this.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
 			return;
@@ -4299,9 +4523,10 @@ var ModelsSyncCommand = class extends _h3ravel_musket.Command {
 		const updatedLines = result.updated.length === 0 ? [this.app.splitLogger("Updated", "none")] : result.updated.map((path) => this.app.splitLogger("Updated", path));
 		this.success("SUCCESS: Model sync completed with the following results:");
 		[
-			this.app.splitLogger("Source", result.source === "adapter" ? "adapter introspection" : "prisma schema"),
+			this.app.splitLogger("Source", result.source === "adapter" ? "adapter introspection" : result.source === "registry" ? "model registry" : "prisma schema"),
 			...result.schemaPath ? [this.app.splitLogger("Schema", result.schemaPath)] : [],
 			this.app.splitLogger("Models", result.modelsDir),
+			...result.modelTypesPath ? [this.app.splitLogger("Model Types", result.modelTypesPath)] : [],
 			this.app.splitLogger("Processed", String(result.total)),
 			...updatedLines,
 			this.app.splitLogger("Skipped", String(result.skipped.length))
@@ -6466,6 +6691,26 @@ var QueryBuilder = class QueryBuilder {
 		});
 	}
 	/**
+	* Compiles the current query into SQL without executing it. Values remain represented by the
+	* adapter's parameter placeholders; use {@link inspect} when the corresponding bindings are
+	* also required.
+	*
+	* @param operation
+	* @returns
+	*/
+	toSql(operation = "select") {
+		const inspection = this.inspect(operation);
+		if (inspection?.sql) return inspection.sql;
+		throw new require_relationship.UnsupportedAdapterFeatureException("The active database adapter cannot compile this query to SQL.", {
+			operation: "query.toSql",
+			model: this.model.name,
+			meta: {
+				feature: "inspectQuery",
+				requestedOperation: operation
+			}
+		});
+	}
+	/**
 	* Sets offset/limit for a 1-based page.
 	*
 	* @param page
@@ -6501,6 +6746,50 @@ var QueryBuilder = class QueryBuilder {
 		return new require_relationship.ArkormCollection(filteredModels);
 	}
 	/**
+	* Executes a bounded eager-load query independently for each partition while retaining a
+	* single set-based database query. Returns null when the active adapter cannot represent the
+	* query so the relationship loader can use its correctness fallback.
+	*
+	* @internal
+	*
+	* @param partitionBy
+	* @returns
+	*/
+	async getForEagerLoad(partitionBy) {
+		if (this.limitValue === void 0 && this.offsetValue === void 0) return await this.get();
+		const rows = await this.getRowsForEagerLoad(partitionBy);
+		if (!rows) return null;
+		const models = await this.model.hydrateManyRetrieved(rows);
+		await this.eagerLoadModels(models);
+		return new require_relationship.ArkormCollection(models);
+	}
+	/** @internal */
+	async getRowsForEagerLoad(partitionBy) {
+		if (this.limitValue === void 0 && this.offsetValue === void 0) return await this.executeReadRows();
+		const adapter = this.requireAdapter();
+		if (partitionBy.length === 0 || typeof adapter.selectPerPartition !== "function" || this.randomOrderEnabled || this.queryDistinct || this.queryGroupBy !== void 0 || this.queryHaving !== void 0 || !this.canExecuteRelationFeaturesInAdapter()) return null;
+		const spec = this.tryBuildSelectSpec(this.buildWhere());
+		if (!spec) return null;
+		return await adapter.selectPerPartition({
+			...spec,
+			limit: void 0,
+			offset: void 0,
+			partitionBy,
+			perPartitionLimit: this.limitValue ?? Number.MAX_SAFE_INTEGER,
+			perPartitionOffset: this.offsetValue
+		});
+	}
+	/** Removes limit and offset clauses from a cloned relationship query. @internal */
+	withoutPagination() {
+		this.limitValue = void 0;
+		this.offsetValue = void 0;
+		return this;
+	}
+	/** @internal */
+	hasEagerLoadPagination() {
+		return this.limitValue !== void 0 || this.offsetValue !== void 0;
+	}
+	/**
 	* Processes the query results in chunks, invoking the callback with each chunk
 	* as a collection. Return `false` from the callback to stop early. Resolves to
 	* `false` when stopped early, otherwise `true`.
@@ -7595,6 +7884,7 @@ var QueryBuilder = class QueryBuilder {
 				const normalizedQuery = constrained instanceof QueryBuilder ? constrained : relatedQuery;
 				if (constrained && !(constrained instanceof QueryBuilder) && constrained !== relatedQuery) return null;
 				if (normalizedQuery.randomOrderEnabled) return null;
+				if (normalizedQuery.hasRelationAggregates()) return null;
 				const callbackRelationLoads = normalizedQuery.tryBuildAdapterRelationLoadPlans();
 				const childRelationLoads = node.children.size > 0 ? toPlans(relatedModel, node.children) : [];
 				if (callbackRelationLoads === null || childRelationLoads === null) return null;
@@ -9551,115 +9841,50 @@ var Model = class Model {
 	isNotSame(model) {
 		return !this.isSame(model);
 	}
-	/**
-	* Define a has one relationship.
-	*
-	* @param related
-	* @param foreignKey
-	* @param localKey
-	* @returns
-	*/
 	hasOne(related, foreignKey, localKey) {
 		const constructor = this.constructor;
-		return new require_relationship.HasOneRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
+		const relatedModel = this.resolveRelationshipModel(related, "hasOne");
+		const resolvedLocalKey = localKey ?? constructor.getPrimaryKey();
+		return new require_relationship.HasOneRelation(this, relatedModel, foreignKey ?? this.resolveDefaultHasForeignKey(constructor, resolvedLocalKey), resolvedLocalKey);
 	}
-	/**
-	* Define a has many relationship.
-	*
-	* @param related
-	* @param foreignKey
-	* @param localKey
-	* @returns
-	*/
 	hasMany(related, foreignKey, localKey) {
 		const constructor = this.constructor;
-		return new require_relationship.HasManyRelation(this, related, foreignKey, localKey ?? constructor.getPrimaryKey());
+		const relatedModel = this.resolveRelationshipModel(related, "hasMany");
+		const resolvedLocalKey = localKey ?? constructor.getPrimaryKey();
+		return new require_relationship.HasManyRelation(this, relatedModel, foreignKey ?? this.resolveDefaultHasForeignKey(constructor, resolvedLocalKey), resolvedLocalKey);
 	}
-	/**
-	* Define a belongs to relationship.
-	*
-	* @param related
-	* @param foreignKey
-	* @param ownerKey
-	* @returns
-	*/
 	belongsTo(related, foreignKey, ownerKey) {
-		return new require_relationship.BelongsToRelation(this, related, foreignKey, ownerKey ?? related.getPrimaryKey());
+		const relatedModel = this.resolveRelationshipModel(related, "belongsTo");
+		const resolvedOwnerKey = ownerKey ?? relatedModel.getPrimaryKey();
+		return new require_relationship.BelongsToRelation(this, relatedModel, foreignKey ?? this.resolveDefaultBelongsToForeignKey(relatedModel, resolvedOwnerKey), resolvedOwnerKey);
 	}
-	/**
-	* Define a belongs to many relationship.
-	*
-	* @param related
-	* @param throughTable
-	* @param foreignPivotKey
-	* @param relatedPivotKey
-	* @param parentKey
-	* @param relatedKey
-	* @returns
-	*/
 	belongsToMany(related, throughTable, foreignPivotKey, relatedPivotKey, parentKey, relatedKey) {
 		const constructor = this.constructor;
-		return new require_relationship.BelongsToManyRelation(this, related, throughTable, foreignPivotKey, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), relatedKey ?? related.getPrimaryKey());
+		const relatedModel = this.resolveRelationshipModel(related, "belongsToMany");
+		const resolvedRelatedKey = relatedKey ?? relatedModel.getPrimaryKey();
+		return new require_relationship.BelongsToManyRelation(this, relatedModel, throughTable, foreignPivotKey, relatedPivotKey, parentKey ?? constructor.getPrimaryKey(), resolvedRelatedKey);
 	}
-	/**
-	* Define a has one through relationship.
-	*
-	* @param related
-	* @param throughTable
-	* @param firstKey
-	* @param secondKey
-	* @param localKey
-	* @param secondLocalKey
-	* @returns
-	*/
-	hasOneThrough(related, throughTable, firstKey, secondKey, localKey, secondLocalKey = "id") {
+	hasOneThrough(related, throughTable, firstKey, secondKey, localKey, secondLocalKey) {
 		const constructor = this.constructor;
-		return new require_relationship.HasOneThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
+		const relatedModel = this.resolveRelationshipModel(related, "hasOneThrough");
+		return new require_relationship.HasOneThroughRelation(this, relatedModel, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey ?? "id");
 	}
-	/**
-	* Define a has many through relationship.
-	*
-	* @param related
-	* @param throughTable
-	* @param firstKey
-	* @param secondKey
-	* @param localKey
-	* @param secondLocalKey
-	* @returns
-	*/
 	hasManyThrough(related, throughTable, firstKey, secondKey, localKey, secondLocalKey = "id") {
 		const constructor = this.constructor;
-		return new require_relationship.HasManyThroughRelation(this, related, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
+		const relatedModel = this.resolveRelationshipModel(related, "hasManyThrough");
+		return new require_relationship.HasManyThroughRelation(this, relatedModel, throughTable, firstKey, secondKey, localKey ?? constructor.getPrimaryKey(), secondLocalKey);
 	}
-	/**
-	* Define a polymorphic one to one relationship.
-	*
-	* @param related
-	* @param morphName
-	* @param idColumn
-	* @param typeColumn
-	* @param localKey
-	* @returns
-	*/
 	morphOne(related, morphName, idColumn, typeColumn, localKey) {
 		const constructor = this.constructor;
+		const relatedModel = this.resolveRelationshipModel(related, "morphOne");
 		const columns = this.resolveMorphColumns(morphName, idColumn, typeColumn);
-		return new require_relationship.MorphOneRelation(this, related, morphName, columns.idColumn, columns.typeColumn, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.MorphOneRelation(this, relatedModel, morphName, columns.idColumn, columns.typeColumn, localKey ?? constructor.getPrimaryKey());
 	}
-	/**
-	* Define a polymorphic one to many relationship.
-	*
-	* @param related
-	* @param morphName
-	* @param idColumn
-	* @param typeColumn
-	* @param localKey
-	* @returns
-	*/
 	morphMany(related, morphName, idColumn, typeColumn, localKey) {
 		const constructor = this.constructor;
+		const relatedModel = this.resolveRelationshipModel(related, "morphMany");
 		const columns = this.resolveMorphColumns(morphName, idColumn, typeColumn);
-		return new require_relationship.MorphManyRelation(this, related, morphName, columns.idColumn, columns.typeColumn, localKey ?? constructor.getPrimaryKey());
+		return new require_relationship.MorphManyRelation(this, relatedModel, morphName, columns.idColumn, columns.typeColumn, localKey ?? constructor.getPrimaryKey());
 	}
 	morphTo(morphName, typeColumnOrRelated, idColumn, ownerKey) {
 		const related = typeof typeColumnOrRelated === "function" ? typeColumnOrRelated : void 0;
@@ -9667,51 +9892,37 @@ var Model = class Model {
 		const columns = this.resolveMorphColumns(morphName, idColumn, typeColumn);
 		return new require_relationship.MorphToRelation(this, morphName, columns.typeColumn, columns.idColumn, ownerKey, related);
 	}
-	/**
-	* Define a polymorphic many to many relationship.
-	*
-	* @param related
-	* @param morphName
-	* @param throughTable
-	* @param foreignPivotKey
-	* @param morphTypeColumn
-	* @param relatedPivotKey
-	* @param parentKey
-	* @param relatedKey
-	* @returns
-	*/
 	morphToMany(related, morphName, throughTable, foreignPivotKey, morphTypeColumn, relatedPivotKey, parentKey, relatedKey) {
 		const constructor = this.constructor;
 		const namingCase = Model.getNamingCase();
-		const resolvedRelatedKey = relatedKey ?? related.getPrimaryKey();
+		const relatedModel = this.resolveRelationshipModel(related, "morphToMany");
+		const resolvedRelatedKey = relatedKey ?? relatedModel.getPrimaryKey();
 		const resolvedTable = throughTable ?? this.formatConventionName(`${(0, _h3ravel_support.str)(morphName).plural()}`, namingCase);
-		const resolvedRelatedPivotKey = relatedPivotKey ?? this.formatConventionName(`${(0, _h3ravel_support.str)(related.getTable()).singular()}_${resolvedRelatedKey}`, namingCase);
+		const resolvedRelatedPivotKey = relatedPivotKey ?? this.formatConventionName(`${(0, _h3ravel_support.str)(relatedModel.getTable()).singular()}_${resolvedRelatedKey}`, namingCase);
 		const morphIdColumn = foreignPivotKey ?? this.formatConventionName(`${morphName}_id`, namingCase);
 		const resolvedMorphTypeColumn = morphTypeColumn ?? this.formatConventionName(`${morphName}_type`, namingCase);
-		return new require_relationship.MorphToManyRelation(this, related, resolvedTable, morphName, morphIdColumn, resolvedMorphTypeColumn, resolvedRelatedPivotKey, parentKey ?? constructor.getPrimaryKey(), resolvedRelatedKey);
+		return new require_relationship.MorphToManyRelation(this, relatedModel, resolvedTable, morphName, morphIdColumn, resolvedMorphTypeColumn, resolvedRelatedPivotKey, parentKey ?? constructor.getPrimaryKey(), resolvedRelatedKey);
 	}
-	/**
-	* Define the inverse side of a polymorphic many-to-many relationship.
-	*
-	* @param related
-	* @param morphName
-	* @param throughTable
-	* @param foreignPivotKey
-	* @param morphTypeColumn
-	* @param relatedPivotKey
-	* @param parentKey
-	* @param relatedKey
-	* @returns
-	*/
 	morphedByMany(related, morphName, throughTable, foreignPivotKey, morphTypeColumn, relatedPivotKey, parentKey, relatedKey) {
 		const constructor = this.constructor;
 		const namingCase = Model.getNamingCase();
-		const resolvedRelatedKey = relatedKey ?? related.getPrimaryKey();
+		const relatedModel = this.resolveRelationshipModel(related, "morphedByMany");
+		const resolvedRelatedKey = relatedKey ?? relatedModel.getPrimaryKey();
 		const resolvedTable = throughTable ?? this.formatConventionName(`${(0, _h3ravel_support.str)(morphName).plural()}`, namingCase);
 		const resolvedForeignPivotKey = foreignPivotKey ?? this.formatConventionName(`${(0, _h3ravel_support.str)(constructor.getTable()).singular()}_${parentKey ?? constructor.getPrimaryKey()}`, namingCase);
 		const resolvedMorphTypeColumn = morphTypeColumn ?? this.formatConventionName(`${morphName}_type`, namingCase);
 		const resolvedRelatedPivotKey = relatedPivotKey ?? this.formatConventionName(`${morphName}_id`, namingCase);
-		return new require_relationship.MorphedByManyRelation(this, related, resolvedTable, morphName, resolvedForeignPivotKey, resolvedMorphTypeColumn, resolvedRelatedPivotKey, parentKey ?? constructor.getPrimaryKey(), resolvedRelatedKey);
+		return new require_relationship.MorphedByManyRelation(this, relatedModel, resolvedTable, morphName, resolvedForeignPivotKey, resolvedMorphTypeColumn, resolvedRelatedPivotKey, parentKey ?? constructor.getPrimaryKey(), resolvedRelatedKey);
+	}
+	resolveRelationshipModel(related, operation) {
+		if (typeof related === "function") return related;
+		return require_relationship.resolveRegisteredModel(related, { operation });
+	}
+	resolveDefaultHasForeignKey(parent, localKey) {
+		return this.formatConventionName(`${(0, _h3ravel_support.str)(parent.getTable()).singular()}_${localKey}`, Model.getNamingCase());
+	}
+	resolveDefaultBelongsToForeignKey(related, ownerKey) {
+		return this.formatConventionName(`${(0, _h3ravel_support.str)(related.getTable()).singular()}_${ownerKey}`, Model.getNamingCase());
 	}
 	resolveMorphColumns(morphName, idColumn, typeColumn) {
 		const namingCase = Model.getNamingCase();
@@ -10783,6 +10994,7 @@ exports.getLastBatchMigrations = require_relationship.getLastBatchMigrations;
 exports.getLastMigrationRun = require_relationship.getLastMigrationRun;
 exports.getLatestAppliedMigrations = require_relationship.getLatestAppliedMigrations;
 exports.getMigrationPlan = require_relationship.getMigrationPlan;
+exports.getModel = getModel;
 exports.getPersistedColumnMap = require_relationship.getPersistedColumnMap;
 exports.getPersistedEnumMap = require_relationship.getPersistedEnumMap;
 exports.getPersistedEnumTsType = require_relationship.getPersistedEnumTsType;
@@ -10841,6 +11053,7 @@ exports.resolveMigrationClassName = require_relationship.resolveMigrationClassNa
 exports.resolveMigrationStateFilePath = require_relationship.resolveMigrationStateFilePath;
 exports.resolvePersistedMetadataFeatures = require_relationship.resolvePersistedMetadataFeatures;
 exports.resolvePrismaType = require_relationship.resolvePrismaType;
+exports.resolveRegisteredModel = require_relationship.resolveRegisteredModel;
 exports.resolveRuntimeCompatibilityQuerySchema = resolveRuntimeCompatibilityQuerySchema;
 exports.resolveRuntimeCompatibilityQuerySchemaOrThrow = resolveRuntimeCompatibilityQuerySchemaOrThrow;
 exports.runArkormTransaction = require_relationship.runArkormTransaction;