@prisma-next/sql-runtime 0.3.0-dev.7 → 0.3.0-dev.71

package/test/sql-runtime.test.ts

@@ -1,4 +1,10 @@
-import { createOperationRegistry } from '@prisma-next/operations';
+import { coreHash, type ExecutionPlan } from '@prisma-next/contract/types';
+import type { ExecutionStackInstance } from '@prisma-next/core-execution-plane/stack';
+import { instantiateExecutionStack } from '@prisma-next/core-execution-plane/stack';
+import type {
+  RuntimeDriverInstance,
+  RuntimeExtensionInstance,
+} from '@prisma-next/core-execution-plane/types';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   CodecRegistry,
@@ -8,15 +14,19 @@ import type {
 } from '@prisma-next/sql-relational-core/ast';
 import { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import { describe, expect, it, vi } from 'vitest';
-import type { RuntimeContext } from '../src/sql-context';
+import type {
+  SqlRuntimeAdapterDescriptor,
+  SqlRuntimeAdapterInstance,
+  SqlRuntimeTargetDescriptor,
+} from '../src/sql-context';
+import { createExecutionContext, createSqlExecutionStack } from '../src/sql-context';
 import { createRuntime } from '../src/sql-runtime';
 
-// Minimal test contract
 const testContract: SqlContract<SqlStorage> = {
   schemaVersion: '1',
   targetFamily: 'sql',
   target: 'postgres',
-  coreHash: 'sha256:test',
+  storageHash: coreHash('sha256:test'),
   models: {},
   relations: {},
   storage: { tables: {} },
@@ -30,7 +40,14 @@ const testContract: SqlContract<SqlStorage> = {
   },
 };
 
-// Create a stub codec registry
+interface DriverExecuteSpies {
+  rootExecute: ReturnType<typeof vi.fn>;
+  connectionExecute: ReturnType<typeof vi.fn>;
+  transactionExecute: ReturnType<typeof vi.fn>;
+}
+
+type MockSqlDriver = SqlDriver & { __spies: DriverExecuteSpies };
+
 function createStubCodecs(): CodecRegistry {
   const registry = createCodecRegistry();
   registry.register(
@@ -44,7 +61,6 @@ function createStubCodecs(): CodecRegistry {
   return registry;
 }
 
-// Create a stub adapter
 function createStubAdapter() {
   const codecs = createStubCodecs();
   return {
@@ -67,37 +83,141 @@ function createStubAdapter() {
   };
 }
 
-// Create a mock driver that implements SqlDriver interface
-function createMockDriver(): SqlDriver {
-  const execute = vi.fn().mockImplementation(async function* (_request: SqlExecuteRequest) {
+function createMockDriver(): MockSqlDriver {
+  const rootExecute = vi.fn().mockImplementation(async function* (_request: SqlExecuteRequest) {
     yield { id: 1 };
   });
+  const connectionExecute = vi.fn().mockImplementation(async function* (
+    _request: SqlExecuteRequest,
+  ) {
+    yield { id: 2 };
+  });
+  const transactionExecute = vi.fn().mockImplementation(async function* (
+    _request: SqlExecuteRequest,
+  ) {
+    yield { id: 3 };
+  });
 
-  return {
-    connect: vi.fn().mockResolvedValue(undefined),
-    execute,
-    query: vi.fn().mockResolvedValue({ rows: [], rowCount: 0 }),
+  const query = vi.fn().mockResolvedValue({ rows: [], rowCount: 0 });
+
+  const transaction = {
+    execute: transactionExecute,
+    query,
+    commit: vi.fn().mockResolvedValue(undefined),
+    rollback: vi.fn().mockResolvedValue(undefined),
+  };
+
+  const connection = {
+    execute: connectionExecute,
+    query,
+    release: vi.fn().mockResolvedValue(undefined),
+    beginTransaction: vi.fn().mockResolvedValue(transaction),
+  };
+
+  const driver: SqlDriver = {
+    execute: rootExecute,
+    query,
+    connect: vi.fn().mockImplementation(async (_binding?: undefined) => undefined),
+    acquireConnection: vi.fn().mockResolvedValue(connection),
     close: vi.fn().mockResolvedValue(undefined),
   };
+
+  return Object.assign(driver, {
+    __spies: {
+      rootExecute,
+      connectionExecute,
+      transactionExecute,
+    },
+  });
 }
 
-// Create a test runtime context
-function createTestContext(contract: SqlContract<SqlStorage>): RuntimeContext<typeof contract> {
+function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {
+  return {
+    kind: 'target',
+    id: 'postgres',
+    version: '0.0.1',
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    codecs: () => createCodecRegistry(),
+    operationSignatures: () => [],
+    parameterizedCodecs: () => [],
+    create() {
+      return { familyId: 'sql' as const, targetId: 'postgres' as const };
+    },
+  };
+}
+
+function createTestAdapterDescriptor(
+  adapter: ReturnType<typeof createStubAdapter>,
+): SqlRuntimeAdapterDescriptor<'postgres'> {
+  const codecRegistry = adapter.profile.codecs();
+  return {
+    kind: 'adapter',
+    id: 'test-adapter',
+    version: '0.0.1',
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    codecs: () => codecRegistry,
+    operationSignatures: () => [],
+    parameterizedCodecs: () => [],
+    create() {
+      return Object.assign(
+        { familyId: 'sql' as const, targetId: 'postgres' as const },
+        adapter,
+      ) as SqlRuntimeAdapterInstance<'postgres'>;
+    },
+  };
+}
+
+function createTestSetup() {
   const adapter = createStubAdapter();
+  const driver = createMockDriver();
+
+  const targetDescriptor = createTestTargetDescriptor();
+  const adapterDescriptor = createTestAdapterDescriptor(adapter);
+
+  const stack = createSqlExecutionStack({
+    target: targetDescriptor,
+    adapter: adapterDescriptor,
+    extensionPacks: [],
+  });
+  type SqlTestStackInstance = ExecutionStackInstance<
+    'sql',
+    'postgres',
+    SqlRuntimeAdapterInstance<'postgres'>,
+    RuntimeDriverInstance<'sql', 'postgres'>,
+    RuntimeExtensionInstance<'sql', 'postgres'>
+  >;
+  const stackInstance = instantiateExecutionStack(stack) as SqlTestStackInstance;
+
+  const context = createExecutionContext({
+    contract: testContract,
+    stack: { target: targetDescriptor, adapter: adapterDescriptor, extensionPacks: [] },
+  });
+
+  return { stackInstance, context, driver };
+}
+
+function createRawExecutionPlan<Row = Record<string, unknown>>(): ExecutionPlan<Row> {
   return {
-    contract,
-    adapter,
-    codecs: adapter.profile.codecs(),
-    operations: createOperationRegistry(),
+    sql: 'select 1',
+    params: [],
+    meta: {
+      target: testContract.target,
+      targetFamily: testContract.targetFamily,
+      storageHash: testContract.storageHash,
+      lane: 'raw',
+      paramDescriptors: [],
+    },
   };
 }
 
 describe('createRuntime', () => {
-  it('creates runtime with valid options', () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+  it('creates runtime with context and driver', () => {
+    const { stackInstance, context, driver } = createTestSetup();
 
     const runtime = createRuntime({
+      stackInstance,
       context,
       driver,
       verify: { mode: 'onFirstUse', requireMarker: false },
@@ -111,10 +231,10 @@ describe('createRuntime', () => {
   });
 
   it('returns operations registry', () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+    const { stackInstance, context, driver } = createTestSetup();
 
     const runtime = createRuntime({
+      stackInstance,
       context,
       driver,
       verify: { mode: 'onFirstUse', requireMarker: false },
@@ -126,24 +246,23 @@ describe('createRuntime', () => {
   });
 
   it('returns null telemetry when no events', () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+    const { stackInstance, context, driver } = createTestSetup();
 
     const runtime = createRuntime({
+      stackInstance,
       context,
       driver,
       verify: { mode: 'onFirstUse', requireMarker: false },
     });
 
-    // Before any execution, telemetry should be null
     expect(runtime.telemetry()).toBeNull();
   });
 
-  it('closes runtime', async () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+  it('closes runtime and driver', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
 
     const runtime = createRuntime({
+      stackInstance,
       context,
       driver,
       verify: { mode: 'onFirstUse', requireMarker: false },
@@ -152,4 +271,73 @@ describe('createRuntime', () => {
     await runtime.close();
     expect(driver.close).toHaveBeenCalled();
   });
+
+  it('validates codec registry at startup when verify mode is startup', () => {
+    const { stackInstance, context, driver } = createTestSetup();
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'startup', requireMarker: false },
+    });
+
+    expect(runtime).toBeDefined();
+  });
+
+  it('uses acquired connection queryable for connection.execute', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    const connection = await runtime.connection();
+    await connection.execute(createRawExecutionPlan()).toArray();
+
+    expect(driver.__spies.connectionExecute).toHaveBeenCalledTimes(1);
+    expect(driver.__spies.transactionExecute).not.toHaveBeenCalled();
+    expect(driver.__spies.rootExecute).not.toHaveBeenCalled();
+
+    await connection.release();
+  });
+
+  it('uses transaction queryable for transaction.execute', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    const connection = await runtime.connection();
+    const transaction = await connection.transaction();
+    await transaction.execute(createRawExecutionPlan()).toArray();
+
+    expect(driver.__spies.transactionExecute).toHaveBeenCalledTimes(1);
+    expect(driver.__spies.connectionExecute).not.toHaveBeenCalled();
+    expect(driver.__spies.rootExecute).not.toHaveBeenCalled();
+
+    await transaction.rollback();
+    await connection.release();
+  });
+
+  it('keeps root execute on driver queryable for runtime.execute', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    await runtime.execute(createRawExecutionPlan()).toArray();
+
+    expect(driver.__spies.rootExecute).toHaveBeenCalledTimes(1);
+    expect(driver.__spies.connectionExecute).not.toHaveBeenCalled();
+    expect(driver.__spies.transactionExecute).not.toHaveBeenCalled();
+  });
 });

package/test/utils.ts

@@ -1,4 +1,7 @@
 import type { ExecutionPlan, ResultType } from '@prisma-next/contract/types';
+import { coreHash, profileHash } from '@prisma-next/contract/types';
+import { instantiateExecutionStack } from '@prisma-next/core-execution-plane/stack';
+import type { RuntimeDriverDescriptor } from '@prisma-next/core-execution-plane/types';
 import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
 import type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';
 import { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
@@ -7,16 +10,20 @@ import { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';
 import type { Client } from 'pg';
 import type { SqlStatement } from '../src/exports';
 import {
+  createExecutionContext,
   type createRuntime,
-  createRuntimeContext,
+  createSqlExecutionStack,
   ensureSchemaStatement,
   ensureTableStatement,
   writeContractMarker,
 } from '../src/exports';
 import type {
-  RuntimeContext,
+  ExecutionContext,
+  SqlRuntimeAdapterDescriptor,
   SqlRuntimeAdapterInstance,
+  SqlRuntimeDriverInstance,
   SqlRuntimeExtensionDescriptor,
+  SqlRuntimeTargetDescriptor,
 } from '../src/sql-context';
 
 /**
@@ -71,8 +78,8 @@ export async function setupTestDatabase(
   await executeStatement(client, ensureSchemaStatement);
   await executeStatement(client, ensureTableStatement);
   const write = writeContractMarker({
-    coreHash: contract.coreHash,
-    profileHash: contract.profileHash ?? contract.coreHash,
+    storageHash: contract.storageHash,
+    profileHash: contract.profileHash ?? contract.storageHash,
     contractJson: contract,
     canonicalVersion: 1,
   });
@@ -88,8 +95,8 @@ export async function writeTestContractMarker(
   contract: SqlContract<SqlStorage>,
 ): Promise<void> {
   const write = writeContractMarker({
-    coreHash: contract.coreHash,
-    profileHash: contract.profileHash ?? contract.coreHash,
+    storageHash: contract.storageHash,
+    profileHash: contract.profileHash ?? contract.storageHash,
     contractJson: contract,
     canonicalVersion: 1,
   });
@@ -98,56 +105,41 @@ export async function writeTestContractMarker(
 
 /**
  * Creates a test adapter descriptor from a raw adapter.
- * This wraps the adapter in a descriptor for descriptor-first context creation in tests.
- * The adapter instance IS an Adapter (via intersection), with identity properties added.
+ * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions
+ * derived from the adapter's codec registry.
  */
-function createTestAdapterDescriptor(
+export function createTestAdapterDescriptor(
   adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-): {
-  readonly kind: 'adapter';
-  readonly id: string;
-  readonly version: string;
-  readonly familyId: 'sql';
-  readonly targetId: 'postgres';
-  create(): SqlRuntimeAdapterInstance<'postgres'>;
-} {
+): SqlRuntimeAdapterDescriptor<'postgres'> {
+  const codecRegistry = adapter.profile.codecs();
   return {
     kind: 'adapter' as const,
     id: 'test-adapter',
     version: '0.0.1',
     familyId: 'sql' as const,
     targetId: 'postgres' as const,
+    codecs: () => codecRegistry,
+    operationSignatures: () => [],
+    parameterizedCodecs: () => [],
     create(): SqlRuntimeAdapterInstance<'postgres'> {
-      // Return an object that combines identity properties with the adapter's methods
-      return Object.assign(
-        {
-          familyId: 'sql' as const,
-          targetId: 'postgres' as const,
-        },
-        adapter,
-      );
+      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);
     },
   };
 }
 
 /**
- * Creates a test target descriptor.
- * This is a minimal descriptor for descriptor-first context creation in tests.
+ * Creates a test target descriptor with empty static contributions.
  */
-function createTestTargetDescriptor(): {
-  readonly kind: 'target';
-  readonly id: string;
-  readonly version: string;
-  readonly familyId: 'sql';
-  readonly targetId: 'postgres';
-  create(): { readonly familyId: 'sql'; readonly targetId: 'postgres' };
-} {
+export function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {
   return {
     kind: 'target' as const,
     id: 'postgres',
     version: '0.0.1',
     familyId: 'sql' as const,
     targetId: 'postgres' as const,
+    codecs: () => createCodecRegistry(),
+    operationSignatures: () => [],
+    parameterizedCodecs: () => [],
     create() {
       return { familyId: 'sql' as const, targetId: 'postgres' as const };
     },
@@ -155,7 +147,7 @@ function createTestTargetDescriptor(): {
 }
 
 /**
- * Creates a runtime context with standard test configuration.
+ * 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
@@ -167,13 +159,34 @@ export function createTestContext<TContract extends SqlContract<SqlStorage>>(
   options?: {
     extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
   },
-): RuntimeContext<TContract> {
-  return createRuntimeContext<TContract, 'postgres'>({
+): ExecutionContext<TContract> {
+  return createExecutionContext({
     contract,
+    stack: {
+      target: createTestTargetDescriptor(),
+      adapter: createTestAdapterDescriptor(adapter),
+      extensionPacks: options?.extensionPacks ?? [],
+    },
+  });
+}
+
+export function createTestStackInstance(options?: {
+  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
+  driver?: RuntimeDriverDescriptor<
+    'sql',
+    'postgres',
+    unknown,
+    SqlRuntimeDriverInstance<'postgres'>
+  >;
+}) {
+  const stack = createSqlExecutionStack({
     target: createTestTargetDescriptor(),
-    adapter: createTestAdapterDescriptor(adapter),
+    adapter: createTestAdapterDescriptor(createStubAdapter()),
+    driver: options?.driver,
     extensionPacks: options?.extensionPacks ?? [],
   });
+
+  return instantiateExecutionStack(stack);
 }
 
 /**
@@ -212,8 +225,7 @@ export function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>,
       typeId: 'pg/timestamptz@1',
       targetTypes: ['timestamptz'],
       encode: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),
-      decode: (wire: string | Date) =>
-        typeof wire === 'string' ? wire : wire instanceof Date ? wire.toISOString() : String(wire),
+      decode: (wire: string | Date) => (wire instanceof Date ? wire : new Date(wire)),
     }),
   );
 
@@ -238,18 +250,35 @@ export function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>,
 
 /**
  * Creates a valid test contract without using validateContract.
- * Ensures mappings are present and returns the contract with proper typing.
+ * Ensures all required fields are present (mappings, capabilities, extensionPacks, meta, sources)
+ * and returns the contract with proper typing.
  * This helper allows tests to create contracts without depending on sql-query.
  */
-export function createTestContract<T extends SqlContract<SqlStorage>>(contract: T): T {
-  // Ensure mappings are present
-  if (!contract.mappings) {
-    return {
-      ...contract,
-      mappings: { codecTypes: {}, operationTypes: {} },
-    } as T;
-  }
-  return contract;
+export function createTestContract(
+  contract: Partial<Omit<SqlContract<SqlStorage>, 'storageHash' | 'profileHash'>> & {
+    storageHash?: string;
+    profileHash?: string;
+  },
+): SqlContract<SqlStorage> {
+  const { execution, ...rest } = contract;
+
+  return {
+    ...rest,
+    schemaVersion: rest.schemaVersion ?? '1',
+    target: rest.target ?? 'postgres',
+    targetFamily: rest.targetFamily ?? 'sql',
+    storage: rest.storage ?? { tables: {} },
+    models: rest.models ?? {},
+    relations: rest.relations ?? {},
+    mappings: rest.mappings ?? { codecTypes: {}, operationTypes: {} },
+    capabilities: rest.capabilities ?? {},
+    extensionPacks: rest.extensionPacks ?? {},
+    meta: rest.meta ?? {},
+    sources: rest.sources ?? {},
+    ...(execution ? { execution } : {}),
+    storageHash: coreHash(rest.storageHash ?? 'sha256:testcore'),
+    profileHash: profileHash(rest.profileHash ?? 'sha256:testprofile'),
+  } satisfies SqlContract<SqlStorage>;
 }
 
 // Re-export generic utilities from test-utils