@prisma-next/sql-runtime 0.3.0-dev.34 → 0.3.0-dev.37

package/package.json

@@ -1,27 +1,30 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.3.0-dev.34",
+  "version": "0.3.0-dev.37",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.26",
-    "@prisma-next/contract": "0.3.0-dev.34",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.34",
-    "@prisma-next/operations": "0.3.0-dev.34",
-    "@prisma-next/runtime-executor": "0.3.0-dev.34",
-    "@prisma-next/sql-contract": "0.3.0-dev.34",
-    "@prisma-next/sql-operations": "0.3.0-dev.34",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.34"
+    "@prisma-next/utils": "0.3.0-dev.37",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.37",
+    "@prisma-next/ids": "0.3.0-dev.37",
+    "@prisma-next/contract": "0.3.0-dev.37",
+    "@prisma-next/operations": "0.3.0-dev.37",
+    "@prisma-next/runtime-executor": "0.3.0-dev.37",
+    "@prisma-next/sql-operations": "0.3.0-dev.37",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.37",
+    "@prisma-next/sql-contract": "0.3.0-dev.37"
   },
   "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/tsconfig": "0.0.0",
+    "@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

@@ -1,5 +1,7 @@
 import type { ExecutionPlan, ParamDescriptor } 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 resolveParamCodec(
   paramDescriptor: ParamDescriptor,
@@ -31,11 +33,18 @@ export function encodeParam(
   paramDescriptor: ParamDescriptor,
   plan: ExecutionPlan,
   registry: CodecRegistry,
+  jsonValidators?: JsonSchemaValidatorRegistry,
 ): unknown {
   if (value === null || value === undefined) {
     return null;
   }
 
+  // Validate JSON value against schema before encoding
+  if (jsonValidators && paramDescriptor.refs) {
+    const { table, column } = paramDescriptor.refs;
+    validateJsonValue(jsonValidators, table, column, value, 'encode', paramDescriptor.codecId);
+  }
+
   const codec = resolveParamCodec(paramDescriptor, plan, registry);
   if (!codec) {
     return value;
@@ -54,7 +63,11 @@ export function encodeParam(
   return value;
 }
 
-export function encodeParams(plan: ExecutionPlan, registry: CodecRegistry): readonly unknown[] {
+export function encodeParams(
+  plan: ExecutionPlan,
+  registry: CodecRegistry,
+  jsonValidators?: JsonSchemaValidatorRegistry,
+): readonly unknown[] {
   if (plan.params.length === 0) {
     return plan.params;
   }
@@ -66,7 +79,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, plan, registry, jsonValidators));
     } else {
       encoded.push(paramValue);
     }

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

@@ -0,0 +1,61 @@
+import { runtimeError } from '@prisma-next/runtime-executor';
+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/exports/index.ts

@@ -14,15 +14,20 @@ export {
 } from '../codecs/validation';
 export { lowerSqlPlan } from '../lower-sql-plan';
 export type {
-  CreateRuntimeContextOptions,
-  RuntimeContext,
+  ExecutionContext,
   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 +36,8 @@ export {
   writeContractMarker,
 } from '../sql-marker';
 export type {
+  CreateRuntimeOptions,
   Runtime,
-  RuntimeOptions,
   RuntimeTelemetryEvent,
   RuntimeVerifyOptions,
   TelemetryOutcome,

package/src/lower-sql-plan.ts

@@ -1,23 +1,23 @@
 import type { ExecutionPlan } from '@prisma-next/contract/types';
+import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Adapter, LoweredStatement, QueryAst } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import type { RuntimeContext } from './sql-context';
 
 /**
  * Lowers a SQL query plan to an executable Plan by calling the adapter's lower method.
  *
- * This function is responsible for converting a lane-produced SqlQueryPlan (which contains
- * AST and params but no SQL) into a fully executable Plan (which includes SQL string).
- *
- * @param context - Runtime context containing the adapter
+ * @param adapter - Adapter to lower AST to SQL
+ * @param contract - Contract for lowering context
  * @param queryPlan - SQL query plan from a lane (contains AST, params, meta, but no SQL)
  * @returns Fully executable Plan with SQL string
  */
 export function lowerSqlPlan<Row>(
-  context: RuntimeContext,
+  adapter: Adapter<QueryAst, SqlContract<SqlStorage>, LoweredStatement>,
+  contract: SqlContract<SqlStorage>,
   queryPlan: SqlQueryPlan<Row>,
 ): ExecutionPlan<Row> {
-  const lowered = context.adapter.lower(queryPlan.ast, {
-    contract: context.contract,
+  const lowered = adapter.lower(queryPlan.ast, {
+    contract,
     params: queryPlan.params,
   });