@prisma-next/sql-runtime 0.5.0-dev.1 → 0.5.0-dev.2

package/src/middleware/lints.ts

@@ -1,6 +1,5 @@
 import type { ExecutionPlan } from '@prisma-next/contract/types';
 import { runtimeError } from '@prisma-next/framework-components/runtime';
-import type { Middleware, MiddlewareContext } from '@prisma-next/runtime-executor';
 import { evaluateRawGuardrails } from '@prisma-next/runtime-executor';
 import {
   type AnyFromSource,
@@ -8,6 +7,7 @@ import {
   isQueryAst,
 } from '@prisma-next/sql-relational-core/ast';
 import { ifDefined } from '@prisma-next/utils/defined';
+import type { SqlMiddleware, SqlMiddlewareContext } from './sql-middleware';
 
 export interface LintsOptions {
   readonly severities?: {
@@ -138,14 +138,14 @@ function getConfiguredSeverity(code: string, options?: LintsOptions): 'warn' | '
  * Fallback: When ast is missing, `fallbackWhenAstMissing: 'raw'` uses heuristic
  * SQL parsing; `'skip'` skips all lints. Default is `'raw'`.
  */
-export function lints<TContract = unknown>(options?: LintsOptions): Middleware<TContract> {
+export function lints(options?: LintsOptions): SqlMiddleware {
   const fallback = options?.fallbackWhenAstMissing ?? 'raw';
 
   return Object.freeze({
     name: 'lints',
     familyId: 'sql' as const,
 
-    async beforeExecute(plan: ExecutionPlan, ctx: MiddlewareContext<TContract>) {
+    async beforeExecute(plan: ExecutionPlan, ctx: SqlMiddlewareContext) {
       if (isQueryAst(plan.ast)) {
         const findings = evaluateAstLints(plan.ast);
 

package/src/middleware/sql-middleware.ts

@@ -1,17 +1,46 @@
-import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
+import type { Contract, ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
 import type {
   AfterExecuteResult,
   RuntimeMiddleware,
   RuntimeMiddlewareContext,
 } from '@prisma-next/framework-components/runtime';
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { AnyQueryAst } from '@prisma-next/sql-relational-core/ast';
 
 export interface SqlMiddlewareContext extends RuntimeMiddlewareContext {
   readonly contract: Contract<SqlStorage>;
 }
 
+/**
+ * Pre-lowering query view passed to `beforeCompile`. Carries the typed SQL
+ * AST and plan metadata; `sql`/`params` are produced later by the adapter.
+ */
+export interface DraftPlan {
+  readonly ast: AnyQueryAst;
+  readonly meta: PlanMeta;
+}
+
 export interface SqlMiddleware extends RuntimeMiddleware {
-  readonly familyId: 'sql';
+  readonly familyId?: 'sql';
+  /**
+   * Rewrite the query AST before it is lowered to SQL. Middlewares run in
+   * registration order; each sees the predecessor's output, so rewrites
+   * compose (e.g. soft-delete + tenant isolation).
+   *
+   * Return `undefined` (or a draft whose `ast` reference equals the input's)
+   * to pass through. Return a draft with a new `ast` reference to replace it;
+   * the runtime emits a `middleware.rewrite` debug log event and continues
+   * with the new draft. `adapter.lower()` runs once after the chain.
+   *
+   * Use `AstRewriter` / `SelectAst.withWhere` / `AndExpr.of` etc. to build
+   * the rewritten AST. Predicates and literals go through parameterized
+   * constructors by default — no SQL-injection surface is added. **Warning:**
+   * constructing `LiteralExpr.of(userInput)` from untrusted input bypasses
+   * that guarantee; use `ParamRef.of(userInput, ...)` instead.
+   *
+   * See `docs/architecture docs/subsystems/4. Runtime & Middleware Framework.md`.
+   */
+  beforeCompile?(draft: DraftPlan, ctx: SqlMiddlewareContext): Promise<DraftPlan | undefined>;
   beforeExecute?(plan: ExecutionPlan, ctx: SqlMiddlewareContext): Promise<void>;
   onRow?(
     row: Record<string, unknown>,

package/src/sql-runtime.ts

@@ -6,7 +6,6 @@ import type {
 import { checkMiddlewareCompatibility } from '@prisma-next/framework-components/runtime';
 import type {
   Log,
-  Middleware,
   RuntimeCore,
   RuntimeCoreOptions,
   RuntimeTelemetryEvent,
@@ -33,6 +32,8 @@ import { decodeRow } from './codecs/decoding';
 import { encodeParams } from './codecs/encoding';
 import { validateCodecRegistryCompleteness } from './codecs/validation';
 import { lowerSqlPlan } from './lower-sql-plan';
+import { runBeforeCompileChain } from './middleware/before-compile-chain';
+import type { SqlMiddleware } from './middleware/sql-middleware';
 import type {
   ExecutionContext,
   SqlRuntimeAdapterInstance,
@@ -45,7 +46,7 @@ export interface RuntimeOptions<TContract extends Contract<SqlStorage> = Contrac
   readonly adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
   readonly driver: SqlDriver<unknown>;
   readonly verify: RuntimeVerifyOptions;
-  readonly middleware?: readonly Middleware<TContract>[];
+  readonly middleware?: readonly SqlMiddleware[];
   readonly mode?: 'strict' | 'permissive';
   readonly log?: Log;
 }
@@ -64,7 +65,7 @@ export interface CreateRuntimeOptions<
   readonly context: ExecutionContext<TContract>;
   readonly driver: SqlDriver<unknown>;
   readonly verify: RuntimeVerifyOptions;
-  readonly middleware?: readonly Middleware<TContract>[];
+  readonly middleware?: readonly SqlMiddleware[];
   readonly mode?: 'strict' | 'permissive';
   readonly log?: Log;
 }
@@ -125,7 +126,7 @@ export type { RuntimeTelemetryEvent, RuntimeVerifyOptions, TelemetryOutcome };
 class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>
   implements Runtime
 {
-  private readonly core: RuntimeCore<TContract, SqlDriver<unknown>>;
+  private readonly core: RuntimeCore<TContract, SqlDriver<unknown>, SqlMiddleware>;
   private readonly contract: TContract;
   private readonly adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
   private readonly codecRegistry: CodecRegistry;
@@ -148,7 +149,7 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
 
     const familyAdapter = new SqlFamilyAdapter(context.contract, adapter.profile);
 
-    const coreOptions: RuntimeCoreOptions<TContract, SqlDriver<unknown>> = {
+    const coreOptions: RuntimeCoreOptions<TContract, SqlDriver<unknown>, SqlMiddleware> = {
       familyAdapter,
       driver,
       verify,
@@ -172,12 +173,27 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
     }
   }
 
-  private toExecutionPlan<Row>(plan: ExecutionPlan<Row> | SqlQueryPlan<Row>): ExecutionPlan<Row> {
+  private async toExecutionPlan<Row>(
+    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+  ): Promise<ExecutionPlan<Row>> {
     const isSqlQueryPlan = (p: ExecutionPlan<Row> | SqlQueryPlan<Row>): p is SqlQueryPlan<Row> => {
       return 'ast' in p && !('sql' in p);
     };
 
-    return isSqlQueryPlan(plan) ? lowerSqlPlan(this.adapter, this.contract, plan) : plan;
+    if (!isSqlQueryPlan(plan)) {
+      return plan;
+    }
+
+    const rewrittenDraft = await runBeforeCompileChain(
+      this.core.middleware,
+      { ast: plan.ast, meta: plan.meta },
+      this.core.middlewareContext,
+    );
+
+    const planToLower: SqlQueryPlan<Row> =
+      rewrittenDraft.ast === plan.ast ? plan : { ...plan, ast: rewrittenDraft.ast };
+
+    return lowerSqlPlan(this.adapter, this.contract, planToLower);
   }
 
   private executeAgainstQueryable<Row = Record<string, unknown>>(
@@ -185,11 +201,11 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
     queryable: CoreQueryable,
   ): AsyncIterableResult<Row> {
     this.ensureCodecRegistryValidated(this.contract);
-    const executablePlan = this.toExecutionPlan(plan);
 
     const iterator = async function* (
       self: SqlRuntimeImpl<TContract>,
     ): AsyncGenerator<Row, void, unknown> {
+      const executablePlan = await self.toExecutionPlan(plan);
       const encodedParams = encodeParams(executablePlan, self.codecRegistry);
       const planWithEncodedParams: ExecutionPlan<Row> = {
         ...executablePlan,

package/test/before-compile-chain.test.ts

@@ -0,0 +1,223 @@
+import type { Contract, PlanMeta } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import {
+  AndExpr,
+  BinaryExpr,
+  ColumnRef,
+  LiteralExpr,
+  SelectAst,
+  TableSource,
+} from '@prisma-next/sql-relational-core/ast';
+import { timeouts } from '@prisma-next/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+import { runBeforeCompileChain } from '../src/middleware/before-compile-chain';
+import type {
+  DraftPlan,
+  SqlMiddleware,
+  SqlMiddlewareContext,
+} from '../src/middleware/sql-middleware';
+
+function createContext(): SqlMiddlewareContext & {
+  log: { debug: ReturnType<typeof vi.fn> };
+} {
+  const debug = vi.fn();
+  return {
+    contract: {} as Contract<SqlStorage>,
+    mode: 'strict' as const,
+    now: () => 0,
+    log: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug,
+    },
+  };
+}
+
+const meta: PlanMeta = {
+  target: 'postgres',
+  storageHash: 'sha256:test',
+  lane: 'dsl',
+  paramDescriptors: [],
+};
+
+function createDraft(): DraftPlan {
+  const users = TableSource.named('users');
+  return {
+    ast: SelectAst.from(users).withProjection([]),
+    meta,
+  };
+}
+
+describe('runBeforeCompileChain', () => {
+  it(
+    'returns the initial draft unchanged when no middleware rewrites',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const mw: SqlMiddleware = {
+        name: 'noop',
+        familyId: 'sql',
+        async beforeCompile() {
+          return undefined;
+        },
+      };
+
+      const result = await runBeforeCompileChain([mw], draft, ctx);
+
+      expect(result).toBe(draft);
+      expect(ctx.log.debug).not.toHaveBeenCalled();
+    },
+    timeouts.default,
+  );
+
+  it(
+    'treats a returned draft with same ast reference as passthrough',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const mw: SqlMiddleware = {
+        name: 'sameRef',
+        familyId: 'sql',
+        async beforeCompile(d) {
+          return { ...d };
+        },
+      };
+
+      const result = await runBeforeCompileChain([mw], draft, ctx);
+
+      expect(result.ast).toBe(draft.ast);
+      expect(ctx.log.debug).not.toHaveBeenCalled();
+    },
+    timeouts.default,
+  );
+
+  it(
+    'replaces the current draft when a middleware returns a new ast ref',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const addWhere = BinaryExpr.eq(ColumnRef.of('users', 'deleted_at'), LiteralExpr.of(null));
+      const mw: SqlMiddleware = {
+        name: 'softDelete',
+        familyId: 'sql',
+        async beforeCompile(d) {
+          if (d.ast.kind !== 'select') return;
+          return { ...d, ast: d.ast.withWhere(addWhere) };
+        },
+      };
+
+      const result = await runBeforeCompileChain([mw], draft, ctx);
+
+      expect(result.ast).not.toBe(draft.ast);
+      expect(result.ast.kind).toBe('select');
+      expect((result.ast as SelectAst).where).toBe(addWhere);
+    },
+    timeouts.default,
+  );
+
+  it(
+    'chains rewrites in registration order',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const order: string[] = [];
+
+      const predA = BinaryExpr.eq(ColumnRef.of('users', 'a'), LiteralExpr.of(1));
+      const predB = BinaryExpr.eq(ColumnRef.of('users', 'b'), LiteralExpr.of(2));
+
+      const mwA: SqlMiddleware = {
+        name: 'addA',
+        familyId: 'sql',
+        async beforeCompile(d) {
+          order.push('A');
+          if (d.ast.kind !== 'select') return;
+          return { ...d, ast: d.ast.withWhere(predA) };
+        },
+      };
+      const mwB: SqlMiddleware = {
+        name: 'addB',
+        familyId: 'sql',
+        async beforeCompile(d) {
+          order.push('B');
+          if (d.ast.kind !== 'select') return;
+          const current = d.ast.where;
+          const combined = current ? AndExpr.of([current, predB]) : predB;
+          return { ...d, ast: d.ast.withWhere(combined) };
+        },
+      };
+
+      const result = await runBeforeCompileChain([mwA, mwB], draft, ctx);
+
+      expect(order).toEqual(['A', 'B']);
+      expect(result.ast.kind).toBe('select');
+      const where = (result.ast as SelectAst).where;
+      expect(where?.kind).toBe('and');
+    },
+    timeouts.default,
+  );
+
+  it(
+    'emits a debug log event per rewrite with middleware name and lane',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const pred = BinaryExpr.eq(ColumnRef.of('users', 'a'), LiteralExpr.of(1));
+      const mw: SqlMiddleware = {
+        name: 'rewriteOne',
+        familyId: 'sql',
+        async beforeCompile(d) {
+          if (d.ast.kind !== 'select') return;
+          return { ...d, ast: d.ast.withWhere(pred) };
+        },
+      };
+
+      await runBeforeCompileChain([mw, mw], draft, ctx);
+
+      expect(ctx.log.debug).toHaveBeenCalledTimes(2);
+      expect(ctx.log.debug).toHaveBeenCalledWith({
+        event: 'middleware.rewrite',
+        middleware: 'rewriteOne',
+        lane: 'dsl',
+      });
+    },
+    timeouts.default,
+  );
+
+  it(
+    'skips middleware without beforeCompile',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const observerOnly: SqlMiddleware = {
+        name: 'observer',
+        familyId: 'sql',
+        async beforeExecute() {},
+      };
+
+      const result = await runBeforeCompileChain([observerOnly], draft, ctx);
+
+      expect(result).toBe(draft);
+      expect(ctx.log.debug).not.toHaveBeenCalled();
+    },
+    timeouts.default,
+  );
+
+  it(
+    'propagates errors thrown inside beforeCompile',
+    async () => {
+      const draft = createDraft();
+      const ctx = createContext();
+      const mw: SqlMiddleware = {
+        name: 'thrower',
+        familyId: 'sql',
+        async beforeCompile() {
+          throw new Error('boom');
+        },
+      };
+
+      await expect(runBeforeCompileChain([mw], draft, ctx)).rejects.toThrow('boom');
+    },
+    timeouts.default,
+  );
+});

package/test/budgets.test.ts

@@ -1,5 +1,6 @@
-import type { ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
-import type { AfterExecuteResult, MiddlewareContext } from '@prisma-next/runtime-executor';
+import type { Contract, ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
+import type { AfterExecuteResult } from '@prisma-next/runtime-executor';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   AggregateExpr,
   ColumnRef,
@@ -11,15 +12,14 @@ import {
 import { timeouts } from '@prisma-next/test-utils';
 import { describe, expect, it, vi } from 'vitest';
 import { budgets } from '../src/middleware/budgets';
+import type { SqlMiddlewareContext } from '../src/middleware/sql-middleware';
 
 const userTable = TableSource.named('user');
 const idCol = ColumnRef.of('user', 'id');
 
-function createMiddlewareContext(
-  overrides?: Partial<MiddlewareContext<unknown>>,
-): MiddlewareContext<unknown> {
+function createMiddlewareContext(overrides?: Partial<SqlMiddlewareContext>): SqlMiddlewareContext {
   return {
-    contract: {},
+    contract: {} as Contract<SqlStorage>,
     mode: 'strict' as const,
     now: () => Date.now(),
     log: {

package/test/lints.test.ts

@@ -1,5 +1,5 @@
-import type { ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
-import type { MiddlewareContext } from '@prisma-next/runtime-executor';
+import type { Contract, ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import {
   BinaryExpr,
   ColumnRef,
@@ -14,10 +14,11 @@ import {
 import { timeouts } from '@prisma-next/test-utils';
 import { describe, expect, it, vi } from 'vitest';
 import { lints } from '../src/middleware/lints';
+import type { SqlMiddlewareContext } from '../src/middleware/sql-middleware';
 
-function createMiddlewareContext(): MiddlewareContext<unknown> {
+function createMiddlewareContext(): SqlMiddlewareContext {
   return {
-    contract: {},
+    contract: {} as Contract<SqlStorage>,
     mode: 'strict' as const,
     now: () => Date.now(),
     log: {

package/test/sql-runtime.test.ts

@@ -9,12 +9,21 @@ import {
 import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   CodecRegistry,
-  SelectAst,
   SqlDriver,
   SqlExecuteRequest,
 } from '@prisma-next/sql-relational-core/ast';
-import { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import {
+  BinaryExpr,
+  ColumnRef,
+  codec,
+  createCodecRegistry,
+  LiteralExpr,
+  SelectAst,
+  TableSource,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
 import { describe, expect, it, vi } from 'vitest';
+import type { SqlMiddleware } from '../src/middleware/sql-middleware';
 import type {
   SqlRuntimeAdapterDescriptor,
   SqlRuntimeAdapterInstance,
@@ -380,18 +389,167 @@ describe('createRuntime', () => {
 
   it('rejects a Mongo middleware with a clear error', () => {
     const { stackInstance, context, driver } = createTestSetup();
+    // Simulate a caller bypassing the SqlMiddleware type constraint (e.g. dynamically-loaded
+    // middleware). Static typing already rejects familyId: 'mongo'; this tests the runtime guard.
+    const mongoMiddleware = { name: 'mongo-mw', familyId: 'mongo' } as unknown as SqlMiddleware;
     expect(() =>
       createRuntime({
         stackInstance,
         context,
         driver,
         verify: { mode: 'onFirstUse', requireMarker: false },
-        middleware: [{ name: 'mongo-mw', familyId: 'mongo' }],
+        middleware: [mongoMiddleware],
       }),
     ).toThrow(
       "Middleware 'mongo-mw' requires family 'mongo' but the runtime is configured for family 'sql'",
     );
   });
+
+  it('invokes beforeCompile and lowers the rewritten AST', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+    const debug = vi.fn();
+    const softDeletePredicate = BinaryExpr.eq(
+      ColumnRef.of('users', 'deleted_at'),
+      LiteralExpr.of(null),
+    );
+    const softDelete: SqlMiddleware = {
+      name: 'softDelete',
+      familyId: 'sql',
+      async beforeCompile(draft) {
+        if (draft.ast.kind !== 'select') return;
+        return { ...draft, ast: draft.ast.withWhere(softDeletePredicate) };
+      },
+    };
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+      middleware: [softDelete],
+      log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug },
+    });
+
+    const queryPlan: SqlQueryPlan = {
+      ast: SelectAst.from(TableSource.named('users')).withProjection([]),
+      params: [],
+      meta: {
+        target: 'postgres',
+        storageHash: testContract.storage.storageHash,
+        lane: 'dsl',
+        paramDescriptors: [],
+      },
+    };
+
+    await runtime.execute(queryPlan).toArray();
+
+    expect(driver.__spies.rootExecute).toHaveBeenCalledTimes(1);
+    const request = driver.__spies.rootExecute.mock.calls[0]?.[0] as SqlExecuteRequest;
+    expect(request.sql).toContain('deleted_at');
+    expect(debug).toHaveBeenCalledWith({
+      event: 'middleware.rewrite',
+      middleware: 'softDelete',
+      lane: 'dsl',
+    });
+  });
+
+  it('invokes adapter.lower exactly once per execute regardless of chain length', async () => {
+    const adapter = createStubAdapter();
+    const lowerSpy = vi.spyOn(adapter, 'lower');
+    const driver = createMockDriver();
+
+    const targetDescriptor = createTestTargetDescriptor();
+    const adapterDescriptor = createTestAdapterDescriptor(adapter);
+    const stack = createSqlExecutionStack({
+      target: targetDescriptor,
+      adapter: adapterDescriptor,
+      extensionPacks: [],
+    });
+    const stackInstance = instantiateExecutionStack(stack) as ExecutionStackInstance<
+      'sql',
+      'postgres',
+      SqlRuntimeAdapterInstance<'postgres'>,
+      RuntimeDriverInstance<'sql', 'postgres'>,
+      RuntimeExtensionInstance<'sql', 'postgres'>
+    >;
+    const context = createExecutionContext({
+      contract: testContract,
+      stack: { target: targetDescriptor, adapter: adapterDescriptor, extensionPacks: [] },
+    });
+
+    const rewriteA: SqlMiddleware = {
+      name: 'rewriteA',
+      familyId: 'sql',
+      async beforeCompile(draft) {
+        if (draft.ast.kind !== 'select') return undefined;
+        return {
+          ...draft,
+          ast: draft.ast.withWhere(BinaryExpr.eq(ColumnRef.of('users', 'a'), LiteralExpr.of(1))),
+        };
+      },
+    };
+    const rewriteB: SqlMiddleware = {
+      name: 'rewriteB',
+      familyId: 'sql',
+      async beforeCompile(draft) {
+        if (draft.ast.kind !== 'select') return undefined;
+        return {
+          ...draft,
+          ast: draft.ast.withWhere(BinaryExpr.eq(ColumnRef.of('users', 'b'), LiteralExpr.of(2))),
+        };
+      },
+    };
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+      middleware: [rewriteA, rewriteB],
+    });
+
+    const queryPlan: SqlQueryPlan = {
+      ast: SelectAst.from(TableSource.named('users')).withProjection([]),
+      params: [],
+      meta: {
+        target: 'postgres',
+        storageHash: testContract.storage.storageHash,
+        lane: 'dsl',
+        paramDescriptors: [],
+      },
+    };
+
+    await runtime.execute(queryPlan).toArray();
+
+    expect(lowerSpy).toHaveBeenCalledTimes(1);
+    const loweredAst = lowerSpy.mock.calls[0]?.[0] as SelectAst;
+    expect(loweredAst.where?.kind).toBe('binary');
+  });
+
+  it('skips beforeCompile for raw execution plans with no AST', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+    const debug = vi.fn();
+    const beforeCompile = vi.fn();
+    const observer: SqlMiddleware = {
+      name: 'observer',
+      familyId: 'sql',
+      beforeCompile,
+    };
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+      middleware: [observer],
+      log: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug },
+    });
+
+    await runtime.execute(createRawExecutionPlan()).toArray();
+
+    expect(beforeCompile).not.toHaveBeenCalled();
+    expect(debug).not.toHaveBeenCalled();
+  });
 });
 
 describe('withTransaction', () => {