@prisma/orm-family-sql 8.0.0-rc.1-dev.44 → 8.0.0-rc.1-dev.46

package/dist/runtime.mjs

@@ -1,10 +1,10 @@
 import { t as createSqlOperationRegistry } from "./dist-C_q1_QR9.mjs";
-import { A as PreparedParamRef, H as isQueryAst } from "./types-B7_v-z12-De5tf8LE.mjs";
+import { A as PreparedParamRef, H as isQueryAst } from "./types-Dt4e_jC--COeP8xzN.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
 import { t as createSqlParamRefMutator } from "./middleware-CMr4CHNz-DHIUdxlm.mjs";
-import { t as buildSqlAggregateDescriptorRegistry } from "./aggregate-descriptor-registry-CTo0ry7h.mjs";
+import { t as buildSqlAggregateDescriptorRegistry } from "./aggregate-descriptor-registry-C7hel5O7.mjs";
 import { t as buildCodecDescriptorRegistry } from "./codec-descriptor-registry-N0dhtKaH.mjs";
-import { n as runPreparedQuery, t as preparedStatementQuery } from "./prepared-query-BDLztUzY-CaDR0Rqc.mjs";
+import { i as runPreparedQuery, n as preparedStatementQuery, r as runPreparedExecute, t as preparedStatementExecute } from "./prepared-query-BJr50wPm-ChoqfJbX.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { createHash } from "node:crypto";
 import { assertNever } from "@prisma/orm-framework/utils/internal-error";
@@ -17,7 +17,7 @@ import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatib
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
 import { createExecutionStack } from "@prisma/orm-framework/components/execution";
 import { hashContent } from "@prisma/orm-framework/utils/hash-content";
-//#region ../../../2-sql/5-runtime/dist/exports-CNtR1FrC.mjs
+//#region ../../../2-sql/5-runtime/dist/exports-BDzGy_bM.mjs
 /**
 * Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
 *
@@ -401,7 +401,7 @@ function evaluateAstLints(ast) {
 			}
 			break;
 		case "insert": break;
-		case "raw-sql": break;
+		case "raw-query": break;
 		// v8 ignore next 2
 		default: assertNever(ast, `Unsupported AST kind: ${ast.kind}`);
 	}
@@ -439,7 +439,7 @@ function lints(options) {
 		const findings = [];
 		if (isQueryAst(plan.ast)) {
 			findings.push(...evaluateAstLints(plan.ast));
-			if (plan.ast.kind === "raw-sql") findings.push(...evaluateRawGuardrails(plan).lints);
+			if (plan.ast.kind === "raw-query") findings.push(...evaluateRawGuardrails(plan).lints);
 		} else if (fallback !== "skip") findings.push(...evaluateRawGuardrails(plan).lints);
 		for (const lint of findings) {
 			const effectiveSeverity = getConfiguredSeverity(lint.code, options) ?? lint.severity;
@@ -478,6 +478,34 @@ var PreparedStatementImpl = class {
 		return runPreparedQuery(target, this, params, options);
 	}
 };
+/**
+* The statistics-reporting sibling of {@link PreparedStatementImpl}. A plan
+* declaring an affected-row count prepares into one of these, which carries
+* the same lowered statement and bind slots and is consumed by executing it.
+*
+* The two classes are separate so the consumption a plan did not declare is
+* absent from the value, not merely from its type.
+*/
+var PreparedExecutionImpl = class {
+	sql;
+	ast;
+	meta;
+	slots;
+	decodeContext;
+	paramMetadata;
+	constructor(internals) {
+		this.sql = internals.sql;
+		this.ast = internals.ast;
+		this.meta = internals.meta;
+		this.slots = internals.slots;
+		this.decodeContext = internals.decodeContext;
+		this.paramMetadata = internals.paramMetadata;
+		Object.freeze(this);
+	}
+	execute(target, params, options) {
+		return runPreparedExecute(target, this, params, options);
+	}
+};
 function documentScopedCodecTypes(contract) {
 	return blindCast(contract.storage.types);
 }
@@ -849,22 +877,52 @@ const WIRE_PREVIEW_LIMIT = 100;
 const EMPTY_INCLUDE_ALIASES = /* @__PURE__ */ new Set();
 function projectionListFromAst(ast) {
 	if (ast.kind === "select") return ast.projection;
-	if (ast.kind === "raw-sql") return;
 	return ast.returning;
 }
 function resolveProjectionCodec(item, contractCodecs) {
 	if (item.codec && contractCodecs) return contractCodecs.forCodecRef(item.codec);
 }
 const EMPTY_MANY_ALIASES = /* @__PURE__ */ new Set();
