@prisma-next/sql-runtime 0.5.0-dev.22 → 0.5.0-dev.24

package/src/codecs/encoding.ts

@@ -1,33 +1,29 @@
-import type { ParamDescriptor } from '@prisma-next/contract/types';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
-import type { Codec, CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import {
+  type Codec,
+  type CodecRegistry,
+  collectOrderedParamRefs,
+} from '@prisma-next/sql-relational-core/ast';
 import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan';
 
-function resolveParamCodec(
-  paramDescriptor: ParamDescriptor,
-  registry: CodecRegistry,
-): Codec | null {
-  if (paramDescriptor.codecId) {
-    const codec = registry.get(paramDescriptor.codecId);
-    if (codec) {
-      return codec;
-    }
-  }
-
-  return null;
+interface ParamMetadata {
+  readonly codecId: string | undefined;
+  readonly name: string | undefined;
 }
 
-function paramLabel(paramDescriptor: ParamDescriptor, paramIndex: number): string {
-  return paramDescriptor.name ?? `param[${paramIndex}]`;
+const NO_METADATA: ParamMetadata = Object.freeze({ codecId: undefined, name: undefined });
+
+function paramLabel(metadata: ParamMetadata, paramIndex: number): string {
+  return metadata.name ?? `param[${paramIndex}]`;
 }
 
 function wrapEncodeFailure(
   error: unknown,
-  paramDescriptor: ParamDescriptor,
+  metadata: ParamMetadata,
   paramIndex: number,
   codecId: string,
 ): never {
-  const label = paramLabel(paramDescriptor, paramIndex);
+  const label = paramLabel(metadata, paramIndex);
   const message = error instanceof Error ? error.message : String(error);
   const wrapped = runtimeError(
     'RUNTIME.ENCODE_FAILED',
@@ -47,7 +43,21 @@ function wrapEncodeFailure(
  */
 export async function encodeParam(
   value: unknown,
-  paramDescriptor: ParamDescriptor,
+  paramRef: { readonly codecId?: string; readonly name?: string },
+  paramIndex: number,
+  registry: CodecRegistry,
+): Promise<unknown> {
+  return encodeParamValue(
+    value,
+    { codecId: paramRef.codecId, name: paramRef.name },
+    paramIndex,
+    registry,
+  );
+}
+
+async function encodeParamValue(
+  value: unknown,
+  metadata: ParamMetadata,
   paramIndex: number,
   registry: CodecRegistry,
 ): Promise<unknown> {
@@ -55,7 +65,11 @@ export async function encodeParam(
     return null;
   }
 
-  const codec = resolveParamCodec(paramDescriptor, registry);
+  if (!metadata.codecId) {
+    return value;
+  }
+
+  const codec: Codec | undefined = registry.get(metadata.codecId);
   if (!codec) {
     return value;
   }
@@ -63,7 +77,7 @@ export async function encodeParam(
   try {
     return await codec.encode(value);
   } catch (error) {
-    wrapEncodeFailure(error, paramDescriptor, paramIndex, codec.id);
+    wrapEncodeFailure(error, metadata, paramIndex, codec.id);
   }
 }
 
@@ -80,23 +94,22 @@ export async function encodeParams(
     return plan.params;
   }
 
-  const descriptorCount = plan.meta.paramDescriptors.length;
   const paramCount = plan.params.length;
+  const metadata: ParamMetadata[] = new Array(paramCount).fill(NO_METADATA);
 
-  const tasks: Promise<unknown>[] = 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 },
-      );
+  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 };
+      }
     }
+  }
 
-    tasks[i] = encodeParam(paramValue, paramDescriptor, i, registry);
+  const tasks: Promise<unknown>[] = 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);

package/src/guardrails/raw.ts

@@ -1,4 +1,4 @@
-import type { PlanMeta, PlanRefs } from '@prisma-next/contract/types';
+import type { PlanMeta } from '@prisma-next/contract/types';
 
 export type LintSeverity = 'error' | 'warn';
 export type BudgetSeverity = 'error' | 'warn';
@@ -103,58 +103,9 @@ export function evaluateRawGuardrails(
     );
   }
 
-  const refs = plan.meta.refs;
-  if (refs) {
-    evaluateIndexCoverage(refs, lints);
-  }
-
   return { lints, budgets, statement: statementType };
 }
 
