@prisma-next/sql-runtime 0.3.0-pr.99.6 → 0.4.0-dev.1

package/dist/test/utils.mjs

@@ -0,0 +1,221 @@
+import { a as writeContractMarker, n as ensureSchemaStatement, o as createExecutionContext, r as ensureTableStatement, s as createSqlExecutionStack } from "../exports-BO6Fl7yn.mjs";
+import { codec, createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
+import { coreHash, profileHash } from "@prisma-next/contract/types";
+import { builtinGeneratorIds } from "@prisma-next/ids";
+import { generateId } from "@prisma-next/ids/runtime";
+import { collectAsync, collectAsync as collectAsync$1, createDevDatabase, drainAsyncIterable, teardownTestDatabase, withClient } from "@prisma-next/test-utils";
+
+//#region test/utils.ts
+function createTestMutationDefaultGenerators() {
+	return builtinGeneratorIds.map((id) => ({
+		id,
+		generate: (params) => generateId(params ? {
+			id,
+			params
+		} : { id })
+	}));
+}
+/**
+* Executes a plan and collects all results into an array.
+* This helper DRYs up the common pattern of executing plans in tests.
+* The return type is inferred from the plan's type parameter.
+*/
+async function executePlanAndCollect(runtime, plan) {
+	return collectAsync$1(runtime.execute(plan));
+}
+/**
+* Drains a plan execution, consuming all results without collecting them.
+* Useful for testing side effects without memory overhead.
+*/
+async function drainPlanExecution(runtime, plan) {
+	return drainAsyncIterable(runtime.execute(plan));
+}
+/**
+* Executes a SQL statement on a database client.
+*/
+async function executeStatement(client, statement) {
+	if (statement.params.length > 0) {
+		await client.query(statement.sql, [...statement.params]);
+		return;
+	}
+	await client.query(statement.sql);
+}
+/**
+* Sets up database schema and data, then writes the contract marker.
+* This helper DRYs up the common pattern of database setup in tests.
+*/
+async function setupTestDatabase(client, contract, setupFn) {
+	await client.query("drop schema if exists prisma_contract cascade");
+	await client.query("create schema if not exists public");
+	await setupFn(client);
+	await executeStatement(client, ensureSchemaStatement);
+	await executeStatement(client, ensureTableStatement);
+	await executeStatement(client, writeContractMarker({
+		storageHash: contract.storage.storageHash,
+		profileHash: contract.profileHash,
+		contractJson: contract,
+		canonicalVersion: 1
+	}).insert);
+}
+/**
+* Writes a contract marker to the database.
+* This helper DRYs up the common pattern of writing contract markers in tests.
+*/
+async function writeTestContractMarker(client, contract) {
+	await executeStatement(client, writeContractMarker({
+		storageHash: contract.storage.storageHash,
+		profileHash: contract.profileHash,
+		contractJson: contract,
+		canonicalVersion: 1
+	}).insert);
+}
+/**
+* Creates a test adapter descriptor from a raw adapter.
+* Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions
+* derived from the adapter's codec registry.
+*/
+function createTestAdapterDescriptor(adapter) {
+	const codecRegistry = adapter.profile.codecs();
+	return {
+		kind: "adapter",
+		id: "test-adapter",
+		version: "0.0.1",
+		familyId: "sql",
+		targetId: "postgres",
+		codecs: () => codecRegistry,
+		parameterizedCodecs: () => [],
+		mutationDefaultGenerators: createTestMutationDefaultGenerators,
+		create() {
+			return Object.assign({
+				familyId: "sql",
+				targetId: "postgres"
+			}, adapter);
+		}
+	};
+}
+/**
+* Creates a test target descriptor with empty static contributions.
+*/
+function createTestTargetDescriptor() {
+	return {
+		kind: "target",
+		id: "postgres",
+		version: "0.0.1",
+		familyId: "sql",
+		targetId: "postgres",
+		codecs: () => createCodecRegistry(),
+		parameterizedCodecs: () => [],
+		create() {
+			return {
+				familyId: "sql",
+				targetId: "postgres"
+			};
+		}
+	};
+}
+/**
+* Creates an ExecutionContext for testing.
+* This helper DRYs up the common pattern of context creation in tests.
+*
+* Accepts a raw adapter and optional extension descriptors, wrapping the
+* adapter in a descriptor internally for descriptor-first context creation.
+*/
+function createTestContext(contract, adapter, options) {
+	return createExecutionContext({
+		contract,
+		stack: {
+			target: createTestTargetDescriptor(),
+			adapter: createTestAdapterDescriptor(adapter),
+			extensionPacks: options?.extensionPacks ?? []
+		}
+	});
+}
+function createTestStackInstance(options) {
+	return instantiateExecutionStack(createSqlExecutionStack({
+		target: createTestTargetDescriptor(),
+		adapter: createTestAdapterDescriptor(createStubAdapter()),
+		driver: options?.driver,
+		extensionPacks: options?.extensionPacks ?? []
+	}));
+}
+/**
+* Creates a stub adapter for testing.
+* This helper DRYs up the common pattern of adapter creation in tests.
+*
+* The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)
+* to enable type inference in tests without requiring the postgres adapter package.
+*/
+function createStubAdapter() {
+	const codecRegistry = createCodecRegistry();
+	codecRegistry.register(codec({
+		typeId: "pg/int4@1",
+		targetTypes: ["int4"],
+		encode: (value) => value,
+		decode: (wire) => wire
+	}));
+	codecRegistry.register(codec({
+		typeId: "pg/text@1",
+		targetTypes: ["text"],
+		encode: (value) => value,
+		decode: (wire) => wire
+	}));
+	codecRegistry.register(codec({
+		typeId: "pg/timestamptz@1",
+		targetTypes: ["timestamptz"],
+		encode: (value) => value instanceof Date ? value.toISOString() : value,
+		decode: (wire) => wire instanceof Date ? wire : new Date(wire)
+	}));
+	return {
+		profile: {
+			id: "stub-profile",
+			target: "postgres",
+			capabilities: {},
+			codecs() {
+				return codecRegistry;
+			},
+			readMarkerStatement() {
+				return {
+					sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
+					params: [1]
+				};
+			}
+		},
+		lower(ast, ctx) {
+			const sqlText = JSON.stringify(ast);
+			return {
+				profileId: this.profile.id,
+				body: Object.freeze({
+					sql: sqlText,
+					params: ctx.params ? [...ctx.params] : []
+				})
+			};
+		}
+	};
+}
+function createTestContract(contract) {
+	const { execution, ...rest } = contract;
+	const storageHashValue = coreHash(rest["storageHash"] ?? "sha256:testcore");
+	return {
+		target: rest["target"] ?? "postgres",
+		targetFamily: rest["targetFamily"] ?? "sql",
+		storage: rest["storage"] ? {
+			...rest["storage"],
+			storageHash: storageHashValue
+		} : {
+			storageHash: storageHashValue,
+			tables: {}
+		},
+		models: rest["models"] ?? {},
+		roots: rest["roots"] ?? {},
+		capabilities: rest["capabilities"] ?? {},
+		extensionPacks: rest["extensionPacks"] ?? {},
+		meta: rest["meta"] ?? {},
+		...execution ? { execution } : {},
+		profileHash: profileHash(rest["profileHash"] ?? "sha256:testprofile")
+	};
+}
+
+//#endregion
+export { collectAsync, createDevDatabase, createStubAdapter, createTestAdapterDescriptor, createTestContext, createTestContract, createTestStackInstance, createTestTargetDescriptor, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, teardownTestDatabase, withClient, writeTestContractMarker };
+//# sourceMappingURL=utils.mjs.map

package/dist/test/utils.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract, ExecutionPlan, ResultType } 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 { 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 { 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  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 ExecutionPlan<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: ExecutionPlan | 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(): 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    }),\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 from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return {\n        profileId: this.profile.id,\n        body: Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] }),\n      };\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,27 +1,30 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.3.0-pr.99.6",
+  "version": "0.4.0-dev.1",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.26",
-    "@prisma-next/contract": "0.3.0-pr.99.6",
-    "@prisma-next/core-execution-plane": "0.3.0-pr.99.6",
-    "@prisma-next/operations": "0.3.0-pr.99.6",
-    "@prisma-next/runtime-executor": "0.3.0-pr.99.6",
-    "@prisma-next/sql-contract": "0.3.0-pr.99.6",
-    "@prisma-next/sql-operations": "0.3.0-pr.99.6",
-    "@prisma-next/sql-relational-core": "0.3.0-pr.99.6"
+    "@prisma-next/contract": "0.4.0-dev.1",
+    "@prisma-next/framework-components": "0.4.0-dev.1",
+    "@prisma-next/utils": "0.4.0-dev.1",
+    "@prisma-next/operations": "0.4.0-dev.1",
+    "@prisma-next/ids": "0.4.0-dev.1",
+    "@prisma-next/sql-contract": "0.4.0-dev.1",
+    "@prisma-next/runtime-executor": "0.4.0-dev.1",
+    "@prisma-next/sql-relational-core": "0.4.0-dev.1",
+    "@prisma-next/sql-operations": "0.4.0-dev.1"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
     "pg": "8.16.3",
