@prisma-next/sql-runtime 0.5.0-dev.28 → 0.5.0-dev.29

package/dist/test/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport type { ResultType } from '@prisma-next/framework-components/runtime';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlExecutionPlan, SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  parseContractMarkerRow,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array.\n * This helper DRYs up the common pattern of executing plans in tests.\n * The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them.\n * Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: SqlExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker.\n * This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database.\n * This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter.\n * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions\n * derived from the adapter's codec registry.\n */\nexport function createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const codecRegistry = adapter.profile.codecs();\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => codecRegistry,\n    parameterizedCodecs: () => [],\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => createCodecRegistry(),\n    parameterizedCodecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing.\n * This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the\n * adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Creates a stub adapter for testing.\n * This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)\n * to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {\n  const codecRegistry = createCodecRegistry();\n\n  // Register stub codecs for common test types\n  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)\n  // but don't require importing from the postgres adapter package\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),\n      decode: (wire: string | Date) => (wire instanceof Date ? wire : new Date(wire)),\n      // string | Date includes Date which is not assignable to JsonValue, so\n      // the JSON round-trip pair must be supplied explicitly.\n      encodeJson: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),\n      decodeJson: (json) => {\n        if (typeof json !== 'string') throw new Error('expected ISO date string');\n        return new Date(json);\n      },\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n      readMarkerStatement() {\n        return {\n          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n      parseMarkerRow: parseContractMarkerRow,\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}
+{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport type { ResultType } from '@prisma-next/framework-components/runtime';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlExecutionPlan, SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  parseContractMarkerRow,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array.\n * This helper DRYs up the common pattern of executing plans in tests.\n * The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them.\n * Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: SqlExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker.\n * This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database.\n * This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter.\n * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions\n * derived from the adapter's codec registry.\n */\nexport function createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const codecRegistry = adapter.profile.codecs();\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => codecRegistry,\n    parameterizedCodecs: () => [],\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => createCodecRegistry(),\n    parameterizedCodecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing.\n * This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the\n * adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Creates a stub adapter for testing.\n * This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)\n * to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {\n  const codecRegistry = createCodecRegistry();\n\n  // Register stub codecs for common test types\n  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)\n  // but don't require importing from the postgres adapter package\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: Date) => value,\n      decode: (wire: Date) => wire,\n      // Date is not assignable to JsonValue, so the JSON round-trip pair\n      // must be supplied explicitly.\n      encodeJson: (value: Date) => value.toISOString(),\n      decodeJson: (json) => {\n        if (typeof json !== 'string') throw new Error('expected ISO date string');\n        return new Date(json);\n      },\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n      readMarkerStatement() {\n        return {\n          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n      parseMarkerRow: parseContractMarkerRow,\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.5.0-dev.28",
+  "version": "0.5.0-dev.29",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.26",
-    "@prisma-next/framework-components": "0.5.0-dev.28",
-    "@prisma-next/contract": "0.5.0-dev.28",
-    "@prisma-next/ids": "0.5.0-dev.28",
-    "@prisma-next/utils": "0.5.0-dev.28",
-    "@prisma-next/sql-contract": "0.5.0-dev.28",
-    "@prisma-next/operations": "0.5.0-dev.28",
-    "@prisma-next/sql-operations": "0.5.0-dev.28",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.28"
+    "@prisma-next/contract": "0.5.0-dev.29",
+    "@prisma-next/framework-components": "0.5.0-dev.29",
+    "@prisma-next/utils": "0.5.0-dev.29",
+    "@prisma-next/ids": "0.5.0-dev.29",
+    "@prisma-next/operations": "0.5.0-dev.29",
+    "@prisma-next/sql-contract": "0.5.0-dev.29",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.29",
+    "@prisma-next/sql-operations": "0.5.0-dev.29"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
@@ -21,8 +21,8 @@
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
-    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsdown": "0.0.0",
+    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [

package/src/codecs/decoding.ts

@@ -1,9 +1,15 @@
-import { isRuntimeError, runtimeError } from '@prisma-next/framework-components/runtime';
+import {
+  checkAborted,
+  isRuntimeError,
+  raceAgainstAbort,
+  runtimeError,
+} from '@prisma-next/framework-components/runtime';
 import type {
   AnyQueryAst,
   Codec,
   CodecRegistry,
   ProjectionItem,
+  SqlCodecCallContext,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan';
 import type { JsonSchemaValidatorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
@@ -157,27 +163,55 @@ function decodeIncludeAggregate(alias: string, wireValue: unknown): unknown {
  * Decodes a single field. Single-armed: every cell takes the same path —
  * `codec.decode → await → JSON-Schema validate → return plain value` — so
  * sync- and async-authored codecs are indistinguishable to callers.
+ *
+ * The row-level `rowCtx` is repackaged into a per-cell
+ * `SqlCodecCallContext` whose `column = { table, name }` is a structural
+ * projection of the per-cell `ColumnRef = { table, column }` resolved from
+ * the AST-backed `DecodeContext` (the same resolution `wrapDecodeFailure`
+ * uses for envelope construction — one resolution per cell, two consumers).
+ * Cells the runtime cannot resolve to a single underlying column (aggregate
+ * aliases, computed projections without a simple ref) get
+ * `column: undefined`, matching the spec contract that the runtime never
+ * silently defaults this field.
  */
 async function decodeField(
   alias: string,
   wireValue: unknown,
-  ctx: DecodeContext,
+  decodeCtx: DecodeContext,
   jsonValidators: JsonSchemaValidatorRegistry | undefined,
+  rowCtx: SqlCodecCallContext,
 ): Promise<unknown> {
   if (wireValue === null) {
     return null;
   }
 
-  const codec = ctx.codecs.get(alias);
+  const codec = decodeCtx.codecs.get(alias);
   if (!codec) {
     return wireValue;
   }
 
-  const ref = ctx.columnRefs.get(alias);
+  const ref = decodeCtx.columnRefs.get(alias);
+
+  // Per-cell ctx: the cell-level `column` is a `SqlColumnRef = { table, name }`
+  // projection of the resolved `ColumnRef = { table, column }` (same
+  // resolution `wrapDecodeFailure` uses below — no double work). Cells the
+  // runtime cannot resolve (aggregate aliases, computed projections without
+  // a simple ref) drop the `column` field entirely — explicitly cleared so
+  // a previously-populated `rowCtx.column` cannot leak through to unrelated
+  // cells. Destructuring (rather than `column: undefined`) is required
+  // because `SqlCodecCallContext.column` is declared `column?: SqlColumnRef`
+  // under `exactOptionalPropertyTypes`.
+  let cellCtx: SqlCodecCallContext;
+  if (ref) {
+    cellCtx = { ...rowCtx, column: { table: ref.table, name: ref.column } };
+  } else {
+    const { column: _drop, ...rowCtxWithoutColumn } = rowCtx;
+    cellCtx = rowCtxWithoutColumn;
+  }
 
   let decoded: unknown;
   try {
-    decoded = await codec.decode(wireValue);
+    decoded = await codec.decode(wireValue, cellCtx);
   } catch (error) {
     wrapDecodeFailure(error, alias, ref, codec, wireValue);
   }
@@ -200,23 +234,38 @@ async function decodeField(
  * Failures are wrapped in `RUNTIME.DECODE_FAILED` with `{ table, column,
  * codec }` (or `{ alias, codec }` when no column ref is resolvable) and the
  * original error attached on `cause`.
+ *
+ * When `rowCtx.signal` is provided:
+ *
+ * - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED`
+ *   (`{ phase: 'decode' }`) before any `codec.decode` call is made.
+ * - **Mid-flight aborts** race the per-cell `Promise.all` against the
+ *   signal so the runtime returns promptly even when codec bodies ignore
+ *   it. In-flight bodies that ignore the signal complete in the
+ *   background (cooperative cancellation).
+ * - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass
+ *   through unchanged (no double wrap).
  */
 export async function decodeRow(
   row: Record<string, unknown>,
   plan: SqlExecutionPlan,
   registry: CodecRegistry,
-  jsonValidators?: JsonSchemaValidatorRegistry,
+  jsonValidators: JsonSchemaValidatorRegistry | undefined,
+  rowCtx: SqlCodecCallContext,
 ): Promise<Record<string, unknown>> {
-  const ctx = buildDecodeContext(plan, registry);
+  checkAborted(rowCtx, 'decode');
+  const signal = rowCtx.signal;
+
+  const decodeCtx = buildDecodeContext(plan, registry);
 
-  const aliases = ctx.aliases ?? Object.keys(row);
+  const aliases = decodeCtx.aliases ?? Object.keys(row);
 
-  if (ctx.aliases !== undefined) {
-    for (const alias of ctx.aliases) {
+  if (decodeCtx.aliases !== undefined) {
+    for (const alias of decodeCtx.aliases) {
       if (!Object.hasOwn(row, alias)) {
         throw runtimeError('RUNTIME.DECODE_FAILED', `Row missing projection alias "${alias}"`, {
           alias,
-          expectedAliases: ctx.aliases,
+          expectedAliases: decodeCtx.aliases,
           presentKeys: Object.keys(row),
         });
       }
@@ -230,16 +279,16 @@ export async function decodeRow(
     const alias = aliases[i] as string;
     const wireValue = row[alias];
 
-    if (ctx.includeAliases.has(alias)) {
+    if (decodeCtx.includeAliases.has(alias)) {
       includeIndices.push({ index: i, alias, value: wireValue });
       tasks.push(Promise.resolve(undefined));
       continue;
     }
 
-    tasks.push(decodeField(alias, wireValue, ctx, jsonValidators));
+    tasks.push(decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx));
   }
 
-  const settled = await Promise.all(tasks);
+  const settled = await raceAgainstAbort(Promise.all(tasks), signal, 'decode');
 
   // Include aggregates are decoded synchronously after concurrent codec
   // dispatch settles, so any decode failures upstream propagate first.

package/src/codecs/encoding.ts

@@ -1,8 +1,13 @@
-import { runtimeError } from '@prisma-next/framework-components/runtime';
+import {
+  checkAborted,
+  raceAgainstAbort,
+  runtimeError,
+} from '@prisma-next/framework-components/runtime';
 import {
   type Codec,
   type CodecRegistry,
   collectOrderedParamRefs,
+  type SqlCodecCallContext,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan';
 
@@ -40,18 +45,27 @@ function wrapEncodeFailure(
  * lifted to async by the codec() factory. Failures are wrapped in
  * `RUNTIME.ENCODE_FAILED` with `{ label, codec, paramIndex }` and the original
  * error attached on `cause`.
+ *
+ * `ctx` is forwarded verbatim to `codec.encode` so codec authors who opt
+ * into the `(value, ctx)` arity see the same `SqlCodecCallContext` the
+ * runtime built for the surrounding `runtime.execute()` call. The ctx is
+ * always present; its `signal` field may be `undefined`. Encode call
+ * sites do not populate `ctx.column` — encode-time column context is the
+ * middleware's domain.
  */
 export async function encodeParam(
   value: unknown,
   paramRef: { readonly codecId?: string; readonly name?: string },
   paramIndex: number,
   registry: CodecRegistry,
+  ctx: SqlCodecCallContext,
 ): Promise<unknown> {
   return encodeParamValue(
     value,
     { codecId: paramRef.codecId, name: paramRef.name },
     paramIndex,
     registry,
+    ctx,
   );
 }
 
@@ -60,6 +74,7 @@ async function encodeParamValue(
   metadata: ParamMetadata,
   paramIndex: number,
   registry: CodecRegistry,
+  ctx: SqlCodecCallContext,
 ): Promise<unknown> {
   if (value === null || value === undefined) {
     return null;
@@ -75,7 +90,7 @@ async function encodeParamValue(
   }
 
   try {
-    return await codec.encode(value);
+    return await codec.encode(value, ctx);
   } catch (error) {
     wrapEncodeFailure(error, metadata, paramIndex, codec.id);
   }
@@ -85,11 +100,29 @@ async function encodeParamValue(
  * Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-
  * and async-authored codecs share the same path: `codec.encode → await →
  * return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
+ *
+ * When `ctx.signal` is provided:
+ *
+ * - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED`
+ *   (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs
+ *   can pin this with a per-call counter that stays at zero.
+ * - **Mid-flight abort** races the per-param `Promise.all` against
+ *   `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly
+ *   even if codec bodies ignore the signal; the in-flight bodies are
+ *   abandoned and run to completion in the background (cooperative
+ *   cancellation, see ADR 204).
+ * - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec
+ *   body before the runtime observes the abort pass through unchanged
+ *   (no double wrap).
  */
 export async function encodeParams(
   plan: SqlExecutionPlan,
   registry: CodecRegistry,
+  ctx: SqlCodecCallContext,
 ): Promise<readonly unknown[]> {
+  checkAborted(ctx, 'encode');
+  const signal = ctx.signal;
+
   if (plan.params.length === 0) {
     return plan.params;
   }
@@ -109,9 +142,9 @@ export async function encodeParams(
 
   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);
+    tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, registry, ctx);
   }
 
-  const encoded = await Promise.all(tasks);
-  return Object.freeze(encoded);
+  const settled = await raceAgainstAbort(Promise.all(tasks), signal, 'encode');
+  return Object.freeze(settled);
 }

package/src/sql-runtime.ts

@@ -5,8 +5,10 @@ import type {
 } from '@prisma-next/framework-components/execution';
 import {
   AsyncIterableResult,
+  checkAborted,
   checkMiddlewareCompatibility,
   RuntimeCore,
+  type RuntimeExecuteOptions,
   type RuntimeLog,
   runtimeError,
   runWithMiddleware,
@@ -17,6 +19,7 @@ import type {
   AnyQueryAst,
   CodecRegistry,
   LoweredStatement,
+  SqlCodecCallContext,
   SqlDriver,
   SqlQueryable,
   SqlTransaction,
@@ -187,12 +190,21 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
    * Lower a `SqlQueryPlan` (AST + meta) into a `SqlExecutionPlan` with
    * encoded parameters ready for the driver. This is the single point at
    * which params transition from app-layer values to driver wire-format.
+   *
+   * `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so per-query
+   * cancellation reaches every codec body during parameter encoding. The
+   * framework abstract typed this as `CodecCallContext`; the SQL family
+   * narrows it to the SQL-specific extension. SQL params do not populate
+   * `ctx.column` — encode-side column metadata is the middleware's domain.
    */
-  protected override async lower(plan: SqlQueryPlan): Promise<SqlExecutionPlan> {
+  protected override async lower(
+    plan: SqlQueryPlan,
+    ctx: SqlCodecCallContext,
+  ): Promise<SqlExecutionPlan> {
     const lowered = lowerSqlPlan(this.adapter, this.contract, plan);
     return Object.freeze({
       ...lowered,
-      params: await encodeParams(lowered, this.codecRegistry),
+      params: await encodeParams(lowered, this.codecRegistry, ctx),
     });
   }
 
@@ -231,24 +243,37 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
 
   override execute<Row>(
     plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & { readonly _row?: Row },
+    options?: RuntimeExecuteOptions,
   ): AsyncIterableResult<Row> {
-    return this.executeAgainstQueryable<Row>(plan, this.driver);
+    return this.executeAgainstQueryable<Row>(plan, this.driver, options);
   }
 
   private executeAgainstQueryable<Row>(
     plan: SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>,
     queryable: SqlQueryable,
+    options?: RuntimeExecuteOptions,
   ): AsyncIterableResult<Row> {
     this.ensureCodecRegistryValidated();
 
     const self = this;
+    const signal = options?.signal;
+    // One ctx per execute() call — the same reference is shared by
+    // encodeParams (lower), decodeRow (per-row), and the stream loop's
+    // between-row checks. Per-cell ctx allocations inside decodeField add
+    // `column` for resolvable cells without re-wrapping the signal. The
+    // ctx object is always allocated; the `signal` field is only included
+    // when a signal was supplied (exactOptionalPropertyTypes).
+    const codecCtx: SqlCodecCallContext = signal === undefined ? {} : { signal };
+
     const generator = async function* (): AsyncGenerator<Row, void, unknown> {
+      checkAborted(codecCtx, 'stream');
+
       const exec: SqlExecutionPlan = isExecutionPlan(plan)
         ? Object.freeze({
             ...plan,
-            params: await encodeParams(plan, self.codecRegistry),
+            params: await encodeParams(plan, self.codecRegistry, codecCtx),
           })
-        : await self.lower(await self.runBeforeCompile(plan));
+        : await self.lower(await self.runBeforeCompile(plan), codecCtx);
 
       self.familyAdapter.validatePlan(exec, self.contract);
       self._telemetry = null;
@@ -280,14 +305,33 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
             }),
         );
 
-        for await (const rawRow of stream) {
-          const decodedRow = await decodeRow(
-            rawRow,
-            exec,
-            self.codecRegistry,
-            self.jsonSchemaValidators,
-          );
-          yield decodedRow as Row;
+        // Manually drive the driver's async iterator so the between-row
+        // abort check fires *before* requesting the next row. With a
+        // `for await...of` loop the runtime would await `iterator.next()`
+        // first, leaving a window where one extra row is pulled through
+        // the driver after the signal aborted.
+        const iterator = stream[Symbol.asyncIterator]();
+        try {
+          while (true) {
+            checkAborted(codecCtx, 'stream');
+            const next = await iterator.next();
+            if (next.done) {
+              break;
+            }
+            const decodedRow = await decodeRow(
+              next.value,
+              exec,
+              self.codecRegistry,
+              self.jsonSchemaValidators,
+              codecCtx,
+            );
+            yield decodedRow as Row;
+          }
+        } finally {
+          // Best-effort iterator cleanup so the driver can release its
+          // resources whether the stream finished normally, threw, or was
+          // abandoned by the consumer.
+          await iterator.return?.();
         }
 
         outcome = 'success';
@@ -321,8 +365,9 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
       },
       execute<Row>(
         plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & { readonly _row?: Row },
+        options?: RuntimeExecuteOptions,
       ): AsyncIterableResult<Row> {
-        return self.executeAgainstQueryable<Row>(plan, driverConn);
+        return self.executeAgainstQueryable<Row>(plan, driverConn, options);
       },
     };
 
@@ -340,8 +385,9 @@ class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorag
       },
       execute<Row>(
         plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & { readonly _row?: Row },
+        options?: RuntimeExecuteOptions,
       ): AsyncIterableResult<Row> {
-        return self.executeAgainstQueryable<Row>(plan, driverTx);
+        return self.executeAgainstQueryable<Row>(plan, driverTx, options);
       },
     };
   }
@@ -455,11 +501,12 @@ export async function withTransaction<R>(
     },
     execute<Row>(
       plan: (SqlExecutionPlan<unknown> | SqlQueryPlan<unknown>) & { readonly _row?: Row },
+      options?: RuntimeExecuteOptions,
     ): AsyncIterableResult<Row> {
       if (invalidated) {
         throw transactionClosedError();
       }
-      const inner = transaction.execute(plan);
+      const inner = transaction.execute(plan, options);
       const guarded = async function* (): AsyncGenerator<Row, void, unknown> {
         for await (const row of inner) {
           if (invalidated) {