arkormx 2.10.2 → 2.11.1

package/dist/relationship/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_relationship = require('../relationship-DWtfgLfh.cjs');
+const require_relationship = require('../relationship-IC-TAFyG.cjs');
 
 exports.BelongsToManyRelation = require_relationship.BelongsToManyRelation;
 exports.BelongsToRelation = require_relationship.BelongsToRelation;

package/dist/relationship/index.d.cts

@@ -1,2 +1,2 @@
-import { Ao as HasOneRelation, Do as MorphOneRelation, Eo as MorphToManyRelation, Fo as BelongsToManyRelation, Io as Relation, Lo as RelationTableLoader, Mo as HasManyRelation, No as BelongsToRelation, Oo as MorphManyRelation, Po as SingleResultRelation, To as MorphToRelation, jo as HasManyThroughRelation, ko as HasOneThroughRelation, wo as SetBasedEagerLoader } from "../index-CGawfwb8.cjs";
+import { $o as SetBasedEagerLoader, as as HasOneRelation, cs as BelongsToRelation, ds as Relation, es as MorphToRelation, fs as RelationTableLoader, is as HasOneThroughRelation, ls as SingleResultRelation, ns as MorphOneRelation, os as HasManyThroughRelation, rs as MorphManyRelation, ss as HasManyRelation, ts as MorphToManyRelation, us as BelongsToManyRelation } from "../index-DLNIbeRi.cjs";
 export { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, HasOneThroughRelation, MorphManyRelation, MorphOneRelation, MorphToManyRelation, MorphToRelation, Relation, RelationTableLoader, SetBasedEagerLoader, SingleResultRelation };

package/dist/relationship/index.d.mts

@@ -1,2 +1,2 @@
-import { Ao as HasOneRelation, Do as MorphOneRelation, Eo as MorphToManyRelation, Fo as BelongsToManyRelation, Io as Relation, Lo as RelationTableLoader, Mo as HasManyRelation, No as BelongsToRelation, Oo as MorphManyRelation, Po as SingleResultRelation, To as MorphToRelation, jo as HasManyThroughRelation, ko as HasOneThroughRelation, wo as SetBasedEagerLoader } from "../index-ClVzjhGq.mjs";
+import { $o as SetBasedEagerLoader, as as HasOneRelation, cs as BelongsToRelation, ds as Relation, es as MorphToRelation, fs as RelationTableLoader, is as HasOneThroughRelation, ls as SingleResultRelation, ns as MorphOneRelation, os as HasManyThroughRelation, rs as MorphManyRelation, ss as HasManyRelation, ts as MorphToManyRelation, us as BelongsToManyRelation } from "../index-43R9yWVX.mjs";
 export { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, HasOneThroughRelation, MorphManyRelation, MorphOneRelation, MorphToManyRelation, MorphToRelation, Relation, RelationTableLoader, SetBasedEagerLoader, SingleResultRelation };

package/dist/relationship/index.mjs

@@ -1,3 +1,3 @@
-import { Nn as SetBasedEagerLoader, Pn as RelationTableLoader, a as HasOneThroughRelation, c as HasManyRelation, d as BelongsToManyRelation, f as Relation, i as MorphManyRelation, l as BelongsToRelation, n as MorphToManyRelation, o as HasOneRelation, r as MorphOneRelation, s as HasManyThroughRelation, t as MorphToRelation, u as SingleResultRelation } from "../relationship-SFhKrphd.mjs";
+import { $n as SetBasedEagerLoader, a as HasOneThroughRelation, c as HasManyRelation, d as BelongsToManyRelation, er as RelationTableLoader, f as Relation, i as MorphManyRelation, l as BelongsToRelation, n as MorphToManyRelation, o as HasOneRelation, r as MorphOneRelation, s as HasManyThroughRelation, t as MorphToRelation, u as SingleResultRelation } from "../relationship-CP1xbMOa.mjs";
 
 export { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasManyThroughRelation, HasOneRelation, HasOneThroughRelation, MorphManyRelation, MorphOneRelation, MorphToManyRelation, MorphToRelation, Relation, RelationTableLoader, SetBasedEagerLoader, SingleResultRelation };

