@prisma-next/sql-lane 0.3.0-dev.10 → 0.3.0-dev.113

package/dist/builder-MYJh5-Gn.mjs

@@ -0,0 +1,1153 @@
+import { planInvalid } from "@prisma-next/plan";
+import { AndExpr, BinaryExpr, ColumnRef, DeleteAst, DerivedTableSource, EqColJoinOn, InsertAst, JoinAst, JsonArrayAggExpr, JsonObjectExpr, NullCheckExpr, OrderByItem, ParamRef, ProjectionItem, SelectAst, TableSource, UpdateAst, compact, createJoinOnBuilder, createJoinOnBuilder as createJoinOnBuilder$1 } from "@prisma-next/sql-relational-core/ast";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { isColumnBuilder, isExpressionBuilder, isExpressionSource, isParamPlaceholder } from "@prisma-next/sql-relational-core/utils/guards";
+
+//#region src/raw.ts
+const RAW_OPTIONS_SENTINEL = Symbol("rawOptions");
+function ifDefined$1(key, value) {
+	return value !== void 0 ? { [key]: value } : {};
+}
+function createRawFactory(contract) {
+	const factory = ((first, ...rest) => {
+		if (isTemplateInvocation(first)) {
+			const { values, options: options$1 } = splitTemplateValues(rest);
+			const compiled = compileTemplateToPositional(first, values);
+			return buildRawPlan({
+				contract,
+				sql: compiled.sql,
+				params: compiled.params,
+				paramDescriptors: compiled.paramDescriptors,
+				...options$1 ? { options: options$1 } : {}
+			});
+		}
+		const text = first;
+		const [options] = rest;
+		if (!options) throw planInvalid("Function form requires params option");
+		if (!Array.isArray(options.params)) throw planInvalid("Function form params must be an array");
+		const paramDescriptors = buildSequentialDescriptors(options.params.length);
+		return buildRawPlan({
+			contract,
+			sql: text,
+			params: options.params,
+			paramDescriptors,
+			options
+		});
+	});
+	factory.with = (options) => {
+		return ((strings, ...values) => {
+			const compiled = compileTemplateToPositional(strings, values);
+			return buildRawPlan({
+				contract,
+				sql: compiled.sql,
+				params: compiled.params,
+				paramDescriptors: compiled.paramDescriptors,
+				options
+			});
+		});
+	};
+	return factory;
+}
+function compileTemplateToPositional(strings, values) {
+	let sql$1 = "";
+	const params = [];
+	const paramDescriptors = [];
+	strings.forEach((part, index) => {
+		sql$1 += part;
+		if (index < values.length) {
+			const value = values[index];
+			const placeholderIndex = params.push(value);
+			sql$1 += `$${placeholderIndex}`;
+			paramDescriptors.push({
+				index: placeholderIndex,
+				name: `p${placeholderIndex}`,
+				source: "raw"
+			});
+		}
+	});
+	return {
+		sql: sql$1,
+		params,
+		paramDescriptors
+	};
+}
+function buildRawPlan(args) {
+	const params = Array.from(args.params);
+	const descriptors = args.paramDescriptors.map((descriptor) => Object.freeze({
+		...descriptor,
+		source: "raw"
+	}));
+	const meta = buildRawMeta({
+		contract: args.contract,
+		paramDescriptors: descriptors,
+		...args.options ? { options: args.options } : {}
+	});
+	return Object.freeze({
+		sql: args.sql,
+		params: Object.freeze(params),
+		meta
+	});
+}
+function buildRawMeta(args) {
+	const { contract, paramDescriptors, options } = args;
+	const meta = {
+		target: contract.target,
+		targetFamily: contract.targetFamily,
+		storageHash: contract.storageHash,
+		...ifDefined$1("profileHash", contract.profileHash),
+		lane: "raw",
+		paramDescriptors: Object.freeze([...paramDescriptors]),
+		...options?.annotations ? { annotations: Object.freeze({ ...options.annotations }) } : {},
+		...options?.refs ? { refs: freezeRefs(options.refs) } : {},
+		...options?.projection ? { projection: Object.freeze([...options.projection]) } : {}
+	};
+	return Object.freeze(meta);
+}
+function freezeRefs(refs) {
+	return Object.freeze({
+		...refs.tables ? { tables: Object.freeze([...refs.tables]) } : {},
+		...refs.columns ? { columns: Object.freeze(refs.columns.map((col) => Object.freeze({ ...col }))) } : {},
+		...refs.indexes ? { indexes: Object.freeze(refs.indexes.map((index) => Object.freeze({
+			...index,
+			columns: Object.freeze([...index.columns])
+		}))) } : {}
+	});
+}
+function buildSequentialDescriptors(count) {
+	return Array.from({ length: count }, (_, idx) => Object.freeze({
+		index: idx + 1,
+		name: `p${idx + 1}`,
+		source: "raw"
+	}));
+}
+function isTemplateInvocation(value) {
+	return Array.isArray(value) && Object.hasOwn(value, "raw");
+}
+function rawOptions(options) {
+	return Object.freeze({
+		[RAW_OPTIONS_SENTINEL]: true,
+		value: options
+	});
+}
+function splitTemplateValues(values) {
+	if (values.length === 0) return { values };
+	const last = values[values.length - 1];
+	if (!isOptionsSentinel(last)) return { values };
+	return {
+		values: values.slice(0, values.length - 1),
+		options: last.value
+	};
+}
+function isOptionsSentinel(value) {
+	return typeof value === "object" && value !== null && RAW_OPTIONS_SENTINEL in value;
+}
+
+//#endregion
+//#region src/utils/errors.ts
+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 errorLimitMustBeNonNegativeInteger() {
+	throw planInvalid("Limit must be a non-negative integer");
+}
+function errorChildProjectionMustBeSpecified() {
+	throw planInvalid("Child projection must be specified");
+}
+function errorIncludeRequiresCapabilities(target) {
+	throw planInvalid("includeMany requires lateral and jsonAgg capabilities", target ? { target } : void 0, [
+		"Enable capabilities for your target in contract.capabilities[target]",
+		"For SQL includes, set both 'lateral' and 'jsonAgg' to true",
+		"If your database lacks lateral/json_agg, use explicit joins + group aggregates"
+	], [
+		"docs/Architecture Overview.md",
+		"docs/reference/extensions-glossary.md",
+		"packages/3-targets/6-adapters/postgres/README.md"
+	]);
+}
+function errorIncludeCapabilitiesNotTrue(target, values) {
+	throw planInvalid("includeMany requires lateral and jsonAgg capabilities to be true", target ? {
+		target,
+		values
+	} : void 0, ["Set contract.capabilities[target].lateral = true and .jsonAgg = true", "If the target does not support these, avoid includeMany and compose a two-step plan"], [
+		"docs/Architecture Overview.md",
+		"docs/reference/extensions-glossary.md",
+		"packages/3-targets/6-adapters/postgres/README.md"
+	]);
+}
+function errorUnknownTable(tableName) {
+	throw planInvalid(`Unknown table ${tableName}`);
+}
+function errorSelfJoinNotSupported() {
+	throw planInvalid("Self-joins are not supported in MVP");
+}
+function errorChildProjectionEmpty() {
+	throw planInvalid("Child projection must not be empty");
+}
+function errorIncludeAliasCollision(alias, type) {
+	throw planInvalid(`Alias collision: include alias "${alias}" conflicts with existing ${type} alias`);
+}
+function errorMissingColumnForAlias(alias, index) {
+	throw planInvalid(`Missing column for alias ${alias} at index ${index}`);
+}
+function errorMissingAlias(index) {
+	throw planInvalid(`Missing alias at index ${index}`);
+}
+function errorFromMustBeCalled() {
+	throw planInvalid("from() must be called before building a query");
+}
+function errorSelectMustBeCalled() {
+	throw planInvalid("select() must be called before build()");
+}
+function errorMissingParameter(paramName) {
+	throw planInvalid(`Missing value for parameter ${paramName}`);
+}
+function errorInvalidProjectionValue(path) {
+	throw planInvalid(`Invalid projection value at path ${path.join(".")}: expected ExpressionSource (ColumnBuilder or ExpressionBuilder) 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 errorReturningRequiresCapability(target) {
+	throw planInvalid("returning() requires returning capability", target ? { target } : void 0, [
+		"Enable 'returning' for your target in contract.capabilities[target]",
+		"PostgreSQL supports RETURNING; MySQL does not",
+		"If unsupported, remove returning() and fetch with a follow-up select()"
+	], [
+		"docs/Architecture Overview.md",
+		"docs/reference/extensions-glossary.md",
+		"packages/3-targets/6-adapters/postgres/README.md"
+	]);
+}
+function errorReturningCapabilityNotTrue(target, value) {
+	throw planInvalid("returning() requires returning capability to be true", target ? {
+		target,
+		value
+	} : void 0, ["Set contract.capabilities[target].returning = true", "If your database/adapter cannot support RETURNING, remove returning() and select after"], [
+		"docs/Architecture Overview.md",
+		"docs/reference/extensions-glossary.md",
+		"packages/3-targets/6-adapters/postgres/README.md"
+	]);
+}
+function errorUnknownColumn(columnName, tableName) {
+	throw planInvalid(`Unknown column ${columnName} in table ${tableName}`);
+}
+function errorWhereMustBeCalledForUpdate() {
+	throw planInvalid("where() must be called before building an UPDATE query");
+}
+function errorFailedToBuildWhereClause() {
+	throw planInvalid("Failed to build WHERE clause");
+}
+function errorWhereMustBeCalledForDelete() {
+	throw planInvalid("where() must be called before building a DELETE query");
+}
+
+//#endregion
+//#region src/utils/capabilities.ts
+function checkIncludeCapabilities(contract) {
+	const target = contract.target;
+	const contractCapabilities = contract.capabilities;
+	const declaredTargetCapabilities = contractCapabilities?.[target];
+	if (!contractCapabilities || !declaredTargetCapabilities) errorIncludeRequiresCapabilities(target);
+	if (declaredTargetCapabilities["lateral"] !== true || declaredTargetCapabilities["jsonAgg"] !== true) errorIncludeCapabilitiesNotTrue(target, {
+		lateral: declaredTargetCapabilities["lateral"],
+		jsonAgg: declaredTargetCapabilities["jsonAgg"]
+	});
+}
+function checkReturningCapability(contract) {
+	const target = contract.target;
+	const capabilities = contract.capabilities;
+	if (!capabilities || !capabilities[target]) errorReturningRequiresCapability(target);
+	const targetCapabilities = capabilities[target];
+	if (targetCapabilities["returning"] !== true) errorReturningCapabilityNotTrue(target, targetCapabilities["returning"]);
+}
+
+//#endregion
+//#region src/utils/assertions.ts
+/**
+* Asserts that a ColumnBuilder has table and column properties.
+*/
+function assertColumnBuilder(col, context) {
+	if (typeof col === "object" && col !== null && "table" in col && "column" in col && typeof col.table === "string" && typeof col.column === "string") return col;
+	throw planInvalid(`ColumnBuilder missing table/column in ${context}`);
+}
+
+//#endregion
+//#region src/sql/plan.ts
+/**
+* Extracts column references from an ExpressionSource (ColumnBuilder or ExpressionBuilder).
+*/
+function collectRefsFromExpressionSource(source, refsColumns) {
+	if (isExpressionBuilder(source)) {
+		const allRefs = source.expr.collectColumnRefs();
+		for (const ref of allRefs) refsColumns.set(`${ref.table}.${ref.column}`, {
+			table: ref.table,
+			column: ref.column
+		});
+	} else if (isColumnBuilder(source)) {
+		const col = source;
+		refsColumns.set(`${col.table}.${col.column}`, {
+			table: col.table,
+			column: col.column
+		});
+	}
+}
+/**
+* Extracts column references from an Expression (AST node).
+*/
+function collectRefsFromExpression(expr, refsColumns) {
+	for (const ref of expr.collectColumnRefs()) refsColumns.set(`${ref.table}.${ref.column}`, {
+		table: ref.table,
+		column: ref.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.joins) for (const join of args.joins) {
+		refsTables.add(join.table.name);
+		const onLeft = assertColumnBuilder(join.on.left, "join ON left");
+		const onRight = assertColumnBuilder(join.on.right, "join ON right");
+		refsColumns.set(`${onLeft.table}.${onLeft.column}`, {
+			table: onLeft.table,
+			column: onLeft.column
+		});
+		refsColumns.set(`${onRight.table}.${onRight.column}`, {
+			table: onRight.table,
+			column: onRight.column
+		});
+	}
+	if (args.includes) for (const include of args.includes) {
+		refsTables.add(include.table.name);
+		const leftCol = assertColumnBuilder(include.on.left, "include ON left");
+		const rightCol = assertColumnBuilder(include.on.right, "include ON right");
+		refsColumns.set(`${leftCol.table}.${leftCol.column}`, {
+			table: leftCol.table,
+			column: leftCol.column
+		});
+		refsColumns.set(`${rightCol.table}.${rightCol.column}`, {
+			table: rightCol.table,
+			column: rightCol.column
+		});
+		for (const column of include.childProjection.columns) {
+			const col = assertColumnBuilder(column, "include child projection column");
+			refsColumns.set(`${col.table}.${col.column}`, {
+				table: col.table,
+				column: col.column
+			});
+		}
+		if (include.childWhere) if (include.childWhere.kind === "nullCheck") collectRefsFromExpression(include.childWhere.expr, refsColumns);
+		else {
+			collectRefsFromExpression(include.childWhere.left, refsColumns);
+			const childWhereRight = include.childWhere.right;
+			if (isColumnBuilder(childWhereRight) || isExpressionBuilder(childWhereRight)) collectRefsFromExpressionSource(childWhereRight, refsColumns);
+		}
+		if (include.childOrderBy) collectRefsFromExpression(include.childOrderBy.expr, refsColumns);
+	}
+	if (args.where) if (args.where.kind === "nullCheck") collectRefsFromExpression(args.where.expr, refsColumns);
+	else {
+		collectRefsFromExpression(args.where.left, refsColumns);
+		const whereRight = args.where.right;
+		if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) collectRefsFromExpressionSource(whereRight, refsColumns);
+	}
+	if (args.orderBy) collectRefsFromExpression(args.orderBy.expr, refsColumns);
+	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) errorMissingColumnForAlias(alias, 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 column = args.projection.columns[i];
+		if (!column) continue;
+		if (isExpressionBuilder(column)) {
+			const operationExpr = column.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 = column.columnMeta?.codecId;
+			if (codecId) projectionTypes[alias] = codecId;
+		}
+	}
+	const codecs = {};
+	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") codecs[alias] = operationExpr.returns.type;
+		} else {
+			const codecId = column.columnMeta?.codecId;
+			if (codecId) codecs[alias] = codecId;
+		}
+	}
+	return Object.freeze(compact({
+		target: args.contract.target,
+		targetFamily: args.contract.targetFamily,
+		storageHash: args.contract.storageHash,
+		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(codecs).length > 0 || args.limit !== void 0 ? Object.freeze(compact({
+			codecs: Object.keys(codecs).length > 0 ? Object.freeze(codecs) : void 0,
+			limit: args.limit
+		})) : void 0,
+		paramDescriptors: args.paramDescriptors,
+		profileHash: args.contract.profileHash
+	}));
+}
+
+//#endregion
+//#region src/sql/predicate-builder.ts
+function isNullCheckBuilder(builder) {
+	return builder.kind === "nullCheck";
+}
+function buildNullCheckExpr(contract, where) {
+	const expr = where.expr;
+	if (expr.kind === "column-ref") {
+		const { table, column } = expr;
+		const contractTable = contract.storage.tables[table];
+		if (!contractTable) errorUnknownTable(table);
+		if (!contractTable.columns[column]) errorUnknownColumn(column, table);
+	}
+	return where.isNull ? NullCheckExpr.isNull(expr) : NullCheckExpr.isNotNull(expr);
+}
+function buildWhereExpr(contract, where, paramsMap) {
+	if (isNullCheckBuilder(where)) return {
+		expr: buildNullCheckExpr(contract, where),
+		codecId: void 0,
+		paramName: ""
+	};
+	let leftExpr;
+	let codecId;
+	let rightExpr;
+	let paramName;
+	leftExpr = where.left;
+	if (leftExpr.kind === "column-ref") {
+		const { table, column } = leftExpr;
+		const contractTable = contract.storage.tables[table];
+		if (!contractTable) errorUnknownTable(table);
+		const columnMeta = contractTable.columns[column];
+		if (!columnMeta) errorUnknownColumn(column, table);
+		codecId = columnMeta.codecId;
+	} else if (leftExpr.kind === "operation") codecId = leftExpr.returns.kind === "typeId" ? leftExpr.returns.type : leftExpr.forTypeId;
+	if (isParamPlaceholder(where.right)) {
+		paramName = where.right.name;
+		if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
+		const value = paramsMap[paramName];
+		if (!codecId) throw planInvalid(`Cannot determine codecId for parameter '${paramName}'`);
+		rightExpr = ParamRef.of(value, {
+			name: paramName,
+			codecId
+		});
+	} else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+		rightExpr = where.right.toExpr();
+		if (rightExpr.kind === "column-ref") {
+			const { table, column } = rightExpr;
+			const contractTable = contract.storage.tables[table];
+			if (!contractTable) errorUnknownTable(table);
+			if (!contractTable.columns[column]) errorUnknownColumn(column, table);
+		}
+		paramName = "";
+	} else errorFailedToBuildWhereClause();
+	return {
+		expr: new BinaryExpr(where.op, leftExpr, rightExpr),
+		codecId,
+		paramName
+	};
+}
+
+//#endregion
+//#region src/sql/mutation-builder.ts
+function deriveParamsFromAst$1(ast) {
+	const collected = [...new Set(ast.collectParamRefs())];
+	return {
+		paramValues: collected.map((p) => p.value),
+		paramDescriptors: collected.map((p) => ({
+			...ifDefined("name", p.name),
+			source: "dsl",
+			...ifDefined("codecId", p.codecId)
+		}))
+	};
+}
+var InsertBuilderImpl = class InsertBuilderImpl {
+	contract;
+	context;
+	table;
+	values;
+	returningColumns = [];
+	constructor(options, table, values) {
+		this.context = options.context;
+		this.contract = options.context.contract;
+		this.table = table;
+		this.values = values;
+	}
+	returning(...columns) {
+		checkReturningCapability(this.contract);
+		const builder = new InsertBuilderImpl({ context: this.context }, this.table, this.values);
+		builder.returningColumns = [...this.returningColumns, ...columns];
+		return builder;
+	}
+	build(options) {
+		const paramsMap = options?.params ?? {};
+		const contractTable = this.contract.storage.tables[this.table.name];
+		if (!contractTable) errorUnknownTable(this.table.name);
+		const values = {};
+		for (const [columnName, placeholder] of Object.entries(this.values)) {
+			const columnMeta = contractTable.columns[columnName];
+			if (!columnMeta) errorUnknownColumn(columnName, this.table.name);
+			const paramName = placeholder.name;
+			if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
+			const value = paramsMap[paramName];
+			values[columnName] = ParamRef.of(value, {
+				name: paramName,
+				codecId: columnMeta.codecId
+			});
+		}
+		const appliedDefaults = this.context.applyMutationDefaults({
+			op: "create",
+			table: this.table.name,
+			values
+		});
+		for (const defaultValue of appliedDefaults) {
+			const columnMeta = contractTable.columns[defaultValue.column];
+			if (!columnMeta) errorUnknownColumn(defaultValue.column, this.table.name);
+			values[defaultValue.column] = ParamRef.of(defaultValue.value, {
+				name: defaultValue.column,
+				codecId: columnMeta.codecId
+			});
+		}
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return ColumnRef.of(c.table, c.column);
+		});
+		let ast = InsertAst.into(TableSource.named(this.table.name)).withValues(values);
+		if (returning.length > 0) ast = ast.withReturning(returning);
+		const { paramValues, paramDescriptors } = deriveParamsFromAst$1(ast);
+		const returningProjection = {
+			aliases: this.returningColumns.map((col) => {
+				return col.column;
+			}),
+			columns: this.returningColumns
+		};
+		const planMeta = buildMeta({
+			contract: this.contract,
+			table: this.table,
+			projection: returning.length > 0 ? returningProjection : {
+				aliases: [],
+				columns: []
+			},
+			paramDescriptors
+		});
+		return Object.freeze({
+			ast,
+			params: paramValues,
+			meta: {
+				...planMeta,
+				lane: "dsl",
+				annotations: {
+					...planMeta.annotations,
+					intent: "write",
+					isMutation: true
+				}
+			}
+		});
+	}
+};
+var UpdateBuilderImpl = class UpdateBuilderImpl {
+	contract;
+	context;
+	table;
+	set;
+	wherePredicate;
+	returningColumns = [];
+	constructor(options, table, set) {
+		this.context = options.context;
+		this.contract = options.context.contract;
+		this.table = table;
+		this.set = set;
+	}
+	where(predicate) {
+		const builder = new UpdateBuilderImpl({ context: this.context }, this.table, this.set);
+		builder.wherePredicate = predicate;
+		builder.returningColumns = [...this.returningColumns];
+		return builder;
+	}
+	returning(...columns) {
+		checkReturningCapability(this.contract);
+		const builder = new UpdateBuilderImpl({ context: this.context }, this.table, this.set);
+		if (this.wherePredicate) builder.wherePredicate = this.wherePredicate;
+		builder.returningColumns = [...this.returningColumns, ...columns];
+		return builder;
+	}
+	build(options) {
+		if (!this.wherePredicate) errorWhereMustBeCalledForUpdate();
+		const paramsMap = options?.params ?? {};
+		const contractTable = this.contract.storage.tables[this.table.name];
+		if (!contractTable) errorUnknownTable(this.table.name);
+		const set = {};
+		for (const [columnName, placeholder] of Object.entries(this.set)) {
+			const columnMeta = contractTable.columns[columnName];
+			if (!columnMeta) errorUnknownColumn(columnName, this.table.name);
+			const paramName = placeholder.name;
+			if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
+			const value = paramsMap[paramName];
+			set[columnName] = ParamRef.of(value, {
+				name: paramName,
+				codecId: columnMeta.codecId
+			});
+		}
+		const appliedDefaults = this.context.applyMutationDefaults({
+			op: "update",
+			table: this.table.name,
+			values: set
+		});
+		for (const defaultValue of appliedDefaults) {
+			const columnMeta = contractTable.columns[defaultValue.column];
+			if (!columnMeta) errorUnknownColumn(defaultValue.column, this.table.name);
+			set[defaultValue.column] = ParamRef.of(defaultValue.value, {
+				name: defaultValue.column,
+				codecId: columnMeta.codecId
+			});
+		}
+		const whereExpr = buildWhereExpr(this.contract, this.wherePredicate, paramsMap).expr;
+		if (!whereExpr) errorFailedToBuildWhereClause();
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return ColumnRef.of(c.table, c.column);
+		});
+		let ast = UpdateAst.table(TableSource.named(this.table.name)).withSet(set).withWhere(whereExpr);
+		if (returning.length > 0) ast = ast.withReturning(returning);
+		const { paramValues, paramDescriptors } = deriveParamsFromAst$1(ast);
+		const returningProjection = {
+			aliases: this.returningColumns.map((col) => {
+				return col.column;
+			}),
+			columns: this.returningColumns
+		};
+		const planMeta = buildMeta({
+			contract: this.contract,
+			table: this.table,
+			projection: returning.length > 0 ? returningProjection : {
+				aliases: [],
+				columns: []
+			},
+			paramDescriptors,
+			where: this.wherePredicate
+		});
+		return Object.freeze({
+			ast,
+			params: paramValues,
+			meta: {
+				...planMeta,
+				lane: "dsl",
+				annotations: {
+					...planMeta.annotations,
+					intent: "write",
+					isMutation: true,
+					hasWhere: true
+				}
+			}
+		});
+	}
+};
+var DeleteBuilderImpl = class DeleteBuilderImpl {
+	contract;
+	context;
+	table;
+	wherePredicate;
+	returningColumns = [];
+	constructor(options, table) {
+		this.context = options.context;
+		this.contract = options.context.contract;
+		this.table = table;
+	}
+	where(predicate) {
+		const builder = new DeleteBuilderImpl({ context: this.context }, this.table);
+		builder.wherePredicate = predicate;
+		builder.returningColumns = [...this.returningColumns];
+		return builder;
+	}
+	returning(...columns) {
+		checkReturningCapability(this.contract);
+		const builder = new DeleteBuilderImpl({ context: this.context }, this.table);
+		if (this.wherePredicate) builder.wherePredicate = this.wherePredicate;
+		builder.returningColumns = [...this.returningColumns, ...columns];
+		return builder;
+	}
+	build(options) {
+		if (!this.wherePredicate) errorWhereMustBeCalledForDelete();
+		const paramsMap = options?.params ?? {};
+		if (!this.contract.storage.tables[this.table.name]) errorUnknownTable(this.table.name);
+		const whereExpr = buildWhereExpr(this.contract, this.wherePredicate, paramsMap).expr;
+		if (!whereExpr) errorFailedToBuildWhereClause();
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return ColumnRef.of(c.table, c.column);
+		});
+		let ast = DeleteAst.from(TableSource.named(this.table.name)).withWhere(whereExpr);
+		if (returning.length > 0) ast = ast.withReturning(returning);
+		const { paramValues, paramDescriptors } = deriveParamsFromAst$1(ast);
+		const returningProjection = {
+			aliases: this.returningColumns.map((col) => {
+				return col.column;
+			}),
+			columns: this.returningColumns
+		};
+		const planMeta = buildMeta({
+			contract: this.contract,
+			table: this.table,
+			projection: returning.length > 0 ? returningProjection : {
+				aliases: [],
+				columns: []
+			},
+			paramDescriptors,
+			where: this.wherePredicate
+		});
+		return Object.freeze({
+			ast,
+			params: paramValues,
+			meta: {
+				...planMeta,
+				lane: "dsl",
+				annotations: {
+					...planMeta.annotations,
+					intent: "write",
+					isMutation: true,
+					hasWhere: true
+				}
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/sql/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 (isExpressionSource(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: () => ColumnRef.of(matchingInclude.table.name, "")
+		});
+	} else if (isExpressionSource(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/sql/include-builder.ts
+var IncludeChildBuilderImpl = class IncludeChildBuilderImpl {
+	contract;
+	table;
+	childProjection;
+	childWhere;
+	childOrderBy;
+	childLimit;
+	constructor(contract, table) {
+		this.contract = contract;
+		this.table = table;
+	}
+	select(projection) {
+		const projectionState = buildProjectionState(this.table, projection);
+		const builder = new IncludeChildBuilderImpl(this.contract, this.table);
+		builder.childProjection = projectionState;
+		if (this.childWhere !== void 0) builder.childWhere = this.childWhere;
+		if (this.childOrderBy !== void 0) builder.childOrderBy = this.childOrderBy;
+		if (this.childLimit !== void 0) builder.childLimit = this.childLimit;
+		return builder;
+	}
+	where(expr) {
+		const builder = new IncludeChildBuilderImpl(this.contract, this.table);
+		if (this.childProjection !== void 0) builder.childProjection = this.childProjection;
+		builder.childWhere = expr;
+		if (this.childOrderBy !== void 0) builder.childOrderBy = this.childOrderBy;
+		if (this.childLimit !== void 0) builder.childLimit = this.childLimit;
+		return builder;
+	}
+	orderBy(order) {
+		const builder = new IncludeChildBuilderImpl(this.contract, this.table);
+		if (this.childProjection !== void 0) builder.childProjection = this.childProjection;
+		if (this.childWhere !== void 0) builder.childWhere = this.childWhere;
+		builder.childOrderBy = order;
+		if (this.childLimit !== void 0) builder.childLimit = this.childLimit;
+		return builder;
+	}
+	limit(count) {
+		if (!Number.isInteger(count) || count < 0) errorLimitMustBeNonNegativeInteger();
+		const builder = new IncludeChildBuilderImpl(this.contract, this.table);
+		if (this.childProjection !== void 0) builder.childProjection = this.childProjection;
+		if (this.childWhere !== void 0) builder.childWhere = this.childWhere;
+		if (this.childOrderBy !== void 0) builder.childOrderBy = this.childOrderBy;
+		builder.childLimit = count;
+		return builder;
+	}
+	getState() {
+		if (!this.childProjection) errorChildProjectionMustBeSpecified();
+		const state = { childProjection: this.childProjection };
+		if (this.childWhere !== void 0) state.childWhere = this.childWhere;
+		if (this.childOrderBy !== void 0) state.childOrderBy = this.childOrderBy;
+		if (this.childLimit !== void 0) state.childLimit = this.childLimit;
+		return state;
+	}
+};
+function buildIncludeOrderArtifacts(include, rowsAlias) {
+	const childOrderBy = include.childOrderBy ? (() => {
+		const orderBy = include.childOrderBy;
+		return [new OrderByItem(orderBy.expr, orderBy.dir)];
+	})() : void 0;
+	if (!childOrderBy || childOrderBy.length === 0) return {
+		childOrderBy: void 0,
+		hiddenOrderProjection: [],
+		aggregateOrderBy: void 0
+	};
+	const hiddenOrderProjection = childOrderBy.map((orderItem, index) => ProjectionItem.of(`${include.alias}__order_${index}`, orderItem.expr));
+	return {
+		childOrderBy,
+		hiddenOrderProjection,
+		aggregateOrderBy: hiddenOrderProjection.map((projection, index) => {
+			const orderItem = childOrderBy[index];
+			if (!orderItem) throw new Error(`Missing include order metadata at index ${index}`);
+			return new OrderByItem(ColumnRef.of(rowsAlias, projection.alias), orderItem.dir);
+		})
+	};
+}
+function buildChildProjectionItems(include) {
+	return include.childProjection.aliases.map((alias, idx) => {
+		const column = include.childProjection.columns[idx];
+		if (!column) errorMissingColumnForAlias(alias, idx);
+		return ProjectionItem.of(alias, column.toExpr());
+	});
+}
+function buildIncludeJoinArtifact(include, contract, paramsMap) {
+	let childWhere;
+	if (include.childWhere) childWhere = buildWhereExpr(contract, include.childWhere, paramsMap).expr;
+	const onLeft = include.on.left;
+	const onRight = include.on.right;
+	const onExpr = BinaryExpr.eq(ColumnRef.of(onLeft.table, onLeft.column), ColumnRef.of(onRight.table, onRight.column));
+	const rowsWhere = childWhere ? AndExpr.of([onExpr, childWhere]) : onExpr;
+	const childProjectItems = buildChildProjectionItems(include);
+	const rowsAlias = `${include.alias}__rows`;
+	const { childOrderBy, hiddenOrderProjection, aggregateOrderBy } = buildIncludeOrderArtifacts(include, rowsAlias);
+	let childRowsAst = SelectAst.from(TableSource.named(include.table.name, include.table.alias)).withProjection([...childProjectItems, ...hiddenOrderProjection]).withWhere(rowsWhere);
+	if (childOrderBy) childRowsAst = childRowsAst.withOrderBy(childOrderBy);
+	if (typeof include.childLimit === "number") childRowsAst = childRowsAst.withLimit(include.childLimit);
+	const aggregatedAlias = `${include.alias}_lateral`;
+	const jsonObjectExpr = JsonObjectExpr.fromEntries(childProjectItems.map((item) => JsonObjectExpr.entry(item.alias, ColumnRef.of(rowsAlias, item.alias))));
+	const jsonAggExpr = JsonArrayAggExpr.of(jsonObjectExpr, "emptyArray", aggregateOrderBy);
+	const aggregateSelect = SelectAst.from(DerivedTableSource.as(rowsAlias, childRowsAst)).withProjection([ProjectionItem.of(include.alias, jsonAggExpr)]);
+	return {
+		join: JoinAst.left(DerivedTableSource.as(aggregatedAlias, aggregateSelect), AndExpr.true(), true),
+		projection: ProjectionItem.of(include.alias, ColumnRef.of(aggregatedAlias, include.alias))
+	};
+}
+
+//#endregion
+//#region src/sql/join-builder.ts
+function buildJoinAst(join) {
+	const onLeft = join.on.left;
+	const onRight = join.on.right;
+	const onExpr = EqColJoinOn.of(ColumnRef.of(onLeft.table, onLeft.column), ColumnRef.of(onRight.table, onRight.column));
+	const tableSource = TableSource.named(join.table.name, join.table.alias);
+	switch (join.joinType) {
+		case "inner": return JoinAst.inner(tableSource, onExpr);
+		case "left": return JoinAst.left(tableSource, onExpr);
+		case "right": return JoinAst.right(tableSource, onExpr);
+		case "full": return JoinAst.full(tableSource, onExpr);
+		default: {
+			const exhaustiveCheck = join.joinType;
+			throw new Error(`Unsupported join type: ${String(exhaustiveCheck)}`);
+		}
+	}
+}
+
+//#endregion
+//#region src/sql/select-builder.ts
+function deriveParamsFromAst(ast) {
+	const collected = [...new Set(ast.collectParamRefs())];
+	return {
+		paramValues: collected.map((p) => p.value),
+		paramDescriptors: collected.map((p) => ({
+			...ifDefined("name", p.name),
+			source: "dsl",
+			...ifDefined("codecId", p.codecId)
+		}))
+	};
+}
+var SelectBuilderImpl = class SelectBuilderImpl {
+	contract;
+	context;
+	state = {};
+	constructor(options, state) {
+		this.context = options.context;
+		this.contract = options.context.contract;
+		if (state) this.state = state;
+	}
+	from(table) {
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			from: table
+		});
+	}
+	innerJoin(table, on) {
+		return this._addJoin("inner", table, on);
+	}
+	leftJoin(table, on) {
+		return this._addJoin("left", table, on);
+	}
+	rightJoin(table, on) {
+		return this._addJoin("right", table, on);
+	}
+	fullJoin(table, on) {
+		return this._addJoin("full", table, on);
+	}
+	includeMany(childTable, on, childBuilder, options) {
+		checkIncludeCapabilities(this.contract);
+		if (!this.contract.storage.tables[childTable.name]) errorUnknownTable(childTable.name);
+		const onPredicate = on(createJoinOnBuilder());
+		const onLeft = onPredicate.left;
+		const onRight = onPredicate.right;
+		if (onLeft.table === onRight.table) errorSelfJoinNotSupported();
+		const childState = childBuilder(new IncludeChildBuilderImpl(this.contract, childTable)).getState();
+		if (childState.childProjection.aliases.length === 0) errorChildProjectionEmpty();
+		const alias = options?.alias ?? childTable.name;
+		if (this.state.projection) {
+			if (this.state.projection.aliases.includes(alias)) errorIncludeAliasCollision(alias, "projection");
+		}
+		const existingIncludes = this.state.includes ?? [];
+		if (existingIncludes.some((inc) => inc.alias === alias)) errorIncludeAliasCollision(alias, "include");
+		const includeState = {
+			alias,
+			table: childTable,
+			on: onPredicate,
+			childProjection: childState.childProjection,
+			...childState.childWhere !== void 0 ? { childWhere: childState.childWhere } : {},
+			...childState.childOrderBy !== void 0 ? { childOrderBy: childState.childOrderBy } : {},
+			...childState.childLimit !== void 0 ? { childLimit: childState.childLimit } : {}
+		};
+		const newIncludes = [...existingIncludes, includeState];
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			includes: newIncludes
+		});
+	}
+	_addJoin(joinType, table, on) {
+		const fromTable = this.ensureFrom();
+		if (!this.contract.storage.tables[table.name]) errorUnknownTable(table.name);
+		if (table.name === fromTable.name) errorSelfJoinNotSupported();
+		const joinState = {
+			joinType,
+			table,
+			on: on(createJoinOnBuilder())
+		};
+		const newJoins = [...this.state.joins ?? [], joinState];
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			joins: newJoins
+		});
+	}
+	where(expr) {
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			where: expr
+		});
+	}
+	select(projection) {
+		const projectionState = buildProjectionState(this.ensureFrom(), projection, this.state.includes);
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			projection: projectionState
+		});
+	}
+	orderBy(order) {
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			orderBy: order
+		});
+	}
+	limit(count) {
+		if (!Number.isInteger(count) || count < 0) errorLimitMustBeNonNegativeInteger();
+		return new SelectBuilderImpl({ context: this.context }, {
+			...this.state,
+			limit: count
+		});
+	}
+	build(options) {
+		const table = this.ensureFrom();
+		const projection = this.ensureProjection();
+		const paramsMap = options?.params ?? {};
+		if (!this.contract.storage.tables[table.name]) errorUnknownTable(table.name);
+		const whereExpr = (this.state.where ? buildWhereExpr(this.contract, this.state.where, paramsMap) : void 0)?.expr;
+		const orderByClause = this.state.orderBy ? (() => {
+			const orderBy = this.state.orderBy;
+			return [new OrderByItem(orderBy.expr, orderBy.dir)];
+		})() : void 0;
+		const joins = this.state.joins?.map((join) => buildJoinAst(join)) ?? [];
+		const includeArtifacts = this.state.includes?.map((include) => buildIncludeJoinArtifact(include, this.contract, paramsMap)) ?? [];
+		const includeProjectionByAlias = new Map(includeArtifacts.map((artifact) => [artifact.projection.alias, artifact.projection]));
+		const projectEntries = [];
+		for (let i = 0; i < projection.aliases.length; i++) {
+			const alias = projection.aliases[i];
+			if (!alias) errorMissingAlias(i);
+			const column = projection.columns[i];
+			const includeProjection = includeProjectionByAlias.get(alias);
+			if (includeProjection) projectEntries.push(includeProjection);
+			else if (column && isExpressionBuilder(column)) projectEntries.push(ProjectionItem.of(alias, column.expr));
+			else if (column) projectEntries.push(ProjectionItem.of(alias, column.toExpr()));
+		}
+		let ast = SelectAst.from(TableSource.named(table.name, table.alias)).withProjection(projectEntries).withWhere(whereExpr);
+		const allJoins = [...joins, ...includeArtifacts.map((artifact) => artifact.join)];
+		if (allJoins.length > 0) ast = ast.withJoins(allJoins);
+		if (orderByClause) ast = ast.withOrderBy(orderByClause);
+		if (this.state.limit !== void 0) ast = ast.withLimit(this.state.limit);
+		const { paramValues, paramDescriptors } = deriveParamsFromAst(ast);
+		const planMeta = buildMeta({
+			contract: this.contract,
+			table,
+			projection,
+			joins: this.state.joins,
+			includes: this.state.includes,
+			paramDescriptors,
+			where: this.state.where,
+			orderBy: this.state.orderBy,
+			limit: this.state.limit
+		});
+		return Object.freeze({
+			ast,
+			params: paramValues,
+			meta: planMeta
+		});
+	}
+	ensureFrom() {
+		if (!this.state.from) errorFromMustBeCalled();
+		return this.state.from;
+	}
+	ensureProjection() {
+		if (!this.state.projection) errorSelectMustBeCalled();
+		return this.state.projection;
+	}
+};
+
+//#endregion
+//#region src/sql/builder.ts
+function sql(options) {
+	const builder = new SelectBuilderImpl(options);
+	const rawFactory = createRawFactory(options.context.contract);
+	Object.defineProperty(builder, "raw", {
+		value: rawFactory,
+		enumerable: true,
+		configurable: false
+	});
+	Object.defineProperty(builder, "insert", {
+		value: (table, values) => {
+			return new InsertBuilderImpl(options, table, values);
+		},
+		enumerable: true,
+		configurable: false
+	});
+	Object.defineProperty(builder, "update", {
+		value: (table, set) => {
+			return new UpdateBuilderImpl(options, table, set);
+		},
+		enumerable: true,
+		configurable: false
+	});
+	Object.defineProperty(builder, "delete", {
+		value: (table) => {
+			return new DeleteBuilderImpl(options, table);
+		},
+		enumerable: true,
+		configurable: false
+	});
+	return builder;
+}
+
+//#endregion
+export { sql as n, rawOptions as r, createJoinOnBuilder$1 as t };
+//# sourceMappingURL=builder-MYJh5-Gn.mjs.map