@prisma-next/mongo-runtime 0.5.0-dev.4 → 0.5.0-dev.42

package/src/mongo-runtime.ts

@@ -1,115 +1,156 @@
-import type {
-  RuntimeMiddleware,
-  RuntimeMiddlewareContext,
-} from '@prisma-next/framework-components/runtime';
+import type { CodecCallContext } from '@prisma-next/framework-components/codec';
 import {
   AsyncIterableResult,
+  checkAborted,
   checkMiddlewareCompatibility,
+  RuntimeCore,
+  type RuntimeExecuteOptions,
+  runWithMiddleware,
 } from '@prisma-next/framework-components/runtime';
 import type { MongoAdapter, MongoDriver } from '@prisma-next/mongo-lowering';
 import type { MongoQueryPlan } from '@prisma-next/mongo-query-ast/execution';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { decodeMongoRow } from './codecs/decoding';
+import type { MongoExecutionPlan } from './mongo-execution-plan';
+import type { MongoCodecLookup, MongoExecutionContext } from './mongo-execution-stack';
+import type { MongoMiddleware, MongoMiddlewareContext } from './mongo-middleware';
 
 function noop() {}
-function now() {
-  return Date.now();
-}
 
+/**
+ * Mongo runtime options.
+ *
+ * The runtime takes a {@link MongoExecutionContext} (built via
+ * `createMongoExecutionContext`) and a driver. Codec resolution flows from
+ * the context — there is no `codecs` field on this options bag. The adapter
+ * is reached via `context.stack.adapter` (instantiated lazily through the
+ * stack's `create(stack)` factory). See ADR — Mongo result-shape as a
+ * structural plan field, § Codec registry: stack aggregation, not user
+ * threading.
+ */
 export interface MongoRuntimeOptions {
-  readonly adapter: MongoAdapter;
+  readonly context: MongoExecutionContext;
   readonly driver: MongoDriver;
-  readonly contract: unknown;
-  readonly targetId: string;
-  readonly middleware?: readonly RuntimeMiddleware[];
+  readonly middleware?: readonly MongoMiddleware[];
   readonly mode?: 'strict' | 'permissive';
 }
 
 export interface MongoRuntime {
-  execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row>;
+  /**
+   * Execute a `MongoQueryPlan` and return an async iterable of rows.
+   *
+   * The optional `options.signal` is threaded through
+   * `lower → adapter.lower → resolveValue → codec.encode` so codec authors
+   * who forward the signal to their underlying SDK get true cancellation
+   * of in-flight network calls. The runtime additionally observes the
+   * signal at two boundaries:
+   *
+   * - **Already-aborted at entry** — first `next()` throws
+   *   `RUNTIME.ABORTED { phase: 'stream' }` before any work is done.
+   *   (Inherited from `RuntimeCore.execute`.)
+   * - **Mid-encode abort** — surfaces as
+   *   `RUNTIME.ABORTED { phase: 'encode' }` from inside `resolveValue`'s
+   *   per-level `Promise.all` race.
+   *
+   * Mongo's read path decodes rows via `resultShape` (per ADR 209). The
+   * same `CodecCallContext` is forwarded into each `codec.decode(wire, ctx)`
+   * call, so async decoders that respect the signal get cancellation; the
+   * runtime itself does not currently emit a `phase: 'decode'` envelope.
+   */
+  execute<Row>(
+    plan: MongoQueryPlan<Row>,
+    options?: RuntimeExecuteOptions,
+  ): AsyncIterableResult<Row>;
   close(): Promise<void>;
 }
 
