@prisma-next/sql-runtime 0.3.0-dev.33 → 0.3.0-dev.36

package/test/sql-runtime.test.ts

@@ -1,4 +1,10 @@
-import { createOperationRegistry } from '@prisma-next/operations';
+import { coreHash } 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,6 @@ const testContract: SqlContract<SqlStorage> = {
   },
 };
 
-// Create a stub codec registry
 function createStubCodecs(): CodecRegistry {
   const registry = createCodecRegistry();
   registry.register(
@@ -44,7 +53,6 @@ function createStubCodecs(): CodecRegistry {
   return registry;
 }
 
-// Create a stub adapter
 function createStubAdapter() {
   const codecs = createStubCodecs();
   return {
@@ -67,37 +75,103 @@ function createStubAdapter() {
   };
 }
 
-// Create a mock driver that implements SqlDriver interface
 function createMockDriver(): SqlDriver {
-  const execute = vi.fn().mockImplementation(async function* (_request: SqlExecuteRequest) {
-    yield { id: 1 };
-  });
+  const queryable = {
+    execute: vi.fn().mockImplementation(async function* (_request: SqlExecuteRequest) {
+      yield { id: 1 };
+    }),
+    query: vi.fn().mockResolvedValue({ rows: [], rowCount: 0 }),
+  };
 
   return {
-    connect: vi.fn().mockResolvedValue(undefined),
-    execute,
-    query: vi.fn().mockResolvedValue({ rows: [], rowCount: 0 }),
+    ...queryable,
+    connect: vi.fn().mockImplementation(async (_binding?: undefined) => undefined),
+    acquireConnection: vi.fn().mockResolvedValue({
+      ...queryable,
+      release: vi.fn().mockResolvedValue(undefined),
+      beginTransaction: vi.fn().mockResolvedValue({
+        ...queryable,
+        commit: vi.fn().mockResolvedValue(undefined),
+        rollback: vi.fn().mockResolvedValue(undefined),
+      }),
+    }),
     close: vi.fn().mockResolvedValue(undefined),
   };
 }
 
-// Create a test runtime context
-function createTestContext(contract: SqlContract<SqlStorage>): RuntimeContext<typeof contract> {
-  const adapter = createStubAdapter();
+function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {
   return {
-    contract,
-    adapter,
-    codecs: adapter.profile.codecs(),
-    operations: createOperationRegistry(),
+    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 };
+}
+
 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 +185,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 +200,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 +225,17 @@ 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();
+  });
 });

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);
 }
 
 /**
@@ -242,18 +255,31 @@ export function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>,
  * 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: Partial<T> &
-    Omit<T, 'mappings' | 'capabilities' | 'extensionPacks' | 'meta' | 'sources'>,
-): T {
+export function createTestContract(
+  contract: Partial<Omit<SqlContract<SqlStorage>, 'storageHash' | 'profileHash'>> & {
+    storageHash?: string;
+    profileHash?: string;
+  },
+): SqlContract<SqlStorage> {
+  const { execution, ...rest } = contract;
+
   return {
-    ...contract,
-    mappings: contract.mappings ?? { codecTypes: {}, operationTypes: {} },
-    capabilities: contract.capabilities ?? {},
-    extensionPacks: contract.extensionPacks ?? {},
-    meta: contract.meta ?? {},
-    sources: contract.sources ?? {},
-  } as T;
+    ...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