@prisma-next/sql-runtime 0.3.0-dev.13 → 0.3.0-dev.146

package/src/sql-marker.ts

@@ -6,7 +6,7 @@ export interface SqlStatement {
 }
 
 export interface WriteMarkerInput {
-  readonly coreHash: string;
+  readonly storageHash: string;
   readonly profileHash: string;
   readonly contractJson?: unknown;
   readonly canonicalVersion?: number;
@@ -57,7 +57,7 @@ export interface WriteContractMarkerStatements {
 export function writeContractMarker(input: WriteMarkerInput): WriteContractMarkerStatements {
   const baseParams: readonly unknown[] = [
     1,
-    input.coreHash,
+    input.storageHash,
     input.profileHash,
     input.contractJson ?? null,
     input.canonicalVersion ?? null,

package/src/sql-runtime.ts

@@ -1,5 +1,8 @@
-import type { ExecutionPlan } from '@prisma-next/contract/types';
-import type { OperationRegistry } from '@prisma-next/operations';
+import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
+import type {
+  ExecutionStackInstance,
+  RuntimeDriverInstance,
+} from '@prisma-next/framework-components/execution';
 import type {
   Log,
   Plugin,
@@ -10,86 +13,133 @@ import type {
   TelemetryOutcome,
 } from '@prisma-next/runtime-executor';
 import { AsyncIterableResult, createRuntimeCore } from '@prisma-next/runtime-executor';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   Adapter,
+  AnyQueryAst,
   CodecRegistry,
   LoweredStatement,
   SelectAst,
   SqlDriver,
 } from '@prisma-next/sql-relational-core/ast';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import type { JsonSchemaValidatorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { decodeRow } from './codecs/decoding';
 import { encodeParams } from './codecs/encoding';
 import { validateCodecRegistryCompleteness } from './codecs/validation';
 import { lowerSqlPlan } from './lower-sql-plan';
-import type { RuntimeContext } from './sql-context';
+import type {
+  ExecutionContext,
+  SqlRuntimeAdapterInstance,
+  SqlRuntimeExtensionInstance,
+} from './sql-context';
 import { SqlFamilyAdapter } from './sql-family-adapter';
 
-export interface RuntimeOptions<
-  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
+export interface RuntimeOptions<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> {
+  readonly context: ExecutionContext<TContract>;
+  readonly adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
+  readonly driver: SqlDriver<unknown>;
+  readonly verify: RuntimeVerifyOptions;
+  readonly plugins?: readonly Plugin<
+    TContract,
+    Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+    SqlDriver<unknown>
+  >[];
+  readonly mode?: 'strict' | 'permissive';
+  readonly log?: Log;
+}
+
+export interface CreateRuntimeOptions<
+  TContract extends Contract<SqlStorage> = Contract<SqlStorage>,
+  TTargetId extends string = string,
 > {
-  readonly driver: SqlDriver;
+  readonly stackInstance: ExecutionStackInstance<
+    'sql',
+    TTargetId,
+    SqlRuntimeAdapterInstance<TTargetId>,
+    RuntimeDriverInstance<'sql', TTargetId>,
+    SqlRuntimeExtensionInstance<TTargetId>
+  >;
+  readonly context: ExecutionContext<TContract>;
+  readonly driver: SqlDriver<unknown>;
   readonly verify: RuntimeVerifyOptions;
-  readonly context: RuntimeContext<TContract>;
   readonly plugins?: readonly Plugin<
     TContract,
-    Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-    SqlDriver
+    Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+    SqlDriver<unknown>
   >[];
   readonly mode?: 'strict' | 'permissive';
   readonly log?: Log;
 }
 
-export interface Runtime {
+export interface Runtime extends RuntimeQueryable {
+  connection(): Promise<RuntimeConnection>;
+  telemetry(): RuntimeTelemetryEvent | null;
+  close(): Promise<void>;
+}
+
+export interface RuntimeConnection extends RuntimeQueryable {
+  transaction(): Promise<RuntimeTransaction>;
+  release(): Promise<void>;
+}
+
+export interface RuntimeTransaction extends RuntimeQueryable {
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+}
+
+export interface RuntimeQueryable {
   execute<Row = Record<string, unknown>>(
     plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
   ): AsyncIterableResult<Row>;
-  telemetry(): RuntimeTelemetryEvent | null;
-  close(): Promise<void>;
-  operations(): OperationRegistry;
+}
+
+interface CoreQueryable {
+  execute<Row = Record<string, unknown>>(plan: ExecutionPlan<Row>): AsyncIterableResult<Row>;
 }
 
 export type { RuntimeTelemetryEvent, RuntimeVerifyOptions, TelemetryOutcome };
 
-class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>>
+class SqlRuntimeImpl<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>
   implements Runtime
 {
   private readonly core: RuntimeCore<
     TContract,
-    Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-    SqlDriver
+    Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+    SqlDriver<unknown>
   >;
   private readonly contract: TContract;
-  private readonly context: RuntimeContext<TContract>;
+  private readonly adapter: Adapter<AnyQueryAst, Contract<SqlStorage>, LoweredStatement>;
   private readonly codecRegistry: CodecRegistry;
+  private readonly jsonSchemaValidators: JsonSchemaValidatorRegistry | undefined;
   private codecRegistryValidated: boolean;
 
   constructor(options: RuntimeOptions<TContract>) {
-    const { context, driver, verify, plugins, mode, log } = options;
+    const { context, adapter, driver, verify, plugins, mode, log } = options;
     this.contract = context.contract;
-    this.context = context;
+    this.adapter = adapter;
     this.codecRegistry = context.codecs;
+    this.jsonSchemaValidators = context.jsonSchemaValidators;
     this.codecRegistryValidated = false;
 
-    const familyAdapter = new SqlFamilyAdapter(context.contract);
+    const familyAdapter = new SqlFamilyAdapter(context.contract, adapter.profile);
 
     const coreOptions: RuntimeCoreOptions<
       TContract,
-      Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-      SqlDriver
+      Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+      SqlDriver<unknown>
     > = {
       familyAdapter,
       driver,
       verify,
       plugins: plugins as readonly Plugin<
         TContract,
-        Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-        SqlDriver
+        Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+        SqlDriver<unknown>
       >[],
-      ...(mode !== undefined ? { mode } : {}),
-      ...(log !== undefined ? { log } : {}),
-      operationRegistry: context.operations,
+      ...ifDefined('mode', mode),
+      ...ifDefined('log', log),
     };
 
     this.core = createRuntimeCore(coreOptions);
@@ -100,27 +150,27 @@ class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<Sql
     }
   }
 
-  private ensureCodecRegistryValidated(contract: SqlContract<SqlStorage>): void {
+  private ensureCodecRegistryValidated(contract: Contract<SqlStorage>): void {
     if (!this.codecRegistryValidated) {
       validateCodecRegistryCompleteness(this.codecRegistry, contract);
       this.codecRegistryValidated = true;
     }
   }
 
-  execute<Row = Record<string, unknown>>(
-    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
-  ): AsyncIterableResult<Row> {
-    this.ensureCodecRegistryValidated(this.contract);
-
-    // Check if plan is SqlQueryPlan (has ast but no sql)
+  private toExecutionPlan<Row>(plan: ExecutionPlan<Row> | SqlQueryPlan<Row>): ExecutionPlan<Row> {
     const isSqlQueryPlan = (p: ExecutionPlan<Row> | SqlQueryPlan<Row>): p is SqlQueryPlan<Row> => {
       return 'ast' in p && !('sql' in p);
     };
 
-    // Lower SqlQueryPlan to Plan if needed
-    const executablePlan: ExecutionPlan<Row> = isSqlQueryPlan(plan)
-      ? lowerSqlPlan(this.context, plan)
-      : plan;
+    return isSqlQueryPlan(plan) ? lowerSqlPlan(this.adapter, this.contract, plan) : plan;
+  }
+
+  private executeAgainstQueryable<Row = Record<string, unknown>>(
+    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+    queryable: CoreQueryable,
+  ): AsyncIterableResult<Row> {
+    this.ensureCodecRegistryValidated(this.contract);
+    const executablePlan = this.toExecutionPlan(plan);
 
     const iterator = async function* (
       self: SqlRuntimeImpl<TContract>,
@@ -131,13 +181,14 @@ class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<Sql
         params: encodedParams,
       };
 
-      const coreIterator = self.core.execute(planWithEncodedParams);
+      const coreIterator = queryable.execute(planWithEncodedParams);
 
       for await (const rawRow of coreIterator) {
         const decodedRow = decodeRow(
           rawRow as Record<string, unknown>,
           executablePlan,
           self.codecRegistry,
+          self.jsonSchemaValidators,
         );
         yield decodedRow as Row;
       }
@@ -146,12 +197,40 @@ class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<Sql
     return new AsyncIterableResult(iterator(this));
   }
 
-  telemetry(): RuntimeTelemetryEvent | null {
-    return this.core.telemetry();
+  execute<Row = Record<string, unknown>>(
+    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+  ): AsyncIterableResult<Row> {
+    return this.executeAgainstQueryable(plan, this.core);
   }
 
-  operations(): OperationRegistry {
-    return this.core.operations();
+  async connection(): Promise<RuntimeConnection> {
+    const coreConn = await this.core.connection();
+    const self = this;
+    const wrappedConnection: RuntimeConnection = {
+      async transaction(): Promise<RuntimeTransaction> {
+        const coreTx = await coreConn.transaction();
+        return {
+          commit: coreTx.commit.bind(coreTx),
+          rollback: coreTx.rollback.bind(coreTx),
+          execute<Row = Record<string, unknown>>(
+            plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+          ): AsyncIterableResult<Row> {
+            return self.executeAgainstQueryable(plan, coreTx);
+          },
+        };
+      },
+      release: coreConn.release.bind(coreConn),
+      execute<Row = Record<string, unknown>>(
+        plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+      ): AsyncIterableResult<Row> {
+        return self.executeAgainstQueryable(plan, coreConn);
+      },
+    };
+    return wrappedConnection;
+  }
+
+  telemetry(): RuntimeTelemetryEvent | null {
+    return this.core.telemetry();
   }
 
   close(): Promise<void> {
@@ -159,8 +238,18 @@ class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<Sql
   }
 }
 
-export function createRuntime<TContract extends SqlContract<SqlStorage>>(
-  options: RuntimeOptions<TContract>,
+export function createRuntime<TContract extends Contract<SqlStorage>, TTargetId extends string>(
+  options: CreateRuntimeOptions<TContract, TTargetId>,
 ): Runtime {
-  return new SqlRuntimeImpl(options);
+  const { stackInstance, context, driver, verify, plugins, mode, log } = options;
+
+  return new SqlRuntimeImpl({
+    context,
+    adapter: stackInstance.adapter,
+    driver,
+    verify,
+    ...ifDefined('plugins', plugins),
+    ...ifDefined('mode', mode),
+    ...ifDefined('log', log),
+  });
 }

package/test/async-iterable-result.test.ts

@@ -1,10 +1,17 @@
 import type { ExecutionPlan } from '@prisma-next/contract/types';
+import { instantiateExecutionStack } from '@prisma-next/framework-components/execution';
 import type { AsyncIterableResult } from '@prisma-next/runtime-executor';
 import { describe, expect, it } from 'vitest';
-import { createRuntime } from '../src/exports';
-import { createStubAdapter, createTestContext, createTestContract } from './utils';
+import type { Runtime } from '../src/exports';
+import { createRuntime, createSqlExecutionStack } from '../src/exports';
+import {
+  createStubAdapter,
+  createTestAdapterDescriptor,
+  createTestContext,
+  createTestContract,
+  createTestTargetDescriptor,
+} from './utils';
 
-// Mock driver that implements SqlDriver interface
 class MockDriver {
   private rows: ReadonlyArray<Record<string, unknown>> = [];
 
@@ -12,11 +19,10 @@ class MockDriver {
     this.rows = rows;
   }
 
-  async query(
+  async query<Row = Record<string, unknown>>(
     _sql: string,
-    _params: readonly unknown[],
-  ): Promise<{ rows: ReadonlyArray<unknown> }> {
-    // Return empty marker result for contract verification
+    _params?: readonly unknown[],
+  ): Promise<{ rows: ReadonlyArray<Row> }> {
     return { rows: [] };
   }
 
@@ -29,20 +35,19 @@ class MockDriver {
     }
   }
 
-  async connect(): Promise<void> {
-    // No-op
+  async acquireConnection(): Promise<never> {
+    throw new Error('Not implemented in mock');
   }
 
-  async close(): Promise<void> {
-    // No-op
-  }
+  async connect(): Promise<void> {}
+
+  async close(): Promise<void> {}
 }
 
 const fixtureContract = createTestContract({
-  schemaVersion: '1',
   targetFamily: 'sql',
   target: 'postgres',
-  coreHash: 'test-hash',
+  storageHash: 'test-hash',
   profileHash: 'test-profile-hash',
   storage: {
     tables: {
@@ -58,24 +63,33 @@ const fixtureContract = createTestContract({
     },
   },
   models: {},
-  relations: {},
-  mappings: { codecTypes: {}, operationTypes: {} },
 });
 
+function createTestRuntime(mockDriver: MockDriver): Runtime {
+  const adapter = createStubAdapter();
+  const stack = createSqlExecutionStack({
+    target: createTestTargetDescriptor(),
+    adapter: createTestAdapterDescriptor(adapter),
+    extensionPacks: [],
+  });
+  const stackInstance = instantiateExecutionStack(stack);
+  const context = createTestContext(fixtureContract, adapter);
+  return createRuntime({
+    stackInstance,
+    context,
+    driver: mockDriver,
+    verify: { mode: 'onFirstUse', requireMarker: false },
+  });
+}
+
 describe('SqlRuntime AsyncIterableResult integration', () => {
   it('returns AsyncIterableResult from execute', async () => {
-    const adapter = createStubAdapter();
     const driver = new MockDriver();
     driver.setRows([
       { id: 1, email: 'test1@example.com' },
       { id: 2, email: 'test2@example.com' },
     ]);
-    const context = createTestContext(fixtureContract, adapter);
-    const runtime = createRuntime({
-      driver: driver as unknown as Parameters<typeof createRuntime>[0]['driver'],
-      context,
-      verify: { mode: 'onFirstUse', requireMarker: false },
-    });
+    const runtime = createTestRuntime(driver);
 
     const plan: ExecutionPlan<{ id: number; email: string }> = {
       sql: 'SELECT id, email FROM "user" ORDER BY id',
@@ -83,7 +97,7 @@ describe('SqlRuntime AsyncIterableResult integration', () => {
       meta: {
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'test-hash',
+        storageHash: 'test-hash',
         lane: 'sql',
         paramDescriptors: [],
       },
@@ -91,7 +105,6 @@ describe('SqlRuntime AsyncIterableResult integration', () => {
 
     const result = runtime.execute(plan);
 
-    // Verify it's an AsyncIterableResult
     expect(result).toBeInstanceOf(Object);
     expect(typeof result.toArray).toBe('function');
     expect(typeof result[Symbol.asyncIterator]).toBe('function');
@@ -100,15 +113,9 @@ describe('SqlRuntime AsyncIterableResult integration', () => {
   });
 
   it('preserves type information', async () => {
-    const adapter = createStubAdapter();
     const driver = new MockDriver();
     driver.setRows([{ id: 1, email: 'test@example.com' }]);
-    const context = createTestContext(fixtureContract, adapter);
-    const runtime = createRuntime({
-      driver: driver as unknown as Parameters<typeof createRuntime>[0]['driver'],
-      context,
-      verify: { mode: 'onFirstUse', requireMarker: false },
-    });
+    const runtime = createTestRuntime(driver);
 
     const plan: ExecutionPlan<{ id: number; email: string }> = {
       sql: 'SELECT id, email FROM "user" LIMIT 1',
@@ -116,7 +123,7 @@ describe('SqlRuntime AsyncIterableResult integration', () => {
       meta: {
         target: 'postgres',
         targetFamily: 'sql',
-        coreHash: 'test-hash',
+        storageHash: 'test-hash',
         lane: 'sql',
         paramDescriptors: [],
       },
@@ -126,10 +133,8 @@ describe('SqlRuntime AsyncIterableResult integration', () => {
     const rows = await result.toArray();
 
     expect(rows.length).toBe(1);
-    if (rows[0]) {
-      expect(typeof rows[0].id).toBe('number');
-      expect(typeof rows[0].email).toBe('string');
-    }
+    expect(typeof rows[0]!.id).toBe('number');
+    expect(typeof rows[0]!.email).toBe('string');
 
     await runtime.close();
   });