-class MongoRuntimeImpl implements MongoRuntime {
+class MongoRuntimeImpl
+  extends RuntimeCore<MongoQueryPlan, MongoExecutionPlan, MongoMiddleware>
+  implements MongoRuntime
+{
   readonly #adapter: MongoAdapter;
   readonly #driver: MongoDriver;
-  readonly #middleware: readonly RuntimeMiddleware[];
-  readonly #middlewareContext: RuntimeMiddlewareContext;
+  readonly #codecs: MongoCodecLookup;
 
   constructor(options: MongoRuntimeOptions) {
-    this.#adapter = options.adapter;
-    this.#driver = options.driver;
-
     const middleware = options.middleware ? [...options.middleware] : [];
+    const targetId = options.context.stack.target.targetId;
     for (const mw of middleware) {
-      checkMiddlewareCompatibility(mw, 'mongo', options.targetId);
+      checkMiddlewareCompatibility(mw, 'mongo', targetId);
     }
-    this.#middleware = middleware;
 
-    this.#middlewareContext = {
-      contract: options.contract,
+    const ctx: MongoMiddlewareContext = {
+      contract: options.context.contract,
       mode: options.mode ?? 'strict',
-      now,
+      now: () => Date.now(),
       log: { info: noop, warn: noop, error: noop },
     };
-  }
-
-  execute<Row>(plan: MongoQueryPlan<Row>): AsyncIterableResult<Row> {
-    const adapter = this.#adapter;
-    const driver = this.#driver;
-    const middleware = this.#middleware;
-    const ctx = this.#middlewareContext;
-
-    const iterator = async function* (): AsyncGenerator<Row, void, unknown> {
-      const startedAt = ctx.now();
-      let rowCount = 0;
-      let completed = false;
-      let failed = false;
-
-      try {
-        for (const mw of middleware) {
-          if (mw.beforeExecute) {
-            await mw.beforeExecute(plan, ctx);
-          }
-        }
 
-        const wireCommand = adapter.lower(plan);
+    super({ middleware, ctx });
 
-        for await (const row of driver.execute<Row>(wireCommand)) {
-          for (const mw of middleware) {
-            if (mw.onRow) {
-              await mw.onRow(row as Record<string, unknown>, plan, ctx);
-            }
-          }
-          rowCount++;
-          yield row;
-        }
+    const adapterDescriptor = options.context.stack.adapter;
+    const adapterInstance = adapterDescriptor.create(options.context.stack);
+    this.#adapter = adapterInstance;
+    this.#driver = options.driver;
+    this.#codecs = options.context.codecs;
+  }
 
-        completed = true;
-      } catch (error) {
-        failed = true;
-        throw error;
-      } finally {
-        const latencyMs = ctx.now() - startedAt;
-        for (const mw of middleware) {
-          if (!mw.afterExecute) continue;
+  protected override async lower(
+    plan: MongoQueryPlan,
+    ctx: CodecCallContext,
+  ): Promise<MongoExecutionPlan> {
+    return {
+      command: await this.#adapter.lower(plan, ctx),
+      meta: plan.meta,
+      ...ifDefined('resultShape', plan.resultShape),
+    };
+  }
 
-          if (failed) {
-            try {
-              await mw.afterExecute(plan, { rowCount, latencyMs, completed }, ctx);
-            } catch {
-              // Ignore errors from afterExecute during error handling
-            }
-            continue;
-          }
+  protected override runDriver(exec: MongoExecutionPlan): AsyncIterable<Record<string, unknown>> {
+    return this.#driver.execute<Record<string, unknown>>(exec.command);
+  }
 
-          await mw.afterExecute(plan, { rowCount, latencyMs, completed }, ctx);
+  override execute<Row>(
+    plan: MongoQueryPlan & { readonly _row?: Row },
+    options?: RuntimeExecuteOptions,
+  ): AsyncIterableResult<Row> {
+    const self = this;
+    const signal = options?.signal;
+    const codecCtx: CodecCallContext = signal === undefined ? {} : { signal };
+    const generator = async function* (): AsyncGenerator<Row, void, unknown> {
+      checkAborted(codecCtx, 'stream');
+      const compiled = await self.runBeforeCompile(plan);
+      const exec = await self.lower(compiled, codecCtx);
+      const stream = runWithMiddleware<MongoExecutionPlan, Record<string, unknown>>(
+        exec,
+        self.middleware,
+        self.ctx,
+        () => self.runDriver(exec),
+      );
+      for await (const rawRow of stream) {
+        if (exec.resultShape === undefined) {
+          yield rawRow as Row;
+        } else {
+          // Source the collection from the lowered exec rather than the
+          // pre-lowering plan: a `runBeforeCompile` middleware is allowed to
+          // rewrite collection names during compilation, and the wire
+          // command carried by `exec` is always authoritative for what just
+          // ran.
+          const decoded = await decodeMongoRow(
+            rawRow,
+            exec.resultShape,
+            self.#codecs,
+            exec.command.collection,
+            codecCtx,
+          );
+          yield decoded as Row;
         }
       }
     };
-
-    return new AsyncIterableResult(iterator());
+    return new AsyncIterableResult(generator());
   }
 
-  async close(): Promise<void> {
+  override async close(): Promise<void> {
     await this.#driver.close();
   }
 }