-    "tsup": "8.5.1",
+    "tsdown": "0.18.4",
     "typescript": "5.9.3",
-    "vitest": "4.0.16",
+    "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1"
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",
@@ -29,17 +32,20 @@
     "test"
   ],
   "exports": {
-    ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js"
-    },
-    "./test/utils": {
-      "types": "./dist/test/utils.d.ts",
-      "import": "./dist/test/utils.js"
-    }
+    ".": "./dist/index.mjs",
+    "./test/utils": "./dist/test/utils.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/2-sql/5-runtime"
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
+    "build": "tsdown",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --project tsconfig.json --noEmit",

package/src/codecs/decoding.ts

@@ -1,5 +1,7 @@
 import type { ExecutionPlan } from '@prisma-next/contract/types';
 import type { Codec, CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import type { JsonSchemaValidatorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { validateJsonValue } from './json-schema-validation';
 
 function resolveRowCodec(
   alias: string,
@@ -27,15 +29,69 @@ function resolveRowCodec(
   return null;
 }
 
+type ColumnRefIndex = Map<string, { table: string; column: string }>;
+
+/**
+ * Builds a lookup index from column name → { table, column } ref.
+ * Called once per decodeRow invocation to avoid O(aliases × refs) linear scans.
+ */
+function buildColumnRefIndex(plan: ExecutionPlan): ColumnRefIndex | null {
+  const columns = plan.meta.refs?.columns;
+  if (!columns) return null;
+
+  const index: ColumnRefIndex = new Map();
+  for (const ref of columns) {
+    index.set(ref.column, ref);
+  }
+  return index;
+}
+
+function parseProjectionRef(value: string): { table: string; column: string } | null {
+  if (value.startsWith('include:') || value.startsWith('operation:')) {
+    return null;
+  }
+
+  const separatorIndex = value.indexOf('.');
+  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+    return null;
+  }
+
+  return {
+    table: value.slice(0, separatorIndex),
+    column: value.slice(separatorIndex + 1),
+  };
+}
+
+function resolveColumnRefForAlias(
+  alias: string,
+  projection: ExecutionPlan['meta']['projection'],
+  fallbackColumnRefIndex: ColumnRefIndex | null,
+): { table: string; column: string } | undefined {
+  if (projection && !Array.isArray(projection)) {
+    const mappedRef = (projection as Record<string, string>)[alias];
+    if (typeof mappedRef !== 'string') {
+      return undefined;
+    }
+    return parseProjectionRef(mappedRef) ?? undefined;
+  }
+
+  return fallbackColumnRefIndex?.get(alias);
+}
+
 export function decodeRow(
   row: Record<string, unknown>,
   plan: ExecutionPlan,
   registry: CodecRegistry,
+  jsonValidators?: JsonSchemaValidatorRegistry,
 ): Record<string, unknown> {
   const decoded: Record<string, unknown> = {};
+  const projection = plan.meta.projection;
+
+  // Fallback for plans that do not provide projection alias -> table.column mapping.
+  const fallbackColumnRefIndex =
+    jsonValidators && (!projection || Array.isArray(projection)) ? buildColumnRefIndex(plan) : null;
 
   let aliases: readonly string[];
-  const projection = plan.meta.projection;
   if (projection && !Array.isArray(projection)) {
     aliases = Object.keys(projection);
   } else if (projection && Array.isArray(projection)) {
@@ -47,7 +103,6 @@ export function decodeRow(
   for (const alias of aliases) {
     const wireValue = row[alias];
 
-    const projection = plan.meta.projection;
     const projectionValue =
       projection && typeof projection === 'object' && !Array.isArray(projection)
         ? (projection as Record<string, string>)[alias]
@@ -111,8 +166,34 @@ export function decodeRow(
     }
 
     try {
-      decoded[alias] = codec.decode(wireValue);
+      const decodedValue = codec.decode(wireValue);
+
+      // Validate decoded JSON value against schema
+      if (jsonValidators) {
+        const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
+        if (ref) {
+          validateJsonValue(
+            jsonValidators,
+            ref.table,
+            ref.column,
+            decodedValue,
+            'decode',
+            codec.id,
+          );
+        }
+      }
+
+      decoded[alias] = decodedValue;
     } catch (error) {
+      // Re-throw JSON schema validation errors as-is
+      if (
+        error instanceof Error &&
+        'code' in error &&
+        (error as Error & { code: string }).code === 'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED'
+      ) {
+        throw error;
+      }
+
       const decodeError = new Error(
         `Failed to decode row alias '${alias}' with codec '${codec.id}': ${error instanceof Error ? error.message : String(error)}`,
       ) as Error & {

package/src/codecs/encoding.ts

@@ -3,19 +3,8 @@ import type { Codec, CodecRegistry } from '@prisma-next/sql-relational-core/ast'
 
 function resolveParamCodec(
   paramDescriptor: ParamDescriptor,
-  plan: ExecutionPlan,
   registry: CodecRegistry,
 ): Codec | null {
-  const paramName = paramDescriptor.name ?? `param_${paramDescriptor.index ?? 0}`;
-
-  const planCodecId = plan.meta.annotations?.codecs?.[paramName] as string | undefined;
-  if (planCodecId) {
-    const codec = registry.get(planCodecId);
-    if (codec) {
-      return codec;
-    }
-  }
-
   if (paramDescriptor.codecId) {
     const codec = registry.get(paramDescriptor.codecId);
     if (codec) {
@@ -29,14 +18,14 @@ function resolveParamCodec(
 export function encodeParam(
   value: unknown,
   paramDescriptor: ParamDescriptor,
-  plan: ExecutionPlan,
+  paramIndex: number,
   registry: CodecRegistry,
 ): unknown {
   if (value === null || value === undefined) {
     return null;
   }
 
-  const codec = resolveParamCodec(paramDescriptor, plan, registry);
+  const codec = resolveParamCodec(paramDescriptor, registry);
   if (!codec) {
     return value;
   }
@@ -45,8 +34,9 @@ export function encodeParam(
     try {
       return codec.encode(value);
     } catch (error) {
+      const label = paramDescriptor.name ?? `param[${paramIndex}]`;
       throw new Error(
-        `Failed to encode parameter ${paramDescriptor.name ?? paramDescriptor.index}: ${error instanceof Error ? error.message : String(error)}`,
+        `Failed to encode parameter ${label}: ${error instanceof Error ? error.message : String(error)}`,
       );
     }
   }
@@ -66,7 +56,7 @@ export function encodeParams(plan: ExecutionPlan, registry: CodecRegistry): read
     const paramDescriptor = plan.meta.paramDescriptors[i];
 
     if (paramDescriptor) {
-      encoded.push(encodeParam(paramValue, paramDescriptor, plan, registry));
+      encoded.push(encodeParam(paramValue, paramDescriptor, i, registry));
     } else {
       encoded.push(paramValue);
     }

package/src/codecs/json-schema-validation.ts

@@ -0,0 +1,61 @@
+import { runtimeError } from '@prisma-next/framework-components/runtime';
+import type {
+  JsonSchemaValidationError,
+  JsonSchemaValidatorRegistry,
+} from '@prisma-next/sql-relational-core/query-lane-context';
+
+/**
+ * Validates a JSON value against its column's JSON Schema, if a validator exists.
+ *
+ * Throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on validation failure.
+ * No-ops if no validator is registered for the column.
+ */
+export function validateJsonValue(
+  registry: JsonSchemaValidatorRegistry,
+  table: string,
+  column: string,
+  value: unknown,
+  direction: 'encode' | 'decode',
+  codecId?: string,
+): void {
+  const key = `${table}.${column}`;
+  const validate = registry.get(key);
+  if (!validate) return;
+
+  const result = validate(value);
+  if (result.valid) return;
+
+  throw createJsonSchemaValidationError(table, column, direction, result.errors, codecId);
+}
+
+function createJsonSchemaValidationError(
+  table: string,
+  column: string,
+  direction: 'encode' | 'decode',
+  errors: ReadonlyArray<JsonSchemaValidationError>,
+  codecId?: string,
+): Error {
+  const summary = formatErrorSummary(errors);
+  return runtimeError(
+    'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED',
+    `JSON schema validation failed for column '${table}.${column}' (${direction}): ${summary}`,
+    {
+      table,
+      column,
+      codecId,
+      direction,
+      errors: [...errors],
+    },
+  );
+}
+
+function formatErrorSummary(errors: ReadonlyArray<JsonSchemaValidationError>): string {
+  if (errors.length === 0) return 'unknown validation error';
+  if (errors.length === 1) {
+    const err = errors[0] as JsonSchemaValidationError;
+    return err.path === '/' ? err.message : `${err.path}: ${err.message}`;
+  }
+  return errors
+    .map((err) => (err.path === '/' ? err.message : `${err.path}: ${err.message}`))
+    .join('; ');
+}

package/src/codecs/validation.ts

@@ -1,8 +1,9 @@
-import { runtimeError } from '@prisma-next/runtime-executor';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Contract } from '@prisma-next/contract/types';
+import { runtimeError } from '@prisma-next/framework-components/runtime';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type { CodecRegistry } from '@prisma-next/sql-relational-core/ast';
 
-export function extractCodecIds(contract: SqlContract<SqlStorage>): Set<string> {
+export function extractCodecIds(contract: Contract<SqlStorage>): Set<string> {
   const codecIds = new Set<string>();
 
   for (const table of Object.values(contract.storage.tables)) {
@@ -15,7 +16,7 @@ export function extractCodecIds(contract: SqlContract<SqlStorage>): Set<string>
   return codecIds;
 }
 
-function extractCodecIdsFromColumns(contract: SqlContract<SqlStorage>): Map<string, string> {
+function extractCodecIdsFromColumns(contract: Contract<SqlStorage>): Map<string, string> {
   const codecIds = new Map<string, string>();
 
   for (const [tableName, table] of Object.entries(contract.storage.tables)) {
@@ -31,7 +32,7 @@ function extractCodecIdsFromColumns(contract: SqlContract<SqlStorage>): Map<stri
 
 export function validateContractCodecMappings(
   registry: CodecRegistry,
-  contract: SqlContract<SqlStorage>,
+  contract: Contract<SqlStorage>,
 ): void {
   const codecIds = extractCodecIdsFromColumns(contract);
   const invalidCodecs: Array<{ table: string; column: string; codecId: string }> = [];
@@ -61,7 +62,7 @@ export function validateContractCodecMappings(
 
 export function validateCodecRegistryCompleteness(
   registry: CodecRegistry,
-  contract: SqlContract<SqlStorage>,
+  contract: Contract<SqlStorage>,
 ): void {
   validateContractCodecMappings(registry, contract);
 }

package/src/exports/index.ts

@@ -1,28 +1,39 @@
 export type {
   AfterExecuteResult,
-  BudgetsOptions,
-  LintsOptions,
   Log,
-  Plugin,
-  PluginContext,
+  Middleware,
+  MiddlewareContext,
 } from '@prisma-next/runtime-executor';
-export { budgets, lints } from '@prisma-next/runtime-executor';
 export {
   extractCodecIds,
   validateCodecRegistryCompleteness,
   validateContractCodecMappings,
 } from '../codecs/validation';
 export { lowerSqlPlan } from '../lower-sql-plan';
+export type { BudgetsOptions } from '../middleware/budgets';
+export { budgets } from '../middleware/budgets';
+export type { LintsOptions } from '../middleware/lints';
+export { lints } from '../middleware/lints';
+export type { SqlMiddleware, SqlMiddlewareContext } from '../middleware/sql-middleware';
 export type {
-  CreateRuntimeContextOptions,
-  RuntimeContext,
+  ExecutionContext,
+  RuntimeMutationDefaultGenerator,
   RuntimeParameterizedCodecDescriptor,
+  SqlExecutionStack,
+  SqlExecutionStackWithDriver,
+  SqlRuntimeAdapterDescriptor,
   SqlRuntimeAdapterInstance,
+  SqlRuntimeDriverInstance,
   SqlRuntimeExtensionDescriptor,
   SqlRuntimeExtensionInstance,
+  SqlRuntimeTargetDescriptor,
+  SqlStaticContributions,
   TypeHelperRegistry,
 } from '../sql-context';
-export { createRuntimeContext } from '../sql-context';
+export {
+  createExecutionContext,
+  createSqlExecutionStack,
+} from '../sql-context';
 export type { SqlStatement } from '../sql-marker';
 export {
   ensureSchemaStatement,
@@ -31,8 +42,8 @@ export {
   writeContractMarker,
 } from '../sql-marker';
 export type {
+  CreateRuntimeOptions,
   Runtime,
-  RuntimeOptions,
   RuntimeTelemetryEvent,
   RuntimeVerifyOptions,
   TelemetryOutcome,