@prisma-next/adapter-postgres 0.12.0-dev.31 → 0.12.0-dev.33

package/src/core/control-adapter.ts

@@ -3,7 +3,11 @@ import type {
   ContractMarkerRecord,
   LedgerEntryRecord,
 } from '@prisma-next/contract/types';
-import { parseMarkerRowSafely, withMarkerReadErrorHandling } from '@prisma-next/errors/execution';
+import {
+  parseMarkerRowSafely,
+  rethrowMarkerReadError,
+  withMarkerReadErrorHandling,
+} from '@prisma-next/errors/execution';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
@@ -19,6 +23,7 @@ import type {
   DdlNode,
   LoweredStatement,
   LowererContext,
+  MarkerReadResult,
 } from '@prisma-next/sql-relational-core/ast';
 import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type {
@@ -53,12 +58,31 @@ import {
   introspectPostgresEnumTypes,
   type PostgresEnumStorageTypeAnnotation,
 } from './enum-control-hooks';
+import {
+  execute,
+  infoSchemaTables,
+  ledger,
+  ledgerReadShape,
+  marker,
+  mergeInvariants,
+  NOW,
+} from './marker-ledger';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresContract } from './types';
 
 const POSTGRES_MARKER_TABLE = 'prisma_contract.marker';
 const POSTGRES_LEDGER_TABLE = 'prisma_contract.ledger';
 
