@prisma-next/sql-runtime 0.3.0-dev.3 → 0.3.0-dev.31

package/package.json

@@ -1,33 +1,36 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.3.0-dev.3",
+  "version": "0.3.0-dev.31",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
-    "@prisma-next/contract": "0.3.0-dev.3",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.3",
-    "@prisma-next/operations": "0.3.0-dev.3",
-    "@prisma-next/runtime-executor": "0.3.0-dev.3",
-    "@prisma-next/sql-contract": "0.3.0-dev.3",
-    "@prisma-next/sql-operations": "0.3.0-dev.3",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.3"
+    "arktype": "^2.1.26",
+    "@prisma-next/contract": "0.3.0-dev.31",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.31",
+    "@prisma-next/operations": "0.3.0-dev.31",
+    "@prisma-next/runtime-executor": "0.3.0-dev.31",
+    "@prisma-next/sql-contract": "0.3.0-dev.31",
+    "@prisma-next/sql-operations": "0.3.0-dev.31",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.31"
   },
   "devDependencies": {
-    "@types/pg": "^8.11.10",
-    "@vitest/coverage-v8": "^4.0.0",
-    "pg": "^8.11.5",
-    "tsup": "^8.3.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16",
-    "@prisma-next/test-utils": "0.0.1"
+    "@types/pg": "8.16.0",
+    "pg": "8.16.3",
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.16",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "test"
   ],
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/index.js"
     },
     "./test/utils": {
@@ -36,13 +39,13 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run --passWithNoTests",
     "test:coverage": "vitest run --coverage --passWithNoTests",
     "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
-    "clean": "node ../../../scripts/clean.mjs"
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/codecs/decoding.ts

@@ -0,0 +1,140 @@
+import type { ExecutionPlan } from '@prisma-next/contract/types';
+import type { Codec, CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+
+function resolveRowCodec(
+  alias: string,
+  plan: ExecutionPlan,
+  registry: CodecRegistry,
+): Codec | null {
+  const planCodecId = plan.meta.annotations?.codecs?.[alias] as string | undefined;
+  if (planCodecId) {
+    const codec = registry.get(planCodecId);
+    if (codec) {
+      return codec;
+    }
+  }
+
+  if (plan.meta.projectionTypes) {
+    const typeId = plan.meta.projectionTypes[alias];
+    if (typeId) {
+      const codec = registry.get(typeId);
+      if (codec) {
+        return codec;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function decodeRow(
+  row: Record<string, unknown>,
+  plan: ExecutionPlan,
+  registry: CodecRegistry,
+): Record<string, unknown> {
+  const decoded: Record<string, unknown> = {};
+
+  let aliases: readonly string[];
+  const projection = plan.meta.projection;
+  if (projection && !Array.isArray(projection)) {
+    aliases = Object.keys(projection);
+  } else if (projection && Array.isArray(projection)) {
+    aliases = projection;
+  } else {
+    aliases = Object.keys(row);
+  }
+
+  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]
+        : undefined;
+
+    if (typeof projectionValue === 'string' && projectionValue.startsWith('include:')) {
+      if (wireValue === null || wireValue === undefined) {
+        decoded[alias] = [];
+        continue;
+      }
+
+      try {
+        let parsed: unknown;
+        if (typeof wireValue === 'string') {
+          parsed = JSON.parse(wireValue);
+        } else if (Array.isArray(wireValue)) {
+          parsed = wireValue;
+        } else {
+          parsed = JSON.parse(String(wireValue));
+        }
+
+        if (!Array.isArray(parsed)) {
+          throw new Error(`Expected array for include alias '${alias}', got ${typeof parsed}`);
+        }
+
+        decoded[alias] = parsed;
+      } catch (error) {
+        const decodeError = new Error(
+          `Failed to parse JSON array for include alias '${alias}': ${error instanceof Error ? error.message : String(error)}`,
+        ) as Error & {
+          code: string;
+          category: string;
+          severity: string;
+          details?: Record<string, unknown>;
+        };
+        decodeError.code = 'RUNTIME.DECODE_FAILED';
+        decodeError.category = 'RUNTIME';
+        decodeError.severity = 'error';
+        decodeError.details = {
+          alias,
+          wirePreview:
+            typeof wireValue === 'string' && wireValue.length > 100
+              ? `${wireValue.substring(0, 100)}...`
+              : String(wireValue).substring(0, 100),
+        };
+        throw decodeError;
+      }
+      continue;
+    }
+
+    if (wireValue === null || wireValue === undefined) {
+      decoded[alias] = wireValue;
+      continue;
+    }
+
+    const codec = resolveRowCodec(alias, plan, registry);
+
+    if (!codec) {
+      decoded[alias] = wireValue;
+      continue;
+    }
+
+    try {
+      decoded[alias] = codec.decode(wireValue);
+    } catch (error) {
+      const decodeError = new Error(
+        `Failed to decode row alias '${alias}' with codec '${codec.id}': ${error instanceof Error ? error.message : String(error)}`,
+      ) as Error & {
+        code: string;
+        category: string;
+        severity: string;
+        details?: Record<string, unknown>;
+      };
+      decodeError.code = 'RUNTIME.DECODE_FAILED';
+      decodeError.category = 'RUNTIME';
+      decodeError.severity = 'error';
+      decodeError.details = {
+        alias,
+        codec: codec.id,
+        wirePreview:
+          typeof wireValue === 'string' && wireValue.length > 100
+            ? `${wireValue.substring(0, 100)}...`
+            : String(wireValue).substring(0, 100),
+      };
+      throw decodeError;
+    }
+  }
+
+  return decoded;
+}

package/src/codecs/encoding.ts

@@ -0,0 +1,76 @@
+import type { ExecutionPlan, ParamDescriptor } from '@prisma-next/contract/types';
+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) {
+      return codec;
+    }
+  }
+
+  return null;
+}
+
+export function encodeParam(
+  value: unknown,
+  paramDescriptor: ParamDescriptor,
+  plan: ExecutionPlan,
+  registry: CodecRegistry,
+): unknown {
+  if (value === null || value === undefined) {
+    return null;
+  }
+
+  const codec = resolveParamCodec(paramDescriptor, plan, registry);
+  if (!codec) {
+    return value;
+  }
+
+  if (codec.encode) {
+    try {
+      return codec.encode(value);
+    } catch (error) {
+      throw new Error(
+        `Failed to encode parameter ${paramDescriptor.name ?? paramDescriptor.index}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  return value;
+}
+
+export function encodeParams(plan: ExecutionPlan, registry: CodecRegistry): readonly unknown[] {
+  if (plan.params.length === 0) {
+    return plan.params;
+  }
+
+  const encoded: unknown[] = [];
+
+  for (let i = 0; i < plan.params.length; i++) {
+    const paramValue = plan.params[i];
+    const paramDescriptor = plan.meta.paramDescriptors[i];
+
+    if (paramDescriptor) {
+      encoded.push(encodeParam(paramValue, paramDescriptor, plan, registry));
+    } else {
+      encoded.push(paramValue);
+    }
+  }
+
+  return Object.freeze(encoded);
+}

package/src/codecs/validation.ts

@@ -0,0 +1,67 @@
+import { runtimeError } from '@prisma-next/runtime-executor';
+import type { SqlContract, 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> {
+  const codecIds = new Set<string>();
+
+  for (const table of Object.values(contract.storage.tables)) {
+    for (const column of Object.values(table.columns)) {
+      const codecId = column.codecId;
+      codecIds.add(codecId);
+    }
+  }
+
+  return codecIds;
+}
+
+function extractCodecIdsFromColumns(contract: SqlContract<SqlStorage>): Map<string, string> {
+  const codecIds = new Map<string, string>();
+
+  for (const [tableName, table] of Object.entries(contract.storage.tables)) {
+    for (const [columnName, column] of Object.entries(table.columns)) {
+      const codecId = column.codecId;
+      const key = `${tableName}.${columnName}`;
+      codecIds.set(key, codecId);
+    }
+  }
+
+  return codecIds;
+}
+
+export function validateContractCodecMappings(
+  registry: CodecRegistry,
+  contract: SqlContract<SqlStorage>,
+): void {
+  const codecIds = extractCodecIdsFromColumns(contract);
+  const invalidCodecs: Array<{ table: string; column: string; codecId: string }> = [];
+
+  for (const [key, codecId] of codecIds.entries()) {
+    if (!registry.has(codecId)) {
+      const parts = key.split('.');
+      const table = parts[0] ?? '';
+      const column = parts[1] ?? '';
+      invalidCodecs.push({ table, column, codecId });
+    }
+  }
+
+  if (invalidCodecs.length > 0) {
+    const details: Record<string, unknown> = {
+      contractTarget: contract.target,
+      invalidCodecs,
+    };
+
+    throw runtimeError(
+      'RUNTIME.CODEC_MISSING',
+      `Missing codec implementations for column codecIds: ${invalidCodecs.map((c) => `${c.table}.${c.column} (${c.codecId})`).join(', ')}`,
+      details,
+    );
+  }
+}
+
+export function validateCodecRegistryCompleteness(
+  registry: CodecRegistry,
+  contract: SqlContract<SqlStorage>,
+): void {
+  validateContractCodecMappings(registry, contract);
+}

package/src/exports/index.ts

@@ -0,0 +1,40 @@
+export type {
+  AfterExecuteResult,
+  BudgetsOptions,
+  LintsOptions,
+  Log,
+  Plugin,
+  PluginContext,
+} 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 {
+  CreateRuntimeContextOptions,
+  RuntimeContext,
+  RuntimeParameterizedCodecDescriptor,
+  SqlRuntimeAdapterInstance,
+  SqlRuntimeExtensionDescriptor,
+  SqlRuntimeExtensionInstance,
+  TypeHelperRegistry,
+} from '../sql-context';
+export { createRuntimeContext } from '../sql-context';
+export type { SqlStatement } from '../sql-marker';
+export {
+  ensureSchemaStatement,
+  ensureTableStatement,
+  readContractMarker,
+  writeContractMarker,
+} from '../sql-marker';
+export type {
+  Runtime,
+  RuntimeOptions,
+  RuntimeTelemetryEvent,
+  RuntimeVerifyOptions,
+  TelemetryOutcome,
+} from '../sql-runtime';
+export { createRuntime } from '../sql-runtime';

package/src/index.ts

@@ -0,0 +1 @@
+export * from './exports';

package/src/lower-sql-plan.ts

@@ -0,0 +1,32 @@
+import type { ExecutionPlan } from '@prisma-next/contract/types';
+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 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,
+  queryPlan: SqlQueryPlan<Row>,
+): ExecutionPlan<Row> {
+  const lowered = context.adapter.lower(queryPlan.ast, {
+    contract: context.contract,
+    params: queryPlan.params,
+  });
+
+  const body = lowered.body;
+
+  return Object.freeze({
+    sql: body.sql,
+    params: body.params ?? queryPlan.params,
+    ast: queryPlan.ast,
+    meta: queryPlan.meta,
+  });
+}