@prisma-next/sql-runtime 0.5.0-dev.23 → 0.5.0-dev.25

package/dist/{exports-BET5HxxT.mjs → exports-CwCgOv6w.mjs}

@@ -1,6 +1,6 @@
 import { AsyncIterableResult, RuntimeCore, checkMiddlewareCompatibility, isRuntimeError, runWithMiddleware, runtimeError } from "@prisma-next/framework-components/runtime";
 import { type } from "arktype";
-import { createCodecRegistry, isQueryAst } from "@prisma-next/sql-relational-core/ast";
+import { collectOrderedParamRefs, createCodecRegistry, isQueryAst } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { checkContractComponentRequirements } from "@prisma-next/framework-components/components";
 import { createExecutionStack } from "@prisma-next/framework-components/execution";
@@ -124,25 +124,21 @@ function hasAggregateWithoutGroupBy(ast) {
 	if (ast.groupBy !== void 0) return false;
 	return ast.projection.some((item) => item.expr.kind === "aggregate");
 }
-function estimateRowsFromAst(ast, tableRows, defaultTableRows, refs, hasAggregateWithoutGroup) {
+function primaryTableFromAst(ast) {
+	switch (ast.from.kind) {
+		case "table-source": return ast.from.name;
+		case "derived-table-source": return ast.from.alias;
+		default: return;
+	}
+}
+function estimateRowsFromAst(ast, tableRows, defaultTableRows, hasAggregateWithoutGroup) {
 	if (hasAggregateWithoutGroup) return 1;
-	const table = refs?.tables?.[0];
+	const table = primaryTableFromAst(ast);
 	if (!table) return null;
 	const tableEstimate = tableRows[table] ?? defaultTableRows;
 	if (ast.limit !== void 0) return Math.min(ast.limit, tableEstimate);
 	return tableEstimate;
 }
-function estimateRowsFromHeuristics(plan, tableRows, defaultTableRows) {
-	const table = plan.meta.refs?.tables?.[0];
-	if (!table) return null;
-	const tableEstimate = tableRows[table] ?? defaultTableRows;
-	const limit = plan.meta.annotations?.["limit"];
-	if (typeof limit === "number") return Math.min(limit, tableEstimate);
-	return tableEstimate;
-}
-function hasDetectableLimitFromHeuristics(plan) {
-	return typeof plan.meta.annotations?.["limit"] === "number";
-}
 function emitBudgetViolation(error, shouldBlock, ctx) {
 	if (shouldBlock) throw error;
 	ctx.log.warn({
@@ -163,11 +159,7 @@ function budgets(options) {
 		familyId: "sql",
 		async beforeExecute(plan, ctx) {
 			observedRowsByPlan.set(plan, { count: 0 });
-			if (isQueryAst(plan.ast)) {
-				if (plan.ast.kind === "select") return evaluateSelectAst(plan, plan.ast, ctx);
-				return;
-			}
-			return evaluateWithHeuristics(plan, ctx);
+			if (isQueryAst(plan.ast) && plan.ast.kind === "select") return evaluateSelectAst(plan.ast, ctx);
 		},
 		async onRow(_row, plan, _ctx) {
 			const state = observedRowsByPlan.get(plan);
@@ -190,9 +182,9 @@ function budgets(options) {
 			}
 		}
 	});
-	function evaluateSelectAst(plan, ast, ctx) {
+	function evaluateSelectAst(ast, ctx) {
 		const hasAggNoGroup = hasAggregateWithoutGroupBy(ast);
-		const estimated = estimateRowsFromAst(ast, tableRows, defaultTableRows, plan.meta.refs, hasAggNoGroup);
+		const estimated = estimateRowsFromAst(ast, tableRows, defaultTableRows, hasAggNoGroup);
 		const isUnbounded = ast.limit === void 0 && !hasAggNoGroup;
 		const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
 		if (isUnbounded) {
@@ -216,35 +208,6 @@ function budgets(options) {
 			maxRows
 		}), shouldBlock, ctx);
 	}
-	async function evaluateWithHeuristics(plan, ctx) {
-		const estimated = estimateRowsFromHeuristics(plan, tableRows, defaultTableRows);
-		const isUnbounded = !hasDetectableLimitFromHeuristics(plan);
-		const isSelect = plan.sql.trimStart().toUpperCase().startsWith("SELECT");
-		const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
-		if (isSelect && isUnbounded) {
-			if (estimated !== null && estimated >= maxRows) {
-				emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-					source: "heuristic",
-					estimatedRows: estimated,
-					maxRows
-				}), shouldBlock, ctx);
-				return;
-			}
-			emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-				source: "heuristic",
-				maxRows
-			}), shouldBlock, ctx);
-			return;
-		}
-		if (estimated !== null) {
-			if (estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
-				source: "heuristic",
-				estimatedRows: estimated,
-				maxRows
-			}), shouldBlock, ctx);
-			return;
-		}
-	}
 }
 
 //#endregion
