@prisma-next/sql-orm-client 0.5.0-dev.6 → 0.5.0-dev.61

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AsyncIterableResult } from "@prisma-next/runtime-executor";
-import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, EqColJoinOn, ExistsExpr, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst, isWhereExpr } from "@prisma-next/sql-relational-core/ast";
+import { AsyncIterableResult } from "@prisma-next/framework-components/runtime";
+import { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, EqColJoinOn, ExistsExpr, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, SubqueryExpr, TableSource, UpdateAst, collectOrderedParamRefs, isWhereExpr } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
 
 //#region src/collection-contract.ts
@@ -398,83 +398,70 @@ function executeQueryPlan(scope, plan) {
 
 //#endregion
 //#region src/include-strategy.ts
+/**
+* Choose the SQL emission strategy for nested includes based on the
+* contract's declared capabilities.
+*
+* - `'lateral'`: outer SELECT with one LATERAL JOIN per relation,
+*   aggregating to JSON. Requires both `lateral` and `jsonAgg`.
+*   Postgres has both.
+* - `'correlated'`: outer SELECT with one correlated subquery per
+*   relation, aggregating to JSON. Requires `jsonAgg` only.
+*   SQLite has `jsonAgg` (via `json_group_array`) but no LATERAL.
+* - `'multiQuery'`: fallback. One SELECT per relation, stitched
+*   together in JS via `WHERE pk IN (parent-pk-values)`. Always
+*   correct; just N+1 round-trips.
+*
+* The capability flags are looked up under the contract's
+* `targetFamily` and `target` namespaces — the two layers the contract
+* emitter actually populates. Cross-namespace ("`postgres.lateral`
+* found while running SQLite") false positives are impossible because
+* we only inspect the running target's namespaces.
+*/
 function selectIncludeStrategy(contract) {
-	const capabilities = contract.capabilities;
-	const hasLateral = hasCapability(capabilities?.["lateral"]);
-	const hasJsonAgg = hasCapability(capabilities?.["jsonAgg"]);
+	const hasLateral = capabilityFlag(contract, "lateral");
+	const hasJsonAgg = capabilityFlag(contract, "jsonAgg");
 	if (hasLateral && hasJsonAgg) return "lateral";
 	if (hasJsonAgg) return "correlated";
 	return "multiQuery";
 }
-function hasCapability(value) {
-	if (value === true) return true;
-	if (typeof value !== "object" || value === null) return false;
-	const flags = value;
-	return Object.values(flags).some((flag) => flag === true);
+/**
+* Read a capability flag from the contract's target/family namespaces.
+*
+* The contract emitter populates `capabilities[targetFamily]` (universal
+* SQL flags like `jsonAgg`, `returning`) and `capabilities[target]`
+* (target-specific flags like `lateral` on Postgres). Either may
+* declare a given flag; the family namespace declares the floor and the
+* target namespace can extend on top.
+*/
+function capabilityFlag(contract, flag) {
+	return contract.capabilities[contract.targetFamily]?.[flag] === true || contract.capabilities[contract.target]?.[flag] === true;
 }
 
 //#endregion
 //#region src/query-plan-meta.ts
-function resolveProjectionCodecs(contract, ast) {
-	const codecs = {};
-	if (ast.kind === "select") {
-		for (const item of ast.projection) if (item.expr.kind === "column-ref") {
-			const col = contract.storage.tables[item.expr.table]?.columns[item.expr.column];
-			if (col?.codecId) codecs[item.alias] = col.codecId;
-		}
-	} else if (ast.returning) {
-		const tableName = ast.table.name;
-		const table = contract.storage.tables[tableName];
-		if (!table) return void 0;
-		for (const colRef of ast.returning) {
-			const col = table.columns[colRef.column];
-			if (col?.codecId) codecs[colRef.column] = col.codecId;
-		}
-	}
-	return Object.keys(codecs).length > 0 ? codecs : void 0;
-}
 function deriveParamsFromAst(ast) {
-	const collectedParams = [...new Set(ast.collectParamRefs())];
-	return {
-		params: collectedParams.map((p) => p.value),
-		paramDescriptors: collectedParams.map((p) => ({
-			...ifDefined("name", p.name),
-			...ifDefined("codecId", p.codecId),
-			source: "dsl"
-		}))
-	};
+	return { params: collectOrderedParamRefs(ast).map((p) => p.value) };
 }
 function resolveTableColumns(contract, tableName) {
 	const table = contract.storage.tables[tableName];
 	if (!table) throw new Error(`Unknown table "${tableName}" in SQL ORM query planner`);
 	return Object.keys(table.columns);
 }
-function buildOrmPlanMeta(contract, paramDescriptors = []) {
+function buildOrmPlanMeta(contract) {
 	return {
 		target: contract.target,
 		targetFamily: contract.targetFamily,
 		storageHash: contract.storage.storageHash,
 		...contract.profileHash !== void 0 ? { profileHash: contract.profileHash } : {},
-		lane: "orm-client",
-		paramDescriptors: [...paramDescriptors]
+		lane: "orm-client"
 	};
 }
-function buildOrmQueryPlan(contract, ast, params, paramDescriptors = []) {
-	const projectionTypes = resolveProjectionCodecs(contract, ast);
-	const codecAnnotations = projectionTypes ? { codecs: Object.freeze({ ...projectionTypes }) } : void 0;
-	const limitAnnotation = ast.kind === "select" && ast.limit !== void 0 ? { limit: ast.limit } : void 0;
-	const annotations = codecAnnotations || limitAnnotation ? Object.freeze({
-		...codecAnnotations,
-		...limitAnnotation
-	}) : void 0;
+function buildOrmQueryPlan(contract, ast, params) {
 	return Object.freeze({
 		ast,
 		params: [...params],
-		meta: {
-			...buildOrmPlanMeta(contract, paramDescriptors),
-			...ifDefined("projectionTypes", projectionTypes),
-			...ifDefined("annotations", annotations)
-		}
+		meta: buildOrmPlanMeta(contract)
 	});
 }
 
@@ -488,10 +475,21 @@ function combineWhereExprs(filters) {
 
 //#endregion
 //#region src/query-plan-aggregate.ts
-function toAggregateExpr(tableName, selector) {
-	if (selector.fn === "count") return AggregateExpr.count();
+function toAggregateProjection(contract, tableName, selector) {
+	if (selector.fn === "count") return {
+		expr: AggregateExpr.count(),
+		codecId: void 0
+	};
 	if (!selector.column) throw new Error(`Aggregate selector "${selector.fn}" requires a field`);
-	return new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+	const expr = new AggregateExpr(selector.fn, ColumnRef.of(tableName, selector.column));
+	if (selector.fn === "min" || selector.fn === "max") return {
+		expr,
+		codecId: contract.storage.tables[tableName]?.columns[selector.column]?.codecId
+	};
+	return {
+		expr,
+		codecId: void 0
+	};
 }
 function validateGroupedComparable(value) {
 	switch (value.kind) {
@@ -551,30 +549,39 @@ function validateGroupedHavingExpr(expr) {
 function compileAggregate(contract, tableName, filters, aggregateSpec) {
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw new Error("aggregate() requires at least one aggregation selector");
-	const projection = entries.map(([alias, selector]) => ProjectionItem.of(alias, toAggregateExpr(tableName, selector)));
+	const projection = entries.map(([alias, selector]) => {
+		const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+		return ProjectionItem.of(alias, expr, codecId);
+	});
 	let ast = SelectAst.from(TableSource.named(tableName)).withProjection(projection);
 	const where = combineWhereExprs(filters);
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileGroupedAggregate(contract, tableName, filters, groupByColumns, aggregateSpec, havingExpr) {
 	if (groupByColumns.length === 0) throw new Error("groupBy() requires at least one field");
 	const entries = Object.entries(aggregateSpec);
 	if (entries.length === 0) throw new Error("groupBy().aggregate() requires at least one aggregation selector");
-	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column))), ...entries.map(([alias, selector]) => ProjectionItem.of(alias, toAggregateExpr(tableName, selector)))];
+	const table = contract.storage.tables[tableName];
+	const projection = [...groupByColumns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId)), ...entries.map(([alias, selector]) => {
+		const { expr, codecId } = toAggregateProjection(contract, tableName, selector);
+		return ProjectionItem.of(alias, expr, codecId);
+	})];
 	let ast = SelectAst.from(TableSource.named(tableName)).withProjection(projection).withGroupBy(groupByColumns.map((column) => ColumnRef.of(tableName, column)));
 	const where = combineWhereExprs(filters);
 	if (where) ast = ast.withWhere(where);
 	if (havingExpr) ast = ast.withHaving(validateGroupedHavingExpr(havingExpr));
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 
 //#endregion
 //#region src/query-plan-mutations.ts
 function buildReturningColumns(contract, tableName, returningColumns) {
-	return (returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, tableName)).map((column) => ColumnRef.of(tableName, column));
+	const columns = returningColumns && returningColumns.length > 0 ? [...returningColumns] : resolveTableColumns(contract, tableName);
+	const table = contract.storage.tables[tableName];
+	return columns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableName, column), table?.columns[column]?.codecId));
 }
 function toParamAssignments(contract, tableName, values) {
 	const assignments = {};
@@ -585,7 +592,11 @@ function toParamAssignments(contract, tableName, values) {
 		if (!codecId) throw new Error(`Unknown column "${column}" in table "${tableName}"`);
 		assignments[column] = ParamRef.of(value, {
 			name: column,
-			codecId
+			codecId,
+			refs: {
+				table: tableName,
+				column
+			}
 		});
 	}
 	return { assignments };
@@ -610,7 +621,11 @@ function normalizeInsertRows(contract, tableName, rows) {
 				if (!codecId) throw new Error(`Unknown column "${column}" in table "${tableName}"`);
 				normalizedRow[column] = ParamRef.of(row[column], {
 					name: column,
-					codecId
+					codecId,
+					refs: {
+						table: tableName,
+						column
+					}
 				});
 				continue;
 			}
@@ -622,14 +637,14 @@ function normalizeInsertRows(contract, tableName, rows) {
 function compileInsertReturning(contract, tableName, rows, returningColumns) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, tableName, rows);
 	const ast = InsertAst.into(TableSource.named(tableName)).withRows(normalizedRows).withReturning(buildReturningColumns(contract, tableName, returningColumns));
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileInsertCount(contract, tableName, rows) {
 	const { rows: normalizedRows } = normalizeInsertRows(contract, tableName, rows);
 	const ast = InsertAst.into(TableSource.named(tableName)).withRows(normalizedRows);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function stripUndefinedValues(row) {
 	const result = {};
@@ -665,38 +680,38 @@ function compileUpsertReturning(contract, tableName, createValues, updateValues,
 	const updateAssignments = Object.keys(updateValues).length > 0 ? toParamAssignments(contract, tableName, updateValues) : void 0;
 	const onConflict = updateAssignments ? InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doUpdateSet(updateAssignments.assignments) : InsertOnConflict.on(conflictColumns.map((column) => ColumnRef.of(tableName, column))).doNothing();
 	const ast = InsertAst.into(TableSource.named(tableName)).withValues(createAssignments.assignments).withOnConflict(onConflict).withReturning(buildReturningColumns(contract, tableName, returningColumns));
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileUpdateReturning(contract, tableName, setValues, filters, returningColumns) {
 	const where = combineWhereExprs(filters);
 	const { assignments } = toParamAssignments(contract, tableName, setValues);
 	let ast = UpdateAst.table(TableSource.named(tableName)).withSet(assignments).withReturning(buildReturningColumns(contract, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileUpdateCount(contract, tableName, setValues, filters) {
 	const where = combineWhereExprs(filters);
 	const { assignments } = toParamAssignments(contract, tableName, setValues);
 	let ast = UpdateAst.table(TableSource.named(tableName)).withSet(assignments);
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileDeleteReturning(contract, tableName, filters, returningColumns) {
 	const where = combineWhereExprs(filters);
 	let ast = DeleteAst.from(TableSource.named(tableName)).withReturning(buildReturningColumns(contract, tableName, returningColumns));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileDeleteCount(contract, tableName, filters) {
 	const where = combineWhereExprs(filters);
 	let ast = DeleteAst.from(TableSource.named(tableName));
 	if (where) ast = ast.withWhere(where);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 
 //#endregion
@@ -767,7 +782,13 @@ function bindComparable(contract, comparable, bindingColumn) {
 function createParamRef(contract, columnRef, value) {
 	const codecId = contract.storage.tables[columnRef.table]?.columns[columnRef.column]?.codecId;
 	if (!codecId) throw new Error(`Unknown column "${columnRef.column}" in table "${columnRef.table}"`);
-	return ParamRef.of(value, { codecId });
+	return ParamRef.of(value, {
+		codecId,
+		refs: {
+			table: columnRef.table,
+			column: columnRef.column
+		}
+	});
 }
 function createExpressionBinder(contract) {
 	return { select: (ast) => bindSelectAst(contract, ast) };
@@ -796,7 +817,7 @@ function bindSelectAst(contract, ast) {
 	return new SelectAst({
 		from: bindFromSource(contract, ast.from),
 		joins: ast.joins?.map((join) => bindJoin(contract, join)),
-		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr))),
+		projection: ast.projection.map((projection) => new ProjectionItem(projection.alias, bindProjectionExpr(contract, projection.expr), projection.codecId, projection.refs)),
 		where: ast.where ? bindWhereExprNode(contract, ast.where) : void 0,
 		orderBy: ast.orderBy?.map((orderItem) => bindOrderByItem(contract, orderItem)),
 		distinct: ast.distinct,
@@ -812,7 +833,9 @@ function bindSelectAst(contract, ast) {
 //#endregion
 //#region src/query-plan-select.ts
 function buildProjection(contract, tableName, selectedFields, tableRef = tableName) {
-	return (selectedFields && selectedFields.length > 0 ? [...selectedFields] : resolveTableColumns(contract, tableName)).map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column)));
+	const columns = selectedFields && selectedFields.length > 0 ? [...selectedFields] : resolveTableColumns(contract, tableName);
+	const table = contract.storage.tables[tableName];
+	return columns.map((column) => ProjectionItem.of(column, ColumnRef.of(tableRef, column), table?.columns[column]?.codecId));
 }
 function createBoundaryExpr(tableName, entry) {
 	return new BinaryExpr(entry.direction === "asc" ? "gt" : "lt", ColumnRef.of(tableName, entry.column), LiteralExpr.of(entry.value));
@@ -946,10 +969,11 @@ function buildMtiJoins(contract, polyInfo, variantName) {
 		const join = joinType === "inner" ? JoinAst.inner(TableSource.named(variant.table), joinOn) : JoinAst.left(TableSource.named(variant.table), joinOn);
 		joins.push(join);
 		const variantColumns = resolveTableColumns(contract, variant.table);
+		const variantTable = contract.storage.tables[variant.table];
 		for (const col of variantColumns) {
 			if (col === pkColumn) continue;
 			const alias = `${variant.table}__${col}`;
-			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col)));
+			projection.push(ProjectionItem.of(alias, ColumnRef.of(variant.table, col), variantTable?.columns[col]?.codecId));
 		}
 	}
 	return {
@@ -967,8 +991,8 @@ function compileSelect(contract, tableName, state, modelName) {
 		joins: mtiArtifacts.joins,
 		includeProjection: mtiArtifacts.projection
 	} : void 0);
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 function compileRelationSelect(contract, relatedTableName, targetColumn, parentPks, nestedState) {
 	const inFilter = BinaryExpr.in(ColumnRef.of(relatedTableName, targetColumn), ListExpression.fromValues(parentPks));
@@ -1009,8 +1033,8 @@ function compileSelectWithIncludeStrategy(contract, tableName, state, strategy,
 		includeProjection,
 		...topLevelWhere ? { where: topLevelWhere } : {}
 	});
-	const { params, paramDescriptors } = deriveParamsFromAst(ast);
-	return buildOrmQueryPlan(contract, ast, params, paramDescriptors);
+	const { params } = deriveParamsFromAst(ast);
+	return buildOrmQueryPlan(contract, ast, params);
 }
 
 //#endregion
@@ -1401,7 +1425,7 @@ function shorthandToWhereExpr(context, modelName, filters) {
 function assertFieldHasEqualityTrait(context, modelName, fieldName) {
 	const fieldType = modelOf(context.contract, modelName)?.fields?.[fieldName]?.type;
 	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
-	if (!(codecId ? context.codecs.traitsOf(codecId) : []).includes("equality")) throw new Error(`Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`);
+	if (!(codecId ? context.codecDescriptors.descriptorFor(codecId)?.traits ?? [] : []).includes("equality")) throw new Error(`Shorthand filter on "${modelName}.${fieldName}": field does not support equality comparisons`);
 }
 
 //#endregion
@@ -1565,17 +1589,40 @@ function emptyState() {
 		variantName: void 0
 	};
 }
-function param(codecId, value) {
-	return codecId ? ParamRef.of(value, { codecId }) : ParamRef.of(value);
+/**
+* Resolve the unique column ref carried by `left` so its surrounding `ParamRef` can dispatch through `forColumn`. The previous implementation only matched bare `column-ref` expressions, which lost refs the moment the expression got wrapped (`upper(f.id)`, `BinaryExpr`, function-call expressions, etc.) — and column-aware dispatch (AC-5) silently degraded for any predicate that touched a computed column.
+*
+* Walking via `collectColumnRefs()` and accepting only a single unambiguous ref gives `eq(upper(f.id), value)` and friends correct dispatch without inventing refs for ambiguous shapes (e.g. `eq(concat(f.firstName, f.lastName), value)` returns `undefined` and falls through to the codec-id path, which is correct for non-parameterized comparisons).
+*/
+function refsFromLeft(left) {
+	if (left.kind === "column-ref") return {
+		table: left.table,
+		column: left.column
+	};
+	const columnRefs = left.collectColumnRefs();
+	if (columnRefs.length !== 1) return void 0;
+	const single = columnRefs[0];
+	if (!single) return void 0;
+	return {
+		table: single.table,
+		column: single.column
+	};
+}
+function param(codecId, value, refs) {
+	if (codecId === void 0 && refs === void 0) return ParamRef.of(value);
+	return ParamRef.of(value, {
+		...ifDefined("codecId", codecId),
+		...ifDefined("refs", refs)
+	});
 }
-function paramList(codecId, values) {
-	return ListExpression.of(values.map((value) => param(codecId, value)));
+function paramList(codecId, values, refs) {
+	return ListExpression.of(values.map((value) => param(codecId, value, refs)));
 }
 function scalarComparisonMethod(op) {
-	return ((left, codecId) => (value) => new BinaryExpr(op, left, param(codecId, value)));
+	return ((left, codecId) => (value) => new BinaryExpr(op, left, param(codecId, value, refsFromLeft(left))));
 }
 function listComparisonMethod(op) {
-	return ((left, codecId) => (values) => new BinaryExpr(op, left, paramList(codecId, values)));
+	return ((left, codecId) => (values) => new BinaryExpr(op, left, paramList(codecId, values, refsFromLeft(left))));
 }
 /**
 * Declares trait requirements and runtime factory for each comparison method.
@@ -1655,12 +1702,13 @@ function createModelAccessor(context, modelName) {
 		existing.push(op);
 	}
 	for (const [name, entry] of Object.entries(context.queryOperations.entries())) {
-		const self = entry.args[0];
 		const op = [name, entry];
-		if (self?.codecId) registerOp(self.codecId, op);
-		else if (self?.traits) for (const codec of context.codecs.values()) {
-			const codecTraits = codec.traits ?? [];
-			if (self.traits.every((t) => codecTraits.includes(t))) registerOp(codec.id, op);
+		const self = entry.self;
+		if (!self) continue;
+		if (self.codecId !== void 0) registerOp(self.codecId, op);
+		else if (self.traits !== void 0) for (const descriptor of context.codecDescriptors.values()) {
+			const descriptorTraits = descriptor.traits;
+			if (self.traits.every((t) => descriptorTraits.includes(t))) registerOp(descriptor.codecId, op);
 		}
 	}
 	return new Proxy({}, { get(_target, prop) {
@@ -1668,48 +1716,51 @@ function createModelAccessor(context, modelName) {
 		const relation = modelRelations[prop];
 		if (relation) return createRelationFilterAccessor(context, modelName, tableName, relation);
 		const columnName = fieldToColumn[prop] ?? prop;
-		const traits = resolveFieldTraits(contract, modelName, prop, context);
-		const codecId = resolveFieldCodecId(contract, tableName, columnName);
-		return createScalarFieldAccessor(tableName, columnName, codecId, traits, codecId ? opsByCodecId.get(codecId) ?? [] : [], context);
+		const column = resolveColumn(contract, tableName, columnName);
+		if (!column) return;
+		const traits = context.codecDescriptors.descriptorFor(column.codecId)?.traits ?? [];
+		const operations = opsByCodecId.get(column.codecId) ?? [];
+		return createScalarFieldAccessor(tableName, columnName, column.codecId, column.nullable, traits, operations, context);
 	} });
 }
-function resolveFieldTraits(contract, modelName, fieldName, context) {
-	const fieldType = modelOf(contract, modelName)?.fields?.[fieldName]?.type;
-	const codecId = fieldType?.kind === "scalar" ? fieldType.codecId : void 0;
-	if (!codecId) return [];
-	return context.codecs.traitsOf(codecId);
-}
-function resolveFieldCodecId(contract, tableName, columnName) {
-	return (contract.storage.tables?.[tableName])?.columns?.[columnName]?.codecId;
+function resolveColumn(contract, tableName, columnName) {
+	const column = contract.storage.tables?.[tableName]?.columns?.[columnName];
+	if (!column) return void 0;
+	return {
+		codecId: column.codecId,
+		nullable: column.nullable
+	};
 }
-function createScalarFieldAccessor(tableName, columnName, codecId, traits, operations, context) {
+function createScalarFieldAccessor(tableName, columnName, codecId, nullable, traits, operations, context) {
 	const column = ColumnRef.of(tableName, columnName);
-	const methods = {};
+	const comparisonEntries = [];
 	for (const [name, meta] of Object.entries(COMPARISON_METHODS_META)) {
 		if (meta.traits.some((t) => !traits.includes(t))) continue;
-		methods[name] = meta.create(column, codecId);
+		comparisonEntries.push([name, meta.create(column, codecId)]);
 	}
-	for (const [name, entry] of operations) methods[name] = createExtensionMethodFactory(column, name, entry, context);
-	return methods;
+	const accessor = {
+		returnType: {
+			codecId,
+			nullable
+		},
+		buildAst: () => column,
+		...Object.fromEntries(comparisonEntries)
+	};
+	for (const [name, entry] of operations) accessor[name] = createExtensionMethodFactory(accessor, entry, context);
+	return accessor;
 }
-function createExtensionMethodFactory(column, methodName, entry, context) {
-	const returnTraits = context.codecs.traitsOf(entry.returns.codecId);
-	const isPredicate = returnTraits.includes("boolean");
+function createExtensionMethodFactory(selfExpr, entry, context) {
 	return (...args) => {
-		const opExpr = new OperationExpr({
-			method: methodName,
-			self: column,
-			args: entry.args.slice(1).map((argSpec, i) => {
-				return ParamRef.of(args[i], argSpec.codecId ? { codecId: argSpec.codecId } : void 0);
-			}),
-			returns: entry.returns,
-			lowering: entry.lowering
-		});
-		if (isPredicate) return opExpr;
+		const impl = entry.impl;
+		const result = impl(selfExpr, ...args);
+		const returnCodecId = result.returnType.codecId;
+		const returnTraits = context.codecDescriptors.descriptorFor(returnCodecId)?.traits ?? [];
+		if (returnTraits.includes("boolean")) return result.buildAst();
+		const resultAst = result.buildAst();
 		const methods = {};
 		for (const [resultMethodName, meta] of Object.entries(COMPARISON_METHODS_META)) {
 			if (meta.traits.some((t) => !returnTraits.includes(t))) continue;
-			methods[resultMethodName] = meta.create(opExpr, entry.returns.codecId);
+			methods[resultMethodName] = meta.create(resultAst, returnCodecId);
 		}
 		return methods;
 	};
@@ -1756,7 +1807,7 @@ function toRelationWhereExpr(context, relatedModelName, predicate) {
 	for (const [fieldName, value] of Object.entries(predicate)) {
 		if (value === void 0) continue;
 		const fieldAccessor = accessor[fieldName];
-		if (!fieldAccessor) continue;
+		if (!fieldAccessor) throw new Error(`Shorthand filter on "${relatedModelName}.${fieldName}": field is not defined on the model`);
 		if (value === null) {
 			if (!fieldAccessor.isNull) throw new Error(`Shorthand filter on "${relatedModelName}.${fieldName}": isNull is unexpectedly missing — this is a bug in trait gating`);
 			exprs.push(fieldAccessor.isNull());
@@ -1895,9 +1946,16 @@ async function updateFirstGraph(scope, context, modelName, filters, input) {
 	let parentRow = existingRow;
 	const mappedUpdateData = mapModelDataToStorageRow(contract, modelName, scalarData);
 	if (Object.keys(mappedUpdateData).length > 0) {
+		const tableName = resolveModelTableName(contract, modelName);
+		const appliedUpdateDefaults = context.applyMutationDefaults({
+			op: "update",
+			table: tableName,
+			values: mappedUpdateData
+		});
+		for (const def of appliedUpdateDefaults) mappedUpdateData[def.column] = def.value;
 		const pkWhere = shorthandToWhereExpr(context, modelName, buildPrimaryKeyFilterFromRow(contract, modelName, existingRow));
 		if (!pkWhere) throw new Error(`Failed to build primary key filter for model "${modelName}"`);
-		const updatedRaw = (await executeQueryPlan(scope, compileUpdateReturning(contract, resolveModelTableName(contract, modelName), mappedUpdateData, [pkWhere], void 0)).toArray())[0];
+		const updatedRaw = (await executeQueryPlan(scope, compileUpdateReturning(contract, tableName, mappedUpdateData, [pkWhere], void 0)).toArray())[0];
 		if (updatedRaw) parentRow = mapStorageRowToModelFields(contract, modelName, updatedRaw);
 	}
 	for (const relationMutation of childOwned) await applyChildOwnedMutation(scope, context, modelName, parentRow, relationMutation.relation, relationMutation.mutation);
@@ -2109,15 +2167,25 @@ function isToWhereExpr(arg) {
 //#endregion
 //#region src/collection.ts
 function applyCreateDefaults(ctx, tableName, rows) {
+	const defaultValueCache = rows.length > 1 ? /* @__PURE__ */ new Map() : void 0;
 	for (const row of rows) {
 		const applied = ctx.context.applyMutationDefaults({
 			op: "create",
 			table: tableName,
-			values: row
+			values: row,
+			...defaultValueCache ? { defaultValueCache } : {}
 		});
 		for (const def of applied) row[def.column] = def.value;
 	}
 }
+function applyUpdateDefaults(ctx, tableName, values) {
+	const applied = ctx.context.applyMutationDefaults({
+		op: "update",
+		table: tableName,
+		values
+	});
+	for (const def of applied) values[def.column] = def.value;
+}
 function isToWhereExprInput(value) {
 	return typeof value === "object" && value !== null && "toWhereExpr" in value && typeof value.toWhereExpr === "function";
 }
@@ -2480,6 +2548,7 @@ var Collection = class Collection {
 		applyCreateDefaults(this.ctx, this.tableName, [createValues]);
 		const updateValues = mapModelDataToStorageRow(this.contract, this.modelName, input.update);
 		const hasUpdateValues = Object.keys(updateValues).length > 0;
+		if (hasUpdateValues) applyUpdateDefaults(this.ctx, this.tableName, updateValues);
 		const conflictColumns = resolveUpsertConflictColumns(this.contract, this.modelName, input.conflictOn);
 		if (conflictColumns.length === 0) throw new Error(`upsert() for model "${this.modelName}" requires conflict columns`);
 		const parentJoinColumns = this.state.includes.map((include) => include.localColumn);
@@ -2526,6 +2595,7 @@ var Collection = class Collection {
 			const generator = async function* () {};
 			return new AsyncIterableResult(generator());
 		}
+		applyUpdateDefaults(this.ctx, this.tableName, mappedData);
 		const parentJoinColumns = this.state.includes.map((include) => include.localColumn);
 		const { selectedForQuery: selectedForUpdate, hiddenColumns } = augmentSelectionForJoinColumns(this.state.selectedFields, parentJoinColumns);
 		const compiled = compileUpdateReturning(this.contract, this.tableName, mappedData, this.state.filters, selectedForUpdate);
@@ -2542,6 +2612,7 @@ var Collection = class Collection {
 	async updateCount(data) {
 		const mappedData = mapModelDataToStorageRow(this.contract, this.modelName, data);
 		if (Object.keys(mappedData).length === 0) return 0;
+		applyUpdateDefaults(this.ctx, this.tableName, mappedData);
 		const primaryKeyColumn = resolvePrimaryKeyColumn(this.contract, this.tableName);
 		const countState = {
 			...emptyState(),