arkormx 2.10.1 → 2.11.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { $ as applyOperationsToPersistedColumnMappingsState, $t as resolvePrismaType, A as getRuntimePrismaClient, An as writeAppliedMigrationsStateToStore, At as buildInverseRelationLine, B as getRegisteredModels, Bt as deriveRelationFieldName, C as getActiveTransactionClient, Cn as markMigrationRun, Ct as applyMigrationRollbackToPrismaSchema, D as getRuntimeDebugHandler, Dn as resolveMigrationStateFilePath, Dt as buildEnumBlock, E as getRuntimeClient, En as removeAppliedMigration, Et as applyOperationsToPrismaSchema, F as loadArkormConfig, Fn as RelationResolutionException, Ft as buildUniqueConstraintLine, G as loadModelsFrom, Gt as formatDefaultValue, H as getRegisteredSeeders, Ht as escapeRegex, I as resetArkormRuntimeForTests, In as ArkormCollection, It as createMigrationTimestamp, J as registerMigrations, Jt as generateMigrationFile, K as loadSeedersFrom, Kt as formatEnumDefaultValue, L as runArkormTransaction, Ln as ArkormException, Lt as deriveCollectionFieldName, M as isDelegateLike, Mn as UnsupportedAdapterFeatureException, Mt as buildModelBlock, N as isQuerySchemaLike, Nn as SetBasedEagerLoader, Nt as buildPrimaryKeyLine, O as getRuntimePaginationCurrentPageResolver, On as supportsDatabaseMigrationState, Ot as buildFieldLine, P as isTransactionCapableClient, Pt as buildRelationLine, Q as resetRuntimeRegistryForTests, Qt as resolveMigrationClassName, R as getRegisteredFactories, Rt as deriveInverseRelationAlias, S as getActiveTransactionAdapter, Sn as markMigrationApplied, St as applyMigrationRollbackToDatabase, T as getRuntimeAdapter, Tn as readAppliedMigrationsStateFromStore, Tt as applyMigrationToPrismaSchema, U as loadFactoriesFrom, Ut as findEnumBlock, V as getRegisteredPaths, Vt as deriveSingularFieldName, W as loadMigrationsFrom, Wt as findModelBlock, X as registerPaths, Xt as pad, Y as registerModels, Yt as getMigrationPlan, Z as registerSeeders, Zt as resolveEnumName, _ as bindAdapterToModels, _n as deleteAppliedMigrationsStateFromStore, _t as PRISMA_ENUM_REGEX, a as HasOneThroughRelation, an as supportsDatabaseReset, at as getPersistedPrimaryKeyGeneration, b as emitRuntimeDebugEvent, bn as getLatestAppliedMigrations, bt as applyCreateTableOperation, c as HasManyRelation, cn as SchemaBuilder, ct as readPersistedColumnMappingsState, d as BelongsToManyRelation, dn as PrimaryKeyGenerationPlanner, dt as resolveColumnMappingsFilePath, en as runMigrationWithPrisma, et as createEmptyPersistedColumnMappingsState, f as Relation, fn as ForeignKeyBuilder, ft as resolvePersistedMetadataFeatures, g as awaitConfiguredModelsRegistration, gn as createEmptyAppliedMigrationsState, gt as PRISMA_ENUM_MEMBER_REGEX, h as URLDriver, hn as computeMigrationChecksum, ht as writePersistedColumnMappingsState, i as MorphManyRelation, in as supportsDatabaseMigrationExecution, it as getPersistedEnumTsType, j as getUserConfig, jn as RuntimeModuleLoader, jt as buildMigrationSource, k as getRuntimePaginationURLDriverFactory, kn as writeAppliedMigrationsState, kt as buildIndexLine, l as BelongsToRelation, ln as EnumBuilder, lt as rebuildPersistedColumnMappingsState, m as Paginator, mn as buildMigrationRunId, mt as validatePersistedMetadataFeaturesForMigrations, n as MorphToManyRelation, nn as stripPrismaSchemaModelsAndEnums, nt as getPersistedColumnMap, o as HasOneRelation, on as toMigrationFileSlug, ot as getPersistedTableMetadata, p as LengthAwarePaginator, pn as buildMigrationIdentity, pt as syncPersistedColumnMappingsFromState, q as registerFactories, qt as formatRelationAction, r as MorphOneRelation, rn as supportsDatabaseCreation, rt as getPersistedEnumMap, s as HasManyThroughRelation, sn as toModelName, st as getPersistedTimestampColumns, t as MorphToRelation, tn as runPrismaCommand, tt as deletePersistedColumnMappingsState, un as TableBuilder, ut as resetPersistedColumnMappingsCache, v as configureArkormRuntime, vn as findAppliedMigration, vt as PRISMA_MODEL_REGEX, w as getDefaultStubsPath, wn as readAppliedMigrationsState, wt as applyMigrationToDatabase, x as ensureArkormConfigLoading, xn as isMigrationApplied, xt as applyDropTableOperation, y as defineConfig, yn as getLastMigrationRun, yt as applyAlterTableOperation, z as getRegisteredMigrations, zt as deriveRelationAlias } from "./relationship-CmhzOlEo.mjs";
+import { $ as applyOperationsToPersistedColumnMappingsState, $n as SetBasedEagerLoader, $t as resolvePrismaType, A as getRuntimePrismaClient, An as where, At as buildInverseRelationLine, B as getRegisteredModels, Bn as getLatestAppliedMigrations, Bt as deriveRelationFieldName, C as getActiveTransactionClient, Cn as fromExpressionNode, Ct as applyMigrationRollbackToPrismaSchema, D as getRuntimeDebugHandler, Dn as raw, Dt as buildEnumBlock, E as getRuntimeClient, En as min, Et as applyOperationsToPrismaSchema, F as loadArkormConfig, Fn as computeMigrationChecksum, Ft as buildUniqueConstraintLine, G as loadModelsFrom, Gn as readAppliedMigrationsStateFromStore, Gt as formatDefaultValue, H as getRegisteredSeeders, Hn as markMigrationApplied, Ht as escapeRegex, I as resetArkormRuntimeForTests, In as createEmptyAppliedMigrationsState, It as createMigrationTimestamp, J as registerMigrations, Jn as supportsDatabaseMigrationState, Jt as generateMigrationFile, K as loadSeedersFrom, Kn as removeAppliedMigration, Kt as formatEnumDefaultValue, L as runArkormTransaction, Ln as deleteAppliedMigrationsStateFromStore, Lt as deriveCollectionFieldName, M as isDelegateLike, Mn as ForeignKeyBuilder, Mt as buildModelBlock, N as isQuerySchemaLike, Nn as buildMigrationIdentity, Nt as buildPrimaryKeyLine, O as getRuntimePaginationCurrentPageResolver, On as sum, Ot as buildFieldLine, P as isTransactionCapableClient, Pn as buildMigrationRunId, Pt as buildRelationLine, Q as resetRuntimeRegistryForTests, Qn as UnsupportedAdapterFeatureException, Qt as resolveMigrationClassName, R as getRegisteredFactories, Rn as findAppliedMigration, Rt as deriveInverseRelationAlias, S as getActiveTransactionAdapter, Sn as fn, St as applyMigrationRollbackToDatabase, T as getRuntimeAdapter, Tn as max, Tt as applyMigrationToPrismaSchema, U as loadFactoriesFrom, Un as markMigrationRun, Ut as findEnumBlock, V as getRegisteredPaths, Vn as isMigrationApplied, Vt as deriveSingularFieldName, W as loadMigrationsFrom, Wn as readAppliedMigrationsState, Wt as findModelBlock, X as registerPaths, Xn as writeAppliedMigrationsStateToStore, Xt as pad, Y as registerModels, Yn as writeAppliedMigrationsState, Yt as getMigrationPlan, Z as registerSeeders, Zn as RuntimeModuleLoader, Zt as resolveEnumName, _ as bindAdapterToModels, _n as caseWhen, _t as PRISMA_ENUM_REGEX, a as HasOneThroughRelation, an as supportsDatabaseReset, at as getPersistedPrimaryKeyGeneration, b as emitRuntimeDebugEvent, bn as count, bt as applyCreateTableOperation, c as HasManyRelation, cn as SchemaBuilder, ct as readPersistedColumnMappingsState, d as BelongsToManyRelation, dn as resolveGeneratedExpression, dt as resolveColumnMappingsFilePath, en as runMigrationWithPrisma, et as createEmptyPersistedColumnMappingsState, f as Relation, fn as AggregateExpression, ft as resolvePersistedMetadataFeatures, g as awaitConfiguredModelsRegistration, gn as avg, gt as PRISMA_ENUM_MEMBER_REGEX, h as URLDriver, hn as JsonExpression, ht as writePersistedColumnMappingsState, i as MorphManyRelation, in as supportsDatabaseMigrationExecution, it as getPersistedEnumTsType, j as getUserConfig, jn as PrimaryKeyGenerationPlanner, jt as buildMigrationSource, k as getRuntimePaginationURLDriverFactory, kn as val, kt as buildIndexLine, l as BelongsToRelation, ln as EnumBuilder, lt as rebuildPersistedColumnMappingsState, m as Paginator, mn as Expression, mt as validatePersistedMetadataFeaturesForMigrations, n as MorphToManyRelation, nn as stripPrismaSchemaModelsAndEnums, nr as ArkormCollection, nt as getPersistedColumnMap, o as HasOneRelation, on as toMigrationFileSlug, ot as getPersistedTableMetadata, p as LengthAwarePaginator, pn as CaseExpression, pt as syncPersistedColumnMappingsFromState, q as registerFactories, qn as resolveMigrationStateFilePath, qt as formatRelationAction, r as MorphOneRelation, rn as supportsDatabaseCreation, rr as ArkormException, rt as getPersistedEnumMap, s as HasManyThroughRelation, sn as toModelName, st as getPersistedTimestampColumns, t as MorphToRelation, tn as runPrismaCommand, tr as RelationResolutionException, tt as deletePersistedColumnMappingsState, un as TableBuilder, ut as resetPersistedColumnMappingsCache, v as configureArkormRuntime, vn as coalesce, vt as PRISMA_MODEL_REGEX, w as getDefaultStubsPath, wn as json, wt as applyMigrationToDatabase, x as ensureArkormConfigLoading, xn as expressionBuilder, xt as applyDropTableOperation, y as defineConfig, yn as col, yt as applyAlterTableOperation, z as getRegisteredMigrations, zn as getLastMigrationRun, zt as deriveRelationAlias } from "./relationship-CP1xbMOa.mjs";
 import { Pool } from "pg";
 import { join, resolve } from "node:path";
 import { createRequire } from "module";
