@prisma-next/adapter-postgres 0.12.0 → 0.13.0-dev.10

package/src/core/control-adapter.ts

@@ -1,21 +1,35 @@
-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';
-import {
-  APP_SPACE_ID,
-  type ControlDriverInstance,
-} from '@prisma-next/framework-components/control';
+import { APP_SPACE_ID } from '@prisma-next/framework-components/control';
 import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import type { PostgresEnumStorageEntry, SqlStorage } from '@prisma-next/sql-contract/types';
+import { ledgerOriginFromStored } from '@prisma-next/migration-tools/ledger-origin';
+import type {
+  PostgresEnumStorageEntry,
+  SqlControlDriverInstance,
+  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,
+  SqlCheckConstraintIRInput,
   SqlColumnIR,
   SqlForeignKeyIR,
   SqlIndexIR,
@@ -24,10 +38,14 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
+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,
-  enumStorageCompoundKey,
   readExistingEnumValues,
   readPostgresSchemaIrAnnotations,
 } from '@prisma-next/target-postgres/enum-planning';
@@ -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.
@@ -99,6 +138,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 +154,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);
   }
 
@@ -120,55 +170,19 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * parse errors, so we probe before reading.
    */
   async readMarker(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'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: SqlControlDriverInstance<'postgres'>,
+    space: string,
+  ): Promise<MarkerReadResult> {
+    const markerContext = { space, markerLocation: POSTGRES_MARKER_TABLE };
+    return withMarkerReadErrorHandling(() => this.readMarkerResult(driver, space), markerContext);
   }
 
   /**
@@ -178,54 +192,53 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * map rather than raising "relation does not exist".
    */
   async readAllMarkers(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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,
@@ -233,7 +246,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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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: SqlControlDriverInstance<'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) };
   }
 
   /**
@@ -255,13 +532,13 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * Uses batched queries to minimize database round trips (6 queries per
    * schema walked).
    *
-   * @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+   * @param driver - SqlControlDriverInstance<'postgres'> instance for executing queries
    * @param contract - Optional contract for contract-guided introspection (multi-namespace walk, filtering)
    * @param schema - Schema name to introspect when no contract is provided (defaults to 'public')
    * @returns Promise resolving to SqlSchemaIR representing the live database schema
    */
   async introspect(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'postgres'>,
     contract?: unknown,
     schema = 'public',
   ): Promise<SqlSchemaIR> {
@@ -295,7 +572,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * `CREATE SCHEMA` before table DDL.
    */
   private async listExistingSchemas(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'postgres'>,
   ): Promise<readonly string[]> {
     const result = await driver.query<{ nspname: string }>(
       `SELECT nspname
@@ -316,23 +593,29 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * table regardless of which namespace it lives in.
    */
   private async introspectNamespaces(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'postgres'>,
     namespaceIds: readonly string[],
   ): Promise<SqlSchemaIR> {
-    const resolvedSchemas = await Promise.all(
-      namespaceIds.map(async (id) => {
-        if (id === UNBOUND_NAMESPACE_ID) {
-          const { rows } = await driver.query<{ current_schema: string }>(
-            'SELECT current_schema() AS current_schema',
-          );
-          return rows[0]?.current_schema ?? 'public';
-        }
-        return id;
-      }),
-    );
+    const resolvedSchemas: string[] = [];
+    for (const id of namespaceIds) {
+      if (id === UNBOUND_NAMESPACE_ID) {
+        const { rows } = await driver.query<{ current_schema: string }>(
+          'SELECT current_schema() AS current_schema',
+        );
+        resolvedSchemas.push(rows[0]?.current_schema ?? 'public');
+      } else {
+        resolvedSchemas.push(id);
+      }
+    }
     const uniqueSchemas = Array.from(new Set(resolvedSchemas));
 
-    const perSchema = await Promise.all(uniqueSchemas.map((s) => this.introspectSchema(driver, s)));
+    // Walk schemas sequentially: every introspectSchema call shares the one
+    // control connection, so a parallel walk only serialises behind the wire
+    // protocol and trips pg's "already executing a query" deprecation.
+    const perSchema: SqlSchemaIR[] = [];
+    for (const schema of uniqueSchemas) {
+      perSchema.push(await this.introspectSchema(driver, schema));
+    }
 
     const mergedTables: Record<string, SqlTableIR> = {};
     for (const ir of perSchema) {
@@ -341,16 +624,18 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       }
     }
 
-    const mergedStorageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (let i = 0; i < perSchema.length; i++) {
-      const ir = perSchema[i];
-      const pg = blindCast<
-        { storageTypes?: Record<string, PostgresEnumStorageTypeAnnotation> } | undefined,
+    const mergedEnumTypes: Record<string, Record<string, PostgresEnumStorageTypeAnnotation>> = {};
+    for (const ir of perSchema) {
+      const enumTypes = blindCast<
+        | { enumTypes?: Record<string, Record<string, PostgresEnumStorageTypeAnnotation>> }
+        | undefined,
         'pg annotation envelope index slot'
-      >(ir?.annotations?.['pg'])?.storageTypes;
-      if (!pg) continue;
-      for (const [key, value] of Object.entries(pg)) {
-        mergedStorageTypes[key] = value;
+      >(ir?.annotations?.['pg'])?.enumTypes;
+      if (!enumTypes) continue;
+      for (const [schemaName, byType] of Object.entries(enumTypes)) {
+        const merged = mergedEnumTypes[schemaName] ?? {};
+        Object.assign(merged, byType);
+        mergedEnumTypes[schemaName] = merged;
       }
     }
 
@@ -366,8 +651,8 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         pg: {
           ...firstPg,
           ...ifDefined(
-            'storageTypes',
-            Object.keys(mergedStorageTypes).length > 0 ? mergedStorageTypes : undefined,
+            'enumTypes',
+            Object.keys(mergedEnumTypes).length > 0 ? mergedEnumTypes : undefined,
           ),
         },
       }),
@@ -380,35 +665,36 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * the per-namespace walk.
    */
   private async introspectSchema(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
+    driver: SqlControlDriverInstance<'postgres'>,
     schema: string,
   ): Promise<SqlSchemaIR> {
-    // Execute all queries in parallel for efficiency (6 queries instead of 5T+1)
-    const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult] =
-      await Promise.all([
-        // Query all tables
-        driver.query<{ table_name: string }>(
-          `SELECT table_name
+    // Issue the schema-wide queries one at a time. A single control connection
+    // serialises queries anyway, so Promise.all buys no parallelism here and
+    // makes pg emit a "client is already executing a query" deprecation. One
+    // schema-wide query per relation kind keeps this to 7 round-trips, not 6T+1.
+    // Query all tables
+    const tablesResult = await driver.query<{ table_name: string }>(
+      `SELECT table_name
          FROM information_schema.tables
          WHERE table_schema = $1
            AND table_type = 'BASE TABLE'
          ORDER BY table_name`,
-          [schema],
-        ),
-        // Query all columns for all tables in schema
-        driver.query<{
-          table_name: string;
-          column_name: string;
-          data_type: string;
-          udt_name: string;
-          is_nullable: string;
-          character_maximum_length: number | null;
-          numeric_precision: number | null;
-          numeric_scale: number | null;
-          column_default: string | null;
-          formatted_type: string | null;
-        }>(
-          `SELECT
+      [schema],
+    );
+    // Query all columns for all tables in schema
+    const columnsResult = await driver.query<{
+      table_name: string;
+      column_name: string;
+      data_type: string;
+      udt_name: string;
+      is_nullable: string;
+      character_maximum_length: number | null;
+      numeric_precision: number | null;
+      numeric_scale: number | null;
+      column_default: string | null;
+      formatted_type: string | null;
+    }>(
+      `SELECT
            c.table_name,
            column_name,
            data_type,
@@ -432,16 +718,16 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
            AND NOT a.attisdropped
          WHERE c.table_schema = $1
          ORDER BY c.table_name, c.ordinal_position`,
-          [schema],
-        ),
-        // Query all primary keys for all tables in schema
-        driver.query<{
-          table_name: string;
-          constraint_name: string;
-          column_name: string;
-          ordinal_position: number;
-        }>(
-          `SELECT
+      [schema],
+    );
+    // Query all primary keys for all tables in schema
+    const pkResult = await driver.query<{
+      table_name: string;
+      constraint_name: string;
+      column_name: string;
+      ordinal_position: number;
+    }>(
+      `SELECT
            tc.table_name,
            tc.constraint_name,
            kcu.column_name,
@@ -454,24 +740,24 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
          WHERE tc.table_schema = $1
            AND tc.constraint_type = 'PRIMARY KEY'
          ORDER BY tc.table_name, kcu.ordinal_position`,
-          [schema],
-        ),
-        // Query all foreign keys for all tables in schema, including referential actions.
-        // Uses pg_catalog for correct positional pairing of composite FK columns
-        // (information_schema.constraint_column_usage lacks ordinal_position,
-        // which causes Cartesian products for multi-column FKs).
-        driver.query<{
-          table_name: string;
-          constraint_name: string;
-          column_name: string;
-          ordinal_position: number;
-          referenced_table_schema: string;
-          referenced_table_name: string;
-          referenced_column_name: string;
-          delete_rule: string;
-          update_rule: string;
-        }>(
-          `SELECT
+      [schema],
+    );
+    // Query all foreign keys for all tables in schema, including referential actions.
+    // Uses pg_catalog for correct positional pairing of composite FK columns
+    // (information_schema.constraint_column_usage lacks ordinal_position,
+    // which causes Cartesian products for multi-column FKs).
+    const fkResult = await driver.query<{
+      table_name: string;
+      constraint_name: string;
+      column_name: string;
+      ordinal_position: number;
+      referenced_table_schema: string;
+      referenced_table_name: string;
+      referenced_column_name: string;
+      delete_rule: string;
+      update_rule: string;
+    }>(
+      `SELECT
            tc.table_name,
            tc.constraint_name,
            kcu.column_name,
@@ -504,16 +790,16 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
          WHERE tc.table_schema = $1
            AND tc.constraint_type = 'FOREIGN KEY'
          ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`,
-          [schema],
-        ),
-        // Query all unique constraints for all tables in schema (excluding PKs)
-        driver.query<{
-          table_name: string;
-          constraint_name: string;
-          column_name: string;
-          ordinal_position: number;
-        }>(
-          `SELECT
+      [schema],
+    );
+    // Query all unique constraints for all tables in schema (excluding PKs)
+    const uniqueResult = await driver.query<{
+      table_name: string;
+      constraint_name: string;
+      column_name: string;
+      ordinal_position: number;
+    }>(
+      `SELECT
            tc.table_name,
            tc.constraint_name,
            kcu.column_name,
@@ -526,31 +812,31 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
          WHERE tc.table_schema = $1
            AND tc.constraint_type = 'UNIQUE'
          ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`,
-          [schema],
-        ),
-        // Query all indexes for all tables in schema (excluding constraints).
-        // `index_position` is the column's position within the index (1-based),
-        // derived from `pg_index.indkey` so composite indexes round-trip with
-        // their declared column order intact.
-        driver.query<{
-          tablename: string;
-          indexname: string;
-          indisunique: boolean;
-          attname: string | null;
-          index_position: number;
-          amname: string | null;
-          reloptions: string[] | null;
-        }>(
-          // `ix.indkey` is an int2vector of column numbers in the order the
-          // columns appear in the index definition. Unnest it WITH ORDINALITY
-          // so each (index, column) row carries its position in the index,
-          // then ORDER BY that position. Without this the rows come back in
-          // table-column order (`a.attnum`), which silently shuffles the
-          // columns of any composite index whose index order differs from
-          // the table order — verification compares against the contract
-          // with order-sensitive equality and reports a spurious
-          // `index_mismatch`.
-          `SELECT
+      [schema],
+    );
+    // Query all indexes for all tables in schema (excluding constraints).
+    // `index_position` is the column's position within the index (1-based),
+    // derived from `pg_index.indkey` so composite indexes round-trip with
+    // their declared column order intact.
+    const indexResult = await driver.query<{
+      tablename: string;
+      indexname: string;
+      indisunique: boolean;
+      attname: string | null;
+      index_position: number;
+      amname: string | null;
+      reloptions: string[] | null;
+    }>(
+      // `ix.indkey` is an int2vector of column numbers in the order the
+      // columns appear in the index definition. Unnest it WITH ORDINALITY
+      // so each (index, column) row carries its position in the index,
+      // then ORDER BY that position. Without this the rows come back in
+      // table-column order (`a.attnum`), which silently shuffles the
+      // columns of any composite index whose index order differs from
+      // the table order — verification compares against the contract
+      // with order-sensitive equality and reports a spurious
+      // `index_mismatch`.
+      `SELECT
            i.tablename,
            i.indexname,
            ix.indisunique,
@@ -576,9 +862,33 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
                AND tc.constraint_name = i.indexname
            )
          ORDER BY i.tablename, i.indexname, k.ord`,
-          [schema],
-        ),
-      ]);
+      [schema],
+    );
+    // Query all check constraints for enum-restricted columns.
+    // `pg_get_constraintdef(oid)` returns the predicate including the
+    // `CHECK (...)` wrapper. We parse the inner predicate to extract
+    // the column name and permitted values.
+    //
+    // Scope: only parses the `= ANY (ARRAY[...])` and `IN (...)` shapes
+    // that this slice emits. Arbitrary SQL predicates are left as-is
+    // and will not produce check IR entries (they are silently skipped).
+    const checkResult = await driver.query<{
+      table_name: string;
+      constraint_name: string;
+      constraintdef: string;
+    }>(
+      `SELECT
+           cl.relname AS table_name,
+           c.conname AS constraint_name,
+           pg_get_constraintdef(c.oid) AS constraintdef
+         FROM pg_catalog.pg_constraint c
+         JOIN pg_catalog.pg_class cl ON cl.oid = c.conrelid
+         JOIN pg_catalog.pg_namespace ns ON ns.oid = cl.relnamespace
+         WHERE ns.nspname = $1
+           AND c.contype = 'c'
+         ORDER BY cl.relname, c.conname`,
+      [schema],
+    );
 
     // Group results by table name for efficient lookup
     const columnsByTable = groupBy(columnsResult.rows, 'table_name');
@@ -586,6 +896,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
     const fksByTable = groupBy(fkResult.rows, 'table_name');
     const uniquesByTable = groupBy(uniqueResult.rows, 'table_name');
     const indexesByTable = groupBy(indexResult.rows, 'tablename');
+    const checksByTable = groupBy(checkResult.rows, 'table_name');
 
     // Get set of PK constraint names per table (to exclude from uniques)
     const pkConstraintsByTable = new Map<string, Set<string>>();
@@ -757,6 +1068,21 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         ...(idx.options !== undefined && { options: idx.options }),
       }));
 
+      // Process check constraints — parse each predicate into column + value set.
+      // Only the two shapes emitted by this slice are recognised; free-form
+      // predicates are silently skipped (they won't produce check IR entries).
+      const checksForTable: SqlCheckConstraintIRInput[] = [];
+      for (const checkRow of checksByTable.get(tableName) ?? []) {
+        const parsed = parseCheckConstraintDef(checkRow.constraintdef);
+        if (parsed) {
+          checksForTable.push({
+            name: checkRow.constraint_name,
+            column: parsed.column,
+            permittedValues: parsed.permittedValues,
+          });
+        }
+      }
+
       tables[tableName] = {
         name: tableName,
         columns,
@@ -764,23 +1090,21 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         foreignKeys,
         uniques,
         indexes,
+        ...ifDefined('checks', checksForTable.length > 0 ? checksForTable : undefined),
       };
     }
 
-    const rawStorageTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
-    const storageTypes: Record<string, PostgresEnumStorageTypeAnnotation> = {};
-    for (const [typeName, annotation] of Object.entries(rawStorageTypes)) {
-      storageTypes[enumStorageCompoundKey(schema, typeName)] = annotation;
-    }
+    const rawEnumTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
+    const enumTypes: Record<
+      string,
+      Record<string, PostgresEnumStorageTypeAnnotation>
+    > = Object.keys(rawEnumTypes).length > 0 ? { [schema]: rawEnumTypes } : {};
 
     const annotations = {
       pg: {
         schema,
         version: await this.getPostgresVersion(driver),
-        ...ifDefined(
-          'storageTypes',
-          Object.keys(storageTypes).length > 0 ? storageTypes : undefined,
-        ),
+        ...ifDefined('enumTypes', Object.keys(enumTypes).length > 0 ? enumTypes : undefined),
       },
     };
 
@@ -793,9 +1117,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   /**
    * Gets the Postgres version from the database.
    */
-  private async getPostgresVersion(
-    driver: ControlDriverInstance<'sql', 'postgres'>,
-  ): Promise<string> {
+  private async getPostgresVersion(driver: SqlControlDriverInstance<'postgres'>): Promise<string> {
     const result = await driver.query<{ version: string }>('SELECT version() AS version', []);
     const versionString = result.rows[0]?.version ?? '';
     // Extract version number from "PostgreSQL 15.1 ..." format
@@ -947,3 +1269,100 @@ function groupBy<T, K extends keyof T>(items: readonly T[], key: K): Map<T[K], T
   }
   return map;
 }
+
+/**
+ * Parses a Postgres check-constraint definition string (as returned by
+ * `pg_get_constraintdef`) into a column name and permitted values array.
+ *
+ * Handles two shapes that Postgres emits for enum-style checks:
+ *
+ * 1. `= ANY (ARRAY[...])` — Postgres rewrites `col IN ('a','b')` to this form:
+ *    `CHECK ((col = ANY (ARRAY['a'::text, 'b'::text])))`
+ *
+ * 2. `IN (...)` — stays as-is when written directly:
+ *    `CHECK ((col IN ('a', 'b')))`
+ *
+ * Column names may be plain identifiers (`status`) or double-quoted identifiers
+ * (`"my-col"`). Double-quoted identifiers with embedded `""` are un-escaped to a
+ * single `"`.
+ *
+ * String literal values may contain Postgres-style doubled single-quotes (`''`),
+ * which are un-escaped to a single `'` (e.g. `O''Brien` → `O'Brien`).
+ *
+ * Returns `{ column, permittedValues }` when the predicate matches one of
+ * the two recognised shapes. Returns `undefined` for anything else (e.g.
+ * a free-form SQL predicate that wasn't emitted by this slice).
+ */
+export function parseCheckConstraintDef(
+  constraintdef: string,
+): { column: string; permittedValues: readonly string[] } | undefined {
+  // Strip outer `CHECK (...)` wrapper and any extra parentheses.
+  // pg_get_constraintdef returns e.g. `CHECK ((col = ANY (ARRAY[...])))` — note
+  // the double parens: one from CHECK and one that Postgres wraps the predicate
+  // in. Strip both outer layers.
+  const afterCheck = constraintdef
+    .replace(/^CHECK\s*\(/i, '')
+    .replace(/\)$/, '')
+    .trim();
+  // Strip one more optional paren pair (the inner wrap Postgres adds)
+  const inner =
+    afterCheck.startsWith('(') && afterCheck.endsWith(')')
+      ? afterCheck.slice(1, -1).trim()
+      : afterCheck;
+
+  // Shape 1: col = ANY (ARRAY['a'::text, 'b'::text])
+  // Accepts both plain identifiers and double-quoted identifiers for the column.
+  // Anchored at the end so a composite predicate (e.g. `col = ANY (...) AND x > 0`)
+  // does not partial-match.
+  const anyArrayMatch = inner.match(
+    /^(?:"((?:[^"]|"")*)"|(\w+))\s*=\s*ANY\s*\(\s*ARRAY\s*\[(.+)\]\s*\)\s*$/i,
+  );
+  if (anyArrayMatch) {
+    const column =
+      anyArrayMatch[1] !== undefined ? anyArrayMatch[1].replace(/""/g, '"') : anyArrayMatch[2];
+    const arrayBody = anyArrayMatch[3];
+    if (!column || !arrayBody) return undefined;
+    const permittedValues = extractArrayLiterals(arrayBody);
+    return permittedValues ? { column, permittedValues } : undefined;
+  }
+
+  // Shape 2: col IN ('a', 'b')
+  // Accepts both plain identifiers and double-quoted identifiers for the column.
+  // Anchored at the end so a composite predicate (e.g. `col IN (...) AND x > 0`)
+  // does not partial-match.
+  const inMatch = inner.match(/^(?:"((?:[^"]|"")*)"|(\w+))\s+IN\s*\((.+)\)\s*$/i);
+  if (inMatch) {
+    const column = inMatch[1] !== undefined ? inMatch[1].replace(/""/g, '"') : inMatch[2];
+    const listBody = inMatch[3];
+    if (!column || !listBody) return undefined;
+    const permittedValues = extractQuotedLiterals(listBody);
+    return permittedValues ? { column, permittedValues } : undefined;
+  }
+
+  return undefined;
+}
+
+/**
+ * Extracts string literals from an `ARRAY[...]` body.
+ * Handles `'value'::type` casts by stripping the cast part.
+ * Postgres stores single quotes inside values as doubled single-quotes (`''`);
+ * each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
+ */
+function extractArrayLiterals(arrayBody: string): readonly string[] | undefined {
+  // Match 'value'::cast or 'value' (with possible spaces)
+  const pattern = /'((?:[^'\\]|\\.|'')*)'\s*(?:::[^\s,\]]+)?/g;
+  const values = [...arrayBody.matchAll(pattern)].map((m) => (m[1] ?? '').replace(/''/g, "'"));
+  return values.length > 0 ? values : undefined;
+}
+
+/**
+ * Extracts string literals from an `IN (...)` list.
+ * Handles single-quoted literals with possible escaped quotes.
+ * Postgres stores single quotes inside values as doubled single-quotes (`''`);
+ * each extracted value is un-escaped so `O''Brien` becomes `O'Brien`.
+ */
+function extractQuotedLiterals(listBody: string): readonly string[] | undefined {
+  const pattern = /'((?:[^'\\]|\\.|'')*)'/g;
+  const values = [...listBody.matchAll(pattern)].map((m) => (m[1] ?? '').replace(/''/g, "'"));
+  return values.length > 0 ? values : undefined;
+}