package/dist/{relationship-SFhKrphd.mjs → relationship-CP1xbMOa.mjs}

@@ -1098,6 +1098,423 @@ var PrimaryKeyGenerationPlanner = class {
 	}
 };
 
+//#endregion
+//#region src/Expression.ts
+/**
+* A composable SQL expression. Instances are immutable — every operator returns a
+* new expression — and are accepted by `select`, `where`, `groupBy`, `orderBy`,
+* `having`, and the aggregate helpers. Adapters compile the underlying node tree.
+*/
+var Expression = class Expression {
+	/**
+	* Type guard for values that came out of the expression builder.
+	*/
+	static isExpression(value) {
+		return value instanceof Expression;
+	}
+	eq(value) {
+		return binary("=", this, coerceValue(value));
+	}
+	ne(value) {
+		return binary("!=", this, coerceValue(value));
+	}
+	gt(value) {
+		return binary(">", this, coerceValue(value));
+	}
+	gte(value) {
+		return binary(">=", this, coerceValue(value));
+	}
+	lt(value) {
+		return binary("<", this, coerceValue(value));
+	}
+	lte(value) {
+		return binary("<=", this, coerceValue(value));
+	}
+	like(value) {
+		return binary("like", this, coerceValue(value));
+	}
+	ilike(value) {
+		return binary("ilike", this, coerceValue(value));
+	}
+	notLike(value) {
+		return binary("not-like", this, coerceValue(value));
+	}
+	notIlike(value) {
+		return binary("not-ilike", this, coerceValue(value));
+	}
+	in(values) {
+		return new NodeExpression({
+			kind: "in",
+			operand: this.toExpressionNode(),
+			values: values.map((value) => coerceValue(value).toExpressionNode()),
+			not: false
+		});
+	}
+	notIn(values) {
+		return new NodeExpression({
+			kind: "in",
+			operand: this.toExpressionNode(),
+			values: values.map((value) => coerceValue(value).toExpressionNode()),
+			not: true
+		});
+	}
+	isNull() {
+		return new NodeExpression({
+			kind: "null-check",
+			operand: this.toExpressionNode(),
+			not: false
+		});
+	}
+	isNotNull() {
+		return new NodeExpression({
+			kind: "null-check",
+			operand: this.toExpressionNode(),
+			not: true
+		});
+	}
+	and(other) {
+		return binary("and", this, other);
+	}
+	or(other) {
+		return binary("or", this, other);
+	}
+	plus(value) {
+		return binary("+", this, coerceValue(value));
+	}
+	minus(value) {
+		return binary("-", this, coerceValue(value));
+	}
+	times(value) {
+		return binary("*", this, coerceValue(value));
+	}
+	dividedBy(value) {
+		return binary("/", this, coerceValue(value));
+	}
+};
+/**
+* Concrete expression backed by a pre-built node.
+*/
+var NodeExpression = class extends Expression {
+	constructor(node) {
+		super();
+		this.node = node;
+	}
+	toExpressionNode() {
+		return this.node;
+	}
+};
+/**
+* Fluent `CASE … WHEN … THEN … ELSE … END` builder. Immutable.
+*/
+var CaseExpression = class CaseExpression extends Expression {
+	constructor(branches, elseExpr) {
+		super();
+		this.branches = branches;
+		this.elseExpr = elseExpr;
+	}
+	when(condition, result) {
+		return new CaseExpression([...this.branches, {
+			when: condition,
+			then: coerceValue(result)
+		}], this.elseExpr);
+	}
+	else(result) {
+		return new CaseExpression(this.branches, coerceValue(result));
+	}
+	toExpressionNode() {
+		return {
+			kind: "case",
+			cases: this.branches.map((branch) => ({
+				when: branch.when.toExpressionNode(),
+				then: branch.then.toExpressionNode()
+			})),
+			else: this.elseExpr?.toExpressionNode()
+		};
+	}
+};
+/**
+* JSON-path value extraction (`metadata ->> 'billType'`), with optional casts.
+*/
+var JsonExpression = class JsonExpression extends Expression {
+	constructor(column, path, castTo) {
+		super();
+		this.column = column;
+		this.path = path;
+		this.castTo = castTo;
+	}
+	asText() {
+		return new JsonExpression(this.column, this.path, "text");
+	}
+	asNumber() {
+		return new JsonExpression(this.column, this.path, "number");
+	}
+	asBoolean() {
+		return new JsonExpression(this.column, this.path, "boolean");
+	}
+	toExpressionNode() {
+		return {
+			kind: "json",
+			column: this.column,
+			path: this.path,
+			cast: this.castTo
+		};
+	}
+};
+/**
+* Aggregate expression (`sum`, `count`, `avg`, `min`, `max`) with optional filter.
+*/
+var AggregateExpression = class AggregateExpression extends Expression {
+	constructor(fn, arg, options = {}) {
+		super();
+		this.fn = fn;
+		this.arg = arg;
+		this.options = options;
+	}
+	/**
+	* Restricts the aggregate to rows matching `predicate` (`FILTER (WHERE …)`).
+	*/
+	filter(predicate) {
+		return new AggregateExpression(this.fn, this.arg, {
+			...this.options,
+			filterExpr: predicate
+		});
+	}
+	distinct() {
+		return new AggregateExpression(this.fn, this.arg, {
+			...this.options,
+			distinct: true
+		});
+	}
+	toExpressionNode() {
+		return {
+			kind: "aggregate",
+			fn: this.fn,
+			arg: this.arg?.toExpressionNode(),
+			distinct: this.options.distinct,
+			filter: this.options.filterExpr?.toExpressionNode()
+		};
+	}
+};
+const binary = (operator, left, right) => new NodeExpression({
+	kind: "binary",
+	operator,
+	left: left.toExpressionNode(),
+	right: right.toExpressionNode()
+});
+/**
+* Coerces a raw value into a bound-literal expression; passes expressions through.
+*/
+const coerceValue = (value) => {
+	if (value instanceof Expression) return value;
+	return new NodeExpression({
+		kind: "value",
+		value
+	});
+};
+/**
+* Coerces a bare string into a column reference; passes expressions through.
+*/
+const coerceColumn = (value) => {
+	if (value instanceof Expression) return value;
+	if (typeof value === "string") return col(value);
+	return coerceValue(value);
+};
+/**
+* Rebuilds an {@link Expression} around an already-serialized node.
+*/
+const fromExpressionNode = (node) => new NodeExpression(node);
+/**
+* A typed column reference. Supports joined `table.column` syntax.
+*/
+const col = (name) => new NodeExpression({
+	kind: "column",
+	name
+});
+/**
+* A bound literal value (parameterized, never interpolated).
+*/
+const val = (value) => new NodeExpression({
+	kind: "value",
+	value
+});
+/**
+* Raw SQL escape hatch with positional `?` bindings.
+*/
+const raw = (sql, bindings = []) => new NodeExpression({
+	kind: "raw",
+	sql,
+	bindings
+});
+/**
+* Starts a `CASE WHEN condition THEN result` expression.
+*/
+const caseWhen = (condition, result) => new CaseExpression([{
+	when: condition,
+	then: coerceValue(result)
+}]);
+/**
+* `COALESCE(a, b, …)` — first non-null argument. Bare strings are columns.
+*/
+const coalesce = (...args) => new NodeExpression({
+	kind: "function",
+	name: "coalesce",
+	args: args.map((arg) => coerceColumn(arg).toExpressionNode())
+});
+/**
+* An arbitrary SQL function call. Bare-string arguments are treated as columns.
+*/
+const fn = (name, ...args) => new NodeExpression({
+	kind: "function",
+	name,
+	args: args.map((arg) => coerceColumn(arg).toExpressionNode())
+});
+/**
+* JSON value extraction: `json('metadata', 'billType')` => `metadata ->> 'billType'`.
+*/
+const json = (column, ...path) => new JsonExpression(column, path.map(String));
+/**
+* `SUM(expr)`; a bare-string argument is treated as a column.
+*/
+const sum = (arg) => new AggregateExpression("sum", coerceColumn(arg));
+/**
+* `AVG(expr)`; a bare-string argument is treated as a column.
+*/
+const avg = (arg) => new AggregateExpression("avg", coerceColumn(arg));
+/**
+* `MIN(expr)`; a bare-string argument is treated as a column.
+*/
+const min = (arg) => new AggregateExpression("min", coerceColumn(arg));
+/**
+* `MAX(expr)`; a bare-string argument is treated as a column.
+*/
+const max = (arg) => new AggregateExpression("max", coerceColumn(arg));
+/**
+* `COUNT(expr)` — or `COUNT(*)` when called without an argument.
+*/
+const count = (arg) => new AggregateExpression("count", arg === void 0 ? void 0 : coerceColumn(arg));
+const EXPRESSION_OPERATORS = {
+	"=": "=",
+	"==": "=",
+	"!=": "!=",
+	"<>": "!=",
+	">": ">",
+	">=": ">=",
+	"<": "<",
+	"<=": "<=",
+	like: "like",
+	ilike: "ilike",
+	"not like": "not-like",
+	"not ilike": "not-ilike"
+};
+/**
+* Builds a comparison predicate: `where('createdAt', '>=', boundary)`. Handy as an
+* inline predicate for `caseWhen`, `having`, and aggregate `.filter(…)`.
+*/
+const where = (column, operator, value) => {
+	const normalized = EXPRESSION_OPERATORS[operator];
+	if (!normalized) throw new Error(`Unsupported expression operator [${operator}].`);
+	return binary(normalized, col(column), coerceValue(value));
+};
+/**
+* The expression-builder namespace passed to `static computed` factories, so a
+* model can declare a virtual attribute as `category: (e) => e.coalesce(…)`.
+*/
+const expressionBuilder = {
+	col,
+	val,
+	raw,
+	caseWhen,
+	coalesce,
+	fn,
+	json,
+	sum,
+	avg,
+	min,
+	max,
+	count,
+	where
+};
+
+//#endregion
+//#region src/helpers/generated-column.ts
+/**
+* Resolves a generated-column expression into raw Postgres SQL. Generated columns
+* cannot carry bind parameters (they must be immutable), so literal values are
+* inlined and aggregates are rejected.
+*/
+const resolveGeneratedExpression = (expression) => {
+	if (typeof expression === "string") return expression;
+	return expressionNodeToSql(expression(expressionBuilder).toExpressionNode());
+};
+const quoteIdentifier = (name) => name.split(".").map((part) => `"${part.replace(/"/g, "\"\"")}"`).join(".");
+const quoteLiteral = (value) => {
+	if (value === null || value === void 0) return "null";
+	if (typeof value === "number" || typeof value === "bigint") return String(value);
+	if (typeof value === "boolean") return value ? "true" : "false";
+	if (value instanceof Date) return `'${value.toISOString()}'`;
+	return `'${String(value).replace(/'/g, "''")}'`;
+};
+const BINARY_OPERATORS = {
+	"=": "=",
+	"!=": "!=",
+	">": ">",
+	">=": ">=",
+	"<": "<",
+	"<=": "<=",
+	like: "like",
+	ilike: "ilike",
+	"not-like": "not like",
+	"not-ilike": "not ilike",
+	and: "and",
+	or: "or",
+	"+": "+",
+	"-": "-",
+	"*": "*",
+	"/": "/"
+};
+const FUNCTION_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const jsonAccessorSql = (node) => {
+	const base = `${quoteIdentifier(node.column)}::jsonb`;
+	let accessor;
+	if (node.path.length === 0) accessor = base;
+	else if (node.path.length === 1) accessor = `(${base} ->> ${quoteLiteral(node.path[0])})`;
+	else accessor = `(${base} #>> '{${node.path.join(",")}}'::text[])`;
+	if (node.cast === "number") return `(${accessor})::numeric`;
+	if (node.cast === "boolean") return `(${accessor})::boolean`;
+	return accessor;
+};
+const expressionNodeToSql = (node) => {
+	switch (node.kind) {
+		case "column": return quoteIdentifier(node.name);
+		case "value": return quoteLiteral(node.value);
+		case "raw": return inlineRawSql(node.sql, node.bindings);
+		case "json": return jsonAccessorSql(node);
+		case "function":
+			if (!FUNCTION_NAME.test(node.name)) throw new ArkormException(`Unsupported SQL function name [${node.name}].`);
+			return `${node.name}(${node.args.map(expressionNodeToSql).join(", ")})`;
+		case "case": return `case ${node.cases.map((branch) => `when ${expressionNodeToSql(branch.when)} then ${expressionNodeToSql(branch.then)}`).join(" ")}${node.else ? ` else ${expressionNodeToSql(node.else)}` : ""} end`;
+		case "binary": {
+			const operator = BINARY_OPERATORS[node.operator];
+			return `(${expressionNodeToSql(node.left)} ${operator} ${expressionNodeToSql(node.right)})`;
+		}
+		case "in": {
+			const values = node.values.map(expressionNodeToSql).join(", ");
+			return `(${expressionNodeToSql(node.operand)} ${node.not ? "not in" : "in"} (${values}))`;
+		}
+		case "null-check": return `(${expressionNodeToSql(node.operand)} is ${node.not ? "not null" : "null"})`;
+		case "aggregate": throw new ArkormException("Aggregate expressions are not allowed in generated columns.");
+		default: throw new ArkormException(`Unsupported expression node [${node.kind}].`);
+	}
+};
+const inlineRawSql = (sql, bindings) => {
+	const segments = sql.split("?");
+	if (segments.length !== bindings.length + 1) throw new ArkormException("Raw expression bindings do not match the number of placeholders.");
+	return segments.reduce((accumulator, segment, index) => {
+		const binding = index < bindings.length ? quoteLiteral(bindings[index]) : "";
+		return accumulator + segment + binding;
+	}, "");
+};
+
 //#endregion
 //#region src/database/TableBuilder.ts
 const PRISMA_ENUM_MEMBER_REGEX$1 = /^[A-Za-z][A-Za-z0-9_]*$/;