+type PostgresLedgerRow = {
+  readonly space: string;
+  readonly migration_name: string;
+  readonly migration_hash: string;
+  readonly origin_core_hash: string | null;
+  readonly destination_core_hash: string;
+  readonly operations: unknown;
+  readonly created_at: Date | string;
+};
+
 /**
  * Postgres control plane adapter for control-plane operations like introspection.
  * Provides target-specific implementations for control-plane domain actions.
@@ -156,52 +180,16 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
     driver: ControlDriverInstance<'sql', 'postgres'>,
     space: string,
   ): Promise<ContractMarkerRecord | null> {
-    const markerContext = { space, markerLocation: POSTGRES_MARKER_TABLE };
-    const exists = await withMarkerReadErrorHandling(
-      () =>
-        driver.query(
-          `select 1
-       from information_schema.tables
-       where table_schema = $1 and table_name = $2`,
-          ['prisma_contract', 'marker'],
-        ),
-      markerContext,
-    );
-    if (exists.rows.length === 0) {
-      return null;
-    }
-
-    const result = await withMarkerReadErrorHandling(
-      () =>
-        driver.query<{
-          core_hash: string;
-          profile_hash: string;
-          contract_json: unknown | null;
-          canonical_version: number | null;
-          updated_at: Date | string;
-          app_tag: string | null;
-          meta: unknown | null;
-          invariants: readonly string[];
-        }>(
-          `select
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       from prisma_contract.marker
-       where space = $1`,
-          [space],
-        ),
-      markerContext,
-    );
+    const result = await this.readMarkerDiscriminated(driver, space);
+    return result.kind === 'present' ? result.record : null;
+  }
 
-    const row = result.rows[0];
-    if (!row) return null;
-    return parseMarkerRowSafely(row, parseContractMarkerRow, markerContext);
+  async readMarkerDiscriminated(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+  ): Promise<MarkerReadResult> {
+    const markerContext = { space, markerLocation: POSTGRES_MARKER_TABLE };
+    return withMarkerReadErrorHandling(() => this.readMarkerResult(driver, space), markerContext);
   }
 
   /**
@@ -214,51 +202,50 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
     driver: ControlDriverInstance<'sql', 'postgres'>,
   ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
     const markerContext = { space: APP_SPACE_ID, markerLocation: POSTGRES_MARKER_TABLE };
-    const exists = await withMarkerReadErrorHandling(
-      () =>
-        driver.query(
-          `select 1
-       from information_schema.tables
-       where table_schema = $1 and table_name = $2`,
-          ['prisma_contract', 'marker'],
-        ),
-      markerContext,
-    );
-    if (exists.rows.length === 0) {
+    return withMarkerReadErrorHandling(() => this.readAllMarkersResult(driver), markerContext);
+  }
+
+  private async readAllMarkersResult(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+  ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = infoSchemaTables
+      .select(infoSchemaTables.table_schema)
+      .where(
+        infoSchemaTables.table_schema
+          .eq('prisma_contract')
+          .and(infoSchemaTables.table_name.eq('marker')),
+      )
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) {
       return new Map();
     }
 
-    const result = await withMarkerReadErrorHandling(
-      () =>
-        driver.query<{
-          space: string;
-          core_hash: string;
-          profile_hash: string;
-          contract_json: unknown | null;
-          canonical_version: number | null;
-          updated_at: Date | string;
-          app_tag: string | null;
-          meta: unknown | null;
-          invariants: readonly string[];
-        }>(
-          `select
-         space,
-         core_hash,
-         profile_hash,
-         contract_json,
-         canonical_version,
-         updated_at,
-         app_tag,
-         meta,
-         invariants
-       from prisma_contract.marker`,
-        ),
-      markerContext,
-    );
+    await this.assertMarkerTableHasSpaceColumn(driver, APP_SPACE_ID);
 
-    const rows = new Map<string, ContractMarkerRecord>();
-    for (const row of result.rows) {
-      rows.set(
+    const fetch = marker
+      .select(
+        marker.space,
+        marker.core_hash,
+        marker.profile_hash,
+        marker.contract_json,
+        marker.canonical_version,
+        marker.updated_at,
+        marker.app_tag,
+        marker.meta,
+        marker.invariants,
+      )
+      .build();
+    const rawRows = await execute(lower, driver, fetch);
+    const rows = blindCast<
+      ReadonlyArray<{ space: string } & Record<string, unknown>>,
+      'Driver returns rows shaped by SELECT'
+    >(rawRows);
+
+    const out = new Map<string, ContractMarkerRecord>();
+    for (const row of rows) {
+      out.set(
         row.space,
         parseMarkerRowSafely(row, parseContractMarkerRow, {
           space: row.space,
@@ -266,7 +253,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         }),
       );
     }
-    return rows;
+    return out;
   }
 
   /**
@@ -280,59 +267,257 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
     space?: string,
   ): Promise<readonly LedgerEntryRecord[]> {
     const ledgerContext = { space: space ?? '*', markerLocation: POSTGRES_LEDGER_TABLE };
-    const exists = await withMarkerReadErrorHandling(
-      () =>
-        driver.query(
-          `select 1
-       from information_schema.tables
-       where table_schema = $1 and table_name = $2`,
-          ['prisma_contract', 'ledger'],
-        ),
-      ledgerContext,
-    );
-    if (exists.rows.length === 0) {
+    return withMarkerReadErrorHandling(() => this.readLedgerResult(driver, space), ledgerContext);
+  }
+
+  private async readLedgerResult(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string | undefined,
+  ): Promise<readonly LedgerEntryRecord[]> {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = infoSchemaTables
+      .select(infoSchemaTables.table_schema)
+      .where(
+        infoSchemaTables.table_schema
+          .eq('prisma_contract')
+          .and(infoSchemaTables.table_name.eq('ledger')),
+      )
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) {
       return [];
     }
 
-    type LedgerQueryRow = {
-      space: string;
-      migration_name: string;
-      migration_hash: string;
-      origin_core_hash: string | null;
-      destination_core_hash: string;
-      operations: unknown;
-      created_at: Date | string;
-    };
-    let sql = `select
-         space,
-         migration_name,
-         migration_hash,
-         origin_core_hash,
-         destination_core_hash,
-         operations,
-         created_at
-       from prisma_contract.ledger`;
-    if (space !== undefined) {
-      sql += `
-       where space = $1`;
-    }
-    sql += `
-       order by id`;
+    const base = ledgerReadShape.select(
+      ledgerReadShape.space,
+      ledgerReadShape.migration_name,
+      ledgerReadShape.migration_hash,
+      ledgerReadShape.origin_core_hash,
+      ledgerReadShape.destination_core_hash,
+      ledgerReadShape.operations,
+      ledgerReadShape.created_at,
+    );
+    const filtered = space !== undefined ? base.where(ledgerReadShape.space.eq(space)) : base;
+    const rawRows = await execute(lower, driver, filtered.orderBy(ledgerReadShape.id).build());
+    const rows = blindCast<readonly PostgresLedgerRow[], 'Driver returns rows shaped by SELECT'>(
+      rawRows,
+    );
 
-    const result = await withMarkerReadErrorHandling(
-      () => driver.query<LedgerQueryRow>(sql, space === undefined ? undefined : [space]),
-      ledgerContext,
+    return rows.map((row) => {
+      const appliedAt = row.created_at instanceof Date ? row.created_at : new Date(row.created_at);
+      return {
+        space: row.space,
+        migrationName: row.migration_name,
+        migrationHash: row.migration_hash,
+        from: ledgerOriginFromStored(row.origin_core_hash),
+        to: row.destination_core_hash,
+        appliedAt,
+        operationCount: Array.isArray(row.operations) ? row.operations.length : 0,
+      };
+    });
+  }
+
+  /**
+   * Stamps the initial marker row for `space` via the shared contract-free DML
+   * builder, lowered through {@link lower} and executed on the driver. See the
+   * `SqlControlAdapter.initMarker` contract.
+   */
+  async insertMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      marker
+        .insert({
+          space,
+          core_hash: destination.storageHash,
+          profile_hash: destination.profileHash,
+          contract_json: null,
+          canonical_version: null,
+          updated_at: NOW,
+          app_tag: null,
+          meta: {},
+          invariants: destination.invariants ?? [],
+        })
+        .build(),
+    );
+  }
+
+  async initMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      marker
+        .upsert({
+          space,
+          core_hash: destination.storageHash,
+          profile_hash: destination.profileHash,
+          contract_json: null,
+          canonical_version: null,
+          updated_at: NOW,
+          app_tag: null,
+          meta: {},
+          invariants: destination.invariants ?? [],
+        })
+        .onConflict(marker.space)
+        .doUpdate((excluded) => ({
+          core_hash: excluded.core_hash,
+          profile_hash: excluded.profile_hash,
+          contract_json: excluded.contract_json,
+          canonical_version: excluded.canonical_version,
+          updated_at: NOW,
+          app_tag: excluded.app_tag,
+          meta: excluded.meta,
+          invariants: excluded.invariants,
+        }))
+        .build(),
+    );
+  }
+
+  /**
+   * Compare-and-swap advance of the marker row for `space`. See the
+   * `SqlControlAdapter.updateMarker` contract.
+   */
+  async updateMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+    expectedFrom: string,
+    destination: {
+      readonly storageHash: string;
+      readonly profileHash: string;
+      readonly invariants?: readonly string[];
+    },
+  ): Promise<boolean> {
+    const currentInvariants =
+      destination.invariants === undefined
+        ? []
+        : ((await this.readMarker(driver, space))?.invariants ?? []);
+    const mergedInvariants =
+      destination.invariants === undefined
+        ? undefined
+        : mergeInvariants(currentInvariants, destination.invariants);
+
+    const query = marker
+      .update()
+      .set({
+        core_hash: destination.storageHash,
+        profile_hash: destination.profileHash,
+        updated_at: NOW,
+        ...(mergedInvariants !== undefined ? { invariants: mergedInvariants } : {}),
+      })
+      .where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom)))
+      .returning(marker.space)
+      .build();
+
+    const rows = await execute((q) => this.lower(q, { contract: undefined }), driver, query);
+    return rows.length > 0;
+  }
+
+  /**
+   * Appends a ledger entry for `space`. See the
+   * `SqlControlAdapter.writeLedgerEntry` contract.
+   */
+  async writeLedgerEntry(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+    entry: {
+      readonly edgeId: string;
+      readonly from: string;
+      readonly to: string;
+      readonly migrationName: string;
+      readonly migrationHash: string;
+      readonly operations: readonly unknown[];
+    },
+  ): Promise<void> {
+    await execute(
+      (query) => this.lower(query, { contract: undefined }),
+      driver,
+      ledger
+        .insert({
+          space,
+          migration_name: entry.migrationName,
+          migration_hash: entry.migrationHash,
+          origin_core_hash: entry.from,
+          destination_core_hash: entry.to,
+          operations: entry.operations,
+        })
+        .build(),
     );
+  }
+
+  private async assertMarkerTableHasSpaceColumn(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+  ): Promise<void> {
+    const result = await driver.query<{ column_name: string }>(
+      `select column_name
+         from information_schema.columns
+        where table_schema = 'prisma_contract'
+          and table_name = 'marker'`,
+    );
+    const rows = result.rows;
+    if (rows.length === 0) {
+      return;
+    }
+    if (!rows.every((row) => typeof row.column_name === 'string')) {
+      return;
+    }
+    if (rows.some((row) => row.column_name === 'space')) {
+      return;
+    }
+    rethrowMarkerReadError(new Error('column "space" does not exist'), {
+      space,
+      markerLocation: POSTGRES_MARKER_TABLE,
+    });
+  }
+
+  private async readMarkerResult(driver: ControlDriverInstance<'sql', 'postgres'>, space: string) {
+    const lower = (query: AnyQueryAst) => this.lower(query, { contract: undefined });
+    const probe = infoSchemaTables
+      .select(infoSchemaTables.table_schema)
+      .where(
+        infoSchemaTables.table_schema
+          .eq('prisma_contract')
+          .and(infoSchemaTables.table_name.eq('marker')),
+      )
+      .build();
+    const exists = await execute(lower, driver, probe);
+    if (exists.length === 0) return { kind: 'no-table' as const };
+
+    await this.assertMarkerTableHasSpaceColumn(driver, space);
 
-    return result.rows.map((row) => ({
-      space: row.space,
-      migrationName: row.migration_name,
-      migrationHash: row.migration_hash,
-      from: ledgerOriginFromStored(row.origin_core_hash),
-      to: row.destination_core_hash,
-      appliedAt: row.created_at instanceof Date ? row.created_at : new Date(row.created_at),
-      operationCount: Array.isArray(row.operations) ? row.operations.length : 0,
-    }));
+    const fetch = marker
+      .select(
+        marker.core_hash,
+        marker.profile_hash,
+        marker.contract_json,
+        marker.canonical_version,
+        marker.updated_at,
+        marker.app_tag,
+        marker.meta,
+        marker.invariants,
+      )
+      .where(marker.space.eq(space))
+      .build();
+    const result = await execute(lower, driver, fetch);
+    const row = result[0];
+    if (!row) return { kind: 'absent' as const };
+    return { kind: 'present' as const, record: parseContractMarkerRow(row) };
   }
 
   /**

package/src/core/marker-ledger.ts

@@ -0,0 +1,124 @@
+import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import {
+  type AnyQueryAst,
+  type LoweredStatement,
+  RawExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  createAstCodecRegistry,
+  deriveParamMetadata,
+  encodeParamsWithMetadata,
+} from '@prisma-next/sql-runtime';
+import { PG_TIMESTAMPTZ_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+import {
+  int4,
+  int8,
+  jsonb,
+  pgTable,
+  text,
+  textArray,
+  timestamptz,
+} from '@prisma-next/target-postgres/contract-free';
+
+const CONTROL_CODECS = createAstCodecRegistry(postgresCodecRegistry);
+
+export const marker = pgTable(
+  { name: 'marker', schema: 'prisma_contract' },
+  {
+    space: text(),
+    core_hash: text(),
+    profile_hash: text(),
+    contract_json: jsonb({ nullable: true }),
+    canonical_version: int4({ nullable: true }),
+    updated_at: timestamptz(),
+    app_tag: text({ nullable: true }),
+    meta: jsonb({ nullable: true }),
+    invariants: textArray(),
+  },
+);
+
+/**
+ * Writeable subset of the `prisma_contract.ledger` table. Omits the
+ * DB-generated `id` (bigserial) and `created_at` (default `now()`) so the
+ * insert path doesn't have to pass them.
+ */
+export const ledger = pgTable(
+  { name: 'ledger', schema: 'prisma_contract' },
+  {
+    space: text(),
+    migration_name: text(),
+    migration_hash: text(),
+    origin_core_hash: text({ nullable: true }),
+    destination_core_hash: text(),
+    operations: jsonb(),
+  },
+);
+
+/**
+ * Read-side handle covering every column of `prisma_contract.ledger`,
+ * including the DB-generated `id` (for ORDER BY) and `created_at`.
+ */
+export const ledgerReadShape = pgTable(
+  { name: 'ledger', schema: 'prisma_contract' },
+  {
+    id: int8(),
+    space: text(),
+    migration_name: text(),
+    migration_hash: text(),
+    origin_core_hash: text({ nullable: true }),
+    destination_core_hash: text(),
+    operations: jsonb(),
+    created_at: timestamptz(),
+  },
+);
+
+export const infoSchemaTables = pgTable(
+  { name: 'tables', schema: 'information_schema' },
+  { table_schema: text(), table_name: text() },
+);
+
+export const NOW = new RawExpr({
+  parts: ['now()'],
+  returns: { codecId: PG_TIMESTAMPTZ_CODEC_ID, nullable: false },
+});
+
+type Lower = (query: AnyQueryAst) => LoweredStatement;
+
+type MarkerDriver = {
+  query<Row = Record<string, unknown>>(
+    sql: string,
+    params?: readonly unknown[],
+  ): Promise<{ readonly rows: ReadonlyArray<Row> }>;
+};
+
+export function mergeInvariants(
+  current: readonly string[],
+  incoming: readonly string[],
+): readonly string[] {
+  return [...new Set([...current, ...incoming])].sort();
+}
+
+export async function execute(
+  lower: Lower,
+  driver: MarkerDriver,
+  query: AnyQueryAst,
+): Promise<readonly Record<string, unknown>[]> {
+  const lowered = lower(query);
+  const values = lowered.params.map((slot) => {
+    if (slot.kind === 'literal') return slot.value;
+    throw new Error('Postgres control DML lowered to a bind parameter, which is unsupported');
+  });
+  const encoded = await encodeParamsWithMetadata(
+    values,
+    deriveParamMetadata(query),
+    {},
+    CONTROL_CODECS,
+  );
+  const result = await driver.query(lowered.sql, encoded);
+  return result.rows;
+}
+
+export type PostgresMarkerDriver = MarkerDriver;
+export type PostgresMarkerLower = Lower;
+export type PostgresMarkerWriteDriver = ControlDriverInstance<'sql', 'postgres'>;