-function buildDecodeContext(ast, contractCodecs) {
-	const projection = projectionListFromAst(ast);
-	if (!projection || projection.length === 0) return {
+function undecodedContext() {
+	return {
 		aliases: void 0,
 		codecs: /* @__PURE__ */ new Map(),
 		columnRefs: /* @__PURE__ */ new Map(),
 		includeAliases: EMPTY_INCLUDE_ALIASES,
-		manyAliases: EMPTY_MANY_ALIASES
+		manyAliases: EMPTY_MANY_ALIASES,
+		aliasSource: "projection"
+	};
+}
+/**
+* Decode context for a raw statement: the columns come from the row spec its
+* author declared at the terminator, and each carries the codec that decodes
+* it. A statement that reports an affected-row count declares no columns, so
+* its single stats row passes through undecoded.
+*
+* The spec is the only description of the result — the runtime never parses
+* the SQL — so it is also what a mismatched result set is measured against.
+*/
+function rawQueryDecodeContext(ast, contractCodecs) {
+	if (ast.result.kind === "affected-count") return undecodedContext();
+	const aliases = [];
+	const codecs = /* @__PURE__ */ new Map();
+	for (const [name, column] of Object.entries(ast.result.columns)) {
+		aliases.push(name);
+		if (contractCodecs) codecs.set(name, contractCodecs.forCodecRef({ codecId: column.codecId }));
+	}
+	return {
+		aliases,
+		codecs,
+		columnRefs: /* @__PURE__ */ new Map(),
+		includeAliases: EMPTY_INCLUDE_ALIASES,
+		manyAliases: EMPTY_MANY_ALIASES,
+		aliasSource: "row-spec"
 	};
+}
+function buildDecodeContext(ast, contractCodecs) {
+	if (ast.kind === "raw-query") return rawQueryDecodeContext(ast, contractCodecs);
+	const projection = projectionListFromAst(ast);
+	if (!projection || projection.length === 0) return undecodedContext();
 	const aliases = [];
 	const codecs = /* @__PURE__ */ new Map();
 	const columnRefs = /* @__PURE__ */ new Map();
@@ -886,7 +944,8 @@ function buildDecodeContext(ast, contractCodecs) {
 		codecs,
 		columnRefs,
 		includeAliases,
-		manyAliases
+		manyAliases,
+		aliasSource: "projection"
 	};
 }
 function previewWireValue(wireValue) {
@@ -988,7 +1047,11 @@ async function decodeRow(row, decodeCtx, rowCtx) {
 	const signal = rowCtx.signal;
 	const aliases = decodeCtx.aliases ?? Object.keys(row);
 	if (decodeCtx.aliases !== void 0) {
-		for (const alias of decodeCtx.aliases) if (!Object.hasOwn(row, alias)) throw runtimeError("RUNTIME.DECODE_FAILED", `Row missing projection alias "${alias}"`, {
+		for (const alias of decodeCtx.aliases) if (!Object.hasOwn(row, alias)) throw decodeCtx.aliasSource === "row-spec" ? runtimeError("RUNTIME.RAW_ROW_COLUMN_MISSING", `Raw statement result has no column "${alias}", which its row spec declares`, {
+			column: alias,
+			declaredColumns: decodeCtx.aliases,
+			resultColumns: Object.keys(row)
+		}) : runtimeError("RUNTIME.DECODE_FAILED", `Row missing projection alias "${alias}"`, {
 			alias,
 			expectedAliases: decodeCtx.aliases,
 			presentKeys: Object.keys(row)
@@ -1298,6 +1361,9 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	[preparedStatementQuery](ps, params, options) {
 		return this.runPreparedQueryAgainstQueryable(blindCast(ps), params, this.driver, options);
 	}
+	[preparedStatementExecute](ps, params, options) {
+		return this.runPreparedExecuteAgainstQueryable(blindCast(ps), params, this.driver, options);
+	}
 	/**
 	* Returns the raw driver connection. The connection is a `SqlQueryable` — SQL
 	* issued on it runs below the middleware/codec/telemetry pipeline. It carries
@@ -1430,14 +1496,15 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		});
 		const decodeContext = buildDecodeContext(finalPlan.ast, this.contractCodecs);
 		const paramMetadata = deriveParamMetadata(finalPlan.ast);
-		return new PreparedStatementImpl(Object.freeze({
+		const internals = Object.freeze({
 			sql: lowered.sql,
 			ast: finalPlan.ast,
 			meta: finalPlan.meta,
 			slots: lowered.params,
 			decodeContext,
 			paramMetadata
-		}));
+		});
+		return blindCast(finalPlan.ast.kind === "raw-query" && finalPlan.ast.result.kind === "affected-count" ? new PreparedExecutionImpl(internals) : new PreparedStatementImpl(internals));
 	}
 	/** Query prepared rows against a caller-supplied queryable through the full pipeline. */
 	runPreparedQueryAgainstQueryable(ps, userParams, queryable, options) {
@@ -1477,6 +1544,50 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		};
 		return new AsyncIterableResult(generator());
 	}
+	/** Execute a prepared statement's statistics against a caller-supplied queryable through the full pipeline. */
+	async runPreparedExecuteAgainstQueryable(ps, userParams, queryable, options) {
+		this.ensureCodecRegistryValidated();
+		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
+		checkAborted(codecCtx, "stream");
+		const preEncodeValues = resolvePreparedSlotValues(ps, userParams);
+		const preEncodeExec = {
+			sql: ps.sql,
+			params: preEncodeValues,
+			ast: ps.ast,
+			meta: ps.meta
+		};
+		const mutator = createSqlParamRefMutator(preEncodeExec);
+		await runBeforeExecuteChain(preEncodeExec, this.middleware, middlewareCtx, mutator);
+		const exec = {
+			sql: ps.sql,
+			params: await encodeParamsWithMetadata(mutator.currentParams(), ps.paramMetadata, codecCtx, this.contractCodecs),
+			ast: ps.ast,
+			meta: ps.meta
+		};
+		await this.setupDriverExecution(exec);
+		checkAborted(codecCtx, "stream");
+		const handles = this.#preparedStatementHandles;
+		const request = {
+			sql: exec.sql,
+			params: exec.params,
+			preparedStatementHandle: {
+				get: () => handles.get(ps),
+				set: (value) => {
+					handles.set(ps, value);
+				}
+			}
+		};
+		const startedAt = Date.now();
+		let outcome = "success";
+		try {
+			return await runExecuteWithMiddleware(exec, this.middleware, middlewareCtx, () => queryable.execute(request));
+		} catch (error) {
+			outcome = "runtime-error";
+			throw error;
+		} finally {
+			this.recordTelemetry(exec, outcome, Date.now() - startedAt);
+		}
+	}
 	async connection() {
 		const driverConn = await this.driver.acquireConnection();
 		const self = this;
@@ -1508,6 +1619,12 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					...options,
 					scope: "connection"
 				});
+			},
+			[preparedStatementExecute](ps, params, options) {
+				return self.runPreparedExecuteAgainstQueryable(blindCast(ps), params, driverConn, {
+					...options,
+					scope: "connection"
+				});
 			}
 		};
 	}
@@ -1537,6 +1654,12 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					...options,
 					scope: "transaction"
 				});
+			},
+			[preparedStatementExecute](ps, params, options) {
+				return self.runPreparedExecuteAgainstQueryable(blindCast(ps), params, driverTx, {
+					...options,
+					scope: "transaction"
+				});
 			}
 		};
 	}
@@ -1624,6 +1747,10 @@ async function withTransaction(runtime, fn) {
 		[preparedStatementQuery](ps, params, options) {
 			if (invalidated) throw transactionClosedError();
 			return new AsyncIterableResult(guardedStream(runPreparedQuery(transaction, ps, params, options)));
+		},
+		[preparedStatementExecute](ps, params, options) {
+			if (invalidated) throw transactionClosedError();
+			return runPreparedExecute(transaction, ps, params, options);
 		}
 	};
 	let connectionDisposed = false;
@@ -1667,6 +1794,6 @@ async function withTransaction(runtime, fn) {
 	}
 }
 //#endregion
-export { PreparedStatementImpl, SqlRuntimeBase, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };
+export { PreparedExecutionImpl, PreparedStatementImpl, SqlRuntimeBase, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };
 
 //# sourceMappingURL=runtime.mjs.map