@prisma-next/adapter-postgres 0.12.0-dev.4 → 0.12.0-dev.41

package/src/core/control-adapter.ts

@@ -1,5 +1,13 @@
-import type { Contract, ContractMarkerRecord } from '@prisma-next/contract/types';
-import { parseMarkerRowSafely, withMarkerReadErrorHandling } from '@prisma-next/errors/execution';
+import type {
+  Contract,
+  ContractMarkerRecord,
+  LedgerEntryRecord,
+} from '@prisma-next/contract/types';
+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';
@@ -8,12 +16,16 @@ import {
   type ControlDriverInstance,
 } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
+import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
 import type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
+  DdlNode,
   LoweredStatement,
   LowererContext,
+  MarkerReadResult,
 } from '@prisma-next/sql-relational-core/ast';
+import { isDdlNode } from '@prisma-next/sql-relational-core/ast';
 import type {
   PrimaryKey,
   SqlColumnIR,
@@ -24,6 +36,12 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
+import { postgresColumnsCompatible } from '@prisma-next/target-postgres/column-type-compatibility';
+import {
+  buildControlTableBootstrapQueries,
+  buildSignMarkerBootstrapQueries,
+} from '@prisma-next/target-postgres/contract-free';
+import type { PostgresDdlNode } from '@prisma-next/target-postgres/ddl';
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 import {
   createResolveExistingEnumValues,
@@ -35,14 +53,35 @@ import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-t
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { createPostgresBuiltinCodecLookup } from './codec-lookup';
+import { renderLoweredDdl } from './ddl-renderer';
 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.
@@ -78,6 +117,13 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   readonly normalizeNativeType = normalizeSchemaNativeType;
 
+  /**
+   * Target-supplied compatible-shape relation used under the `external`
+   * control policy. Threading the same relation the migration planner/runner
+   * use keeps runtime verify and migration verify in agreement.
+   */
+  readonly columnsCompatible = postgresColumnsCompatible;
+
   /**
    * Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
    * introspection shape (`schema.annotations.pg.storageTypes`). Lets
@@ -99,6 +145,14 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   readonly resolveExistingEnumValuesForContract = (contract: Contract<SqlStorage>) =>
     createResolveExistingEnumValues(contract.storage);
 
+  bootstrapControlTableQueries(): readonly DdlNode[] {
+    return buildControlTableBootstrapQueries();
+  }
+
+  bootstrapSignMarkerQueries(): readonly DdlNode[] {
+    return buildSignMarkerBootstrapQueries();
+  }
+
   /**
    * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
    *
@@ -107,7 +161,10 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
    * without instantiating the runtime adapter.
    */
-  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
+  lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement {
+    if (isDdlNode(ast)) {
+      return renderLoweredDdl(ast);
+    }
     return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
   }
 
@@ -123,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);
   }
 
   /**
@@ -181,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 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 rows = new Map<string, ContractMarkerRecord>();
-    for (const row of result.rows) {
-      rows.set(
+    const out = new Map<string, ContractMarkerRecord>();
+    for (const row of rows) {
+      out.set(
         row.space,
         parseMarkerRowSafely(row, parseContractMarkerRow, {
           space: row.space,
@@ -233,7 +253,271 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         }),
       );
     }
-    return rows;
+    return out;
+  }
+
+  /**
+   * Reads per-migration ledger rows from `prisma_contract.ledger` in apply
+   * order. Probes `information_schema.tables` first so a fresh database
+   * without the ledger table returns `[]` instead of raising "relation does
+   * not exist".
+   */
+  async readLedger(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space?: string,
+  ): Promise<readonly LedgerEntryRecord[]> {
+    const ledgerContext = { space: space ?? '*', markerLocation: POSTGRES_LEDGER_TABLE };
+    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 [];
+    }
+
+    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,
+    );
+
+    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);
+
+    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/ddl-renderer.ts

@@ -0,0 +1,73 @@
+import type {
+  DdlColumn,
+  DdlColumnDefaultVisitor,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+} from '@prisma-next/sql-relational-core/ast';
+import type {
+  PostgresCreateSchema,
+  PostgresCreateTable,
+  PostgresDdlNode,
+  PostgresDdlVisitor,
+} from '@prisma-next/target-postgres/ddl';
+import { escapeLiteral } from '@prisma-next/target-postgres/sql-utils';
+import type { PostgresLoweredStatement } from './types';
+
+class PostgresDdlVisitorImpl implements PostgresDdlVisitor<string> {
+  createTable(node: PostgresCreateTable): string {
+    const ifNotExists = node.ifNotExists ? 'if not exists ' : '';
+    const tableRef = node.schema ? `${node.schema}.${node.table}` : node.table;
+    const columnDefs = node.columns.map((column) => renderColumn(column)).join(',\n    ');
+    return `create table ${ifNotExists}${tableRef} (\n    ${columnDefs}\n  )`;
+  }
+
+  createSchema(node: PostgresCreateSchema): string {
+    const ifNotExists = node.ifNotExists ? 'if not exists ' : '';
+    return `create schema ${ifNotExists}${node.schema}`;
+  }
+}
+
+const defaultVisitor: DdlColumnDefaultVisitor<string> = {
+  literal(node: LiteralColumnDefault): string {
+    const { value } = node;
+    if (typeof value === 'string') {
+      return `default '${escapeLiteral(value)}'`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return `default ${String(value)}`;
+    }
+    if (value === null) {
+      return 'default null';
+    }
+    return `default '${JSON.stringify(value)}'`;
+  },
+  function(node: FunctionColumnDefault): string {
+    if (node.expression === 'autoincrement()') {
+      return '';
+    }
+    if (node.expression === 'now()') {
+      return 'default now()';
+    }
+    return `default (${node.expression})`;
+  },
+};
+
+function renderColumn(column: DdlColumn): string {
+  const parts = [column.name, column.type];
+  if (column.notNull) {
+    parts.push('not null');
+  }
+  if (column.primaryKey) {
+    parts.push('primary key');
+  }
+  const defaultClause = column.default ? column.default.accept(defaultVisitor) : '';
+  if (defaultClause.length > 0) {
+    parts.push(defaultClause);
+  }
+  return parts.join(' ');
+}
+
+export function renderLoweredDdl(ast: PostgresDdlNode): PostgresLoweredStatement {
+  const sql = ast.accept(new PostgresDdlVisitorImpl());
+  return Object.freeze({ sql, params: Object.freeze([]) });
+}