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

package/test/sql-runtime.test.ts

@@ -1,5 +1,12 @@
-import { createOperationRegistry } from '@prisma-next/operations';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
+import { coreHash, profileHash } from '@prisma-next/contract/types';
+import {
+  type ExecutionStackInstance,
+  instantiateExecutionStack,
+  type RuntimeDriverInstance,
+  type RuntimeExtensionInstance,
+} from '@prisma-next/framework-components/execution';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   CodecRegistry,
   SelectAst,
@@ -8,29 +15,34 @@ 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',
+const testContract: Contract<SqlStorage> = {
   targetFamily: 'sql',
   target: 'postgres',
-  coreHash: 'sha256:test',
+  profileHash: profileHash('sha256:test'),
   models: {},
-  relations: {},
-  storage: { tables: {} },
+  roots: {},
+  storage: { storageHash: coreHash('sha256:test'), tables: {} },
   extensionPacks: {},
   capabilities: {},
   meta: {},
-  sources: {},
-  mappings: {
-    codecTypes: {},
-    operationTypes: {},
-  },
 };
 
-// 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 +56,6 @@ function createStubCodecs(): CodecRegistry {
   return registry;
 }
 
-// Create a stub adapter
 function createStubAdapter() {
   const codecs = createStubCodecs();
   return {
@@ -57,6 +68,12 @@ function createStubAdapter() {
       codecs() {
         return codecs;
       },
+      readMarkerStatement() {
+        return {
+          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',
+          params: [1],
+        };
+      },
     },
     lower(ast: SelectAst) {
       return {
@@ -67,37 +84,139 @@ 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,
+    },
+  });
+}
+
+function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {
+  return {
+    kind: 'target',
+    id: 'postgres',
+    version: '0.0.1',
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    codecs: () => createCodecRegistry(),
+    parameterizedCodecs: () => [],
+    create() {
+      return { familyId: 'sql' as const, targetId: 'postgres' as const };
+    },
+  };
 }
 
-// Create a test runtime context
-function createTestContext(contract: SqlContract<SqlStorage>): RuntimeContext<typeof contract> {
+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,
+    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.storage.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 },
@@ -106,50 +225,102 @@ describe('createRuntime', () => {
     expect(runtime).toBeDefined();
     expect(runtime.execute).toBeDefined();
     expect(runtime.telemetry).toBeDefined();
-    expect(runtime.operations).toBeDefined();
     expect(runtime.close).toBeDefined();
   });
 
-  it('returns operations registry', () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+  it('returns null telemetry when no events', () => {
+    const { stackInstance, context, driver } = createTestSetup();
 
     const runtime = createRuntime({
+      stackInstance,
       context,
       driver,
       verify: { mode: 'onFirstUse', requireMarker: false },
     });
 
-    const ops = runtime.operations();
-    expect(ops).toBeDefined();
-    expect(ops.byType).toBeDefined();
+    expect(runtime.telemetry()).toBeNull();
   });
 
-  it('returns null telemetry when no events', () => {
-    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 },
     });
 
-    // Before any execution, telemetry should be null
-    expect(runtime.telemetry()).toBeNull();
+    await runtime.close();
+    expect(driver.close).toHaveBeenCalled();
   });
 
-  it('closes runtime', async () => {
-    const context = createTestContext(testContract);
-    const driver = createMockDriver();
+  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 },
     });
 