package/src/core/sql-renderer.ts

@@ -31,6 +31,7 @@ import {
   type UpdateAst,
   type WindowFuncExpr,
 } from '@prisma-next/sql-relational-core/ast';
+import { PostgresTableSource } from '@prisma-next/target-postgres/contract-free';
 import { escapeLiteral, quoteIdentifier } from '@prisma-next/target-postgres/sql-utils';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { PostgresContract } from './types';
@@ -274,6 +275,9 @@ function qualifyTableFromNamespaceCoordinate(
   table: Pick<TableSource, 'name' | 'namespaceId'>,
   contract: PostgresContract,
 ): string {
+  if (table instanceof PostgresTableSource && table.schema !== undefined) {
+    return `${quoteIdentifier(table.schema)}.${quoteIdentifier(table.name)}`;
+  }
   if (table.namespaceId === undefined) {
     return quoteIdentifier(table.name);
   }
@@ -730,7 +734,11 @@ function getInsertColumnOrder(
   return Object.keys(table.columns);
 }
 
-function renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap): string {
+function renderInsertValue(
+  value: InsertValue | undefined,
+  contract: PostgresContract,
+  pim: ParamIndexMap,
+): string {
   if (!value || value.kind === 'default-value') {
     return 'DEFAULT';
   }
@@ -741,6 +749,8 @@ function renderInsertValue(value: InsertValue | undefined, pim: ParamIndexMap):
       return renderParamRef(value, pim);
     case 'column-ref':
       return renderColumn(value);
+    case 'raw-expr':
+      return renderExpr(value, contract, pim);
     // v8 ignore next 4
     default:
       throw new Error(
@@ -778,7 +788,9 @@ function renderInsert(ast: InsertAst, contract: PostgresContract, pim: ParamInde
     const columns = columnOrder.map((column) => quoteIdentifier(column));
     const values = rows
       .map((row) => {
-        const renderedRow = columnOrder.map((column) => renderInsertValue(row[column], pim));
+        const renderedRow = columnOrder.map((column) =>
+          renderInsertValue(row[column], contract, pim),
+        );
         return `(${renderedRow.join(', ')})`;
       })
       .join(', ');