@prisma-next/sql-orm-lane 0.3.0-pr.94.2 → 0.3.0-pr.95.2

package/dist/orm-BYJaTDLm.mjs

@@ -1,1286 +0,0 @@
-import { planInvalid } from "@prisma-next/plan";
-import { schema } from "@prisma-next/sql-relational-core/schema";
-import { augmentDescriptorWithColumnMeta } from "@prisma-next/sql-relational-core/plan";
-import { collectColumnRefs, extractBaseColumnRef, getColumnMeta, isColumnBuilder, isExpressionBuilder, isOperationExpr, isParamPlaceholder } from "@prisma-next/sql-relational-core/utils/guards";
-import { compact, createBinaryExpr, createColumnRef, createDeleteAst, createInsertAst, createJoinOnExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst } from "@prisma-next/sql-relational-core/ast";
-import { param } from "@prisma-next/sql-relational-core/param";
-
-//#region src/utils/errors.ts
-function errorModelNotFound(modelName) {
-	throw planInvalid(`Model ${modelName} not found in mappings`);
-}
-function errorTableNotFound(tableName) {
-	throw planInvalid(`Table ${tableName} not found in schema`);
-}
-function errorUnknownTable(tableName) {
-	throw planInvalid(`Unknown table ${tableName}`);
-}
-function errorUnknownColumn(columnName, tableName) {
-	throw planInvalid(`Unknown column ${columnName} in table ${tableName}`);
-}
-function errorMissingParameter(paramName) {
-	throw planInvalid(`Missing value for parameter ${paramName}`);
-}
-function errorAliasPathEmpty() {
-	throw planInvalid("Alias path cannot be empty");
-}
-function errorAliasCollision(path, alias, existingPath) {
-	throw planInvalid(`Alias collision: path ${path.join(".")} would generate alias "${alias}" which conflicts with path ${existingPath?.join(".") ?? "unknown"}`);
-}
-function errorInvalidProjectionValue(path) {
-	throw planInvalid(`Invalid projection value at path ${path.join(".")}: expected ColumnBuilder or nested object`);
-}
-function errorIncludeAliasNotFound(alias) {
-	throw planInvalid(`Include alias "${alias}" not found. Did you call includeMany() with alias "${alias}"?`);
-}
-function errorInvalidProjectionKey(key) {
-	throw planInvalid(`Invalid projection value at key "${key}": expected ColumnBuilder, boolean true (for includes), or nested object`);
-}
-function errorProjectionEmpty() {
-	throw planInvalid("select() requires at least one column or include");
-}
-function errorCreateRequiresFields() {
-	throw planInvalid("create() requires at least one field");
-}
-function errorUpdateRequiresFields() {
-	throw planInvalid("update() requires at least one field");
-}
-function errorIncludeRequiresCapabilities() {
-	throw planInvalid("includeMany requires lateral and jsonAgg capabilities");
-}
-function errorIncludeCapabilitiesNotTrue() {
-	throw planInvalid("includeMany requires lateral and jsonAgg capabilities to be true");
-}
-function errorMultiColumnJoinsNotSupported() {
-	throw planInvalid("Multi-column joins in includes are not yet supported");
-}
-function errorJoinColumnsMustBeDefined() {
-	throw planInvalid("Join columns must be defined");
-}
-function errorColumnNotFound(columnName, tableName) {
-	throw planInvalid(`Column ${columnName} not found in table ${tableName}`);
-}
-function errorChildProjectionMustBeSpecified() {
-	throw planInvalid("Child projection must be specified");
-}
-function errorChildProjectionEmpty() {
-	throw planInvalid("Child projection must not be empty after filtering boolean values");
-}
-function errorMissingAlias(index) {
-	throw planInvalid(`Missing alias at index ${index}`);
-}
-function errorMissingColumn(alias, index) {
-	throw planInvalid(`Missing column for alias "${alias}" at index ${index}`);
-}
-function errorInvalidColumn(alias, index) {
-	throw planInvalid(`Invalid column for alias "${alias}" at index ${index}`);
-}
-function errorFailedToBuildWhereClause() {
-	throw planInvalid("Failed to build WHERE clause");
-}
-function assertColumnExists(columnMeta, columnName, tableName) {
-	if (!columnMeta) errorUnknownColumn(columnName, tableName);
-}
-function assertParameterExists(paramsMap, paramName) {
-	if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
-	return paramsMap[paramName];
-}
-
-//#endregion
-//#region src/selection/predicates.ts
-function buildWhereExpr(where, contract, paramsMap, descriptors, values) {
-	let leftExpr;
-	let codecId;
-	let rightExpr;
-	let paramName;
-	leftExpr = where.left;
-	if (leftExpr.kind === "col") {
-		const { table, column } = leftExpr;
-		const contractTable = contract.storage.tables[table];
-		if (!contractTable) errorUnknownTable(table);
-		const columnMeta = contractTable.columns[column];
-		if (columnMeta) codecId = columnMeta.codecId;
-	}
-	if (isParamPlaceholder(where.right)) {
-		paramName = where.right.name;
-		if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
-		const value = paramsMap[paramName];
-		const index = values.push(value);
-		if (leftExpr.kind === "col") {
-			const { table, column } = leftExpr;
-			const columnMeta = contract.storage.tables[table]?.columns[column];
-			descriptors.push({
-				name: paramName,
-				source: "dsl",
-				refs: {
-					table,
-					column
-				},
-				...columnMeta && typeof columnMeta.nullable === "boolean" ? { nullable: columnMeta.nullable } : {}
-			});
-			augmentDescriptorWithColumnMeta(descriptors, columnMeta);
-		}
-		rightExpr = createParamRef(index, paramName);
-	} else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
-		rightExpr = where.right.toExpr();
-		paramName = "";
-	} else errorFailedToBuildWhereClause();
-	return {
-		expr: createBinaryExpr(where.op, leftExpr, rightExpr),
-		...codecId ? { codecId } : {},
-		paramName
-	};
-}
-
-//#endregion
-//#region src/mutations/delete-builder.ts
-function buildDeletePlan(context, modelName, where, getModelAccessor, options) {
-	const wherePredicate = where(getModelAccessor());
-	const tableName = context.contract.mappings.modelToTable?.[modelName];
-	if (!tableName) errorModelNotFound(modelName);
-	const table = createTableRef(tableName);
-	const paramsMap = options?.params ?? {};
-	const paramDescriptors = [];
-	const paramValues = [];
-	const paramCodecs = {};
-	const whereResult = buildWhereExpr(wherePredicate, context.contract, paramsMap, paramDescriptors, paramValues);
-	const whereExpr = whereResult.expr;
-	if (!whereExpr) errorFailedToBuildWhereClause();
-	if (whereResult?.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
-	const ast = createDeleteAst({
-		table,
-		where: whereExpr
-	});
-	return Object.freeze({
-		ast,
-		params: paramValues,
-		meta: {
-			target: context.contract.target,
-			targetFamily: context.contract.targetFamily,
-			coreHash: context.contract.coreHash,
-			lane: "orm",
-			refs: {
-				tables: [tableName],
-				columns: []
-			},
-			projection: {},
-			paramDescriptors,
-			...Object.keys(paramCodecs).length > 0 ? { annotations: {
-				codecs: paramCodecs,
-				intent: "write",
-				isMutation: true
-			} } : { annotations: {
-				intent: "write",
-				isMutation: true
-			} }
-		}
-	});
-}
-
-//#endregion
-//#region src/utils/param-descriptor.ts
-function createParamDescriptor(args) {
-	return {
-		name: args.name,
-		source: "dsl",
-		refs: {
-			table: args.table,
-			column: args.column
-		},
-		...args.codecId ? { codecId: args.codecId } : {},
-		...args.nativeType ? { nativeType: args.nativeType } : {},
-		nullable: args.nullable
-	};
-}
-
-//#endregion
-//#region src/mutations/insert-builder.ts
-function convertModelFieldsToColumns(contract, modelName, fields) {
-	const model = contract.models[modelName];
-	if (!model || typeof model !== "object" || !("fields" in model)) throw new Error(`Model ${modelName} does not have fields`);
-	const modelFields = model.fields;
-	const result = {};
-	for (const fieldName in fields) {
-		if (!Object.hasOwn(fields, fieldName)) continue;
-		if (!Object.hasOwn(modelFields, fieldName)) throw new Error(`Field ${fieldName} does not exist on model ${modelName}`);
-		const field = modelFields[fieldName];
-		if (!field) continue;
-		const columnName = contract.mappings.fieldToColumn?.[modelName]?.[fieldName] ?? field.column ?? fieldName;
-		result[columnName] = param(fieldName);
-	}
-	return result;
-}
-function buildInsertPlan(context, modelName, data, options) {
-	if (!data || Object.keys(data).length === 0) errorCreateRequiresFields();
-	const values = convertModelFieldsToColumns(context.contract, modelName, data);
-	const tableName = context.contract.mappings.modelToTable?.[modelName];
-	if (!tableName) errorModelNotFound(modelName);
-	const table = createTableRef(tableName);
-	const paramsMap = {
-		...options?.params ?? {},
-		...data
-	};
-	const paramDescriptors = [];
-	const paramValues = [];
-	const paramCodecs = {};
-	const contractTable = context.contract.storage.tables[tableName];
-	if (!contractTable) errorUnknownTable(tableName);
-	const insertValues = {};
-	for (const [columnName, placeholder] of Object.entries(values)) {
-		const columnMeta = contractTable.columns[columnName];
-		assertColumnExists(columnMeta, columnName, tableName);
-		const paramName = placeholder.name;
-		const value = assertParameterExists(paramsMap, paramName);
-		const index = paramValues.push(value);
-		const codecId = columnMeta.codecId;
-		if (paramName) paramCodecs[paramName] = codecId;
-		paramDescriptors.push(createParamDescriptor({
-			name: paramName,
-			table: tableName,
-			column: columnName,
-			codecId,
-			nativeType: columnMeta.nativeType,
-			nullable: columnMeta.nullable
-		}));
-		insertValues[columnName] = createParamRef(index, paramName);
-	}
-	const ast = createInsertAst({
-		table,
-		values: insertValues
-	});
-	return Object.freeze({
-		ast,
-		params: paramValues,
-		meta: {
-			target: context.contract.target,
-			targetFamily: context.contract.targetFamily,
-			coreHash: context.contract.coreHash,
-			lane: "orm",
-			refs: {
-				tables: [tableName],
-				columns: []
-			},
-			projection: {},
-			paramDescriptors,
-			...Object.keys(paramCodecs).length > 0 ? { annotations: {
-				codecs: paramCodecs,
-				intent: "write",
-				isMutation: true
-			} } : { annotations: {
-				intent: "write",
-				isMutation: true
-			} }
-		}
-	});
-}
-
-//#endregion
-//#region src/mutations/update-builder.ts
-function buildUpdatePlan(context, modelName, where, getModelAccessor, data, options) {
-	if (!data || Object.keys(data).length === 0) errorUpdateRequiresFields();
-	const set = convertModelFieldsToColumns(context.contract, modelName, data);
-	const wherePredicate = where(getModelAccessor());
-	const tableName = context.contract.mappings.modelToTable?.[modelName];
-	if (!tableName) errorModelNotFound(modelName);
-	const table = createTableRef(tableName);
-	const paramsMap = {
-		...options?.params ?? {},
-		...data
-	};
-	const paramDescriptors = [];
-	const paramValues = [];
-	const paramCodecs = {};
-	const contractTable = context.contract.storage.tables[tableName];
-	if (!contractTable) errorUnknownTable(tableName);
-	const updateSet = {};
-	for (const [columnName, placeholder] of Object.entries(set)) {
-		const columnMeta = contractTable.columns[columnName];
-		assertColumnExists(columnMeta, columnName, tableName);
-		const paramName = placeholder.name;
-		const value = assertParameterExists(paramsMap, paramName);
-		const index = paramValues.push(value);
-		const codecId = columnMeta.codecId;
-		if (paramName) paramCodecs[paramName] = codecId;
-		paramDescriptors.push(createParamDescriptor({
-			name: paramName,
-			table: tableName,
-			column: columnName,
-			codecId,
-			nativeType: columnMeta.nativeType,
-			nullable: columnMeta.nullable
-		}));
-		updateSet[columnName] = createParamRef(index, paramName);
-	}
-	const whereResult = buildWhereExpr(wherePredicate, context.contract, paramsMap, paramDescriptors, paramValues);
-	const whereExpr = whereResult.expr;
-	if (!whereExpr) errorFailedToBuildWhereClause();
-	if (whereResult?.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
-	const ast = createUpdateAst({
-		table,
-		set: updateSet,
-		where: whereExpr
-	});
-	return Object.freeze({
-		ast,
-		params: paramValues,
-		meta: {
-			target: context.contract.target,
-			targetFamily: context.contract.targetFamily,
-			coreHash: context.contract.coreHash,
-			lane: "orm",
-			refs: {
-				tables: [tableName],
-				columns: []
-			},
-			projection: {},
-			paramDescriptors,
-			...Object.keys(paramCodecs).length > 0 ? { annotations: {
-				codecs: paramCodecs,
-				intent: "write",
-				isMutation: true
-			} } : { annotations: {
-				intent: "write",
-				isMutation: true
-			} }
-		}
-	});
-}
-
-//#endregion
-//#region src/orm-include-child.ts
-var OrmIncludeChildBuilderImpl = class OrmIncludeChildBuilderImpl {
-	context;
-	contract;
-	childModelName;
-	childWhere;
-	childOrderBy;
-	childLimit;
-	childProjection = void 0;
-	constructor(options, childModelName) {
-		this.context = options.context;
-		this.contract = options.context.contract;
-		this.childModelName = childModelName;
-	}
-	where(fn) {
-		const builder = new OrmIncludeChildBuilderImpl({ context: this.context }, this.childModelName);
-		builder.childWhere = fn(this._getModelAccessor());
-		builder.childOrderBy = this.childOrderBy;
-		builder.childLimit = this.childLimit;
-		builder.childProjection = this.childProjection;
-		return builder;
-	}
-	orderBy(fn) {
-		const builder = new OrmIncludeChildBuilderImpl({ context: this.context }, this.childModelName);
-		builder.childWhere = this.childWhere;
-		builder.childOrderBy = fn(this._getModelAccessor());
-		builder.childLimit = this.childLimit;
-		builder.childProjection = this.childProjection;
-		return builder;
-	}
-	take(n) {
-		const builder = new OrmIncludeChildBuilderImpl({ context: this.context }, this.childModelName);
-		builder.childWhere = this.childWhere;
-		builder.childOrderBy = this.childOrderBy;
-		builder.childLimit = n;
-		builder.childProjection = this.childProjection;
-		return builder;
-	}
-	select(fn) {
-		const builder = new OrmIncludeChildBuilderImpl({ context: this.context }, this.childModelName);
-		builder.childWhere = this.childWhere;
-		builder.childOrderBy = this.childOrderBy;
-		builder.childLimit = this.childLimit;
-		builder.childProjection = fn(this._getModelAccessor());
-		return builder;
-	}
-	getState() {
-		return {
-			...this.childWhere !== void 0 ? { childWhere: this.childWhere } : {},
-			...this.childOrderBy !== void 0 ? { childOrderBy: this.childOrderBy } : {},
-			...this.childLimit !== void 0 ? { childLimit: this.childLimit } : {},
-			...this.childProjection !== void 0 ? { childProjection: this.childProjection } : {}
-		};
-	}
-	_getModelAccessor() {
-		const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
-		if (!tableName) throw planInvalid(`Model ${this.childModelName} not found in mappings`);
-		const table = schema(this.context).tables[tableName];
-		if (!table) throw planInvalid(`Table ${tableName} not found in schema`);
-		const accessor = {};
-		const model = this.contract.models[this.childModelName];
-		if (!model || typeof model !== "object" || !("fields" in model)) throw planInvalid(`Model ${this.childModelName} does not have fields`);
-		const modelFields = model.fields;
-		for (const fieldName in modelFields) {
-			const field = modelFields[fieldName];
-			if (!field) continue;
-			const columnName = this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ?? field.column ?? fieldName;
-			const column = table.columns[columnName];
-			if (column) accessor[fieldName] = column;
-		}
-		return accessor;
-	}
-};
-
-//#endregion
-//#region src/orm-relation-filter.ts
-var OrmRelationFilterBuilderImpl = class OrmRelationFilterBuilderImpl {
-	context;
-	contract;
-	childModelName;
-	wherePredicate = void 0;
-	modelAccessor = void 0;
-	constructor(options, childModelName) {
-		this.context = options.context;
-		this.contract = options.context.contract;
-		this.childModelName = childModelName;
-		this.modelAccessor = this._getModelAccessor();
-	}
-	where(fn) {
-		const builder = new OrmRelationFilterBuilderImpl({ context: this.context }, this.childModelName);
-		builder.modelAccessor = this.modelAccessor;
-		if (this.modelAccessor) builder.wherePredicate = fn(this.modelAccessor);
-		return builder;
-	}
-	getWherePredicate() {
-		return this.wherePredicate;
-	}
-	getChildModelName() {
-		return this.childModelName;
-	}
-	getModelAccessor() {
-		if (!this.modelAccessor) this.modelAccessor = this._getModelAccessor();
-		if (!this.modelAccessor) throw planInvalid(`Failed to get model accessor for ${this.childModelName}`);
-		return this.modelAccessor;
-	}
-	_getModelAccessor() {
-		const tableName = this.contract.mappings.modelToTable?.[this.childModelName];
-		if (!tableName) throw planInvalid(`Model ${this.childModelName} not found in mappings`);
-		const table = schema(this.context).tables[tableName];
-		if (!table) throw planInvalid(`Table ${tableName} not found in schema`);
-		const accessor = {};
-		const model = this.contract.models[this.childModelName];
-		if (!model || typeof model !== "object" || !("fields" in model)) throw planInvalid(`Model ${this.childModelName} does not have fields`);
-		const modelFields = model.fields;
-		for (const fieldName in modelFields) {
-			const field = modelFields[fieldName];
-			if (!field) continue;
-			const columnName = this.contract.mappings.fieldToColumn?.[this.childModelName]?.[fieldName] ?? field.column ?? fieldName;
-			const column = table.columns[columnName];
-			if (column) accessor[fieldName] = column;
-		}
-		return accessor;
-	}
-};
-
-//#endregion
-//#region src/plan/plan-assembly.ts
-/**
-* Extracts column references from an ExpressionSource (ColumnBuilder or ExpressionBuilder).
-* Skips entries with empty table or column names (e.g., placeholder columns for includes).
-*/
-function collectRefsFromExpressionSource(source, refsColumns) {
-	if (isExpressionBuilder(source)) {
-		const allRefs = collectColumnRefs(source.expr);
-		for (const ref of allRefs) if (ref.table && ref.column) refsColumns.set(`${ref.table}.${ref.column}`, {
-			table: ref.table,
-			column: ref.column
-		});
-	} else if (isColumnBuilder(source)) {
-		const col = source;
-		if (col.table && col.column) refsColumns.set(`${col.table}.${col.column}`, {
-			table: col.table,
-			column: col.column
-		});
-	}
-}
-/**
-* Extracts column references from an Expression (AST node).
-*/
-function collectRefsFromExpression(expr, refsColumns) {
-	if (isOperationExpr(expr)) {
-		const allRefs = collectColumnRefs(expr);
-		for (const ref of allRefs) refsColumns.set(`${ref.table}.${ref.column}`, {
-			table: ref.table,
-			column: ref.column
-		});
-	} else if (expr.kind === "col") refsColumns.set(`${expr.table}.${expr.column}`, {
-		table: expr.table,
-		column: expr.column
-	});
-}
-function buildMeta(args) {
-	const refsColumns = /* @__PURE__ */ new Map();
-	const refsTables = new Set([args.table.name]);
-	for (const column of args.projection.columns) collectRefsFromExpressionSource(column, refsColumns);
-	if (args.includes) for (const include of args.includes) {
-		refsTables.add(include.table.name);
-		const onLeft = include.on.left;
-		const onRight = include.on.right;
-		if (onLeft.table && onLeft.column && onRight.table && onRight.column) {
-			refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
-				table: onLeft.table,
-				column: onLeft.column
-			});
-			refsColumns.set(`${onRight.table}.${onRight.column}`, {
-				table: onRight.table,
-				column: onRight.column
-			});
-		}
-		for (const column of include.childProjection.columns) {
-			const col = column;
-			if (col.table && col.column) refsColumns.set(`${col.table}.${col.column}`, {
-				table: col.table,
-				column: col.column
-			});
-		}
-		if (include.childWhere) collectRefsFromExpression(include.childWhere.left, refsColumns);
-		if (include.childOrderBy) collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
-	}
-	if (args.where) {
-		const leftExpr = args.where.left;
-		if (isOperationExpr(leftExpr)) {
-			const allRefs = collectColumnRefs(leftExpr);
-			for (const ref of allRefs) refsColumns.set(`${ref.table}.${ref.column}`, {
-				table: ref.table,
-				column: ref.column
-			});
-		} else refsColumns.set(`${leftExpr.table}.${leftExpr.column}`, {
-			table: leftExpr.table,
-			column: leftExpr.column
-		});
-	}
-	if (args.orderBy) {
-		const orderByExpr = args.orderBy.expr;
-		if (isOperationExpr(orderByExpr)) {
-			const allRefs = collectColumnRefs(orderByExpr);
-			for (const ref of allRefs) refsColumns.set(`${ref.table}.${ref.column}`, {
-				table: ref.table,
-				column: ref.column
-			});
-		} else refsColumns.set(`${orderByExpr.table}.${orderByExpr.column}`, {
-			table: orderByExpr.table,
-			column: orderByExpr.column
-		});
-	}
-	const includeAliases = new Set(args.includes?.map((inc) => inc.alias) ?? []);
-	const projectionMap = Object.fromEntries(args.projection.aliases.map((alias, index) => {
-		if (includeAliases.has(alias)) return [alias, `include:${alias}`];
-		const column = args.projection.columns[index];
-		if (!column) throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
-		if (isExpressionBuilder(column)) return [alias, `operation:${column.expr.method}`];
-		const col = column;
-		if (!col.table || !col.column) return [alias, `include:${alias}`];
-		return [alias, `${col.table}.${col.column}`];
-	}));
-	const projectionTypes = {};
-	for (let i = 0; i < args.projection.aliases.length; i++) {
-		const alias = args.projection.aliases[i];
-		if (!alias || includeAliases.has(alias)) continue;
-		const col = args.projection.columns[i];
-		if (!col) continue;
-		if (isExpressionBuilder(col)) {
-			const operationExpr = col.expr;
-			if (operationExpr.returns.kind === "typeId") projectionTypes[alias] = operationExpr.returns.type;
-			else if (operationExpr.returns.kind === "builtin") projectionTypes[alias] = operationExpr.returns.type;
-		} else {
-			const codecId = getColumnMeta(col)?.codecId;
-			if (codecId) projectionTypes[alias] = codecId;
-		}
-	}
-	const projectionCodecs = {};
-	for (let i = 0; i < args.projection.aliases.length; i++) {
-		const alias = args.projection.aliases[i];
-		if (!alias || includeAliases.has(alias)) continue;
-		const column = args.projection.columns[i];
-		if (!column) continue;
-		if (isExpressionBuilder(column)) {
-			const operationExpr = column.expr;
-			if (operationExpr.returns.kind === "typeId") projectionCodecs[alias] = operationExpr.returns.type;
-		} else {
-			const codecId = getColumnMeta(column)?.codecId;
-			if (codecId) projectionCodecs[alias] = codecId;
-		}
-	}
-	const allCodecs = {
-		...projectionCodecs,
-		...args.paramCodecs ? args.paramCodecs : {}
-	};
-	return Object.freeze(compact({
-		target: args.contract.target,
-		targetFamily: args.contract.targetFamily,
-		coreHash: args.contract.coreHash,
-		lane: "dsl",
-		refs: {
-			tables: Array.from(refsTables),
-			columns: Array.from(refsColumns.values())
-		},
-		projection: projectionMap,
-		projectionTypes: Object.keys(projectionTypes).length > 0 ? projectionTypes : void 0,
-		annotations: Object.keys(allCodecs).length > 0 ? Object.freeze({ codecs: Object.freeze(allCodecs) }) : void 0,
-		paramDescriptors: args.paramDescriptors,
-		profileHash: args.contract.profileHash
-	}));
-}
-
-//#endregion
-//#region src/orm/capabilities.ts
-function checkIncludeCapabilities(contract) {
-	const target = contract.target;
-	const capabilities = contract.capabilities;
-	if (!capabilities || !capabilities[target]) errorIncludeRequiresCapabilities();
-	const targetCapabilities = capabilities[target];
-	if (capabilities[target]["lateral"] !== true || targetCapabilities["jsonAgg"] !== true) errorIncludeCapabilitiesNotTrue();
-}
-
-//#endregion
-//#region src/selection/join.ts
-function buildJoinOnExpr(parentTableName, parentColName, childTableName, childColName) {
-	return createJoinOnExpr(createColumnRef(parentTableName, parentColName), createColumnRef(childTableName, childColName));
-}
-
-//#endregion
-//#region src/selection/ordering.ts
-function buildOrderByClause(orderBy) {
-	if (!orderBy) return;
-	const orderByBuilder = orderBy;
-	const orderExpr = orderByBuilder.expr;
-	return [createOrderByItem(isOperationExpr(orderExpr) ? orderExpr : (() => {
-		const colBuilder = orderExpr;
-		return createColumnRef(colBuilder.table, colBuilder.column);
-	})(), orderByBuilder.dir)];
-}
-function buildChildOrderByClause(orderBy) {
-	if (!orderBy) return;
-	const orderByBuilder = orderBy;
-	const orderExpr = orderByBuilder.expr;
-	return [createOrderByItem((() => {
-		if (isOperationExpr(orderExpr)) {
-			const baseCol = extractBaseColumnRef(orderExpr);
-			return createColumnRef(baseCol.table, baseCol.column);
-		}
-		const colBuilder = orderExpr;
-		return createColumnRef(colBuilder.table, colBuilder.column);
-	})(), orderByBuilder.dir)];
-}
-
-//#endregion
-//#region src/selection/projection.ts
-function generateAlias(path) {
-	if (path.length === 0) errorAliasPathEmpty();
-	return path.join("_");
-}
-var AliasTracker = class {
-	aliases = /* @__PURE__ */ new Set();
-	aliasToPath = /* @__PURE__ */ new Map();
-	register(path) {
-		const alias = generateAlias(path);
-		if (this.aliases.has(alias)) errorAliasCollision(path, alias, this.aliasToPath.get(alias));
-		this.aliases.add(alias);
-		this.aliasToPath.set(alias, path);
-		return alias;
-	}
-	getPath(alias) {
-		return this.aliasToPath.get(alias);
-	}
-	has(alias) {
-		return this.aliases.has(alias);
-	}
-};
-function flattenProjection(projection, tracker, currentPath = []) {
-	const aliases = [];
-	const columns = [];
-	for (const [key, value] of Object.entries(projection)) {
-		const path = [...currentPath, key];
-		if (isColumnBuilder(value) || isExpressionBuilder(value)) {
-			const alias = tracker.register(path);
-			aliases.push(alias);
-			columns.push(value);
-		} else if (typeof value === "object" && value !== null) {
-			const nested = flattenProjection(value, tracker, path);
-			aliases.push(...nested.aliases);
-			columns.push(...nested.columns);
-		} else errorInvalidProjectionValue(path);
-	}
-	return {
-		aliases,
-		columns
-	};
-}
-function buildProjectionState(_table, projection, includes) {
-	const tracker = new AliasTracker();
-	const aliases = [];
-	const columns = [];
-	for (const [key, value] of Object.entries(projection)) if (value === true) {
-		const matchingInclude = includes?.find((inc) => inc.alias === key);
-		if (!matchingInclude) errorIncludeAliasNotFound(key);
-		aliases.push(key);
-		columns.push({
-			kind: "column",
-			table: matchingInclude.table.name,
-			column: "",
-			columnMeta: {
-				nativeType: "jsonb",
-				codecId: "core/json@1",
-				nullable: true
-			},
-			toExpr() {
-				return {
-					kind: "col",
-					table: matchingInclude.table.name,
-					column: ""
-				};
-			}
-		});
-	} else if (isColumnBuilder(value) || isExpressionBuilder(value)) {
-		const alias = tracker.register([key]);
-		aliases.push(alias);
-		columns.push(value);
-	} else if (typeof value === "object" && value !== null) {
-		const nested = flattenProjection(value, tracker, [key]);
-		aliases.push(...nested.aliases);
-		columns.push(...nested.columns);
-	} else errorInvalidProjectionKey(key);
-	if (aliases.length === 0) errorProjectionEmpty();
-	return {
-		aliases,
-		columns
-	};
-}
-
-//#endregion
-//#region src/relations/include-plan.ts
-function buildIncludeAsts(input) {
-	const { includes, contract, context, modelName, paramsMap, paramDescriptors, paramValues, paramCodecs } = input;
-	const includesAst = [];
-	const includesForMeta = [];
-	for (const includeState of includes) {
-		checkIncludeCapabilities(contract);
-		const parentTableName = contract.mappings.modelToTable?.[modelName];
-		if (!parentTableName) errorModelNotFound(modelName);
-		const parentSchemaTable = schema(context).tables[parentTableName];
-		if (!parentSchemaTable) errorTableNotFound(parentTableName);
-		const childSchemaTable = schema(context).tables[includeState.childTable.name];
-		if (!childSchemaTable) errorTableNotFound(includeState.childTable.name);
-		if (includeState.relation.on.parentCols.length !== 1 || includeState.relation.on.childCols.length !== 1) errorMultiColumnJoinsNotSupported();
-		const parentColName = includeState.relation.on.parentCols[0];
-		const childColName = includeState.relation.on.childCols[0];
-		if (!parentColName || !childColName) errorJoinColumnsMustBeDefined();
-		const parentCol = parentSchemaTable.columns[parentColName];
-		const childCol = childSchemaTable.columns[childColName];
-		if (!parentCol) errorColumnNotFound(parentColName, parentTableName);
-		if (!childCol) errorColumnNotFound(childColName, includeState.childTable.name);
-		const onExpr = buildJoinOnExpr(parentTableName, parentColName, includeState.childTable.name, childColName);
-		if (!includeState.childProjection) errorChildProjectionMustBeSpecified();
-		const filteredProjection = {};
-		for (const [key, value] of Object.entries(includeState.childProjection)) if (value !== true && value !== false) filteredProjection[key] = value;
-		if (Object.keys(filteredProjection).length === 0) errorChildProjectionEmpty();
-		const childProjectionState = buildProjectionState(includeState.childTable, filteredProjection);
-		let childWhere;
-		if (includeState.childWhere) {
-			const whereResult = buildWhereExpr(includeState.childWhere, contract, paramsMap, paramDescriptors, paramValues);
-			childWhere = whereResult.expr;
-			if (whereResult.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
-		}
-		const childOrderBy = buildChildOrderByClause(includeState.childOrderBy);
-		const childProjectionItems = [];
-		for (let i = 0; i < childProjectionState.aliases.length; i++) {
-			const alias = childProjectionState.aliases[i];
-			if (!alias) errorMissingAlias(i);
-			const column = childProjectionState.columns[i];
-			if (!column) errorMissingColumn(alias, i);
-			if (isExpressionBuilder(column)) childProjectionItems.push({
-				alias,
-				expr: column.expr
-			});
-			else childProjectionItems.push({
-				alias,
-				expr: column.toExpr()
-			});
-		}
-		const includeAst = compact({
-			kind: "includeMany",
-			alias: includeState.alias,
-			child: compact({
-				table: includeState.childTable,
-				on: onExpr,
-				project: childProjectionItems,
-				where: childWhere,
-				orderBy: childOrderBy,
-				limit: includeState.childLimit
-			})
-		});
-		includesAst.push(includeAst);
-		const includeForMeta = compact({
-			alias: includeState.alias,
-			table: includeState.childTable,
-			on: {
-				kind: "join-on",
-				left: parentCol,
-				right: childCol
-			},
-			childProjection: childProjectionState,
-			childWhere: includeState.childWhere,
-			childOrderBy: includeState.childOrderBy,
-			childLimit: includeState.childLimit
-		});
-		includesForMeta.push(includeForMeta);
-	}
-	return {
-		includesAst,
-		includesForMeta
-	};
-}
-function buildExistsSubqueries(relationFilters, contract, modelName, options) {
-	const existsExprs = [];
-	for (const filter of relationFilters) {
-		const childTableName = contract.mappings.modelToTable?.[filter.childModelName];
-		if (!childTableName) errorModelNotFound(filter.childModelName);
-		const childTable = {
-			kind: "table",
-			name: childTableName
-		};
-		const parentTableName = contract.mappings.modelToTable?.[modelName];
-		if (!parentTableName) errorModelNotFound(modelName);
-		const joinConditions = [];
-		for (let i = 0; i < filter.relation.on.parentCols.length; i++) {
-			const parentCol = filter.relation.on.parentCols[i];
-			const childCol = filter.relation.on.childCols[i];
-			if (!parentCol || !childCol) continue;
-			joinConditions.push({
-				left: {
-					kind: "col",
-					table: parentTableName,
-					column: parentCol
-				},
-				right: {
-					kind: "col",
-					table: childTableName,
-					column: childCol
-				}
-			});
-		}
-		let childWhere;
-		if (filter.childWhere) {
-			const paramsMap = options?.params ?? {};
-			childWhere = buildWhereExpr(filter.childWhere, contract, paramsMap, [], []).expr;
-		}
-		let subqueryWhere = childWhere;
-		if (joinConditions.length > 0) {
-			const firstJoinCondition = joinConditions[0];
-			if (firstJoinCondition) {
-				const joinWhere = {
-					kind: "bin",
-					op: "eq",
-					left: firstJoinCondition.left,
-					right: firstJoinCondition.right
-				};
-				if (childWhere) subqueryWhere = joinWhere;
-				else subqueryWhere = joinWhere;
-			}
-		}
-		const existsExpr = {
-			kind: "exists",
-			subquery: createSelectAst({
-				from: childTable,
-				project: [{
-					alias: "_exists",
-					expr: joinConditions[0]?.right ?? createColumnRef(childTableName, "id")
-				}],
-				where: subqueryWhere
-			}),
-			not: filter.filterType === "none" || filter.filterType === "every"
-		};
-		existsExprs.push(existsExpr);
-	}
-	return existsExprs;
-}
-function combineWhereClauses(mainWhere, existsExprs) {
-	if (existsExprs.length === 1) return existsExprs[0];
-	if (mainWhere) return mainWhere;
-	if (existsExprs.length > 0) return existsExprs[0];
-}
-
-//#endregion
-//#region src/selection/select-builder.ts
-function buildProjectionItems(projectionState, includesForMeta) {
-	const projectEntries = [];
-	for (let i = 0; i < projectionState.aliases.length; i++) {
-		const alias = projectionState.aliases[i];
-		if (!alias) errorMissingAlias(i);
-		const column = projectionState.columns[i];
-		if (!column) errorMissingColumn(alias, i);
-		if (includesForMeta.find((inc) => inc.alias === alias)) projectEntries.push({
-			alias,
-			expr: {
-				kind: "includeRef",
-				alias
-			}
-		});
-		else if (isExpressionBuilder(column)) projectEntries.push({
-			alias,
-			expr: column.expr
-		});
-		else {
-			const expr = column.toExpr();
-			if (expr.kind === "col" && (!expr.table || !expr.column)) errorInvalidColumn(alias, i);
-			projectEntries.push({
-				alias,
-				expr
-			});
-		}
-	}
-	return projectEntries;
-}
-function buildSelectAst(params) {
-	const { table, projectEntries, includesAst, whereExpr, orderByClause, limit } = params;
-	return createSelectAst({
-		from: createTableRef(table.name),
-		project: projectEntries,
-		...includesAst ? { includes: includesAst } : {},
-		...whereExpr ? { where: whereExpr } : {},
-		...orderByClause ? { orderBy: orderByClause } : {},
-		...limit !== void 0 ? { limit } : {}
-	});
-}
-
-//#endregion
-//#region src/orm/context.ts
-function createOrmContext(context) {
-	return context;
-}
-
-//#endregion
-//#region src/orm/builder.ts
-var OrmModelBuilderImpl = class OrmModelBuilderImpl {
-	context;
-	contract;
-	modelName;
-	table;
-	wherePredicate = void 0;
-	relationFilters = [];
-	includes = [];
-	orderByExpr = void 0;
-	limitValue = void 0;
-	offsetValue = void 0;
-	projection = void 0;
-	constructor(options, modelName) {
-		this.context = options.context;
-		this.contract = options.context.contract;
-		this.modelName = modelName;
-		const tableName = this.contract.mappings.modelToTable?.[modelName];
-		if (!tableName) errorModelNotFound(modelName);
-		const table = schema(options.context).tables[tableName];
-		if (!table) errorTableNotFound(tableName);
-		this.table = table;
-	}
-	get where() {
-		const whereFn = (fn) => {
-			const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-			builder["table"] = this.table;
-			builder.wherePredicate = fn(this._getModelAccessor());
-			builder.relationFilters = this.relationFilters;
-			builder.includes = this.includes;
-			builder.orderByExpr = this.orderByExpr;
-			builder.limitValue = this.limitValue;
-			builder.offsetValue = this.offsetValue;
-			builder.projection = this.projection;
-			return builder;
-		};
-		const related = this._createRelatedProxy();
-		return Object.assign(whereFn, { related });
-	}
-	get include() {
-		return this._createIncludeProxy();
-	}
-	_createIncludeProxy() {
-		const self = this;
-		const tableName = this.contract.mappings.modelToTable?.[this.modelName];
-		if (!tableName) return {};
-		const modelRelations = this.contract.relations?.[tableName];
-		if (!modelRelations || typeof modelRelations !== "object") return {};
-		return new Proxy({}, { get(_target, prop) {
-			if (typeof prop !== "string") return;
-			const relation = modelRelations[prop];
-			if (!relation || typeof relation !== "object" || !("to" in relation)) throw planInvalid(`Relation ${prop} not found on model ${self.modelName}`);
-			const childModelName = relation.to;
-			const relationDef = relation;
-			const relationName = prop;
-			const includeFn = ((child) => {
-				return self._applyInclude(relationName, childModelName, child, relationDef);
-			});
-			return includeFn;
-		} });
-	}
-	_applyInclude(relationName, childModelName, childBuilderFn, relationDef) {
-		const childTableName = this.contract.mappings.modelToTable?.[childModelName];
-		if (!childTableName) errorModelNotFound(childModelName);
-		const childTable = {
-			kind: "table",
-			name: childTableName
-		};
-		const childState = childBuilderFn(new OrmIncludeChildBuilderImpl({ context: this.context }, childModelName)).getState();
-		const includeState = {
-			relationName,
-			childModelName,
-			childTable,
-			childWhere: childState.childWhere,
-			childOrderBy: childState.childOrderBy,
-			childLimit: childState.childLimit,
-			childProjection: childState.childProjection,
-			alias: relationName,
-			relation: relationDef
-		};
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = this.relationFilters;
-		builder.includes = [...this.includes, includeState];
-		builder.orderByExpr = this.orderByExpr;
-		builder.limitValue = this.limitValue;
-		builder.offsetValue = this.offsetValue;
-		builder.projection = this.projection;
-		return builder;
-	}
-	_createRelatedProxy() {
-		const self = this;
-		const tableName = this.contract.mappings.modelToTable?.[this.modelName];
-		if (!tableName) return {};
-		const modelRelations = this.contract.relations?.[tableName];
-		if (!modelRelations || typeof modelRelations !== "object") return {};
-		return new Proxy({}, { get(_target, prop) {
-			if (typeof prop !== "string") return;
-			const relation = modelRelations[prop];
-			if (!relation || typeof relation !== "object" || !("to" in relation)) throw planInvalid(`Relation ${prop} not found on model ${self.modelName}`);
-			const childModelName = relation.to;
-			const relationDef = relation;
-			const filterBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
-			const modelAccessor = filterBuilder.getModelAccessor();
-			const builderWithAccessor = Object.assign(filterBuilder, modelAccessor);
-			return {
-				some: (fn) => {
-					const result = fn(builderWithAccessor);
-					if (result && "kind" in result && result.kind === "binary") {
-						const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
-						wrappedBuilder["wherePredicate"] = result;
-						return self._applyRelationFilter(prop, childModelName, "some", () => wrappedBuilder, relationDef);
-					}
-					return self._applyRelationFilter(prop, childModelName, "some", () => result, relationDef);
-				},
-				none: (fn) => {
-					const result = fn(builderWithAccessor);
-					if (result && "kind" in result && result.kind === "binary") {
-						const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
-						wrappedBuilder["wherePredicate"] = result;
-						return self._applyRelationFilter(prop, childModelName, "none", () => wrappedBuilder, relationDef);
-					}
-					return self._applyRelationFilter(prop, childModelName, "none", () => result, relationDef);
-				},
-				every: (fn) => {
-					const result = fn(builderWithAccessor);
-					if (result && "kind" in result && result.kind === "binary") {
-						const wrappedBuilder = new OrmRelationFilterBuilderImpl({ context: self.context }, childModelName);
-						wrappedBuilder["wherePredicate"] = result;
-						return self._applyRelationFilter(prop, childModelName, "every", () => wrappedBuilder, relationDef);
-					}
-					return self._applyRelationFilter(prop, childModelName, "every", () => result, relationDef);
-				}
-			};
-		} });
-	}
-	_applyRelationFilter(relationName, childModelName, filterType, fn, relationDef) {
-		const relationFilter = {
-			relationName,
-			childModelName,
-			filterType,
-			childWhere: fn(new OrmRelationFilterBuilderImpl({ context: this.context }, childModelName)).getWherePredicate(),
-			relation: relationDef
-		};
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = [...this.relationFilters, relationFilter];
-		builder.includes = this.includes;
-		builder.orderByExpr = this.orderByExpr;
-		builder.limitValue = this.limitValue;
-		builder.offsetValue = this.offsetValue;
-		builder.projection = this.projection;
-		return builder;
-	}
-	orderBy(fn) {
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = this.relationFilters;
-		builder.includes = this.includes;
-		builder.orderByExpr = fn(this._getModelAccessor());
-		builder.limitValue = this.limitValue;
-		builder.offsetValue = this.offsetValue;
-		builder.projection = this.projection;
-		return builder;
-	}
-	take(n) {
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = this.relationFilters;
-		builder.includes = this.includes;
-		builder.orderByExpr = this.orderByExpr;
-		builder.limitValue = n;
-		builder.offsetValue = this.offsetValue;
-		builder.projection = this.projection;
-		return builder;
-	}
-	skip(n) {
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = this.relationFilters;
-		builder.includes = this.includes;
-		builder.orderByExpr = this.orderByExpr;
-		builder.limitValue = this.limitValue;
-		builder.offsetValue = n;
-		builder.projection = this.projection;
-		return builder;
-	}
-	select(fn) {
-		const builder = new OrmModelBuilderImpl({ context: this.context }, this.modelName);
-		builder["table"] = this.table;
-		builder.wherePredicate = this.wherePredicate;
-		builder.relationFilters = this.relationFilters;
-		builder.includes = this.includes;
-		builder.orderByExpr = this.orderByExpr;
-		builder.limitValue = this.limitValue;
-		builder.offsetValue = this.offsetValue;
-		builder.projection = fn(this._getModelAccessor());
-		return builder;
-	}
-	findMany(options) {
-		const paramsMap = options?.params ?? {};
-		if (!this.contract.storage.tables[this.table.name]) errorUnknownTable(this.table.name);
-		const paramDescriptors = [];
-		const paramValues = [];
-		const paramCodecs = {};
-		const projectionInput = this.projection ?? (() => {
-			const modelAccessor = this._getModelAccessor();
-			const defaultProjection = {};
-			for (const fieldName in modelAccessor) defaultProjection[fieldName] = modelAccessor[fieldName];
-			return defaultProjection;
-		})();
-		const { includesAst, includesForMeta } = buildIncludeAsts({
-			includes: this.includes,
-			contract: this.contract,
-			context: this.context,
-			modelName: this.modelName,
-			paramsMap,
-			paramDescriptors,
-			paramValues,
-			paramCodecs
-		});
-		const projectionState = buildProjectionState(this.table, projectionInput, includesForMeta.length > 0 ? includesForMeta : void 0);
-		const whereResult = this.wherePredicate ? buildWhereExpr(this.wherePredicate, this.contract, paramsMap, paramDescriptors, paramValues) : void 0;
-		const whereExpr = whereResult?.expr;
-		if (whereResult?.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
-		const orderByClause = buildOrderByClause(this.orderByExpr);
-		const projectEntries = buildProjectionItems(projectionState, includesForMeta);
-		const ast = buildSelectAst({
-			table: this.table,
-			projectEntries,
-			...includesAst.length > 0 ? { includesAst } : {},
-			...whereExpr ? { whereExpr } : {},
-			...orderByClause ? { orderByClause } : {},
-			...this.limitValue !== void 0 ? { limit: this.limitValue } : {}
-		});
-		const planMeta = buildMeta({
-			contract: this.contract,
-			table: createTableRef(this.table.name),
-			projection: projectionState,
-			includes: includesForMeta.length > 0 ? includesForMeta : void 0,
-			paramDescriptors,
-			paramCodecs: Object.keys(paramCodecs).length > 0 ? paramCodecs : void 0,
-			where: this.wherePredicate,
-			orderBy: this.orderByExpr
-		});
-		if (this.relationFilters.length > 0) {
-			const existsExprs = buildExistsSubqueries(this.relationFilters, this.contract, this.modelName, options);
-			if (existsExprs.length > 0) {
-				const combinedWhere = combineWhereClauses(ast.where, existsExprs);
-				const modifiedAst = {
-					...ast,
-					...combinedWhere !== void 0 ? { where: combinedWhere } : {}
-				};
-				return Object.freeze({
-					ast: modifiedAst,
-					params: paramValues,
-					meta: {
-						...planMeta,
-						lane: "orm"
-					}
-				});
-			}
-		}
-		return Object.freeze({
-			ast,
-			params: paramValues,
-			meta: {
-				...planMeta,
-				lane: "orm"
-			}
-		});
-	}
-	findFirst(options) {
-		return this.take(1).findMany(options);
-	}
-	findUnique(where, options) {
-		return this.where(where).take(1).findMany(options);
-	}
-	create(data, options) {
-		return buildInsertPlan(createOrmContext(this.context), this.modelName, data, options);
-	}
-	update(where, data, options) {
-		return buildUpdatePlan(createOrmContext(this.context), this.modelName, where, () => this._getModelAccessor(), data, options);
-	}
-	delete(where, options) {
-		return buildDeletePlan(createOrmContext(this.context), this.modelName, where, () => this._getModelAccessor(), options);
-	}
-	_getModelAccessor() {
-		const tableName = this.contract.mappings.modelToTable?.[this.modelName];
-		if (!tableName) errorModelNotFound(this.modelName);
-		const table = schema(this.context).tables[tableName];
-		if (!table) errorTableNotFound(tableName);
-		const accessor = {};
-		const model = this.contract.models[this.modelName];
-		if (!model || typeof model !== "object" || !("fields" in model)) throw planInvalid(`Model ${this.modelName} does not have fields`);
-		const modelFields = model.fields;
-		for (const fieldName in modelFields) {
-			const field = modelFields[fieldName];
-			if (!field) continue;
-			const columnName = this.contract.mappings.fieldToColumn?.[this.modelName]?.[fieldName] ?? field.column ?? fieldName;
-			const column = table.columns[columnName];
-			if (column) accessor[fieldName] = column;
-		}
-		return accessor;
-	}
-};
-
-//#endregion
-//#region src/orm.ts
-function orm(options) {
-	const contract = options.context.contract;
-	return new Proxy({}, {
-		get(_target, prop) {
-			if (typeof prop !== "string") return;
-			const modelName = prop.charAt(0).toUpperCase() + prop.slice(1);
-			if (!contract.models || typeof contract.models !== "object" || !(modelName in contract.models)) throw planInvalid(`Model ${prop} (resolved to ${modelName}) not found in contract`);
-			return () => new OrmModelBuilderImpl(options, modelName);
-		},
-		has(_target, prop) {
-			if (typeof prop !== "string") return false;
-			const modelName = prop.charAt(0).toUpperCase() + prop.slice(1);
-			return contract.models && typeof contract.models === "object" && modelName in contract.models;
-		}
-	});
-}
-
-//#endregion
-export { OrmModelBuilderImpl as n, orm as t };
-//# sourceMappingURL=orm-BYJaTDLm.mjs.map