@prisma-next/sql-lane 0.3.0-dev.7 → 0.3.0-dev.70

package/dist/builder-DLGrrQ5F.mjs

@@ -0,0 +1,1254 @@
+import { planInvalid } from "@prisma-next/plan";
+import { compact, createBinaryExpr, createColumnRef, createDeleteAst, createInsertAst, createJoin, createJoinOnBuilder, createJoinOnBuilder as createJoinOnBuilder$1, createJoinOnExpr, createNullCheckExpr, createOrderByItem, createParamRef, createSelectAst, createTableRef, createUpdateAst } from "@prisma-next/sql-relational-core/ast";
+import { collectColumnRefs, extractBaseColumnRef, isColumnBuilder, isExpressionBuilder, isExpressionSource, isOperationExpr, isParamPlaceholder } from "@prisma-next/sql-relational-core/utils/guards";
+
+//#region src/raw.ts
+const RAW_OPTIONS_SENTINEL = Symbol("rawOptions");
+function ifDefined(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("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 ?? "unknown"} 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 = collectColumnRefs(source.expr);
+		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) {
+	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.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") {
+			const expr = include.childWhere.expr;
+			collectRefsFromExpression(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") {
+		const expr = args.where.expr;
+		collectRefsFromExpression(expr, refsColumns);
+	} else {
+		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
+		});
+		const whereRight = args.where.right;
+		if (isColumnBuilder(whereRight) || isExpressionBuilder(whereRight)) collectRefsFromExpressionSource(whereRight, refsColumns);
+	}
+	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) 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 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 = column.columnMeta?.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,
+		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(allCodecs).length > 0 ? Object.freeze({ codecs: Object.freeze(allCodecs) }) : void 0,
+		paramDescriptors: args.paramDescriptors,
+		profileHash: args.contract.profileHash
+	}));
+}
+
+//#endregion
+//#region src/sql/predicate-builder.ts
+/**
+* Type guard to check if a builder is a NullCheckBuilder (unary).
+*/
+function isNullCheckBuilder(builder) {
+	return builder.kind === "nullCheck";
+}
+/**
+* Builds a NullCheckExpr from a NullCheckBuilder.
+*/
+function buildNullCheckExpr(contract, where) {
+	const expr = where.expr;
+	if (expr.kind === "col") {
+		const { table, column } = expr;
+		const contractTable = contract.storage.tables[table];
+		if (!contractTable) errorUnknownTable(table);
+		if (!contractTable.columns[column]) errorUnknownColumn(column, table);
+	}
+	return createNullCheckExpr(expr, where.isNull);
+}
+function buildWhereExpr(contract, where, paramsMap, descriptors, values) {
+	if (isNullCheckBuilder(where)) return {
+		expr: buildNullCheckExpr(contract, where),
+		codecId: void 0,
+		paramName: ""
+	};
+	let leftExpr;
+	let codecId;
+	let rightExpr;
+	let paramName;
+	if (!where.left || typeof where.left !== "object" || !["col", "operation"].includes(where.left.kind ?? "")) errorFailedToBuildWhereClause();
+	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) errorUnknownColumn(column, table);
+		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];
+			if (columnMeta) descriptors.push({
+				name: paramName,
+				source: "dsl",
+				refs: {
+					table,
+					column
+				},
+				nullable: columnMeta.nullable,
+				codecId: columnMeta.codecId,
+				nativeType: columnMeta.nativeType
+			});
+		}
+		rightExpr = createParamRef(index, paramName);
+	} else if (isColumnBuilder(where.right) || isExpressionBuilder(where.right)) {
+		rightExpr = where.right.toExpr();
+		if (rightExpr.kind === "col") {
+			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: createBinaryExpr(where.op, leftExpr, rightExpr),
+		codecId,
+		paramName
+	};
+}
+
+//#endregion
+//#region src/sql/mutation-builder.ts
+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 paramDescriptors = [];
+		const paramValues = [];
+		const paramCodecs = {};
+		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)) {
+			if (!contractTable.columns[columnName]) errorUnknownColumn(columnName, this.table.name);
+			const paramName = placeholder.name;
+			if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
+			const value = paramsMap[paramName];
+			const index = paramValues.push(value);
+			const columnMeta = contractTable.columns[columnName];
+			const codecId = columnMeta?.codecId;
+			if (paramName && codecId) paramCodecs[paramName] = codecId;
+			paramDescriptors.push({
+				name: paramName,
+				source: "dsl",
+				refs: {
+					table: this.table.name,
+					column: columnName
+				},
+				...codecId ? { codecId } : {},
+				...columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {},
+				...columnMeta?.nullable !== void 0 ? { nullable: columnMeta.nullable } : {}
+			});
+			values[columnName] = createParamRef(index, paramName);
+		}
+		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);
+			const index = paramValues.push(defaultValue.value);
+			paramCodecs[defaultValue.column] = columnMeta.codecId;
+			paramDescriptors.push({
+				name: defaultValue.column,
+				source: "dsl",
+				refs: {
+					table: this.table.name,
+					column: defaultValue.column
+				},
+				codecId: columnMeta.codecId,
+				nativeType: columnMeta.nativeType,
+				nullable: columnMeta.nullable
+			});
+			values[defaultValue.column] = createParamRef(index, defaultValue.column);
+		}
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return createColumnRef(c.table, c.column);
+		});
+		const ast = createInsertAst({
+			table: createTableRef(this.table.name),
+			values,
+			returning
+		});
+		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,
+			...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {}
+		});
+		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 paramDescriptors = [];
+		const paramValues = [];
+		const paramCodecs = {};
+		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)) {
+			if (!contractTable.columns[columnName]) errorUnknownColumn(columnName, this.table.name);
+			const paramName = placeholder.name;
+			if (!Object.hasOwn(paramsMap, paramName)) errorMissingParameter(paramName);
+			const value = paramsMap[paramName];
+			const index = paramValues.push(value);
+			const columnMeta = contractTable.columns[columnName];
+			const codecId = columnMeta?.codecId;
+			if (paramName && codecId) paramCodecs[paramName] = codecId;
+			paramDescriptors.push({
+				name: paramName,
+				source: "dsl",
+				refs: {
+					table: this.table.name,
+					column: columnName
+				},
+				...codecId ? { codecId } : {},
+				...columnMeta?.nativeType ? { nativeType: columnMeta.nativeType } : {},
+				...columnMeta?.nullable !== void 0 ? { nullable: columnMeta.nullable } : {}
+			});
+			set[columnName] = createParamRef(index, paramName);
+		}
+		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);
+			const index = paramValues.push(defaultValue.value);
+			paramCodecs[defaultValue.column] = columnMeta.codecId;
+			paramDescriptors.push({
+				name: defaultValue.column,
+				source: "dsl",
+				refs: {
+					table: this.table.name,
+					column: defaultValue.column
+				},
+				codecId: columnMeta.codecId,
+				nativeType: columnMeta.nativeType,
+				nullable: columnMeta.nullable
+			});
+			set[defaultValue.column] = createParamRef(index, defaultValue.column);
+		}
+		const whereResult = buildWhereExpr(this.contract, this.wherePredicate, paramsMap, paramDescriptors, paramValues);
+		const whereExpr = whereResult.expr;
+		if (!whereExpr) errorFailedToBuildWhereClause();
+		if (whereResult.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return createColumnRef(c.table, c.column);
+		});
+		const ast = createUpdateAst({
+			table: createTableRef(this.table.name),
+			set,
+			where: whereExpr,
+			returning
+		});
+		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,
+			...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {},
+			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 ?? {};
+		const paramDescriptors = [];
+		const paramValues = [];
+		const paramCodecs = {};
+		if (!this.contract.storage.tables[this.table.name]) errorUnknownTable(this.table.name);
+		const whereResult = buildWhereExpr(this.contract, this.wherePredicate, paramsMap, paramDescriptors, paramValues);
+		const whereExpr = whereResult.expr;
+		if (!whereExpr) errorFailedToBuildWhereClause();
+		if (whereResult.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
+		const returning = this.returningColumns.map((col) => {
+			const c = col;
+			return createColumnRef(c.table, c.column);
+		});
+		const ast = createDeleteAst({
+			table: createTableRef(this.table.name),
+			where: whereExpr,
+			returning
+		});
+		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,
+			...Object.keys(paramCodecs).length > 0 ? { paramCodecs } : {},
+			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: () => ({
+				kind: "col",
+				table: matchingInclude.table.name,
+				column: ""
+			})
+		});
+	} 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;
+	codecTypes;
+	table;
+	childProjection;
+	childWhere;
+	childOrderBy;
+	childLimit;
+	constructor(contract, codecTypes, table) {
+		this.contract = contract;
+		this.codecTypes = codecTypes;
+		this.table = table;
+	}
+	select(projection) {
+		const projectionState = buildProjectionState(this.table, projection);
+		const builder = new IncludeChildBuilderImpl(this.contract, this.codecTypes, 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.codecTypes, 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.codecTypes, 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.codecTypes, 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 buildIncludeAst(include, contract, paramsMap, paramDescriptors, paramValues) {
+	const childOrderBy = include.childOrderBy ? (() => {
+		const orderBy = include.childOrderBy;
+		const orderExpr = orderBy.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);
+		})(), orderBy.dir)];
+	})() : void 0;
+	let childWhere;
+	if (include.childWhere) childWhere = buildWhereExpr(contract, include.childWhere, paramsMap, paramDescriptors, paramValues).expr;
+	const onLeft = include.on.left;
+	const onRight = include.on.right;
+	const onExpr = createJoinOnExpr(createColumnRef(onLeft.table, onLeft.column), createColumnRef(onRight.table, onRight.column));
+	return {
+		kind: "includeMany",
+		alias: include.alias,
+		child: {
+			table: createTableRef(include.table.name),
+			on: onExpr,
+			...childWhere ? { where: childWhere } : {},
+			...childOrderBy ? { orderBy: childOrderBy } : {},
+			...typeof include.childLimit === "number" ? { limit: include.childLimit } : {},
+			project: include.childProjection.aliases.map((alias, idx) => {
+				const column = include.childProjection.columns[idx];
+				if (!column || !alias) errorMissingColumnForAlias(alias ?? "unknown", idx);
+				return {
+					alias,
+					expr: column.toExpr()
+				};
+			})
+		}
+	};
+}
+
+//#endregion
+//#region src/sql/join-builder.ts
+function buildJoinAst(join) {
+	const onLeft = join.on.left;
+	const onRight = join.on.right;
+	const onExpr = createJoinOnExpr(createColumnRef(onLeft.table, onLeft.column), createColumnRef(onRight.table, onRight.column));
+	return createJoin(join.joinType, createTableRef(join.table.name), onExpr);
+}
+
+//#endregion
+//#region src/sql/select-builder.ts
+var SelectBuilderImpl = class SelectBuilderImpl {
+	contract;
+	codecTypes;
+	context;
+	state = {};
+	constructor(options, state) {
+		this.context = options.context;
+		this.contract = options.context.contract;
+		this.codecTypes = options.context.contract.mappings.codecTypes;
+		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, this.codecTypes, 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 paramDescriptors = [];
+		const paramValues = [];
+		const paramCodecs = {};
+		const whereResult = this.state.where ? buildWhereExpr(this.contract, this.state.where, paramsMap, paramDescriptors, paramValues) : void 0;
+		const whereExpr = whereResult?.expr;
+		if (whereResult?.codecId && whereResult.paramName) paramCodecs[whereResult.paramName] = whereResult.codecId;
+		const orderByClause = this.state.orderBy ? (() => {
+			const orderBy = this.state.orderBy;
+			return [createOrderByItem(orderBy.expr, orderBy.dir)];
+		})() : void 0;
+		const joins = this.state.joins?.map((join) => buildJoinAst(join));
+		const includes = this.state.includes?.map((include) => buildIncludeAst(include, this.contract, paramsMap, paramDescriptors, paramValues));
+		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];
+			if (this.state.includes?.find((inc) => inc.alias === alias)) projectEntries.push({
+				alias,
+				expr: {
+					kind: "includeRef",
+					alias
+				}
+			});
+			else if (column && isExpressionBuilder(column)) projectEntries.push({
+				alias,
+				expr: column.expr
+			});
+			else if (column) {
+				const columnRef = column.toExpr();
+				projectEntries.push({
+					alias,
+					expr: columnRef
+				});
+			}
+		}
+		const ast = createSelectAst({
+			from: createTableRef(table.name),
+			joins,
+			includes,
+			project: projectEntries,
+			where: whereExpr,
+			orderBy: orderByClause,
+			limit: this.state.limit
+		});
+		const planMeta = buildMeta({
+			contract: this.contract,
+			table,
+			projection,
+			joins: this.state.joins,
+			includes: this.state.includes,
+			paramDescriptors,
+			paramCodecs,
+			where: this.state.where,
+			orderBy: this.state.orderBy
+		});
+		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-DLGrrQ5F.mjs.map