-function evaluateIndexCoverage(refs: PlanRefs, lints: LintFinding[]) {
-  const predicateColumns = refs.columns ?? [];
-  if (predicateColumns.length === 0) {
-    return;
-  }
-
-  const indexes = refs.indexes ?? [];
-
-  if (indexes.length === 0) {
-    lints.push(
-      createLint(
-        'LINT.UNINDEXED_PREDICATE',
-        'warn',
-        'Raw SQL plan predicates lack supporting indexes',
-        {
-          predicates: predicateColumns,
-        },
-      ),
-    );
-    return;
-  }
-
-  const hasSupportingIndex = predicateColumns.every((column) =>
-    indexes.some(
-      (index) =>
-        index.table === column.table &&
-        index.columns.some((col) => col.toLowerCase() === column.column.toLowerCase()),
-    ),
-  );
-
-  if (!hasSupportingIndex) {
-    lints.push(
-      createLint(
-        'LINT.UNINDEXED_PREDICATE',
-        'warn',
-        'Raw SQL plan predicates lack supporting indexes',
-        {
-          predicates: predicateColumns,
-        },
-      ),
-    );
-  }
-}
-
 function classifyStatement(sql: string): 'select' | 'mutation' | 'other' {
   const trimmed = sql.trim();
   const lower = trimmed.toLowerCase();

package/src/middleware/before-compile-chain.ts

@@ -1,5 +1,3 @@
-import type { ParamDescriptor, PlanMeta } from '@prisma-next/contract/types';
-import type { AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
 import type { DraftPlan, SqlMiddleware, SqlMiddlewareContext } from './sql-middleware';
 
 export async function runBeforeCompileChain(
@@ -27,33 +25,5 @@ export async function runBeforeCompileChain(
     current = result;
   }
 
-  if (current.ast === initial.ast) {
-    return current;
-  }
-
-  // The rewritten AST may have introduced, removed, or replaced ParamRefs, so
-  // the descriptors collected at lane build time no longer line up with what
-  // the adapter will emit when it walks the new AST. Re-derive descriptors
-  // from the rewritten AST so `params` and `paramDescriptors` stay in lockstep
-  // by the time `encodeParams` runs.
-  const paramDescriptors = deriveParamDescriptorsFromAst(current.ast);
-  const meta: PlanMeta = { ...current.meta, paramDescriptors };
-  return { ast: current.ast, meta };
-}
-
-function deriveParamDescriptorsFromAst(ast: AnyQueryAst): ReadonlyArray<ParamDescriptor> {
-  const refs = ast.collectParamRefs();
-  const seen = new Set<unknown>();
-  const descriptors: ParamDescriptor[] = [];
-  for (const ref of refs) {
-    if (seen.has(ref)) continue;
-    seen.add(ref);
-    descriptors.push({
-      index: descriptors.length + 1,
-      ...(ref.name !== undefined ? { name: ref.name } : {}),
-      source: 'dsl',
-      ...(ref.codecId !== undefined ? { codecId: ref.codecId } : {}),
-    });
-  }
-  return descriptors;
+  return current;
 }

package/src/middleware/budgets.ts

@@ -25,18 +25,28 @@ function hasAggregateWithoutGroupBy(ast: SelectAst): boolean {
   return ast.projection.some((item) => item.expr.kind === 'aggregate');
 }
 
+function primaryTableFromAst(ast: SelectAst): string | undefined {
+  switch (ast.from.kind) {
+    case 'table-source':
+      return ast.from.name;
+    case 'derived-table-source':
+      return ast.from.alias;
+    default:
+      return undefined;
+  }
+}
+
 function estimateRowsFromAst(
   ast: SelectAst,
   tableRows: Record<string, number>,
   defaultTableRows: number,
-  refs: { tables?: readonly string[] } | undefined,
   hasAggregateWithoutGroup: boolean,
 ): number | null {
   if (hasAggregateWithoutGroup) {
     return 1;
   }
 
-  const table = refs?.tables?.[0];
+  const table = primaryTableFromAst(ast);
   if (!table) {
     return null;
   }
@@ -50,30 +60,6 @@ function estimateRowsFromAst(
   return tableEstimate;
 }
 
-function estimateRowsFromHeuristics(
-  plan: SqlExecutionPlan,
-  tableRows: Record<string, number>,
-  defaultTableRows: number,
-): number | null {
-  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: SqlExecutionPlan): boolean {
-  return typeof plan.meta.annotations?.['limit'] === 'number';
-}
-
 function emitBudgetViolation(
   error: RuntimeErrorEnvelope,
   shouldBlock: boolean,
@@ -105,14 +91,9 @@ export function budgets(options?: BudgetsOptions): SqlMiddleware {
     async beforeExecute(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext) {
       observedRowsByPlan.set(plan, { count: 0 });
 
-      if (isQueryAst(plan.ast)) {
-        if (plan.ast.kind === 'select') {
-          return evaluateSelectAst(plan, plan.ast, ctx);
-        }
-        return;
+      if (isQueryAst(plan.ast) && plan.ast.kind === 'select') {
+        return evaluateSelectAst(plan.ast, ctx);
       }
-
-      return evaluateWithHeuristics(plan, ctx);
     },
 
     async onRow(_row: Record<string, unknown>, plan: SqlExecutionPlan, _ctx: SqlMiddlewareContext) {
@@ -148,15 +129,9 @@ export function budgets(options?: BudgetsOptions): SqlMiddleware {
     },
   });
 
-  function evaluateSelectAst(plan: SqlExecutionPlan, ast: SelectAst, ctx: SqlMiddlewareContext) {
+  function evaluateSelectAst(ast: SelectAst, ctx: SqlMiddlewareContext) {
     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 === undefined && !hasAggNoGroup;
     const shouldBlock = rowSeverity === 'error' || ctx.mode === 'strict';
 
@@ -197,52 +172,4 @@ export function budgets(options?: BudgetsOptions): SqlMiddleware {
       );
     }
   }
-
-  async function evaluateWithHeuristics(plan: SqlExecutionPlan, ctx: SqlMiddlewareContext) {
-    const estimated = estimateRowsFromHeuristics(plan, tableRows, defaultTableRows);
-    const isUnbounded = !hasDetectableLimitFromHeuristics(plan);
-    const sqlUpper = plan.sql.trimStart().toUpperCase();
-    const isSelect = sqlUpper.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;
-    }
-  }
 }

package/src/sql-runtime.ts

@@ -211,10 +211,12 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
 
   /**
    * 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.
    */
   protected override async runBeforeCompile(plan: SqlQueryPlan): Promise<SqlQueryPlan> {
     const rewrittenDraft = await runBeforeCompileChain(