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

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

@@ -0,0 +1,28 @@
+import type { DraftPlan, SqlMiddleware, SqlMiddlewareContext } from './sql-middleware';
+
+export async function runBeforeCompileChain(
+  middleware: readonly SqlMiddleware[],
+  initial: DraftPlan,
+  ctx: SqlMiddlewareContext,
+): Promise<DraftPlan> {
+  let current = initial;
+  for (const mw of middleware) {
+    if (!mw.beforeCompile) {
+      continue;
+    }
+    const result = await mw.beforeCompile(current, ctx);
+    if (result === undefined) {
+      continue;
+    }
+    if (result.ast === current.ast) {
+      continue;
+    }
+    ctx.log.debug?.({
+      event: 'middleware.rewrite',
+      middleware: mw.name,
+      lane: current.meta.lane,
+    });
+    current = result;
+  }
+  return current;
+}

package/src/middleware/budgets.ts

@@ -1,11 +1,8 @@
 import type { ExecutionPlan } from '@prisma-next/contract/types';
 import { type RuntimeErrorEnvelope, runtimeError } from '@prisma-next/framework-components/runtime';
-import type {
-  AfterExecuteResult,
-  Middleware,
-  MiddlewareContext,
-} from '@prisma-next/runtime-executor';
+import type { AfterExecuteResult } from '@prisma-next/runtime-executor';
 import { isQueryAst, type SelectAst } from '@prisma-next/sql-relational-core/ast';
+import type { SqlMiddleware, SqlMiddlewareContext } from './sql-middleware';
 
 export interface BudgetsOptions {
   readonly maxRows?: number;
@@ -77,7 +74,7 @@ function hasDetectableLimitFromHeuristics(plan: ExecutionPlan): boolean {
 function emitBudgetViolation(
   error: RuntimeErrorEnvelope,
   shouldBlock: boolean,
-  ctx: MiddlewareContext<unknown>,
+  ctx: SqlMiddlewareContext,
 ): void {
   if (shouldBlock) {
     throw error;
@@ -89,7 +86,7 @@ function emitBudgetViolation(
   });
 }
 
-export function budgets<TContract = unknown>(options?: BudgetsOptions): Middleware<TContract> {
+export function budgets(options?: BudgetsOptions): SqlMiddleware {
   const maxRows = options?.maxRows ?? 10_000;
   const defaultTableRows = options?.defaultTableRows ?? 10_000;
   const tableRows = options?.tableRows ?? {};
@@ -102,7 +99,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
     name: 'budgets',
     familyId: 'sql' as const,
 
-    async beforeExecute(plan: ExecutionPlan, ctx: MiddlewareContext<TContract>) {
+    async beforeExecute(plan: ExecutionPlan, ctx: SqlMiddlewareContext) {
       observedRowsByPlan.set(plan, { count: 0 });
 
       if (isQueryAst(plan.ast)) {
@@ -115,11 +112,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
       return evaluateWithHeuristics(plan, ctx);
     },
 
-    async onRow(
-      _row: Record<string, unknown>,
-      plan: ExecutionPlan,
-      _ctx: MiddlewareContext<TContract>,
-    ) {
+    async onRow(_row: Record<string, unknown>, plan: ExecutionPlan, _ctx: SqlMiddlewareContext) {
       const state = observedRowsByPlan.get(plan);
       if (!state) return;
       state.count += 1;
@@ -135,7 +128,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
     async afterExecute(
       _plan: ExecutionPlan,
       result: AfterExecuteResult,
-      ctx: MiddlewareContext<TContract>,
+      ctx: SqlMiddlewareContext,
     ) {
       const latencyMs = result.latencyMs;
       if (latencyMs > maxLatencyMs) {
@@ -146,17 +139,13 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
             maxLatencyMs,
           }),
           shouldBlock,
-          ctx as MiddlewareContext<unknown>,
+          ctx,
         );
       }
     },
   });
 
-  function evaluateSelectAst(
-    plan: ExecutionPlan,
-    ast: SelectAst,
-    ctx: MiddlewareContext<TContract>,
-  ) {
+  function evaluateSelectAst(plan: ExecutionPlan, ast: SelectAst, ctx: SqlMiddlewareContext) {
     const hasAggNoGroup = hasAggregateWithoutGroupBy(ast);
     const estimated = estimateRowsFromAst(
       ast,
@@ -177,7 +166,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
             maxRows,
           }),
           shouldBlock,
-          ctx as MiddlewareContext<unknown>,
+          ctx,
         );
         return;
       }
@@ -188,7 +177,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
           maxRows,
         }),
         shouldBlock,
-        ctx as MiddlewareContext<unknown>,
+        ctx,
       );
       return;
     }
@@ -201,12 +190,12 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
           maxRows,
         }),
         shouldBlock,
-        ctx as MiddlewareContext<unknown>,
+        ctx,
       );
     }
   }
 
-  async function evaluateWithHeuristics(plan: ExecutionPlan, ctx: MiddlewareContext<TContract>) {
+  async function evaluateWithHeuristics(plan: ExecutionPlan, ctx: SqlMiddlewareContext) {
     const estimated = estimateRowsFromHeuristics(plan, tableRows, defaultTableRows);
     const isUnbounded = !hasDetectableLimitFromHeuristics(plan);
     const sqlUpper = plan.sql.trimStart().toUpperCase();
@@ -222,7 +211,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
             maxRows,
           }),
           shouldBlock,
-          ctx as MiddlewareContext<unknown>,
+          ctx,
         );
         return;
       }
@@ -233,7 +222,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
           maxRows,
         }),
         shouldBlock,
-        ctx as MiddlewareContext<unknown>,
+        ctx,
       );
       return;
     }
@@ -247,7 +236,7 @@ export function budgets<TContract = unknown>(options?: BudgetsOptions): Middlewa
             maxRows,
           }),
           shouldBlock,
-          ctx as MiddlewareContext<unknown>,
+          ctx,
         );
       }
       return;

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/execution-stack.test.ts

@@ -41,10 +41,7 @@ function createStubAdapterDescriptor(): SqlRuntimeAdapterDescriptor<'postgres'>
             readMarkerStatement: () => ({ sql: '', params: [] }),
           },
           lower() {
-            return {
-              profileId: 'test-profile',
-              body: Object.freeze({ sql: '', params: [] }),
-            };
+            return Object.freeze({ sql: '', params: [] });
           },
         },
       );

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: {