@@ -277,24 +240,12 @@ function evaluateRawGuardrails(plan, config) {
 		sql: snippet(plan.sql),
 		intent: plan.meta.annotations?.["intent"]
 	}));
-	const refs = plan.meta.refs;
-	if (refs) evaluateIndexCoverage(refs, lints$1);
 	return {
 		lints: lints$1,
 		budgets: budgets$1,
 		statement: statementType
 	};
 }
-function evaluateIndexCoverage(refs, lints$1) {
-	const predicateColumns = refs.columns ?? [];
-	if (predicateColumns.length === 0) return;
-	const indexes = refs.indexes ?? [];
-	if (indexes.length === 0) {
-		lints$1.push(createLint("LINT.UNINDEXED_PREDICATE", "warn", "Raw SQL plan predicates lack supporting indexes", { predicates: predicateColumns }));
-		return;
-	}
-	if (!predicateColumns.every((column) => indexes.some((index) => index.table === column.table && index.columns.some((col) => col.toLowerCase() === column.column.toLowerCase())))) lints$1.push(createLint("LINT.UNINDEXED_PREDICATE", "warn", "Raw SQL plan predicates lack supporting indexes", { predicates: predicateColumns }));
-}
 function classifyStatement(sql) {
 	const trimmed = sql.trim();
 	const lower = trimmed.toLowerCase();
@@ -781,49 +732,51 @@ function formatErrorSummary(errors) {
 //#endregion
 //#region src/codecs/decoding.ts
 const WIRE_PREVIEW_LIMIT = 100;
-function resolveRowCodec(alias, plan, registry) {
-	const planCodecId = plan.meta.annotations?.codecs?.[alias];
-	if (planCodecId) {
-		const codec$1 = registry.get(planCodecId);
-		if (codec$1) return codec$1;
-	}
-	if (plan.meta.projectionTypes) {
-		const typeId = plan.meta.projectionTypes[alias];
-		if (typeId) {
-			const codec$1 = registry.get(typeId);
-			if (codec$1) return codec$1;
+const EMPTY_INCLUDE_ALIASES = /* @__PURE__ */ new Set();
+function isAstBackedPlan(plan) {
+	return plan.ast !== void 0;
+}
+function projectionListFromAst(ast) {
+	if (ast.kind === "select") return ast.projection;
+	return ast.returning;
+}
+function buildDecodeContext(plan, registry) {
+	if (!isAstBackedPlan(plan)) return {
+		aliases: void 0,
+		codecs: /* @__PURE__ */ new Map(),
+		columnRefs: /* @__PURE__ */ new Map(),
+		includeAliases: EMPTY_INCLUDE_ALIASES
+	};
+	const projection = projectionListFromAst(plan.ast);
+	if (!projection) return {
+		aliases: void 0,
+		codecs: /* @__PURE__ */ new Map(),
+		columnRefs: /* @__PURE__ */ new Map(),
+		includeAliases: EMPTY_INCLUDE_ALIASES
+	};
+	const aliases = [];
+	const codecs = /* @__PURE__ */ new Map();
+	const columnRefs = /* @__PURE__ */ new Map();
+	const includeAliases = /* @__PURE__ */ new Set();
+	for (const item of projection) {
+		aliases.push(item.alias);
+		if (item.codecId) {
+			const codec$1 = registry.get(item.codecId);
+			if (codec$1) codecs.set(item.alias, codec$1);
 		}
+		if (item.expr.kind === "column-ref") columnRefs.set(item.alias, {
+			table: item.expr.table,
+			column: item.expr.column
+		});
+		else if (item.expr.kind === "subquery" || item.expr.kind === "json-array-agg") includeAliases.add(item.alias);
 	}
-	return null;
-}
-/**
-* Builds a lookup index from column name → { table, column } ref.
-* Called once per decodeRow invocation to avoid O(aliases × refs) linear scans.
-*/
-function buildColumnRefIndex(plan) {
-	const columns = plan.meta.refs?.columns;
-	if (!columns) return null;
-	const index = /* @__PURE__ */ new Map();
-	for (const ref of columns) index.set(ref.column, ref);
-	return index;
-}
-function parseProjectionRef(value) {
-	if (value.startsWith("include:") || value.startsWith("operation:")) return null;
-	const separatorIndex = value.indexOf(".");
-	if (separatorIndex <= 0 || separatorIndex === value.length - 1) return null;
 	return {
-		table: value.slice(0, separatorIndex),
-		column: value.slice(separatorIndex + 1)
+		aliases,
+		codecs,
+		columnRefs,
+		includeAliases
 	};
 }
-function resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex) {
-	if (projection && !Array.isArray(projection)) {
-		const mappedRef = projection[alias];
-		if (typeof mappedRef !== "string") return;
-		return parseProjectionRef(mappedRef) ?? void 0;
-	}
-	return fallbackColumnRefIndex?.get(alias);
-}
 function previewWireValue(wireValue) {
 	if (typeof wireValue === "string") return wireValue.length > WIRE_PREVIEW_LIMIT ? `${wireValue.substring(0, WIRE_PREVIEW_LIMIT)}...` : wireValue;
 	return String(wireValue).substring(0, WIRE_PREVIEW_LIMIT);
@@ -870,11 +823,11 @@ function decodeIncludeAggregate(alias, wireValue) {
 * `codec.decode → await → JSON-Schema validate → return plain value` — so
 * sync- and async-authored codecs are indistinguishable to callers.
 */
-async function decodeField(alias, wireValue, plan, registry, jsonValidators, projection, fallbackColumnRefIndex) {
-	if (wireValue === null || wireValue === void 0) return wireValue;
-	const codec$1 = resolveRowCodec(alias, plan, registry);
+async function decodeField(alias, wireValue, ctx, jsonValidators) {
+	if (wireValue === null) return null;
+	const codec$1 = ctx.codecs.get(alias);
 	if (!codec$1) return wireValue;
-	const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
+	const ref = ctx.columnRefs.get(alias);
 	let decoded;
 	try {
 		decoded = await codec$1.decode(wireValue);
@@ -897,19 +850,21 @@ async function decodeField(alias, wireValue, plan, registry, jsonValidators, pro
 * original error attached on `cause`.
 */
 async function decodeRow(row, plan, registry, jsonValidators) {
-	const projection = plan.meta.projection;
-	const fallbackColumnRefIndex = !projection || Array.isArray(projection) ? buildColumnRefIndex(plan) : null;
-	let aliases;
-	if (projection && !Array.isArray(projection)) aliases = Object.keys(projection);
-	else if (projection && Array.isArray(projection)) aliases = projection;
-	else aliases = Object.keys(row);
+	const ctx = buildDecodeContext(plan, registry);
+	const aliases = ctx.aliases ?? Object.keys(row);
+	if (ctx.aliases !== void 0) {
+		for (const alias of ctx.aliases) if (!Object.hasOwn(row, alias)) throw runtimeError("RUNTIME.DECODE_FAILED", `Row missing projection alias "${alias}"`, {
+			alias,
+			expectedAliases: ctx.aliases,
+			presentKeys: Object.keys(row)
+		});
+	}
 	const tasks = [];
 	const includeIndices = [];
 	for (let i = 0; i < aliases.length; i++) {
 		const alias = aliases[i];
 		const wireValue = row[alias];
-		const projectionValue = projection && typeof projection === "object" && !Array.isArray(projection) ? projection[alias] : void 0;
-		if (typeof projectionValue === "string" && projectionValue.startsWith("include:")) {
+		if (ctx.includeAliases.has(alias)) {
 			includeIndices.push({
 				index: i,
 				alias,
@@ -918,7 +873,7 @@ async function decodeRow(row, plan, registry, jsonValidators) {
 			tasks.push(Promise.resolve(void 0));
 			continue;
 		}
-		tasks.push(decodeField(alias, wireValue, plan, registry, jsonValidators, projection, fallbackColumnRefIndex));
+		tasks.push(decodeField(alias, wireValue, ctx, jsonValidators));
 	}
 	const settled = await Promise.all(tasks);
 	for (const entry of includeIndices) settled[entry.index] = decodeIncludeAggregate(entry.alias, entry.value);
@@ -929,18 +884,15 @@ async function decodeRow(row, plan, registry, jsonValidators) {
 
 //#endregion
 //#region src/codecs/encoding.ts
-function resolveParamCodec(paramDescriptor, registry) {
-	if (paramDescriptor.codecId) {
-		const codec$1 = registry.get(paramDescriptor.codecId);
-		if (codec$1) return codec$1;
-	}
-	return null;
-}
-function paramLabel(paramDescriptor, paramIndex) {
-	return paramDescriptor.name ?? `param[${paramIndex}]`;
+const NO_METADATA = Object.freeze({
+	codecId: void 0,
+	name: void 0
+});
+function paramLabel(metadata, paramIndex) {
+	return metadata.name ?? `param[${paramIndex}]`;
 }
-function wrapEncodeFailure(error, paramDescriptor, paramIndex, codecId) {
-	const label = paramLabel(paramDescriptor, paramIndex);
+function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
+	const label = paramLabel(metadata, paramIndex);
 	const wrapped = runtimeError("RUNTIME.ENCODE_FAILED", `Failed to encode parameter ${label} with codec '${codecId}': ${error instanceof Error ? error.message : String(error)}`, {
 		label,
 		codec: codecId,
@@ -949,21 +901,15 @@ function wrapEncodeFailure(error, paramDescriptor, paramIndex, codecId) {
 	wrapped.cause = error;
 	throw wrapped;
 }
-/**
-* Encodes a single parameter through its codec. Always awaits codec.encode so
-* a Promise can never leak into the driver, even if a sync-authored codec is
-* lifted to async by the codec() factory. Failures are wrapped in
-* `RUNTIME.ENCODE_FAILED` with `{ label, codec, paramIndex }` and the original
-* error attached on `cause`.
-*/
-async function encodeParam(value, paramDescriptor, paramIndex, registry) {
+async function encodeParamValue(value, metadata, paramIndex, registry) {
 	if (value === null || value === void 0) return null;
-	const codec$1 = resolveParamCodec(paramDescriptor, registry);
+	if (!metadata.codecId) return value;
+	const codec$1 = registry.get(metadata.codecId);
 	if (!codec$1) return value;
 	try {
 		return await codec$1.encode(value);
 	} catch (error) {
-		wrapEncodeFailure(error, paramDescriptor, paramIndex, codec$1.id);
+		wrapEncodeFailure(error, metadata, paramIndex, codec$1.id);
 	}
 }
 /**
@@ -973,19 +919,20 @@ async function encodeParam(value, paramDescriptor, paramIndex, registry) {
 */
 async function encodeParams(plan, registry) {
 	if (plan.params.length === 0) return plan.params;
-	const descriptorCount = plan.meta.paramDescriptors.length;
 	const paramCount = plan.params.length;
-	const tasks = new Array(paramCount);
-	for (let i = 0; i < paramCount; i++) {
-		const paramValue = plan.params[i];
-		const paramDescriptor = plan.meta.paramDescriptors[i];
-		if (!paramDescriptor) throw runtimeError("RUNTIME.MISSING_PARAM_DESCRIPTOR", `Missing paramDescriptor for parameter at index ${i} (plan has ${paramCount} params, ${descriptorCount} descriptors). The planner must emit one descriptor per param; this is a contract violation.`, {
-			paramIndex: i,
-			paramCount,
-			descriptorCount
-		});
-		tasks[i] = encodeParam(paramValue, paramDescriptor, i, registry);
+	const metadata = new Array(paramCount).fill(NO_METADATA);
+	if (plan.ast) {
+		const refs = collectOrderedParamRefs(plan.ast);
+		for (let i = 0; i < paramCount && i < refs.length; i++) {
+			const ref = refs[i];
+			if (ref) metadata[i] = {
+				codecId: ref.codecId,
+				name: ref.name
+			};
+		}
 	}
+	const tasks = new Array(paramCount);
+	for (let i = 0; i < paramCount; i++) tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, registry);
 	const encoded = await Promise.all(tasks);
 	return Object.freeze(encoded);
 }
@@ -1024,32 +971,7 @@ async function runBeforeCompileChain(middleware, initial, ctx) {
 		});
 		current = result;
 	}
-	if (current.ast === initial.ast) return current;
-	const paramDescriptors = deriveParamDescriptorsFromAst(current.ast);
-	const meta = {
-		...current.meta,
-		paramDescriptors
-	};
-	return {
-		ast: current.ast,
-		meta
-	};
-}
-function deriveParamDescriptorsFromAst(ast) {
-	const refs = ast.collectParamRefs();
-	const seen = /* @__PURE__ */ new Set();
-	const descriptors = [];
-	for (const ref of refs) {
-		if (seen.has(ref)) continue;
-		seen.add(ref);
-		descriptors.push({
-			index: descriptors.length + 1,
-			...ref.name !== void 0 ? { name: ref.name } : {},
-			source: "dsl",
-			...ref.codecId !== void 0 ? { codecId: ref.codecId } : {}
-		});
-	}
-	return descriptors;
+	return current;
 }
 
 //#endregion
@@ -1151,10 +1073,12 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 	}
 	/**
 	* SQL pre-compile hook. Runs the registered middleware `beforeCompile`
-	* chain over the plan's draft (AST + meta) and returns a `SqlQueryPlan`
-	* with the rewritten AST and meta when the chain mutates them. The chain
-	* re-derives `meta.paramDescriptors` from the rewritten AST so descriptors
-	* stay in lockstep with the params the adapter will emit during lowering.
+	* chain over the plan's draft (AST + meta). Returns the original plan
+	* unchanged when no middleware rewrote the AST; otherwise returns a new
+	* plan carrying the rewritten AST and meta. The AST is the authoritative
+	* source of execution metadata, so a rewrite needs no sidecar
+	* reconciliation here — the lowering adapter and the encoder both walk
+	* the rewritten AST directly.
 	*/
 	async runBeforeCompile(plan) {
 		const rewrittenDraft = await runBeforeCompileChain(this.middleware, {
@@ -1359,4 +1283,4 @@ function createRuntime(options) {
 
 //#endregion
 export { readContractMarker as a, createSqlExecutionStack as c, parseContractMarkerRow as d, lowerSqlPlan as f, validateContractCodecMappings as h, ensureTableStatement as i, lints as l, validateCodecRegistryCompleteness as m, withTransaction as n, writeContractMarker as o, extractCodecIds as p, ensureSchemaStatement as r, createExecutionContext as s, createRuntime as t, budgets as u };
-//# sourceMappingURL=exports-BET5HxxT.mjs.map
+//# sourceMappingURL=exports-CwCgOv6w.mjs.map