@@ -1401,6 +1818,30 @@ var TableBuilder = class {
 		return this.column(name, "dateTime", options);
 	}
 	/**
+	* Defines a database-computed column (`GENERATED ALWAYS AS (…) STORED`). The
+	* expression may be a raw SQL string or an expression-builder factory, and must
+	* be immutable and reference only the row's own columns. Combine with
+	* {@link index} to index the generated value.
+	*
+	* @example
+	* table.generated('category', "case when metadata->>'kind' = 'a' then 'x' else 'y' end", {
+	*   type: 'text',
+	* })
+	* table.generated('total', (e) => e.col('price').times(e.col('quantity')), { type: 'integer' })
+	*
+	* @param name        The generated column name.
+	* @param expression  The SQL expression string, or a builder factory.
+	* @param options     Column type (default `text`), `stored` flag, and nullability.
+	* @returns
+	*/
+	generated(name, expression, options = {}) {
+		return this.column(name, options.type ?? "text", {
+			generatedExpression: resolveGeneratedExpression(expression),
+			generatedStored: options.stored ?? true,
+			nullable: options.nullable
+		});
+	}
+	/**
 	* Defines colonns for a polymorphic relationship in the table.
 	*
 	* @param name    The base name for the polymorphic relationship columns.
@@ -1736,6 +2177,8 @@ var TableBuilder = class {
 			updatedAt: options.updatedAt,
 			precision: options.precision,
 			scale: options.scale,
+			generatedExpression: options.generatedExpression,
+			generatedStored: options.generatedStored,
 			primaryKeyGeneration: options.primaryKeyGeneration
 		});
 		const column = this.columns[this.columns.length - 1];
@@ -2119,6 +2562,10 @@ const buildFieldLine = (column) => {
 	const mapped = typeof column.map === "string" && column.map.trim().length > 0 ? ` @map("${column.map.replace(/"/g, "\\\"")}")` : "";
 	const updatedAt = column.updatedAt ? " @updatedAt" : "";
 	const nativeType = column.type === "decimal" ? ` @db.Decimal(${column.precision ?? 8}, ${column.scale ?? 2})` : "";
+	if (column.generatedExpression) {
+		const escaped = column.generatedExpression.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+		return `  ${column.name} ${scalar}${nullable}${unique} @default(dbgenerated("${escaped}"))${mapped}${nativeType}`;
+	}
 	const defaultValue = column.type === "enum" ? formatEnumDefaultValue(column.default) : column.primaryKeyGeneration?.prismaDefault ?? formatDefaultValue(column.default);
 	const defaultSuffix = defaultValue ? ` ${defaultValue}` : "";
 	return `  ${column.name} ${scalar}${nullable}${primary}${unique}${defaultSuffix}${updatedAt}${mapped}${nativeType}`;
@@ -5997,4 +6444,4 @@ var MorphToRelation = class extends Relation {
 };
 
 //#endregion
-export { applyOperationsToPersistedColumnMappingsState as $, resolvePrismaType as $t, getRuntimePrismaClient as A, writeAppliedMigrationsStateToStore as An, buildInverseRelationLine as At, getRegisteredModels as B, deriveRelationFieldName as Bt, getActiveTransactionClient as C, markMigrationRun as Cn, applyMigrationRollbackToPrismaSchema as Ct, getRuntimeDebugHandler as D, resolveMigrationStateFilePath as Dn, buildEnumBlock as Dt, getRuntimeClient as E, removeAppliedMigration as En, applyOperationsToPrismaSchema as Et, loadArkormConfig as F, RelationResolutionException as Fn, buildUniqueConstraintLine as Ft, loadModelsFrom as G, formatDefaultValue as Gt, getRegisteredSeeders as H, escapeRegex as Ht, resetArkormRuntimeForTests as I, ArkormCollection as In, createMigrationTimestamp as It, registerMigrations as J, generateMigrationFile as Jt, loadSeedersFrom as K, formatEnumDefaultValue as Kt, runArkormTransaction as L, ArkormException as Ln, deriveCollectionFieldName as Lt, isDelegateLike as M, UnsupportedAdapterFeatureException as Mn, buildModelBlock as Mt, isQuerySchemaLike as N, SetBasedEagerLoader as Nn, buildPrimaryKeyLine as Nt, getRuntimePaginationCurrentPageResolver as O, supportsDatabaseMigrationState as On, buildFieldLine as Ot, isTransactionCapableClient as P, RelationTableLoader as Pn, buildRelationLine as Pt, resetRuntimeRegistryForTests as Q, resolveMigrationClassName as Qt, getRegisteredFactories as R, deriveInverseRelationAlias as Rt, getActiveTransactionAdapter as S, markMigrationApplied as Sn, applyMigrationRollbackToDatabase as St, getRuntimeAdapter as T, readAppliedMigrationsStateFromStore as Tn, applyMigrationToPrismaSchema as Tt, loadFactoriesFrom as U, findEnumBlock as Ut, getRegisteredPaths as V, deriveSingularFieldName as Vt, loadMigrationsFrom as W, findModelBlock as Wt, registerPaths as X, pad as Xt, registerModels as Y, getMigrationPlan as Yt, registerSeeders as Z, resolveEnumName as Zt, bindAdapterToModels as _, deleteAppliedMigrationsStateFromStore as _n, PRISMA_ENUM_REGEX as _t, HasOneThroughRelation as a, supportsDatabaseReset as an, getPersistedPrimaryKeyGeneration as at, emitRuntimeDebugEvent as b, getLatestAppliedMigrations as bn, applyCreateTableOperation as bt, HasManyRelation as c, SchemaBuilder as cn, readPersistedColumnMappingsState as ct, BelongsToManyRelation as d, PrimaryKeyGenerationPlanner as dn, resolveColumnMappingsFilePath as dt, runMigrationWithPrisma as en, createEmptyPersistedColumnMappingsState as et, Relation as f, ForeignKeyBuilder as fn, resolvePersistedMetadataFeatures as ft, awaitConfiguredModelsRegistration as g, createEmptyAppliedMigrationsState as gn, PRISMA_ENUM_MEMBER_REGEX as gt, URLDriver as h, computeMigrationChecksum as hn, writePersistedColumnMappingsState as ht, MorphManyRelation as i, supportsDatabaseMigrationExecution as in, getPersistedEnumTsType as it, getUserConfig as j, RuntimeModuleLoader as jn, buildMigrationSource as jt, getRuntimePaginationURLDriverFactory as k, writeAppliedMigrationsState as kn, buildIndexLine as kt, BelongsToRelation as l, EnumBuilder as ln, rebuildPersistedColumnMappingsState as lt, Paginator as m, buildMigrationRunId as mn, validatePersistedMetadataFeaturesForMigrations as mt, MorphToManyRelation as n, stripPrismaSchemaModelsAndEnums as nn, getPersistedColumnMap as nt, HasOneRelation as o, toMigrationFileSlug as on, getPersistedTableMetadata as ot, LengthAwarePaginator as p, buildMigrationIdentity as pn, syncPersistedColumnMappingsFromState as pt, registerFactories as q, formatRelationAction as qt, MorphOneRelation as r, supportsDatabaseCreation as rn, getPersistedEnumMap as rt, HasManyThroughRelation as s, toModelName as sn, getPersistedTimestampColumns as st, MorphToRelation as t, runPrismaCommand as tn, deletePersistedColumnMappingsState as tt, SingleResultRelation as u, TableBuilder as un, resetPersistedColumnMappingsCache as ut, configureArkormRuntime as v, findAppliedMigration as vn, PRISMA_MODEL_REGEX as vt, getDefaultStubsPath as w, readAppliedMigrationsState as wn, applyMigrationToDatabase as wt, ensureArkormConfigLoading as x, isMigrationApplied as xn, applyDropTableOperation as xt, defineConfig as y, getLastMigrationRun as yn, applyAlterTableOperation as yt, getRegisteredMigrations as z, deriveRelationAlias as zt };
+export { applyOperationsToPersistedColumnMappingsState as $, SetBasedEagerLoader as $n, resolvePrismaType as $t, getRuntimePrismaClient as A, where as An, buildInverseRelationLine as At, getRegisteredModels as B, getLatestAppliedMigrations as Bn, deriveRelationFieldName as Bt, getActiveTransactionClient as C, fromExpressionNode as Cn, applyMigrationRollbackToPrismaSchema as Ct, getRuntimeDebugHandler as D, raw as Dn, buildEnumBlock as Dt, getRuntimeClient as E, min as En, applyOperationsToPrismaSchema as Et, loadArkormConfig as F, computeMigrationChecksum as Fn, buildUniqueConstraintLine as Ft, loadModelsFrom as G, readAppliedMigrationsStateFromStore as Gn, formatDefaultValue as Gt, getRegisteredSeeders as H, markMigrationApplied as Hn, escapeRegex as Ht, resetArkormRuntimeForTests as I, createEmptyAppliedMigrationsState as In, createMigrationTimestamp as It, registerMigrations as J, supportsDatabaseMigrationState as Jn, generateMigrationFile as Jt, loadSeedersFrom as K, removeAppliedMigration as Kn, formatEnumDefaultValue as Kt, runArkormTransaction as L, deleteAppliedMigrationsStateFromStore as Ln, deriveCollectionFieldName as Lt, isDelegateLike as M, ForeignKeyBuilder as Mn, buildModelBlock as Mt, isQuerySchemaLike as N, buildMigrationIdentity as Nn, buildPrimaryKeyLine as Nt, getRuntimePaginationCurrentPageResolver as O, sum as On, buildFieldLine as Ot, isTransactionCapableClient as P, buildMigrationRunId as Pn, buildRelationLine as Pt, resetRuntimeRegistryForTests as Q, UnsupportedAdapterFeatureException as Qn, resolveMigrationClassName as Qt, getRegisteredFactories as R, findAppliedMigration as Rn, deriveInverseRelationAlias as Rt, getActiveTransactionAdapter as S, fn as Sn, applyMigrationRollbackToDatabase as St, getRuntimeAdapter as T, max as Tn, applyMigrationToPrismaSchema as Tt, loadFactoriesFrom as U, markMigrationRun as Un, findEnumBlock as Ut, getRegisteredPaths as V, isMigrationApplied as Vn, deriveSingularFieldName as Vt, loadMigrationsFrom as W, readAppliedMigrationsState as Wn, findModelBlock as Wt, registerPaths as X, writeAppliedMigrationsStateToStore as Xn, pad as Xt, registerModels as Y, writeAppliedMigrationsState as Yn, getMigrationPlan as Yt, registerSeeders as Z, RuntimeModuleLoader as Zn, resolveEnumName as Zt, bindAdapterToModels as _, caseWhen as _n, PRISMA_ENUM_REGEX as _t, HasOneThroughRelation as a, supportsDatabaseReset as an, getPersistedPrimaryKeyGeneration as at, emitRuntimeDebugEvent as b, count as bn, applyCreateTableOperation as bt, HasManyRelation as c, SchemaBuilder as cn, readPersistedColumnMappingsState as ct, BelongsToManyRelation as d, resolveGeneratedExpression as dn, resolveColumnMappingsFilePath as dt, runMigrationWithPrisma as en, RelationTableLoader as er, createEmptyPersistedColumnMappingsState as et, Relation as f, AggregateExpression as fn, resolvePersistedMetadataFeatures as ft, awaitConfiguredModelsRegistration as g, avg as gn, PRISMA_ENUM_MEMBER_REGEX as gt, URLDriver as h, JsonExpression as hn, writePersistedColumnMappingsState as ht, MorphManyRelation as i, supportsDatabaseMigrationExecution as in, getPersistedEnumTsType as it, getUserConfig as j, PrimaryKeyGenerationPlanner as jn, buildMigrationSource as jt, getRuntimePaginationURLDriverFactory as k, val as kn, buildIndexLine as kt, BelongsToRelation as l, EnumBuilder as ln, rebuildPersistedColumnMappingsState as lt, Paginator as m, Expression as mn, validatePersistedMetadataFeaturesForMigrations as mt, MorphToManyRelation as n, stripPrismaSchemaModelsAndEnums as nn, ArkormCollection as nr, getPersistedColumnMap as nt, HasOneRelation as o, toMigrationFileSlug as on, getPersistedTableMetadata as ot, LengthAwarePaginator as p, CaseExpression as pn, syncPersistedColumnMappingsFromState as pt, registerFactories as q, resolveMigrationStateFilePath as qn, formatRelationAction as qt, MorphOneRelation as r, supportsDatabaseCreation as rn, ArkormException as rr, getPersistedEnumMap as rt, HasManyThroughRelation as s, toModelName as sn, getPersistedTimestampColumns as st, MorphToRelation as t, runPrismaCommand as tn, RelationResolutionException as tr, deletePersistedColumnMappingsState as tt, SingleResultRelation as u, TableBuilder as un, resetPersistedColumnMappingsCache as ut, configureArkormRuntime as v, coalesce as vn, PRISMA_MODEL_REGEX as vt, getDefaultStubsPath as w, json as wn, applyMigrationToDatabase as wt, ensureArkormConfigLoading as x, expressionBuilder as xn, applyDropTableOperation as xt, defineConfig as y, col as yn, applyAlterTableOperation as yt, getRegisteredMigrations as z, getLastMigrationRun as zn, deriveRelationAlias as zt };