@@ -64,7 +64,8 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 			rawWhere: true,
 			distinct: true,
 			groupBy: true,
-			joins: true
+			joins: true,
+			expressions: true
 		};
 	}
 	resolveConfiguredDatabaseName(connectionString) {
@@ -385,6 +386,13 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	}
 	buildSchemaColumnDefinition(table, column) {
 		const parts = [this.quoteIdentifier(column.map ?? column.name), this.resolveSchemaColumnType(table, column)];
+		if (column.generatedExpression) {
+			const storage = column.generatedStored === false ? "" : " stored";
+			parts.push(`generated always as (${column.generatedExpression})${storage}`);
+			if (column.unique) parts.push("unique");
+			if (!column.nullable && !column.primary) parts.push("not null");
+			return parts.join(" ");
+		}
 		if (this.shouldUseIdentity(column)) parts.push("generated by default as identity");
 		const defaultValue = this.resolveSchemaColumnDefault(column);
 		if (defaultValue && !this.shouldUseIdentity(column)) parts.push(`default ${defaultValue}`);
@@ -450,12 +458,60 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		const table = this.resolveMappedTable(operation.table);
 		await this.ensureEnumTypes(table, operation.addColumns, executor);
 		for (const column of operation.addColumns) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add column if not exists ${this.buildSchemaColumnDefinition(table, column)}`, executor);
+		for (const column of operation.changeColumns ?? []) await this.executeChangeColumn(table, column, executor);
 		for (const column of operation.dropColumns) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} drop column if exists ${this.quoteIdentifier(column)}`, executor);
 		for (const foreignKey of operation.addForeignKeys ?? []) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add ${this.buildSchemaForeignKeyConstraint(table, foreignKey, operation.addColumns)}`, executor);
 		if (operation.addPrimaryKey) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add ${this.buildSchemaPrimaryKeyConstraint(table, operation.addPrimaryKey, operation.addColumns)}`, executor);
 		for (const constraint of operation.addUniqueConstraints ?? []) await this.executeRawStatement(`alter table ${this.quoteIdentifier(table)} add ${this.buildSchemaUniqueConstraint(table, constraint, operation.addColumns)}`, executor);
 		for (const index of operation.addIndexes ?? []) await this.executeRawStatement(this.buildSchemaIndexStatement(table, index, operation.addColumns), executor);
 	}
