@prisma-next/sql-runtime 0.3.0-dev.4 → 0.3.0-dev.40

package/test/sql-runtime.test.ts

@@ -0,0 +1,241 @@
+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,
+  SelectAst,
+  SqlDriver,
+  SqlExecuteRequest,
+} 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 {
+  SqlRuntimeAdapterDescriptor,
+  SqlRuntimeAdapterInstance,
+  SqlRuntimeTargetDescriptor,
+} from '../src/sql-context';
+import { createExecutionContext, createSqlExecutionStack } from '../src/sql-context';
+import { createRuntime } from '../src/sql-runtime';
+
+const testContract: SqlContract<SqlStorage> = {
+  schemaVersion: '1',
+  targetFamily: 'sql',
+  target: 'postgres',
+  storageHash: coreHash('sha256:test'),
+  models: {},
+  relations: {},
+  storage: { tables: {} },
+  extensionPacks: {},
+  capabilities: {},
+  meta: {},
+  sources: {},
+  mappings: {
+    codecTypes: {},
+    operationTypes: {},
+  },
+};
+
+function createStubCodecs(): CodecRegistry {
+  const registry = createCodecRegistry();
+  registry.register(
+    codec({
+      typeId: 'pg/int4@1',
+      targetTypes: ['int4'],
+      encode: (v: number) => v,
+      decode: (w: number) => w,
+    }),
+  );
+  return registry;
+}
+
+function createStubAdapter() {
+  const codecs = createStubCodecs();
+  return {
+    familyId: 'sql' as const,
+    targetId: 'postgres' as const,
+    profile: {
+      id: 'test-profile',
+      target: 'postgres',
+      capabilities: {},
+      codecs() {
+        return codecs;
+      },
+    },
+    lower(ast: SelectAst) {
+      return {
+        profileId: 'test-profile',
+        body: Object.freeze({ sql: JSON.stringify(ast), params: [] }),
+      };
+    },
+  };
+}
+
+function createMockDriver(): SqlDriver {
+  const queryable = {
+    execute: vi.fn().mockImplementation(async function* (_request: SqlExecuteRequest) {
+      yield { id: 1 };
+    }),
+    query: vi.fn().mockResolvedValue({ rows: [], rowCount: 0 }),
+  };
+
+  return {
+    ...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),
+  };
+}
+
+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 };
+}
+
+describe('createRuntime', () => {
+  it('creates runtime with context and driver', () => {
+    const { stackInstance, context, driver } = createTestSetup();
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    expect(runtime).toBeDefined();
+    expect(runtime.execute).toBeDefined();
+    expect(runtime.telemetry).toBeDefined();
+    expect(runtime.operations).toBeDefined();
+    expect(runtime.close).toBeDefined();
+  });
+
+  it('returns operations registry', () => {
+    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();
+  });
+
+  it('returns null telemetry when no events', () => {
+    const { stackInstance, context, driver } = createTestSetup();
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    expect(runtime.telemetry()).toBeNull();
+  });
+
+  it('closes runtime and driver', async () => {
+    const { stackInstance, context, driver } = createTestSetup();
+
+    const runtime = createRuntime({
+      stackInstance,
+      context,
+      driver,
+      verify: { mode: 'onFirstUse', requireMarker: false },
+    });
+
+    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

@@ -0,0 +1,292 @@
+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';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+import { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';
+import type { Client } from 'pg';
+import type { SqlStatement } from '../src/exports';
+import {
+  createExecutionContext,
+  type createRuntime,
+  createSqlExecutionStack,
+  ensureSchemaStatement,
+  ensureTableStatement,
+  writeContractMarker,
+} from '../src/exports';
+import type {
+  ExecutionContext,
+  SqlRuntimeAdapterDescriptor,
+  SqlRuntimeAdapterInstance,
+  SqlRuntimeDriverInstance,
+  SqlRuntimeExtensionDescriptor,
+  SqlRuntimeTargetDescriptor,
+} from '../src/sql-context';
+
+/**
+ * Executes a plan and collects all results into an array.
+ * This helper DRYs up the common pattern of executing plans in tests.
+ * The return type is inferred from the plan's type parameter.
+ */
+export async function executePlanAndCollect<
+  P extends ExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,
+>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {
+  type Row = ResultType<P>;
+  return collectAsync<Row>(runtime.execute<Row>(plan));
+}
+
+/**
+ * Drains a plan execution, consuming all results without collecting them.
+ * Useful for testing side effects without memory overhead.
+ */
+export async function drainPlanExecution(
+  runtime: ReturnType<typeof createRuntime>,
+  plan: ExecutionPlan | SqlQueryPlan<unknown>,
+): Promise<void> {
+  return drainAsyncIterable(runtime.execute(plan));
+}
+
+/**
+ * Executes a SQL statement on a database client.
+ */
+export async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {
+  if (statement.params.length > 0) {
+    await client.query(statement.sql, [...statement.params]);
+    return;
+  }
+
+  await client.query(statement.sql);
+}
+
+/**
+ * Sets up database schema and data, then writes the contract marker.
+ * This helper DRYs up the common pattern of database setup in tests.
+ */
+export async function setupTestDatabase(
+  client: Client,
+  contract: SqlContract<SqlStorage>,
+  setupFn: (client: Client) => Promise<void>,
+): Promise<void> {
+  await client.query('drop schema if exists prisma_contract cascade');
+  await client.query('create schema if not exists public');
+
+  await setupFn(client);
+
+  await executeStatement(client, ensureSchemaStatement);
+  await executeStatement(client, ensureTableStatement);
+  const write = writeContractMarker({
+    storageHash: contract.storageHash,
+    profileHash: contract.profileHash ?? contract.storageHash,
+    contractJson: contract,
+    canonicalVersion: 1,
+  });
+  await executeStatement(client, write.insert);
+}
+
+/**
+ * Writes a contract marker to the database.
+ * This helper DRYs up the common pattern of writing contract markers in tests.
+ */
+export async function writeTestContractMarker(
+  client: Client,
+  contract: SqlContract<SqlStorage>,
+): Promise<void> {
+  const write = writeContractMarker({
+    storageHash: contract.storageHash,
+    profileHash: contract.profileHash ?? contract.storageHash,
+    contractJson: contract,
+    canonicalVersion: 1,
+  });
+  await executeStatement(client, write.insert);
+}
+
+/**
+ * Creates a test adapter descriptor from a raw adapter.
+ * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions
+ * derived from the adapter's codec registry.
+ */
+export function createTestAdapterDescriptor(
+  adapter: Adapter<SelectAst, SqlContract<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,
+    operationSignatures: () => [],
+    parameterizedCodecs: () => [],
+    create(): SqlRuntimeAdapterInstance<'postgres'> {
+      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);
+    },
+  };
+}
+
+/**
+ * Creates a test target descriptor with empty static contributions.
+ */
+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 };
+    },
+  };
+}
+
+/**
+ * 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>>(
+  contract: TContract,
+  adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+  options?: {
+    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'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(createStubAdapter()),
+    driver: options?.driver,
+    extensionPacks: options?.extensionPacks ?? [],
+  });
+
+  return instantiateExecutionStack(stack);
+}
+
+/**
+ * Creates a stub adapter for testing.
+ * This helper DRYs up the common pattern of adapter creation in tests.
+ *
+ * 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> {
+  const codecRegistry = createCodecRegistry();
+
+  // Register stub codecs for common test types
+  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)
+  // but don't require importing from the postgres adapter package
+  codecRegistry.register(
+    codec({
+      typeId: 'pg/int4@1',
+      targetTypes: ['int4'],
+      encode: (value: number) => value,
+      decode: (wire: number) => wire,
+    }),
+  );
+
+  codecRegistry.register(
+    codec({
+      typeId: 'pg/text@1',
+      targetTypes: ['text'],
+      encode: (value: string) => value,
+      decode: (wire: string) => wire,
+    }),
+  );
+
+  codecRegistry.register(
+    codec({
+      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),
+    }),
+  );
+
+  return {
+    profile: {
+      id: 'stub-profile',
+      target: 'postgres',
+      capabilities: {},
+      codecs() {
+        return codecRegistry;
+      },
+    },
+    lower(ast: SelectAst, ctx: { contract: SqlContract<SqlStorage>; params?: readonly unknown[] }) {
+      const sqlText = JSON.stringify(ast);
+      return {
+        profileId: this.profile.id,
+        body: Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] }),
+      };
+    },
+  };
+}
+
+/**
+ * Creates a valid test contract without using validateContract.
+ * 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(
+  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
+export {
+  collectAsync,
+  createDevDatabase,
+  type DevDatabase,
+  teardownTestDatabase,
+  withClient,
+} from '@prisma-next/test-utils';