@prisma-next/sql-runtime 0.3.0-pr.73.2 → 0.3.0-pr.75.2

package/src/sql-marker.ts

@@ -0,0 +1,105 @@
+import type { MarkerStatement } from '@prisma-next/runtime-executor';
+
+export interface SqlStatement {
+  readonly sql: string;
+  readonly params: readonly unknown[];
+}
+
+export interface WriteMarkerInput {
+  readonly coreHash: string;
+  readonly profileHash: string;
+  readonly contractJson?: unknown;
+  readonly canonicalVersion?: number;
+  readonly appTag?: string;
+  readonly meta?: Record<string, unknown>;
+}
+
+export const ensureSchemaStatement: SqlStatement = {
+  sql: 'create schema if not exists prisma_contract',
+  params: [],
+};
+
+export const ensureTableStatement: SqlStatement = {
+  sql: `create table if not exists prisma_contract.marker (
+    id smallint primary key default 1,
+    core_hash text not null,
+    profile_hash text not null,
+    contract_json jsonb,
+    canonical_version int,
+    updated_at timestamptz not null default now(),
+    app_tag text,
+    meta jsonb not null default '{}'
+  )`,
+  params: [],
+};
+
+export function readContractMarker(): MarkerStatement {
+  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],
+  };
+}
+
+export interface WriteContractMarkerStatements {
+  readonly insert: SqlStatement;
+  readonly update: SqlStatement;
+}
+
+export function writeContractMarker(input: WriteMarkerInput): WriteContractMarkerStatements {
+  const baseParams: readonly unknown[] = [
+    1,
+    input.coreHash,
+    input.profileHash,
+    input.contractJson ?? null,
+    input.canonicalVersion ?? null,
+    input.appTag ?? null,
+    JSON.stringify(input.meta ?? {}),
+  ];
+
+  const insert: SqlStatement = {
+    sql: `insert into prisma_contract.marker (
+        id,
+        core_hash,
+        profile_hash,
+        contract_json,
+        canonical_version,
+        updated_at,
+        app_tag,
+        meta
+      ) values (
+        $1,
+        $2,
+        $3,
+        $4::jsonb,
+        $5,
+        now(),
+        $6,
+        $7::jsonb
+      )`,
+    params: baseParams,
+  };
+
+  const update: SqlStatement = {
+    sql: `update prisma_contract.marker set
+        core_hash = $2,
+        profile_hash = $3,
+        contract_json = $4::jsonb,
+        canonical_version = $5,
+        updated_at = now(),
+        app_tag = $6,
+        meta = $7::jsonb
+      where id = $1`,
+    params: baseParams,
+  };
+
+  return { insert, update };
+}

package/src/sql-runtime.ts