+	async enumTypeExists(enumName, executor) {
+		const result = await sql`
+            select exists(select 1 from pg_type where typname = ${enumName}) as exists
+        `.execute(executor);
+		return Boolean(result.rows[0]?.exists);
+	}
+	/**
+	* Redefine an existing column in place using ALTER COLUMN statements: the
+	* column type (recreating the enum type when enum values change), nullability,
+	* default, and a conventionally-named unique constraint.
+	*
+	* @param table
+	* @param column
+	* @param executor
+	*/
+	async executeChangeColumn(table, column, executor) {
+		const quotedTable = this.quoteIdentifier(table);
+		const physicalName = column.map ?? column.name;
+		const physical = this.quoteIdentifier(physicalName);
+		if (column.type === "enum") {
+			const enumName = this.resolveSchemaEnumName(table, column);
+			const values = column.enumValues ?? [];
+			if (values.length === 0) throw new ArkormException(`Enum column [${column.name}] requires enum values to change its definition.`);
+			const quotedEnum = this.quoteIdentifier(enumName);
+			const enumLiterals = values.map((value) => this.quoteLiteral(value)).join(", ");
+			if (await this.enumTypeExists(enumName, executor)) {
+				const tempEnum = this.quoteIdentifier(`${enumName}__arkorm_change`);
+				await this.executeRawStatement(`drop type if exists ${tempEnum}`, executor);
+				await this.executeRawStatement(`alter type ${quotedEnum} rename to ${tempEnum}`, executor);
+				await this.executeRawStatement(`create type ${quotedEnum} as enum (${enumLiterals})`, executor);
+				await this.executeRawStatement(`alter table ${quotedTable} alter column ${physical} type ${quotedEnum} using ${physical}::text::${quotedEnum}`, executor);
+				await this.executeRawStatement(`drop type ${tempEnum}`, executor);
+			} else {
+				await this.executeRawStatement(`create type ${quotedEnum} as enum (${enumLiterals})`, executor);
+				await this.executeRawStatement(`alter table ${quotedTable} alter column ${physical} type ${quotedEnum} using ${physical}::text::${quotedEnum}`, executor);
+			}
+		} else {
+			const targetType = this.resolveSchemaColumnType(table, column);
+			await this.executeRawStatement(`alter table ${quotedTable} alter column ${physical} type ${targetType} using ${physical}::${targetType}`, executor);
+		}
+		await this.executeRawStatement(column.nullable ? `alter table ${quotedTable} alter column ${physical} drop not null` : `alter table ${quotedTable} alter column ${physical} set not null`, executor);
+		const defaultValue = this.resolveSchemaColumnDefault(column);
+		await this.executeRawStatement(defaultValue ? `alter table ${quotedTable} alter column ${physical} set default ${defaultValue}` : `alter table ${quotedTable} alter column ${physical} drop default`, executor);
+		const constraint = this.quoteIdentifier(`${table}_${physicalName}_key`);
+		await this.executeRawStatement(`alter table ${quotedTable} drop constraint if exists ${constraint}`, executor);
+		if (column.unique) await this.executeRawStatement(`alter table ${quotedTable} add constraint ${constraint} unique (${physical})`, executor);
+	}
 	async executeDropTableOperation(operation, executor) {
 		const table = this.resolveMappedTable(operation.table);
 		await this.executeRawStatement(`drop table if exists ${this.quoteIdentifier(table)} cascade`, executor);
@@ -594,11 +650,16 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	}
 	buildSelectList(target, columns) {
 		if (!columns || columns.length === 0) return sql.raw("*");
-		return sql.join(columns.map(({ column, alias, raw, wildcard }) => {
+		return sql.join(columns.map(({ column, alias, raw, wildcard, expression }) => {
 			if (wildcard) return sql.raw("*");
+			if (expression) {
+				const compiled = this.buildExpression(target, expression);
+				const resultAlias = alias ?? column;
+				return resultAlias ? sql`${compiled} as ${sql.id(resultAlias)}` : compiled;
+			}
 			if (raw) {
-				const expression = sql.raw(column);
-				return alias ? sql`${expression} as ${sql.id(alias)}` : expression;
+				const rawExpression = sql.raw(column);
+				return alias ? sql`${rawExpression} as ${sql.id(alias)}` : rawExpression;
 			}
 			const mappedColumn = this.mapColumn(target, column);
 			const resultAlias = alias ?? column;
@@ -608,13 +669,18 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 	}
 	buildOrderBy(target, orderBy) {
 		if (!orderBy || orderBy.length === 0) return sql``;
-		return sql` order by ${sql.join(orderBy.map(({ column, direction }) => {
-			return sql`${sql.ref(this.mapColumn(target, column))} ${sql.raw(direction === "desc" ? "desc" : "asc")}`;
+		return sql` order by ${sql.join(orderBy.map(({ column, direction, expression }) => {
+			return sql`${expression ? this.buildExpression(target, expression) : sql.ref(this.mapColumn(target, column))} ${sql.raw(direction === "desc" ? "desc" : "asc")}`;
 		}), sql`, `)}`;
 	}
 	buildGroupBy(target, groupBy) {
 		if (!groupBy || groupBy.length === 0) return sql``;
-		return sql` group by ${sql.join(groupBy.map((column) => sql.ref(this.mapColumn(target, column))), sql`, `)}`;
+		return sql` group by ${sql.join(groupBy.map((item) => {
+			if (typeof item === "string") return sql.ref(this.mapColumn(target, item));
+			if ("alias" in item) return sql.ref(item.alias);
+			if ("expression" in item) return this.buildExpression(target, item.expression);
+			return this.buildRawExpressionFragment(item.raw.sql, item.raw.bindings ?? []);
+		}), sql`, `)}`;
 	}
 	buildHavingClause(target, having) {
 		if (!having) return sql``;
@@ -763,6 +829,96 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		const contains = sql`${accessor} @> ${jsonValue}::jsonb`;
 		return condition.not ? sql`not (${contains})` : contains;
 	}
+	/**
+	* Compiles a serialized {@link ExpressionNode} into a parameterized SQL fragment.
+	* Shared by expression-backed select columns, `group by`, `order by`, and any
+	* boolean expression used as a `where`/`having` predicate.
+	*
+	* @param target
+	* @param node
+	* @returns
+	*/
+	buildExpression(target, node) {
+		switch (node.kind) {
+			case "column": return this.buildExpressionColumn(target, node.name);
+			case "value": return sql`${node.value}`;
+			case "raw": return this.buildRawExpressionFragment(node.sql, node.bindings);
+			case "json": return this.buildJsonValueExpression(target, node);
+			case "function": {
+				const args = node.args.map((arg) => this.buildExpression(target, arg));
+				return sql`${sql.raw(this.sanitizeFunctionName(node.name))}(${sql.join(args, sql`, `)})`;
+			}
+			case "case": {
+				const branches = node.cases.map((branch) => sql`when ${this.buildExpression(target, branch.when)} then ${this.buildExpression(target, branch.then)}`);
+				const elseClause = node.else ? sql` else ${this.buildExpression(target, node.else)}` : sql``;
+				return sql`case ${sql.join(branches, sql` `)}${elseClause} end`;
+			}
+			case "binary": return this.buildBinaryExpression(target, node);
+			case "in": {
+				const operand = this.buildExpression(target, node.operand);
+				const values = node.values.map((value) => this.buildExpression(target, value));
+				const list = values.length > 0 ? sql.join(values, sql`, `) : sql`null`;
+				return node.not ? sql`(${operand} not in (${list}))` : sql`(${operand} in (${list}))`;
+			}
+			case "null-check": {
+				const operand = this.buildExpression(target, node.operand);
+				return node.not ? sql`(${operand} is not null)` : sql`(${operand} is null)`;
+			}
+			case "aggregate": return this.buildAggregateExpression(target, node);
+			default: throw new ArkormException(`Unsupported expression node [${node.kind}].`);
+		}
+	}
+	buildExpressionColumn(target, name) {
+		if (name.includes(".")) return sql.ref(name);
+		return sql.ref(this.mapColumn(target, name));
+	}
+	buildBinaryExpression(target, node) {
+		const left = this.buildExpression(target, node.left);
+		const right = this.buildExpression(target, node.right);
+		switch (node.operator) {
+			case "like": return sql`(${left} like ${right})`;
+			case "ilike": return sql`(${left} ilike ${right})`;
+			case "not-like": return sql`(${left} not like ${right})`;
+			case "not-ilike": return sql`(${left} not ilike ${right})`;
+			case "and": return sql`(${left} and ${right})`;
+			case "or": return sql`(${left} or ${right})`;
+			default: return sql`(${left} ${sql.raw(node.operator)} ${right})`;
+		}
+	}
+	buildAggregateExpression(target, node) {
+		const argument = node.arg ? this.buildExpression(target, node.arg) : sql.raw("*");
+		const distinctKeyword = node.distinct ? sql`distinct ` : sql``;
+		let call = sql`${sql.raw(node.fn)}(${distinctKeyword}${argument})`;
+		if (node.filter) call = sql`${call} filter (where ${this.buildExpression(target, node.filter)})`;
+		if (node.fn === "sum" || node.fn === "avg") return sql`(${call})::double precision`;
+		if (node.fn === "count") return sql`(${call})::bigint`;
+		return call;
+	}
+	buildJsonValueExpression(target, node) {
+		const base = sql`${sql.ref(this.mapColumn(target, node.column))}::jsonb`;
+		let accessor;
+		if (node.path.length === 0) accessor = base;
+		else if (node.path.length === 1) accessor = sql`(${base} ->> ${node.path[0]})`;
+		else accessor = sql`(${base} #>> ${`{${node.path.join(",")}}`}::text[])`;
+		if (node.cast === "number") return sql`(${accessor})::numeric`;
+		if (node.cast === "boolean") return sql`(${accessor})::boolean`;
+		return accessor;
+	}
+	buildRawExpressionFragment(rawSql, bindings) {
+		const segments = rawSql.split("?");
+		if (segments.length !== bindings.length + 1) throw new ArkormException("Raw expression bindings do not match the number of placeholders.");
+		const parts = [];
+		segments.forEach((segment, index) => {
+			if (segment.length > 0) parts.push(sql.raw(this.quoteCamelCaseIdentifiers(segment)));
+			if (index < bindings.length) parts.push(sql`${bindings[index]}`);
+		});
+		if (parts.length === 0) return sql``;
+		return sql`${sql.join(parts, sql``)}`;
+	}
+	sanitizeFunctionName(name) {
+		if (!/^[a-zA-Z_][a-zA-Z0-9_.]*$/.test(name)) throw new ArkormException(`Unsupported SQL function name [${name}].`);
+		return name;
+	}
 	buildWhereCondition(target, condition) {
 		if (!condition) return sql`1 = 1`;
 		if (condition.type === "comparison") return this.buildComparisonCondition(target, condition);
@@ -772,6 +928,7 @@ var KyselyDatabaseAdapter = class KyselyDatabaseAdapter {
 		if (condition.type === "exists") return this.buildExistsCondition(condition);
 		if (condition.type === "full-text") return this.buildFullTextCondition(target, condition);
 		if (condition.type === "json") return this.buildJsonCondition(target, condition);
+		if (condition.type === "expression") return sql`${this.buildExpression(target, condition.expression)}`;
 		if (condition.type === "group") {
 			const group = condition;
 			const conditions = group.conditions.map((entry) => {
@@ -1644,6 +1801,7 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 			rawWhere: false,
 			distinct: false,
 			groupBy: false,
+			expressions: false,
 			returning: false
 		};
 	}
@@ -1679,6 +1837,14 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 	}
 	toQuerySelect(columns) {
 		if (!columns || columns.length === 0) return void 0;
+		const expressionColumn = columns.find((column) => column.expression);
+		if (expressionColumn) throw new UnsupportedAdapterFeatureException("Expression select columns are not supported by the Prisma compatibility adapter; use a SQL-backed adapter.", {
+			operation: "adapter.select",
+			meta: {
+				feature: "expressions",
+				alias: expressionColumn.alias
+			}
+		});
 		const rawColumn = columns.find((column) => column.raw);
 		if (rawColumn) throw new UnsupportedAdapterFeatureException("Raw select expressions are not supported by the Prisma compatibility adapter; use a SQL-backed adapter or DB.raw().", {
 			operation: "adapter.select",
@@ -1696,6 +1862,10 @@ var PrismaDatabaseAdapter = class PrismaDatabaseAdapter {
 	}
 	toQueryOrderBy(orderBy) {
 		if (!orderBy || orderBy.length === 0) return void 0;
+		if (orderBy.some((entry) => entry.expression)) throw new UnsupportedAdapterFeatureException("Order-by expressions are not supported by the Prisma compatibility adapter; use a SQL-backed adapter.", {
+			operation: "adapter.select",
+			meta: { feature: "expressions" }
+		});
 		return orderBy.map((entry) => ({ [entry.column]: entry.direction }));
 	}
 	toComparisonWhere(condition) {
@@ -3325,13 +3495,22 @@ var Migration = class {
 	static {
 		this[MIGRATION_BRAND] = true;
 	}
+	/**
+	* Optional lifecycle hook invoked after the migration's schema operations
+	* have been applied to the database, for either direction. Override it to run
+	* extra logic such as seeding or data backfills once the schema is in place.
+	*
+	* @param direction The direction that just ran (`'up'` or `'down'`).
+	*/
+	done(_direction) {}
 };
 
 //#endregion
 //#region src/cli/commands/MigrateCommand.ts
 /**
 * The MigrateCommand class implements the CLI command for applying migration
-* classes to the Prisma schema and running the Prisma workflow.
+* classes to the database or Prisma schema and running the Prisma workflow when
+* using the Prisma compatibility driver.
 *
 * @author Legacy (3m1n3nc3)
 * @since 0.1.0
@@ -3342,22 +3521,22 @@ var MigrateCommand = class extends Command {
 		this.signature = `migrate
         {name? : Migration class or file name}
         {--all : Run all migrations from the configured migrations directory}
-        {--deploy : Use prisma migrate deploy instead of migrate dev}
-        {--skip-generate : Skip prisma generate}
+        {--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}
         {--state-file= : Path to applied migration state file}
-        {--schema= : Explicit prisma schema path}
-        {--migration-name= : Name for prisma migrate dev}
+        {--schema= : Explicit prisma schema path (Prisma compatibility driver only)}
+        {--migration-name= : Name for prisma migrate dev (Prisma compatibility driver only)}
         {--create-database : Create the configured database without prompting}
     `;
-		this.description = "Apply migration classes to schema.prisma and run Prisma workflow";
+		this.description = "Apply migration classes to the database or schema.prisma and run Prisma workflow when using the Prisma compatibility driver";
 	}
 	/**
 	* Command handler for the migrate command.
 	* This method is responsible for orchestrating the migration
 	* process, including loading migration classes, applying them to
-	* the Prisma schema, and running the appropriate Prisma commands
-	* based on the provided options.
+	* the the database or Prisma schema, and running the appropriate Prisma commands
+	* when using the Prisma compatibility driver based on the provided options.
 	*
 	* @returns
 	*/
@@ -3566,10 +3745,10 @@ var MigrateFreshCommand = class extends Command {
 	constructor(..._args) {
 		super(..._args);
 		this.signature = `migrate:fresh
-        {--skip-generate : Skip prisma generate}
-        {--skip-migrate : Skip prisma database sync}
+        {--skip-generate : Skip prisma generate (Prisma compatibility driver only)}
+        {--skip-migrate : Skip prisma database sync (Prisma compatibility driver only)}
         {--state-file= : Path to applied migration state file}
-        {--schema= : Explicit prisma schema path}
+        {--schema= : Explicit prisma schema path (Prisma compatibility driver only)}
         {--create-database : Create the configured database without prompting}
     `;
 		this.description = "Reset the database and rerun all migration classes";
@@ -3724,12 +3903,12 @@ var MigrateRollbackCommand = class extends Command {
 		this.signature = `migrate:rollback
         {--step= : Number of latest applied migration classes to rollback}
         {--dry-run : Preview rollback targets without applying changes}
-        {--deploy : Use prisma migrate deploy instead of migrate dev}
-        {--skip-generate : Skip prisma generate}
-        {--skip-migrate : Skip prisma migrate command}
+        {--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 (Prisma compatibility driver only)}
         {--state-file= : Path to applied migration state file}
-        {--schema= : Explicit prisma schema path}
-        {--migration-name= : Name for prisma migrate dev}
+        {--schema= : Explicit prisma schema path (Prisma compatibility driver only)}
+        {--migration-name= : Name for prisma migrate dev (Prisma compatibility driver only)}
     `;
 		this.description = "Rollback migration classes from schema.prisma and run Prisma workflow";
 	}
@@ -3744,7 +3923,7 @@ var MigrateRollbackCommand = class extends Command {
 		const useDatabaseMigrations = supportsDatabaseMigrationExecution(adapter);
 		const persistedFeatures = resolvePersistedMetadataFeatures(this.app.getConfig("features"));
 		let appliedState = await readAppliedMigrationsStateFromStore(adapter, stateFilePath);
-		const stepOption = this.option("step");
+		const stepOption = this.option("step", 1);
 		const stepCount = stepOption == null ? void 0 : Number(stepOption);
 		if (stepCount != null && (!Number.isFinite(stepCount) || stepCount <= 0 || !Number.isInteger(stepCount))) return void this.error("Error: --step must be a positive integer.");
 		const targets = stepCount ? getLatestAppliedMigrations(appliedState, stepCount) : (() => {
@@ -4419,14 +4598,34 @@ var QueryBuilder = class QueryBuilder {
 		return Math.max(1, resolvedPage);
 	}
 	where(whereOrCallback) {
+		if (whereOrCallback instanceof Expression) return this.appendExpressionCondition("AND", whereOrCallback);
 		if (typeof whereOrCallback === "function") return this.appendNestedWhere("AND", whereOrCallback);
 		return this.addLogicalWhere("AND", whereOrCallback);
 	}
 	orWhere(whereOrCallback) {
+		if (whereOrCallback instanceof Expression) return this.appendExpressionCondition("OR", whereOrCallback);
 		if (typeof whereOrCallback === "function") return this.appendNestedWhere("OR", whereOrCallback);
 		return this.addLogicalWhere("OR", whereOrCallback);
 	}
 	/**
+	* Appends a boolean {@link Expression} as a where predicate. When the query is
+	* using the Prisma-like legacy where representation, the expression is merged in
+	* as a structured condition alongside it.
+	*/
+	appendExpressionCondition(boolean, expression) {
+		const condition = {
+			type: "expression",
+			expression: expression.toExpressionNode()
+		};
+		if (this.legacyWhere) {
+			const existing = this.tryBuildQueryCondition(this.legacyWhere);
+			this.legacyWhere = void 0;
+			if (existing) this.queryWhere = existing;
+		}
+		this.appendQueryCondition(boolean, condition);
+		return this;
+	}
+	/**
 	* Resolve a callback into a parenthesized group condition and append it.
 	*/
 	appendNestedWhere(boolean, callback) {
@@ -5076,15 +5275,17 @@ var QueryBuilder = class QueryBuilder {
 	whereIn(key, values) {
 		return this.where({ [key]: { in: values } });
 	}
-	/**
-	* Adds an orderBy clause to the query. This will overwrite any existing orderBy clause.
-	*
-	* @param orderBy
-	* @returns
-	*/
-	orderBy(orderBy) {
+	orderBy(orderByOrExpression, direction = "asc") {
 		this.randomOrderEnabled = false;
-		const normalized = this.normalizeQueryOrderBy(orderBy);
+		if (orderByOrExpression instanceof Expression) {
+			this.queryOrderBy = [...this.queryOrderBy ?? [], {
+				column: "",
+				direction,
+				expression: orderByOrExpression.toExpressionNode()
+			}];
+			return this;
+		}
+		const normalized = this.normalizeQueryOrderBy(orderByOrExpression);
 		if (!normalized) throw new UnsupportedAdapterFeatureException("Order clauses must use Arkorm-normalizable column directions.", {
 			operation: "orderBy",
 			model: this.model.name
@@ -5093,6 +5294,28 @@ var QueryBuilder = class QueryBuilder {
 		return this;
 	}
 	/**
+	* Appends a raw SQL `order by` fragment (with positional `?` bindings), useful
+	* for ordering by a computed expression the builder does not model directly.
+	*
+	* @param sql
+	* @param bindings
+	* @param direction
+	* @returns
+	*/
+	orderByRaw(sql, bindings = [], direction = "asc") {
+		this.randomOrderEnabled = false;
+		this.queryOrderBy = [...this.queryOrderBy ?? [], {
+			column: "",
+			direction,
+			expression: {
+				kind: "raw",
+				sql,
+				bindings
+			}
+		}];
+		return this;
+	}
+	/**
 	* Puts the query results in random order.
 	*
 	* @returns
@@ -5458,12 +5681,6 @@ var QueryBuilder = class QueryBuilder {
 	pipe(callback) {
 		return callback(this);
 	}
-	/**
-	* Adds a select clause to the query. This will overwrite any existing select clause.
-	*
-	* @param select
-	* @returns
-	*/
 	select(select) {
 		const normalized = this.normalizeQuerySelect(select);
 		if (normalized === null) throw new UnsupportedAdapterFeatureException("Select clauses must use Arkorm-normalizable column projections.", {
@@ -5473,12 +5690,6 @@ var QueryBuilder = class QueryBuilder {
 		this.querySelect = normalized;
 		return this;
 	}
-	/**
-	* Appends columns or expressions to the existing select clause.
-	*
-	* @param select
-	* @returns
-	*/
 	addSelect(select) {
 		const normalized = this.normalizeQuerySelect(select);
 		if (normalized === null) throw new UnsupportedAdapterFeatureException("Select clauses must use Arkorm-normalizable column projections.", {
@@ -5502,6 +5713,8 @@ var QueryBuilder = class QueryBuilder {
 		return this;
 	}
 	groupBy(...columns) {
+		const first = columns[0];
+		if (columns.length === 1 && this.isGroupByAggregateSpec(first)) return this.executeGroupByAggregate(first);
 		const normalized = Array.isArray(columns[0]) ? columns[0] : columns;
 		if (normalized.length === 0) throw new QueryConstraintException("groupBy requires at least one column.", {
 			operation: "groupBy",
@@ -5510,6 +5723,109 @@ var QueryBuilder = class QueryBuilder {
 		this.queryGroupBy = [...normalized];
 		return this;
 	}
+	/**
+	* Appends a raw SQL `group by` fragment (with positional `?` bindings), mirroring
+	* `whereRaw`/`havingRaw`. Combines with any columns/expressions already grouped.
+	*
+	* @param sql
+	* @param bindings
+	* @returns
+	*/
+	groupByRaw(sql, bindings = []) {
+		this.queryGroupBy = [...this.queryGroupBy ?? [], { raw: {
+			sql,
+			bindings
+		} }];
+		return this;
+	}
+	/**
+	* Resolves the recorded group-by sources into adapter {@link QueryGroupByItem}s.
+	* A bare string that matches a select-column alias is expanded to that column's
+	* underlying expression (group-by-alias); otherwise it is treated as a column.
+	*/
+	buildGroupByItems(selectColumns) {
+		if (!this.queryGroupBy || this.queryGroupBy.length === 0) return void 0;
+		const expressionAliases = /* @__PURE__ */ new Map();
+		selectColumns?.forEach((column) => {
+			if (column.expression && column.alias) expressionAliases.set(JSON.stringify(column.expression), column.alias);
+		});
+		const aliasNames = new Set(expressionAliases.values());
+		return this.queryGroupBy.map((source) => {
+			if (source instanceof Expression) {
+				const node = source.toExpressionNode();
+				const alias = expressionAliases.get(JSON.stringify(node));
+				return alias ? { alias } : { expression: node };
+			}
+			if (typeof source === "object") return { raw: source.raw };
+			return aliasNames.has(source) ? { alias: source } : source;
+		});
+	}
+	isGroupByAggregateSpec(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Expression) && Array.isArray(value.by);
+	}
+	/**
+	* Executes the query and returns plain, un-hydrated rows keyed by their select
+	* alias — the natural shape for `select` + `groupBy` aggregate reports. Pass a
+	* row type to describe the projection.
+	*
+	* @returns
+	*/
+	async getRows() {
+		return await this.executeReadRows();
+	}
+	/**
+	* Runs a Prisma-style grouped aggregate and returns typed rows shaped as
+	* `{ <by columns>, _sum, _avg, _min, _max, _count }`.
+	*/
+	async executeGroupByAggregate(spec) {
+		const selectMap = {};
+		spec.by.forEach((column) => {
+			selectMap[column] = true;
+		});
+		const aggregates = [];
+		const register = (group, factory, map, numeric) => {
+			Object.keys(map).forEach((column) => {
+				if (!map[column]) return;
+				const alias = `${group}_${column}`;
+				selectMap[alias] = factory(column);
+				aggregates.push({
+					group,
+					column,
+					alias,
+					numeric
+				});
+			});
+		};
+		if (spec._sum) register("_sum", (column) => sum(column), spec._sum, true);
+		if (spec._avg) register("_avg", (column) => avg(column), spec._avg, true);
+		if (spec._min) register("_min", (column) => min(column), spec._min, false);
+		if (spec._max) register("_max", (column) => max(column), spec._max, false);
+		let countAllAlias;
+		if (spec._count === true) {
+			countAllAlias = "_count_all";
+			selectMap[countAllAlias] = count();
+		} else if (spec._count) register("_count", (column) => count(column), spec._count, true);
+		this.select(selectMap);
+		this.groupBy(spec.by);
+		return (await this.getRows()).map((row) => {
+			const result = {};
+			spec.by.forEach((column) => {
+				result[column] = row[column];
+			});
+			const grouped = {};
+			aggregates.forEach(({ group, column, alias, numeric }) => {
+				grouped[group] ??= {};
+				grouped[group][column] = numeric ? this.coerceNumeric(row[alias]) : row[alias];
+			});
+			Object.assign(result, grouped);
+			if (countAllAlias) result._count = this.coerceNumeric(row[countAllAlias]);
+			return result;
+		});
+	}
+	coerceNumeric(value) {
+		if (value === null || value === void 0) return null;
+		return Number(value);
+	}
 	appendHavingCondition(boolean, condition) {
 		if (!this.queryHaving) {
 			this.queryHaving = condition;
@@ -5530,12 +5846,35 @@ var QueryBuilder = class QueryBuilder {
 			value: hasOperator ? maybeValue : operatorOrValue
 		};
 	}
-	having(column, operatorOrValue, maybeValue) {
-		this.appendHavingCondition("AND", this.buildHavingComparison(operatorOrValue, maybeValue, column));
+	/**
+	* Resolves the three `having` call shapes into a condition: `having(column, …)`,
+	* `having(expression)` (a boolean expression predicate), and
+	* `having(expression, operator, value)` (compare an aggregate to a value).
+	*/
+	buildHavingCondition(columnOrExpression, operatorOrValue, maybeValue) {
+		if (columnOrExpression instanceof Expression) return {
+			type: "expression",
+			expression: (operatorOrValue === void 0 ? columnOrExpression : this.compareExpression(columnOrExpression, operatorOrValue, maybeValue)).toExpressionNode()
+		};
+		return this.buildHavingComparison(operatorOrValue, maybeValue, columnOrExpression);
+	}
+	compareExpression(expression, operator, value) {
+		switch (operator) {
+			case "=": return expression.eq(value);
+			case "!=": return expression.ne(value);
+			case ">": return expression.gt(value);
+			case ">=": return expression.gte(value);
+			case "<": return expression.lt(value);
+			case "<=": return expression.lte(value);
+			default: return expression.eq(value);
+		}
+	}
+	having(columnOrExpression, operatorOrValue, maybeValue) {
+		this.appendHavingCondition("AND", this.buildHavingCondition(columnOrExpression, operatorOrValue, maybeValue));
 		return this;
 	}
-	orHaving(column, operatorOrValue, maybeValue) {
-		this.appendHavingCondition("OR", this.buildHavingComparison(operatorOrValue, maybeValue, column));
+	orHaving(columnOrExpression, operatorOrValue, maybeValue) {
+		this.appendHavingCondition("OR", this.buildHavingCondition(columnOrExpression, operatorOrValue, maybeValue));
 		return this;
 	}
 	/**
@@ -6693,12 +7032,19 @@ var QueryBuilder = class QueryBuilder {
 		}
 		if (typeof select !== "object" || !select) return null;
 		const entries = Object.entries(select);
-		if (entries.some(([, value]) => value !== true && value !== false && value !== void 0 && typeof value !== "string")) return null;
-		const columns = entries.filter(([, value]) => value === true || typeof value === "string").map(([column, value]) => typeof value === "string" ? {
-			column,
-			alias: value,
-			raw: true
-		} : { column });
+		if (entries.some(([, value]) => value !== true && value !== false && value !== void 0 && typeof value !== "string" && !(value instanceof Expression))) return null;
+		const columns = entries.filter(([, value]) => value === true || typeof value === "string" || value instanceof Expression).map(([column, value]) => {
+			if (value instanceof Expression) return {
+				column,
+				alias: column,
+				expression: value.toExpressionNode()
+			};
+			return typeof value === "string" ? {
+				column,
+				alias: value,
+				raw: true
+			} : { column };
+		});
 		return columns.length > 0 ? columns : [];
 	}
 	normalizeQueryOrderBy(orderBy) {
@@ -6856,7 +7202,7 @@ var QueryBuilder = class QueryBuilder {
 					offset: normalizedQuery.offsetValue,
 					columns: normalizedQuery.querySelect ? [...normalizedQuery.querySelect] : void 0,
 					distinct: normalizedQuery.queryDistinct || void 0,
-					groupBy: normalizedQuery.queryGroupBy ? [...normalizedQuery.queryGroupBy] : void 0,
+					groupBy: normalizedQuery.queryGroupBy ? normalizedQuery.queryGroupBy.filter((source) => typeof source === "string") : void 0,
 					relationLoads: this.mergeRelationLoadPlans(normalizedQuery.queryRelationLoads ? this.cloneRelationLoads(normalizedQuery.queryRelationLoads) : void 0, this.mergeRelationLoadPlans(callbackRelationLoads, childRelationLoads))
 				});
 			}
@@ -7120,11 +7466,11 @@ var QueryBuilder = class QueryBuilder {
 		if (columns === null || orderBy === null || condition === null) return null;
 		if (this.hasRelationFilters() && this.canExecuteRelationFiltersInAdapter() && relationFilters === null) return null;
 		if (this.hasRelationAggregates() && this.canExecuteRelationAggregatesInAdapter() && relationAggregates === null) return null;
-		return {
+		return this.expandComputedAttributes({
 			target: this.buildQueryTarget(),
 			columns,
 			distinct: this.queryDistinct || void 0,
-			groupBy: this.queryGroupBy ? [...this.queryGroupBy] : void 0,
+			groupBy: this.buildGroupByItems(columns ?? void 0),
 			having: this.queryHaving,
 			joins: this.queryJoins ? [...this.queryJoins] : void 0,
 			where: condition,
@@ -7134,8 +7480,87 @@ var QueryBuilder = class QueryBuilder {
 			relationLoads: this.queryRelationLoads,
 			relationFilters: this.canExecuteRelationFiltersInAdapter() ? relationFilters ?? void 0 : void 0,
 			relationAggregates: this.canExecuteRelationAggregatesInAdapter() ? relationAggregates ?? void 0 : void 0
+		});
+	}
+	/** Reads and caches the model's resolved `static computed` expression map. */
+	computedAttributes() {
+		const model = this.model;
+		return typeof model.getComputed === "function" ? model.getComputed() : {};
+	}
+	/**
+	* Expands references to `static computed` attribute names into their backing
+	* expressions across a select spec's columns, group by, order by, where, and
+	* having clauses. A no-op when the model declares no computed attributes.
+	*/
+	expandComputedAttributes(spec) {
+		const computed = this.computedAttributes();
+		if (Object.keys(computed).length === 0) return spec;
+		const columns = spec.columns?.map((column) => {
+			if (column.expression || column.raw || column.wildcard) return column;
+			const expression = computed[column.column];
+			return expression ? {
+				...column,
+				expression,
+				alias: column.alias ?? column.column
+			} : column;
+		});
+		const selectedComputedAliases = new Set(columns?.filter((column) => column.expression && column.alias).map((column) => column.alias));
+		return {
+			...spec,
+			columns,
+			groupBy: spec.groupBy?.map((item) => {
+				if (typeof item !== "string") return item;
+				const expression = computed[item];
+				if (!expression) return item;
+				return selectedComputedAliases.has(item) ? { alias: item } : { expression };
+			}),
+			orderBy: spec.orderBy?.map((clause) => {
+				if (clause.expression) return clause;
+				const expression = computed[clause.column];
+				return expression ? {
+					...clause,
+					expression
+				} : clause;
+			}),
+			where: spec.where ? this.expandComputedCondition(spec.where, computed) : spec.where,
+			having: spec.having ? this.expandComputedCondition(spec.having, computed) : spec.having
 		};
 	}
+	expandComputedCondition(condition, computed) {
+		if (condition.type === "comparison" && computed[condition.column]) return {
+			type: "expression",
+			expression: this.computedComparison(computed[condition.column], condition.operator, condition.value)
+		};
+		if (condition.type === "group") return {
+			...condition,
+			conditions: condition.conditions.map((entry) => this.expandComputedCondition(entry, computed))
+		};
+		if (condition.type === "not") return {
+			...condition,
+			condition: this.expandComputedCondition(condition.condition, computed)
+		};
+		return condition;
+	}
+	/** Converts a where comparison against a computed attribute into an expression. */
+	computedComparison(node, operator, value) {
+		const expression = fromExpressionNode(node);
+		const list = Array.isArray(value) ? value : [];
+		switch (operator) {
+			case "!=": return expression.ne(value).toExpressionNode();
+			case ">": return expression.gt(value).toExpressionNode();
+			case ">=": return expression.gte(value).toExpressionNode();
+			case "<": return expression.lt(value).toExpressionNode();
+			case "<=": return expression.lte(value).toExpressionNode();
+			case "in": return expression.in(list).toExpressionNode();
+			case "not-in": return expression.notIn(list).toExpressionNode();
+			case "is-null": return expression.isNull().toExpressionNode();
+			case "is-not-null": return expression.isNotNull().toExpressionNode();
+			case "contains": return expression.like(`%${String(value)}%`).toExpressionNode();
+			case "starts-with": return expression.like(`${String(value)}%`).toExpressionNode();
+			case "ends-with": return expression.like(`%${String(value)}`).toExpressionNode();
+			default: return expression.eq(value).toExpressionNode();
+		}
+	}
 	tryBuildAggregateSpec() {
 		const condition = this.buildQueryWhereCondition(false);
 		const relationFilters = this.tryBuildRelationFilterSpecs();
@@ -7634,6 +8059,9 @@ var Model = class Model {
 	static {
 		this.castMapCache = /* @__PURE__ */ new WeakMap();
 	}
+	static {
+		this.computedCache = /* @__PURE__ */ new WeakMap();
+	}
 	static {
 		this.emittedDeprecationWarnings = /* @__PURE__ */ new Set();
 	}
@@ -7784,6 +8212,19 @@ var Model = class Model {
 		return casts;
 	}
 	/**
+	* Resolves the model's `static computed` declarations into expression nodes,
+	* cached per class. Returns an empty map when no computed attributes exist.
+	*/
+	static getComputed() {
+		const cached = Model.computedCache.get(this);
+		if (cached) return cached;
+		const definitions = this.computed;
+		const resolved = {};
+		if (definitions) for (const [name, factory] of Object.entries(definitions)) resolved[name] = factory(expressionBuilder).toExpressionNode();
+		Model.computedCache.set(this, resolved);
+		return resolved;
+	}
+	/**
 	* Apply built-in persistence casts (currently `json` serialisation) to a raw
 	* attribute payload, without re-running arbitrary custom setters. Used by
 	* both instance `save()` and the query-builder insert/update paths so a JS
@@ -8190,6 +8631,22 @@ var Model = class Model {
 		});
 		return this;
 	}
+	/**
+	* Merge already-stored (database representation) attribute values into the
+	* model without running set mutators or casts. Used to refresh the instance
+	* from a row returned by a write, where the values are already in storage
+	* form and must not be re-cast (re-applying a non-idempotent set-cast such as
+	* a money or array cast would corrupt the value).
+	*
+	* @param attributes
+	* @returns
+	*/
+	fillRawAttributes(attributes) {
+		Object.entries(attributes).forEach(([key, value]) => {
+			this.attributes[key] = Model.cloneAttributeValue(value);
+		});
+		return this;
+	}
 	async update(attributes) {
 		try {
 			const primaryKey = this.constructor.getPrimaryKey();
@@ -8245,7 +8702,7 @@ var Model = class Model {
 			await Model.dispatchEvent(constructor, "creating", this);
 			const payload = this.normalizePersistenceAttributes(this.getRawAttributes());
 			const model = await constructor.query().create(payload);
-			this.fill(model.getRawAttributes());
+			this.fillRawAttributes(model.getRawAttributes());
 			this.syncChanges(previousOriginal);
 			this.syncPrevious(previousOriginal);
 			this.syncOriginal();
@@ -8262,7 +8719,7 @@ var Model = class Model {
 		const payload = this.normalizePersistenceAttributes(this.getDirtyAttributes());
 		delete payload[primaryKey];
 		const model = await constructor.query().where({ [primaryKey]: identifier }).update(payload);
-		this.fill(model.getRawAttributes());
+		this.fillRawAttributes(model.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncPrevious(previousOriginal);
 		this.syncOriginal();
@@ -8305,7 +8762,7 @@ var Model = class Model {
 		const softDeleteConfig = constructor.getSoftDeleteConfig();
 		if (softDeleteConfig.enabled) {
 			const model = await constructor.query().where({ [primaryKey]: identifier }).update({ [softDeleteConfig.column]: /* @__PURE__ */ new Date() });
-			this.fill(model.getRawAttributes());
+			this.fillRawAttributes(model.getRawAttributes());
 			this.syncChanges(previousOriginal);
 			this.syncOriginal();
 			await Model.dispatchEvent(constructor, "deleted", this);
@@ -8380,7 +8837,7 @@ var Model = class Model {
 		const previousOriginal = this.getOriginal();
 		await Model.dispatchEvent(constructor, "restoring", this);
 		const model = await constructor.query().withTrashed().where({ [primaryKey]: identifier }).update({ [softDeleteConfig.column]: null });
-		this.fill(model.getRawAttributes());
+		this.fillRawAttributes(model.getRawAttributes());
 		this.syncChanges(previousOriginal);
 		this.syncOriginal();
 		await Model.dispatchEvent(constructor, "restored", this);
@@ -9624,4 +10081,4 @@ var PivotModel = class extends Model {
 };
 
 //#endregion
-export { Arkorm, ArkormCollection, ArkormException, Arkormx, Attribute, CliApp, DB, EnumBuilder, ForeignKeyBuilder, InitCommand, InlineFactory, JoinClause, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateFreshCommand, MigrateRollbackCommand, Migration, MigrationHistoryCommand, MissingDelegateException, Model, ModelFactory, ModelNotFoundException, ModelsSyncCommand, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, Paginator, PivotModel, PrimaryKeyGenerationPlanner, PrismaDatabaseAdapter, QueryBuilder, QueryConstraintException, QueryExecutionException, RelationResolutionException, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, ScopeNotDefinedException, SeedCommand, Seeder, TableBuilder, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToDatabase, applyMigrationRollbackToPrismaSchema, applyMigrationToDatabase, applyMigrationToPrismaSchema, applyOperationsToPersistedColumnMappingsState, applyOperationsToPrismaSchema, awaitConfiguredModelsRegistration, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildPrimaryKeyLine, buildRelationLine, buildUniqueConstraintLine, computeMigrationChecksum, configureArkormRuntime, createEmptyAppliedMigrationsState, createEmptyPersistedColumnMappingsState, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deleteAppliedMigrationsStateFromStore, deletePersistedColumnMappingsState, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, emitRuntimeDebugEvent, ensureArkormConfigLoading, escapeRegex, findAppliedMigration, findEnumBlock, findModelBlock, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, generateMigrationFile, getActiveTransactionAdapter, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getPersistedColumnMap, getPersistedEnumMap, getPersistedEnumTsType, getPersistedPrimaryKeyGeneration, getPersistedTableMetadata, getPersistedTimestampColumns, getRegisteredFactories, getRegisteredMigrations, getRegisteredModels, getRegisteredPaths, getRegisteredSeeders, getRuntimeAdapter, getRuntimeClient, getRuntimeCompatibilityAdapter, getRuntimeDebugHandler, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isQuerySchemaLike, isTransactionCapableClient, loadArkormConfig, loadFactoriesFrom, loadMigrationsFrom, loadModelsFrom, loadSeedersFrom, markMigrationApplied, markMigrationRun, pad, readAppliedMigrationsState, readAppliedMigrationsStateFromStore, readPersistedColumnMappingsState, rebuildPersistedColumnMappingsState, registerFactories, registerMigrations, registerModels, registerPaths, registerSeeders, removeAppliedMigration, resetArkormRuntimeForTests, resetPersistedColumnMappingsCache, resetRuntimeRegistryForTests, resolveCast, resolveColumnMappingsFilePath, resolveEnumName, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePersistedMetadataFeatures, resolvePrismaType, resolveRuntimeCompatibilityQuerySchema, resolveRuntimeCompatibilityQuerySchemaOrThrow, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, stripPrismaSchemaModelsAndEnums, supportsDatabaseCreation, supportsDatabaseMigrationExecution, supportsDatabaseMigrationState, supportsDatabaseReset, syncPersistedColumnMappingsFromState, toMigrationFileSlug, toModelName, validatePersistedMetadataFeaturesForMigrations, writeAppliedMigrationsState, writeAppliedMigrationsStateToStore, writePersistedColumnMappingsState };
+export { AggregateExpression, Arkorm, ArkormCollection, ArkormException, Arkormx, Attribute, CaseExpression, CliApp, DB, EnumBuilder, Expression, ForeignKeyBuilder, InitCommand, InlineFactory, JoinClause, JsonExpression, KyselyDatabaseAdapter, LengthAwarePaginator, MIGRATION_BRAND, MakeFactoryCommand, MakeMigrationCommand, MakeModelCommand, MakeSeederCommand, MigrateCommand, MigrateFreshCommand, MigrateRollbackCommand, Migration, MigrationHistoryCommand, MissingDelegateException, Model, ModelFactory, ModelNotFoundException, ModelsSyncCommand, PRISMA_ENUM_MEMBER_REGEX, PRISMA_ENUM_REGEX, PRISMA_MODEL_REGEX, Paginator, PivotModel, PrimaryKeyGenerationPlanner, PrismaDatabaseAdapter, QueryBuilder, QueryConstraintException, QueryExecutionException, RelationResolutionException, RuntimeModuleLoader, SEEDER_BRAND, SchemaBuilder, ScopeNotDefinedException, SeedCommand, Seeder, TableBuilder, URLDriver, UniqueConstraintResolutionException, UnsupportedAdapterFeatureException, applyAlterTableOperation, applyCreateTableOperation, applyDropTableOperation, applyMigrationRollbackToDatabase, applyMigrationRollbackToPrismaSchema, applyMigrationToDatabase, applyMigrationToPrismaSchema, applyOperationsToPersistedColumnMappingsState, applyOperationsToPrismaSchema, avg, awaitConfiguredModelsRegistration, bindAdapterToModels, buildEnumBlock, buildFieldLine, buildIndexLine, buildInverseRelationLine, buildMigrationIdentity, buildMigrationRunId, buildMigrationSource, buildModelBlock, buildPrimaryKeyLine, buildRelationLine, buildUniqueConstraintLine, caseWhen, coalesce, col, computeMigrationChecksum, configureArkormRuntime, count, createEmptyAppliedMigrationsState, createEmptyPersistedColumnMappingsState, createKyselyAdapter, createMigrationTimestamp, createPrismaAdapter, createPrismaCompatibilityAdapter, createPrismaDatabaseAdapter, createPrismaDelegateMap, defineConfig, defineFactory, deleteAppliedMigrationsStateFromStore, deletePersistedColumnMappingsState, deriveCollectionFieldName, deriveInverseRelationAlias, deriveRelationAlias, deriveRelationFieldName, deriveSingularFieldName, emitRuntimeDebugEvent, ensureArkormConfigLoading, escapeRegex, expressionBuilder, findAppliedMigration, findEnumBlock, findModelBlock, fn, formatDefaultValue, formatEnumDefaultValue, formatRelationAction, fromExpressionNode, generateMigrationFile, getActiveTransactionAdapter, getActiveTransactionClient, getDefaultStubsPath, getLastMigrationRun, getLatestAppliedMigrations, getMigrationPlan, getPersistedColumnMap, getPersistedEnumMap, getPersistedEnumTsType, getPersistedPrimaryKeyGeneration, getPersistedTableMetadata, getPersistedTimestampColumns, getRegisteredFactories, getRegisteredMigrations, getRegisteredModels, getRegisteredPaths, getRegisteredSeeders, getRuntimeAdapter, getRuntimeClient, getRuntimeCompatibilityAdapter, getRuntimeDebugHandler, getRuntimePaginationCurrentPageResolver, getRuntimePaginationURLDriverFactory, getRuntimePrismaClient, getUserConfig, inferDelegateName, isDelegateLike, isMigrationApplied, isQuerySchemaLike, isTransactionCapableClient, json, loadArkormConfig, loadFactoriesFrom, loadMigrationsFrom, loadModelsFrom, loadSeedersFrom, markMigrationApplied, markMigrationRun, max, min, pad, raw, readAppliedMigrationsState, readAppliedMigrationsStateFromStore, readPersistedColumnMappingsState, rebuildPersistedColumnMappingsState, registerFactories, registerMigrations, registerModels, registerPaths, registerSeeders, removeAppliedMigration, resetArkormRuntimeForTests, resetPersistedColumnMappingsCache, resetRuntimeRegistryForTests, resolveCast, resolveColumnMappingsFilePath, resolveEnumName, resolveGeneratedExpression, resolveMigrationClassName, resolveMigrationStateFilePath, resolvePersistedMetadataFeatures, resolvePrismaType, resolveRuntimeCompatibilityQuerySchema, resolveRuntimeCompatibilityQuerySchemaOrThrow, runArkormTransaction, runMigrationWithPrisma, runPrismaCommand, stripPrismaSchemaModelsAndEnums, sum, supportsDatabaseCreation, supportsDatabaseMigrationExecution, supportsDatabaseMigrationState, supportsDatabaseReset, syncPersistedColumnMappingsFromState, toMigrationFileSlug, toModelName, val, validatePersistedMetadataFeaturesForMigrations, where, writeAppliedMigrationsState, writeAppliedMigrationsStateToStore, writePersistedColumnMappingsState };