@prisma-next/framework-components 0.5.0-dev.9 → 0.5.1

package/dist/runtime.d.mts

@@ -1,6 +1,7 @@
+import { o as CodecCallContext } from "./codec-m_-FAyQn.mjs";
 import { PlanMeta } from "@prisma-next/contract/types";
 
-//#region src/async-iterable-result.d.ts
+//#region src/execution/async-iterable-result.d.ts
 declare class AsyncIterableResult<Row> implements AsyncIterable<Row>, PromiseLike<Row[]> {
   private readonly generator;
   private consumed;
@@ -14,7 +15,7 @@ declare class AsyncIterableResult<Row> implements AsyncIterable<Row>, PromiseLik
   then<TResult1 = Row[], TResult2 = never>(onfulfilled?: ((value: Row[]) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
 }
 //#endregion
-//#region src/query-plan.d.ts
+//#region src/execution/query-plan.d.ts
 /**
  * Family-agnostic plan marker.
  *
@@ -63,24 +64,209 @@ type ResultType<P> = '_row' extends keyof P ? P extends {
   readonly _row?: infer R;
 } ? R : never : never;
 //#endregion
-//#region src/runtime-middleware.d.ts
+//#region src/execution/runtime-error.d.ts
+interface RuntimeErrorEnvelope extends Error {
+  readonly code: string;
+  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';
+  readonly severity: 'error';
+  readonly details?: Record<string, unknown>;
+}
+/**
+ * Stable code emitted by the runtime when an in-flight `execute()`
+ * is cancelled via the per-query `AbortSignal`. The envelope's
+ * `details.phase` distinguishes where the abort was observed:
+ *
+ * - `'encode'` — abort fired during `encodeParams` (SQL) or
+ *   `resolveValue` (Mongo).
+ * - `'decode'` — abort fired during `decodeRow` / `decodeField`.
+ * - `'stream'` — abort fired between rows or before any codec call
+ *   (already-aborted at entry).
+ * - `'beforeExecute'` / `'afterExecute'` / `'onRow'` — abort fired
+ *   on entry to or during the corresponding middleware phase
+ *   (cooperative cancellation per the param-transform seam).
+ */
+declare const RUNTIME_ABORTED: "RUNTIME.ABORTED";
+/** Discriminator placed in `details.phase` of a `RUNTIME.ABORTED` envelope. */
+type RuntimeAbortedPhase = 'encode' | 'decode' | 'stream' | 'beforeExecute' | 'afterExecute' | 'onRow';
+/**
+ * Type guard for the runtime-error envelope produced by `runtimeError`.
+ *
+ * Prefer this over duck-typing on `error.code` directly so consumers stay
+ * insulated from the envelope's internal shape.
+ */
+declare function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope;
+declare function runtimeError(code: string, message: string, details?: Record<string, unknown>): RuntimeErrorEnvelope;
+/**
+ * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
+ * abort was observed — codec call sites (`encode` / `decode` / `stream`)
+ * or middleware seams (`beforeExecute` / `afterExecute` / `onRow`), as
+ * enumerated on {@link RuntimeAbortedPhase}. Cause carries
+ * `signal.reason` verbatim from the platform — native abort produces a
+ * `DOMException`, explicit `controller.abort(reason)` produces whatever
+ * the caller passed. No synthesis happens here.
+ */
+declare function runtimeAborted(phase: RuntimeAbortedPhase, cause?: unknown): RuntimeErrorEnvelope;
+//#endregion
+//#region src/execution/race-against-abort.d.ts
+/**
+ * Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied
+ * context is already aborted at the precheck site. Centralises the
+ * `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that
+ * every codec dispatch site (and the `beforeExecute` middleware phase)
+ * repeats. Accepts both the framework `CodecCallContext` and the
+ * `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.
+ */
+declare function checkAborted(ctx: {
+  readonly signal?: AbortSignal;
+}, phase: RuntimeAbortedPhase): void;
+/**
+ * Race a per-cell `Promise.all` (or any other in-flight work promise) against
+ * the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly
+ * even when codec bodies ignore the signal. In-flight bodies that ignore the
+ * signal are abandoned and run to completion in the background — the
+ * cooperative-cancellation contract documented in ADR 204.
+ *
+ * Call sites still SHOULD pre-check `signal.aborted` and short-circuit with
+ * a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —
+ * that path is the canonical "aborted at entry" surface and avoids
+ * scheduling the work promise. As a defensive belt-and-braces, this helper
+ * also handles the already-aborted case internally: `AbortSignal` does not
+ * replay past abort events to listeners registered after the abort, so we
+ * inspect `signal.aborted` synchronously and reject with the sentinel
+ * before installing the listener. The rejection is still attributed to the
+ * abort path via the sentinel-identity check.
+ *
+ * Distinguishing the rejection source is load-bearing for AC-ERR4
+ * (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).
+ * The semantically equivalent `abortable(signal)` helper in
+ * `@prisma-next/utils` rejects with `signal.reason ?? new DOMException(...)`,
+ * which is not stably distinguishable from a codec-thrown error by identity
+ * alone (a fresh fallback DOMException is allocated per call). We instead
+ * track abort attribution with a unique sentinel: only the `onAbort` listener
+ * installed here ever rejects with the sentinel, so an `error === sentinel`
+ * identity check after the race is unambiguous.
+ *
+ * Lives in `framework-components` (rather than the SQL family, where it
+ * originated in m2) so every family runtime that needs cooperative
+ * cancellation around a codec-dispatch `Promise.all` (SQL encode + decode
+ * today, Mongo encode in m3) shares the same attribution logic.
+ */
+declare function raceAgainstAbort<T>(work: Promise<T>, signal: AbortSignal | undefined, phase: RuntimeAbortedPhase): Promise<T>;
+//#endregion
+//#region src/execution/runtime-middleware.d.ts
 interface RuntimeLog {
   info(event: unknown): void;
   warn(event: unknown): void;
   error(event: unknown): void;
   debug?(event: unknown): void;
 }
+/**
+ * Per-execute context threaded through every middleware phase
+ * (`beforeExecute`, `onRow`, `afterExecute`). Allocated once per
+ * `runtime.execute()` call and shared by reference across all
+ * middleware in the chain.
+ *
+ * - `signal` carries the per-query `AbortSignal` -- the same
+ *   reference that `runtime.execute(plan, { signal })` was invoked
+ *   with, and the same reference threaded into the per-call
+ *   `CodecCallContext` (ADR 207). Middleware that wraps a
+ *   network-backed SDK forwards `ctx.signal` into that SDK to
+ *   propagate caller cancellation; pure-CPU middleware ignores it.
+ *
+ * Symmetric plumbing across all middleware phases (rather than only
+ * `beforeExecute`) is a deliberate choice: a middleware that wraps a
+ * downstream observability hook or post-processor in `afterExecute` /
+ * `onRow` needs the same cancellation reach as its `beforeExecute`
+ * counterpart.
+ */
 interface RuntimeMiddlewareContext {
   readonly contract: unknown;
   readonly mode: 'strict' | 'permissive';
   readonly now: () => number;
   readonly log: RuntimeLog;
+  /**
+   * Returns a stable string identifying the (storage, statement, params)
+   * tuple of an execution. Two semantically equivalent executions return
+   * the same string. Used by middleware that need per-execution identity
+   * (caching, request coalescing).
+   *
+   * The family runtime owns the implementation:
+   * - SQL: `meta.storageHash` + `exec.sql` + `canonicalStringify(exec.params)`
+   * - Mongo: `meta.storageHash` + `canonicalStringify({ ...exec.command })`
+   *
+   * The method is `async` because the underlying digest helper
+   * (`hashContent`) uses the WebCrypto API, whose `crypto.subtle.digest`
+   * primitive is asynchronous by design.
+   *
+   * The returned string is intended to be consumed directly as a `Map` key
+   * — it is not (and should not be) further hashed by callers.
+   */
+  contentHash(exec: ExecutionPlan): Promise<string>;
+  /**
+   * Per-execute cancellation signal threaded through every middleware
+   * phase. Middleware that wraps async work or downstream cancellable
+   * primitives should observe this and abort early when the consumer
+   * cancels.
+   */
+  readonly signal?: AbortSignal;
 }
 interface AfterExecuteResult {
   readonly rowCount: number;
   readonly latencyMs: number;
   readonly completed: boolean;
+  /**
+   * Indicates where the rows observed during this execution came from.
+   *
+   * - `'driver'` — the default. Rows came from the underlying driver via
+   *   `runDriver` / `runWithMiddleware`'s normal path.
+   * - `'middleware'` — a `RuntimeMiddleware.intercept` hook short-circuited
+   *   execution and supplied the rows directly. The driver was not invoked.
+   *
+   * Observers (telemetry, lints, budgets) that need to distinguish between
+   * driver-served and middleware-served executions read this field.
+   * Observers that don't care can ignore it.
+   */
+  readonly source: 'driver' | 'middleware';
+}
+/**
+ * Result of a successful `RuntimeMiddleware.intercept` hook.
+ *
+ * Carries the rows that the middleware wishes to return in place of
+ * invoking the driver. The runtime iterates `rows` in order and yields
+ * each row to the consumer; `beforeExecute`, `runDriver`, and `onRow` are
+ * all skipped on the hit path. `afterExecute` still fires with
+ * `source: 'middleware'`.
+ *
+ * `rows` accepts both `Iterable` (arrays, sync generators) and
+ * `AsyncIterable` (async generators). `for await` natively handles both
+ * via `Symbol.asyncIterator` / `Symbol.iterator` fallback, so the
+ * orchestrator does not need to branch on the variant. Cached arrays in
+ * the cache middleware are the common case; streaming variants support
+ * future use cases like mock layers replaying recordings.
+ *
+ * Row shape is `Record<string, unknown>` — the same untyped shape
+ * `onRow` receives. The SQL runtime decodes intercepted rows through its
+ * normal codec pass, so interceptors cache and return raw (undecoded)
+ * rows.
+ */
+interface InterceptResult {
+  readonly rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>;
 }
+/**
+ * Marker interface for family-specific param-ref mutators threaded into
+ * `beforeExecute` as the third argument. The framework treats the mutator
+ * opaquely — it allocates and forwards the family's mutator instance so
+ * `runWithMiddleware` can stay family-agnostic. SQL extends this with
+ * `SqlParamRefMutator` (over `ParamRef`); Mongo extends with
+ * `MongoParamRefMutator` (over `MongoParamRef`).
+ *
+ * Extension authors target the family-specific mutator type, not this
+ * marker.
+ */
+declare const PARAM_REF_MUTATOR_BRAND: unique symbol;
+type ParamRefMutator = {
+  readonly [PARAM_REF_MUTATOR_BRAND]?: never;
+};
 /**
  * Family-agnostic middleware SPI parameterized over the plan marker.
  *
@@ -88,15 +274,56 @@ interface AfterExecuteResult {
  * middleware (e.g. cross-family telemetry) can be authored without
  * naming a family. Family-specific middleware (`SqlMiddleware`,
  * `MongoMiddleware`) narrow `TPlan` to their concrete plan type.
+ *
+ * `TMutator` is the family-specific {@link ParamRefMutator} the runtime
+ * threads into `beforeExecute(plan, ctx, params)` as a third argument.
+ * Existing `(plan)` / `(plan, ctx)` middleware bodies continue to compile
+ * — TypeScript permits assigning a function with fewer parameters to a
+ * function-typed slot that declares more. The third arg is additive.
  */
-interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan> {
+interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan, TMutator extends ParamRefMutator = ParamRefMutator> {
   readonly name: string;
   readonly familyId?: string;
   readonly targetId?: string;
-  beforeExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;
+  /**
+   * Optional short-circuit hook. Runs inside `runWithMiddleware`, after
+   * the orchestrator receives the lowered plan and before any
+   * `beforeExecute` hook fires. Middleware run in registration order; the
+   * first to return a non-`undefined` `InterceptResult` wins, and
+   * subsequent middleware's `intercept` does not fire.
+   *
+   * On a hit, `beforeExecute`, `runDriver`, and `onRow` are all skipped.
+   * `afterExecute` still fires with `source: 'middleware'`.
+   *
+   * Returning `undefined` (or omitting the hook entirely) signals
+   * passthrough — execution proceeds through the normal driver path.
+   *
+   * Errors thrown inside `intercept` are rethrown by `runWithMiddleware`
+   * as the original `Error` — no envelope is guaranteed at this layer.
+   * Before rethrowing, `afterExecute` fires with `completed: false` and
+   * `source: 'middleware'`. Errors thrown by `afterExecute` during the
+   * error path remain swallowed (existing semantics, unchanged).
+   *
+   * Used by middleware that need to short-circuit execution and supply
+   * rows directly: caching, mocks, rate limiting, circuit breaking.
+   */
+  intercept?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<InterceptResult | undefined>;
+  beforeExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext, params?: TMutator): void | Promise<void>;
   onRow?(row: Record<string, unknown>, plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;
   afterExecute?(plan: TPlan, result: AfterExecuteResult, ctx: RuntimeMiddlewareContext): Promise<void>;
 }
+/**
+ * Optional per-`execute` options accepted by every family runtime.
+ *
+ * `signal` is the per-query cancellation signal. The runtime threads the
+ * signal through to every codec call for the query and uses it to short-
+ * circuit the row stream with `RUNTIME.ABORTED` when the caller aborts.
+ * Omitting the option (or passing `undefined`) preserves today's behavior
+ * bit-for-bit.
+ */
+interface RuntimeExecuteOptions {
+  readonly signal?: AbortSignal;
+}
 /**
  * Cross-family SPI for any runtime that can execute plans and be shut down.
  * Each family runtime (SQL, Mongo) satisfies this interface — SQL nominally,
@@ -108,33 +335,50 @@ interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan> {
 interface RuntimeExecutor<TPlan extends QueryPlan> {
   execute<Row>(plan: TPlan & {
     readonly _row?: Row;
-  }): AsyncIterableResult<Row>;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
   close(): Promise<void>;
 }
 declare function checkMiddlewareCompatibility(middleware: RuntimeMiddleware, runtimeFamilyId: string, runtimeTargetId: string): void;
 //#endregion
-//#region src/run-with-middleware.d.ts
+//#region src/execution/run-with-middleware.d.ts
 /**
  * Drives a single execution of `runDriver()` through the middleware lifecycle.
  *
  * Lifecycle, in order:
- *  1. For each middleware in registration order: `beforeExecute(exec, ctx)`.
- *  2. For each row yielded by `runDriver()`: for each middleware in registration
- *     order: `onRow(row, exec, ctx)`; then yield the row to the consumer.
- *  3. On successful completion: for each middleware in registration order:
- *     `afterExecute(exec, { rowCount, latencyMs, completed: true }, ctx)`.
- *  4. On any error thrown by the driver loop: for each middleware in
+ *  1. For each middleware in registration order: `intercept(exec, ctx)`. The
+ *     first non-`undefined` result wins; subsequent middleware's `intercept`
+ *     does not fire. On a hit, the runtime emits a `middleware.intercept`
+ *     debug event naming the winning middleware, switches the row source to
+ *     the intercepted rows, and proceeds with `source: 'middleware'`. On
+ *     all-passthrough (every `intercept` returns `undefined` or is omitted),
+ *     `source: 'driver'` is used and the row source is `runDriver()`.
+ *  2. If `source === 'driver'`: for each middleware in registration order,
+ *     `beforeExecute(exec, ctx)`. Skipped on the intercepted hit path —
+ *     `beforeExecute` semantically means "about to hit the driver".
+ *  3. Iterate the row source. On the driver path, for each row, for each
+ *     middleware in registration order: `onRow(row, exec, ctx)`; then yield
+ *     the row. On the intercepted hit path, `onRow` is skipped — intercepted
+ *     rows did not originate from a driver row stream — but rows are still
+ *     yielded to the consumer in order.
+ *  4. On successful completion: for each middleware in registration order:
+ *     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },
+ *     ctx)`.
+ *  5. On any error thrown during steps 1–3: for each middleware in
  *     registration order: `afterExecute(exec, { rowCount, latencyMs,
- *     completed: false }, ctx)`. Errors thrown by `afterExecute` during the
- *     error path are swallowed so they do not mask the original driver error.
- *     The original error is then rethrown.
+ *     completed: false, source }, ctx)`. Errors thrown by `afterExecute`
+ *     during the error path are swallowed so they do not mask the original
+ *     error. The original error is then rethrown.
+ *
+ * The `source` field on `AfterExecuteResult` lets observers (telemetry,
+ * lints, budgets) distinguish driver-served from middleware-served
+ * executions without needing their own out-of-band signal.
  *
  * This helper is the single canonical implementation of the middleware
  * orchestration loop; family runtimes should not reimplement it.
  */
-declare function runWithMiddleware<TExec extends ExecutionPlan, Row>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec>>, ctx: RuntimeMiddlewareContext, runDriver: () => AsyncIterable<Row>): AsyncIterableResult<Row>;
+declare function runWithMiddleware<TExec extends ExecutionPlan, Row, TMutator extends ParamRefMutator = ParamRefMutator>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec, TMutator>>, ctx: RuntimeMiddlewareContext, runDriver: () => AsyncIterable<Row>, paramsMutator?: TMutator): AsyncIterableResult<Row>;
 //#endregion
-//#region src/runtime-core.d.ts
+//#region src/execution/runtime-core.d.ts
 /**
  * Constructor options shared by every concrete `RuntimeCore` subclass.
  *
@@ -185,8 +429,16 @@ declare abstract class RuntimeCore<TPlan extends QueryPlan, TExec extends Execut
    * Lower a pre-lowering `TPlan` into the family's executable `TExec`.
    * Family-specific: SQL produces `{ sql, params, ast?, ... }`; Mongo
    * produces `{ command, ... }`.
+   *
+   * `ctx` carries per-query cancellation (and any future fields on
+   * `CodecCallContext`); concrete subclasses forward it to the
+   * encode-side codec dispatch site (e.g. SQL's `encodeParams` in m2,
+   * Mongo's `resolveValue` in m3). The runtime allocates one ctx per
+   * `execute()` call and threads the same reference everywhere; the
+   * `signal` field inside may be `undefined`, but the ctx object itself
+   * is always present.
    */
-  protected abstract lower(plan: TPlan): TExec | Promise<TExec>;
+  protected abstract lower(plan: TPlan, ctx: CodecCallContext): TExec | Promise<TExec>;
   /**
    * Drive the underlying transport for a lowered `TExec`. Yields raw rows
    * directly from the driver as `Record<string, unknown>`; codec decoding
@@ -201,24 +453,8 @@ declare abstract class RuntimeCore<TPlan extends QueryPlan, TExec extends Execut
   abstract close(): Promise<void>;
   execute<Row>(plan: TPlan & {
     readonly _row?: Row;
-  }): AsyncIterableResult<Row>;
-}
-//#endregion
-//#region src/runtime-error.d.ts
-interface RuntimeErrorEnvelope extends Error {
-  readonly code: string;
-  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';
-  readonly severity: 'error';
-  readonly details?: Record<string, unknown>;
+  }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
 }
-/**
- * Type guard for the runtime-error envelope produced by `runtimeError`.
- *
- * Prefer this over duck-typing on `error.code` directly so consumers stay
- * insulated from the envelope's internal shape.
- */
-declare function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope;
-declare function runtimeError(code: string, message: string, details?: Record<string, unknown>): RuntimeErrorEnvelope;
 //#endregion
-export { type AfterExecuteResult, AsyncIterableResult, type ExecutionPlan, type QueryPlan, type ResultType, RuntimeCore, type RuntimeCoreOptions, type RuntimeErrorEnvelope, type RuntimeExecutor, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, checkMiddlewareCompatibility, isRuntimeError, runWithMiddleware, runtimeError };
+export { type AfterExecuteResult, AsyncIterableResult, type ExecutionPlan, type InterceptResult, type ParamRefMutator, type QueryPlan, RUNTIME_ABORTED, type ResultType, type RuntimeAbortedPhase, RuntimeCore, type RuntimeCoreOptions, type RuntimeErrorEnvelope, type RuntimeExecuteOptions, type RuntimeExecutor, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeAborted, runtimeError };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/async-iterable-result.ts","../src/query-plan.ts","../src/runtime-middleware.ts","../src/run-with-middleware.ts","../src/runtime-core.ts","../src/runtime-error.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/execution/async-iterable-result.ts","../src/execution/query-plan.ts","../src/execution/runtime-error.ts","../src/execution/race-against-abort.ts","../src/execution/runtime-middleware.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts"],"mappings":"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"}