-    await runtime.close();
-    expect(driver.close).toHaveBeenCalled();
+    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,5 +1,12 @@
-import type { ExecutionPlan, ResultType } from '@prisma-next/contract/types';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Contract, ExecutionPlan, ResultType } from '@prisma-next/contract/types';
+import { coreHash, profileHash } from '@prisma-next/contract/types';
+import {
+  instantiateExecutionStack,
+  type RuntimeDriverDescriptor,
+} from '@prisma-next/framework-components/execution';
+import { builtinGeneratorIds } from '@prisma-next/ids';
+import { generateId } from '@prisma-next/ids/runtime';
+import type { 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';
 import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
@@ -7,18 +14,29 @@ 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';
 
+function createTestMutationDefaultGenerators() {
+  return builtinGeneratorIds.map((id) => ({
+    id,
+    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),
+  }));
+}
+
 /**
  * Executes a plan and collects all results into an array.
  * This helper DRYs up the common pattern of executing plans in tests.
@@ -60,7 +78,7 @@ export async function executeStatement(client: Client, statement: SqlStatement):
  */
 export async function setupTestDatabase(
   client: Client,
-  contract: SqlContract<SqlStorage>,
+  contract: Contract<SqlStorage>,
   setupFn: (client: Client) => Promise<void>,
 ): Promise<void> {
   await client.query('drop schema if exists prisma_contract cascade');
@@ -71,8 +89,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.storage.storageHash,
+    profileHash: contract.profileHash,
     contractJson: contract,
     canonicalVersion: 1,
   });
@@ -85,11 +103,11 @@ export async function setupTestDatabase(
  */
 export async function writeTestContractMarker(
   client: Client,
-  contract: SqlContract<SqlStorage>,
+  contract: Contract<SqlStorage>,
 ): Promise<void> {
   const write = writeContractMarker({
-    coreHash: contract.coreHash,
-    profileHash: contract.profileHash ?? contract.coreHash,
+    storageHash: contract.storage.storageHash,
+    profileHash: contract.profileHash,
     contractJson: contract,
     canonicalVersion: 1,
   });
@@ -98,56 +116,40 @@ 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(
-  adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
-): {
-  readonly kind: 'adapter';
-  readonly id: string;
-  readonly version: string;
-  readonly familyId: 'sql';
-  readonly targetId: 'postgres';
-  create(): SqlRuntimeAdapterInstance<'postgres'>;
-} {
+export function createTestAdapterDescriptor(
+  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
+): 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,
+    parameterizedCodecs: () => [],
+    mutationDefaultGenerators: createTestMutationDefaultGenerators,
     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(),
+    parameterizedCodecs: () => [],
     create() {
       return { familyId: 'sql' as const, targetId: 'postgres' as const };
     },
@@ -155,25 +157,46 @@ 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
  * adapter in a descriptor internally for descriptor-first context creation.
  */
-export function createTestContext<TContract extends SqlContract<SqlStorage>>(
+export function createTestContext<TContract extends Contract<SqlStorage>>(
   contract: TContract,
-  adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,
   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);
 }
 
 /**
@@ -183,7 +206,7 @@ export function createTestContext<TContract extends SqlContract<SqlStorage>>(
  * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)
  * to enable type inference in tests without requiring the postgres adapter package.
  */
-export function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement> {
+export function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {
   const codecRegistry = createCodecRegistry();
 
   // Register stub codecs for common test types
@@ -212,8 +235,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)),
     }),
   );
 
@@ -225,8 +247,14 @@ export function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>,
       codecs() {
         return codecRegistry;
       },
+      readMarkerStatement() {
+        return {
+          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',
+          params: [1],
+        };
+      },
     },
-    lower(ast: SelectAst, ctx: { contract: SqlContract<SqlStorage>; params?: readonly unknown[] }) {
+    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {
       const sqlText = JSON.stringify(ast);
       return {
         profileId: this.profile.id,
@@ -236,20 +264,30 @@ 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.
- * 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<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {
+    storageHash?: string;
+    profileHash?: string;
+    storage?: Omit<SqlStorage, 'storageHash'>;
+  },
+): Contract<SqlStorage> {
+  const { execution, ...rest } = contract;
+  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');
+
+  return {
+    target: rest['target'] ?? 'postgres',
+    targetFamily: rest['targetFamily'] ?? 'sql',
+    storage: rest['storage']
+      ? { ...rest['storage'], storageHash: storageHashValue }
+      : { storageHash: storageHashValue, tables: {} },
+    models: rest['models'] ?? {},
+    roots: rest['roots'] ?? {},
+    capabilities: rest['capabilities'] ?? {},
+    extensionPacks: rest['extensionPacks'] ?? {},
+    meta: rest['meta'] ?? {},
+    ...(execution ? { execution } : {}),
+    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),
+  };
 }
 
 // Re-export generic utilities from test-utils