@@ -0,0 +1,166 @@
+import type { ExecutionPlan } from '@prisma-next/contract/types';
+import type { OperationRegistry } from '@prisma-next/operations';
+import type {
+  Log,
+  Plugin,
+  RuntimeCore,
+  RuntimeCoreOptions,
+  RuntimeTelemetryEvent,
+  RuntimeVerifyOptions,
+  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 {
+  Adapter,
+  CodecRegistry,
+  LoweredStatement,
+  SelectAst,
+  SqlDriver,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
+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 { SqlFamilyAdapter } from './sql-family-adapter';
+
+export interface RuntimeOptions<
+  TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>,
+> {
+  readonly driver: SqlDriver;
+  readonly verify: RuntimeVerifyOptions;
+  readonly context: RuntimeContext<TContract>;
+  readonly plugins?: readonly Plugin<
+    TContract,
+    Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+    SqlDriver
+  >[];
+  readonly mode?: 'strict' | 'permissive';
+  readonly log?: Log;
+}
+
+export interface Runtime {
+  execute<Row = Record<string, unknown>>(
+    plan: ExecutionPlan<Row> | SqlQueryPlan<Row>,
+  ): AsyncIterableResult<Row>;
+  telemetry(): RuntimeTelemetryEvent | null;
+  close(): Promise<void>;
+  operations(): OperationRegistry;
+}
+
+export type { RuntimeTelemetryEvent, RuntimeVerifyOptions, TelemetryOutcome };
+
+class SqlRuntimeImpl<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>>
+  implements Runtime
+{
+  private readonly core: RuntimeCore<
+    TContract,
+    Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+    SqlDriver
+  >;
+  private readonly contract: TContract;
+  private readonly context: RuntimeContext<TContract>;
+  private readonly codecRegistry: CodecRegistry;
+  private codecRegistryValidated: boolean;
+
+  constructor(options: RuntimeOptions<TContract>) {
+    const { context, driver, verify, plugins, mode, log } = options;
+    this.contract = context.contract;
+    this.context = context;
+    this.codecRegistry = context.codecs;
+    this.codecRegistryValidated = false;
+
+    const familyAdapter = new SqlFamilyAdapter(context.contract);
+
+    const coreOptions: RuntimeCoreOptions<
+      TContract,
+      Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+      SqlDriver
+    > = {
+      familyAdapter,
+      driver,
+      verify,
+      plugins: plugins as readonly Plugin<
+        TContract,
+        Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>,
+        SqlDriver
+      >[],
+      ...(mode !== undefined ? { mode } : {}),
+      ...(log !== undefined ? { log } : {}),
+      operationRegistry: context.operations,
+    };
+
+    this.core = createRuntimeCore(coreOptions);
+
+    if (verify.mode === 'startup') {
+      validateCodecRegistryCompleteness(this.codecRegistry, context.contract);
+      this.codecRegistryValidated = true;
+    }
+  }
+
+  private ensureCodecRegistryValidated(contract: SqlContract<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)
+    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;
+
+    const iterator = async function* (
+      self: SqlRuntimeImpl<TContract>,
+    ): AsyncGenerator<Row, void, unknown> {
+      const encodedParams = encodeParams(executablePlan, self.codecRegistry);
+      const planWithEncodedParams: ExecutionPlan<Row> = {
+        ...executablePlan,
+        params: encodedParams,
+      };
+
+      const coreIterator = self.core.execute(planWithEncodedParams);
+
+      for await (const rawRow of coreIterator) {
+        const decodedRow = decodeRow(
+          rawRow as Record<string, unknown>,
+          executablePlan,
+          self.codecRegistry,
+        );
+        yield decodedRow as Row;
+      }
+    };
+
+    return new AsyncIterableResult(iterator(this));
+  }
+
+  telemetry(): RuntimeTelemetryEvent | null {
+    return this.core.telemetry();
+  }
+
+  operations(): OperationRegistry {
+    return this.core.operations();
+  }
+
+  close(): Promise<void> {
+    return this.core.close();
+  }
+}
+
+export function createRuntime<TContract extends SqlContract<SqlStorage>>(
+  options: RuntimeOptions<TContract>,
+): Runtime {
+  return new SqlRuntimeImpl(options);
+}

package/dist/sql-runtime-DgEbg2OP.d.ts

@@ -1,109 +0,0 @@
-import { MarkerStatement, AsyncIterableResult, RuntimeTelemetryEvent, RuntimeVerifyOptions, Plugin, Log } from '@prisma-next/runtime-executor';
-import { ExecutionPlan } from '@prisma-next/contract/types';
-import { OperationRegistry } from '@prisma-next/operations';
-import { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import { Adapter, QueryAst, LoweredStatement, CodecRegistry, SqlDriver, SelectAst } from '@prisma-next/sql-relational-core/ast';
-import { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import { RuntimeTargetDescriptor, RuntimeAdapterDescriptor, RuntimeAdapterInstance, RuntimeExtensionDescriptor, RuntimeExtensionInstance } from '@prisma-next/core-execution-plane/types';
-import { SqlOperationSignature } from '@prisma-next/sql-operations';
-import { QueryLaneContext } from '@prisma-next/sql-relational-core/query-lane-context';
-
-/**
- * SQL runtime extension instance.
- * Extends the framework RuntimeExtensionInstance with SQL-specific hooks
- * for contributing codecs and operations to the runtime context.
- *
- * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
- */
-interface SqlRuntimeExtensionInstance<TTargetId extends string> extends RuntimeExtensionInstance<'sql', TTargetId> {
-    /** Returns codecs to register in the runtime context. */
-    codecs?(): CodecRegistry;
-    /** Returns operations to register in the runtime context. */
-    operations?(): ReadonlyArray<SqlOperationSignature>;
-}
-/**
- * SQL runtime extension descriptor.
- * Extends the framework RuntimeExtensionDescriptor with SQL-specific instance type.
- *
- * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
- */
-interface SqlRuntimeExtensionDescriptor<TTargetId extends string> extends RuntimeExtensionDescriptor<'sql', TTargetId, SqlRuntimeExtensionInstance<TTargetId>> {
-    create(): SqlRuntimeExtensionInstance<TTargetId>;
-}
-/**
- * SQL runtime adapter instance interface.
- * Combines RuntimeAdapterInstance identity with SQL Adapter behavior.
- * The instance IS an Adapter (via intersection), not HAS an adapter property.
- *
- * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
- */
-type SqlRuntimeAdapterInstance<TTargetId extends string = string> = RuntimeAdapterInstance<'sql', TTargetId> & Adapter<QueryAst, SqlContract<SqlStorage>, LoweredStatement>;
-interface RuntimeContext<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>> extends QueryLaneContext<TContract> {
-    readonly adapter: Adapter<QueryAst, TContract, LoweredStatement> | Adapter<QueryAst, SqlContract<SqlStorage>, LoweredStatement>;
-}
-/**
- * Descriptor-first options for creating a SQL runtime context.
- * Takes the same framework composition as control-plane: target, adapter, extensionPacks.
- *
- * @template TContract - The SQL contract type
- * @template TTargetId - The target ID (e.g., 'postgres', 'mysql')
- */
-interface CreateRuntimeContextOptions<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>, TTargetId extends string = string> {
-    readonly contract: TContract;
-    readonly target: RuntimeTargetDescriptor<'sql', TTargetId>;
-    readonly adapter: RuntimeAdapterDescriptor<'sql', TTargetId, SqlRuntimeAdapterInstance<TTargetId>>;
-    readonly extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<TTargetId>>;
-}
-/**
- * Creates a SQL runtime context from descriptor-first composition.
- *
- * The context includes:
- * - The validated contract
- * - The adapter instance (created from descriptor)
- * - Codec registry (populated from adapter + extension instances)
- * - Operation registry (populated from extension instances)
- *
- * @param options - Descriptor-first composition options
- * @returns RuntimeContext with registries wired from all components
- */
-declare function createRuntimeContext<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>, TTargetId extends string = string>(options: CreateRuntimeContextOptions<TContract, TTargetId>): RuntimeContext<TContract>;
-
-interface SqlStatement {
-    readonly sql: string;
-    readonly params: readonly unknown[];
-}
-interface WriteMarkerInput {
-    readonly coreHash: string;
-    readonly profileHash: string;
-    readonly contractJson?: unknown;
-    readonly canonicalVersion?: number;
-    readonly appTag?: string;
-    readonly meta?: Record<string, unknown>;
-}
-declare const ensureSchemaStatement: SqlStatement;
-declare const ensureTableStatement: SqlStatement;
-declare function readContractMarker(): MarkerStatement;
-interface WriteContractMarkerStatements {
-    readonly insert: SqlStatement;
-    readonly update: SqlStatement;
-}
-declare function writeContractMarker(input: WriteMarkerInput): WriteContractMarkerStatements;
-
-interface RuntimeOptions<TContract extends SqlContract<SqlStorage> = SqlContract<SqlStorage>> {
-    readonly driver: SqlDriver;
-    readonly verify: RuntimeVerifyOptions;
-    readonly context: RuntimeContext<TContract>;
-    readonly plugins?: readonly Plugin<TContract, Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>, SqlDriver>[];
-    readonly mode?: 'strict' | 'permissive';
-    readonly log?: Log;
-}
-interface Runtime {
-    execute<Row = Record<string, unknown>>(plan: ExecutionPlan<Row> | SqlQueryPlan<Row>): AsyncIterableResult<Row>;
-    telemetry(): RuntimeTelemetryEvent | null;
-    close(): Promise<void>;
-    operations(): OperationRegistry;
-}
-
-declare function createRuntime<TContract extends SqlContract<SqlStorage>>(options: RuntimeOptions<TContract>): Runtime;
-
-export { type CreateRuntimeContextOptions as C, type RuntimeContext as R, type SqlRuntimeAdapterInstance as S, type SqlRuntimeExtensionDescriptor as a, type SqlRuntimeExtensionInstance as b, createRuntimeContext as c, type SqlStatement as d, ensureSchemaStatement as e, ensureTableStatement as f, type Runtime as g, type RuntimeOptions as h, createRuntime as i, readContractMarker as r, writeContractMarker as w };

package/dist/test/utils.d.ts

@@ -1,64 +0,0 @@
-import { ExecutionPlan, ResultType } from '@prisma-next/contract/types';
-import { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import { Adapter, SelectAst, LoweredStatement } from '@prisma-next/sql-relational-core/ast';
-import { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';
-import { Client } from 'pg';
-import { i as createRuntime, d as SqlStatement, a as SqlRuntimeExtensionDescriptor, R as RuntimeContext } from '../sql-runtime-DgEbg2OP.js';
-export { DevDatabase, collectAsync, createDevDatabase, teardownTestDatabase, withClient } from '@prisma-next/test-utils';
-import '@prisma-next/runtime-executor';
-import '@prisma-next/operations';
-import '@prisma-next/core-execution-plane/types';
-import '@prisma-next/sql-operations';
-import '@prisma-next/sql-relational-core/query-lane-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.
- */
-declare function executePlanAndCollect<P extends ExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]>;
-/**
- * Drains a plan execution, consuming all results without collecting them.
- * Useful for testing side effects without memory overhead.
- */
-declare function drainPlanExecution(runtime: ReturnType<typeof createRuntime>, plan: ExecutionPlan | SqlQueryPlan<unknown>): Promise<void>;
-/**
- * Executes a SQL statement on a database client.
- */
-declare function executeStatement(client: Client, statement: SqlStatement): Promise<void>;
-/**
- * Sets up database schema and data, then writes the contract marker.
- * This helper DRYs up the common pattern of database setup in tests.
- */
-declare function setupTestDatabase(client: Client, contract: SqlContract<SqlStorage>, setupFn: (client: Client) => Promise<void>): Promise<void>;
-/**
- * Writes a contract marker to the database.
- * This helper DRYs up the common pattern of writing contract markers in tests.
- */
-declare function writeTestContractMarker(client: Client, contract: SqlContract<SqlStorage>): Promise<void>;
-/**
- * Creates a runtime context with standard test configuration.
- * 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.
- */
-declare function createTestContext<TContract extends SqlContract<SqlStorage>>(contract: TContract, adapter: Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>, options?: {
-    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
-}): RuntimeContext<TContract>;
-/**
- * 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.
- */
-declare function createStubAdapter(): Adapter<SelectAst, SqlContract<SqlStorage>, LoweredStatement>;
-/**
- * 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.
- */
-declare function createTestContract<T extends SqlContract<SqlStorage>>(contract: T): T;
-
-export { createStubAdapter, createTestContext, createTestContract, drainPlanExecution, executePlanAndCollect, executeStatement, setupTestDatabase, writeTestContractMarker };