@prisma-next/adapter-postgres 0.5.0-dev.9 → 0.6.0-dev.1

package/src/core/control-adapter.ts

@@ -1,4 +1,7 @@
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 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 type { ControlDriverInstance } from '@prisma-next/framework-components/control';
 import type {
   AnyQueryAst,
@@ -6,7 +9,6 @@ import type {
   LowererContext,
 } from '@prisma-next/sql-relational-core/ast';
 import type {
-  DependencyIR,
   PrimaryKey,
   SqlColumnIR,
   SqlForeignKeyIR,
@@ -19,6 +21,7 @@ import type {
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 import { ifDefined } from '@prisma-next/utils/defined';
+import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { pgEnumControlHooks } from './enum-control-hooks';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresContract } from './types';
@@ -31,6 +34,19 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   readonly familyId = 'sql' as const;
   readonly targetId = 'postgres' as const;
 
+  private readonly codecLookup: CodecLookup;
+
+  /**
+   * @param codecLookup - Codec lookup used by the SQL renderer to resolve
+   *   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
+   *   lookup when omitted. Stack-aware callers
+   *   (`SqlControlAdapterDescriptor.create(stack)`) supply
+   *   `stack.codecLookup` so extension codecs are visible to the renderer.
+   */
+  constructor(codecLookup?: CodecLookup) {
+    this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
+  }
+
   /**
    * Target-specific normalizer for raw Postgres default expressions.
    * Used by schema verification to normalize raw defaults before comparison.
@@ -53,7 +69,108 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * without instantiating the runtime adapter.
    */
   lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
-    return renderLoweredSql(ast, context.contract as PostgresContract);
+    return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
+  }
+
+  /**
+   * Reads the contract marker from `prisma_contract.marker`. Probes
+   * `information_schema.tables` first so a fresh database (where the
+   * `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+   * "relation does not exist" error — some Postgres wire-protocol clients
+   * (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+   * parse errors, so we probe before reading.
+   */
+  async readMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    space: string,
+  ): Promise<ContractMarkerRecord | null> {
+    const exists = await driver.query(
+      `select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`,
+      ['prisma_contract', 'marker'],
+    );
+    if (exists.rows.length === 0) {
+      return null;
+    }
+
+    const result = await 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],
+    );
+
+    const row = result.rows[0];
+    if (!row) return null;
+    return parseContractMarkerRow(row);
+  }
+
+  /**
+   * Reads every row from `prisma_contract.marker` and returns them keyed
+   * by `space`. Mirrors the existence probe in {@link readMarker}: a
+   * fresh database without the `prisma_contract` schema returns an empty
+   * map rather than raising "relation does not exist".
+   */
+  async readAllMarkers(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+  ): Promise<ReadonlyMap<string, ContractMarkerRecord>> {
+    const exists = await driver.query(
+      `select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`,
+      ['prisma_contract', 'marker'],
+    );
+    if (exists.rows.length === 0) {
+      return new Map();
+    }
+
+    const result = await 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`,
+    );
+
+    const rows = new Map<string, ContractMarkerRecord>();
+    for (const row of result.rows) {
+      rows.set(row.space, parseContractMarkerRow(row));
+    }
+    return rows;
   }
 
   /**
@@ -63,7 +180,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    * and returns the schema structure without type mapping or contract enrichment.
    * Type mapping and enrichment are handled separately by enrichment helpers.
    *
-   * Uses batched queries to minimize database round trips (7 queries instead of 5T+3).
+   * Uses batched queries to minimize database round trips (6 queries instead of 5T+1).
    *
    * @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
    * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
@@ -75,39 +192,32 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
     _contract?: unknown,
     schema = 'public',
   ): Promise<SqlSchemaIR> {
-    // Execute all queries in parallel for efficiency (7 queries instead of 5T+3)
-    const [
-      tablesResult,
-      columnsResult,
-      pkResult,
-      fkResult,
-      uniqueResult,
-      indexResult,
-      extensionsResult,
-    ] = await Promise.all([
-      // Query all tables
-      driver.query<{ table_name: string }>(
-        `SELECT table_name
+    // 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
          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
+        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,
@@ -131,16 +241,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
+        driver.query<{
+          table_name: string;
+          constraint_name: string;
+          column_name: string;
+          ordinal_position: number;
+        }>(
+          `SELECT
            tc.table_name,
            tc.constraint_name,
            kcu.column_name,
@@ -153,24 +263,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).
+        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,
@@ -203,16 +313,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)
+        driver.query<{
+          table_name: string;
+          constraint_name: string;
+          column_name: string;
+          ordinal_position: number;
+        }>(
+          `SELECT
            tc.table_name,
            tc.constraint_name,
            kcu.column_name,
@@ -225,26 +335,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)
-      driver.query<{
-        tablename: string;
-        indexname: string;
-        indisunique: boolean;
-        attname: string;
-        attnum: number;
-      }>(
-        `SELECT
+          [schema],
+        ),
+        // Query all indexes for all tables in schema (excluding constraints)
+        driver.query<{
+          tablename: string;
+          indexname: string;
+          indisunique: boolean;
+          attname: string;
+          attnum: number;
+          amname: string | null;
+          reloptions: string[] | null;
+        }>(
+          `SELECT
            i.tablename,
            i.indexname,
            ix.indisunique,
            a.attname,
-           a.attnum
+           a.attnum,
+           am.amname,
+           ic.reloptions
          FROM pg_indexes i
          JOIN pg_class ic ON ic.relname = i.indexname
          JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1
          JOIN pg_index ix ON ix.indexrelid = ic.oid
+         JOIN pg_am am ON am.oid = ic.relam
          JOIN pg_class t ON t.oid = ix.indrelid
          JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
          LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey) AND a.attnum > 0
@@ -257,16 +372,9 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
                AND tc.constraint_name = i.indexname
            )
          ORDER BY i.tablename, i.indexname, a.attnum`,
-        [schema],
-      ),
-      // Query extensions
-      driver.query<{ extname: string }>(
-        `SELECT extname
-         FROM pg_extension
-         ORDER BY extname`,
-        [],
-      ),
-    ]);
+          [schema],
+        ),
+      ]);
 
     // Group results by table name for efficient lookup
     const columnsByTable = groupBy(columnsResult.rows, 'table_name');
@@ -402,7 +510,16 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       }));
 
       // Process indexes
-      const indexesMap = new Map<string, { columns: string[]; name: string; unique: boolean }>();
+      const indexesMap = new Map<
+        string,
+        {
+          columns: string[];
+          name: string;
+          unique: boolean;
+          type: string | undefined;
+          options: Record<string, string> | undefined;
+        }
+      >();
       for (const idxRow of indexesByTable.get(tableName) ?? []) {
         if (!idxRow.attname) {
           continue;
@@ -411,10 +528,17 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         if (existing) {
           existing.columns.push(idxRow.attname);
         } else {
+          // Drop btree (the Postgres default) so a contract index without an
+          // explicit type matches a default-method introspected index without
+          // forcing DROP+CREATE on every plan.
+          const indexType = idxRow.amname && idxRow.amname !== 'btree' ? idxRow.amname : undefined;
+          const indexOptions = parsePgReloptions(idxRow.reloptions, idxRow.indexname);
           indexesMap.set(idxRow.indexname, {
             columns: [idxRow.attname],
             name: idxRow.indexname,
             unique: idxRow.indisunique,
+            type: indexType,
+            options: indexOptions,
           });
         }
       }
@@ -422,6 +546,8 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
         columns: Object.freeze([...idx.columns]) as readonly string[],
         name: idx.name,
         unique: idx.unique,
+        ...(idx.type !== undefined && { type: idx.type }),
+        ...(idx.options !== undefined && { options: idx.options }),
       }));
 
       tables[tableName] = {
@@ -434,10 +560,6 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       };
     }
 
-    const dependencies: readonly DependencyIR[] = extensionsResult.rows.map((row) => ({
-      id: `postgres.extension.${row.extname}`,
-    }));
-
     const storageTypes =
       (await pgEnumControlHooks.introspectTypes?.({ driver, schemaName: schema })) ?? {};
 
@@ -454,7 +576,6 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
 
     return {
       tables,
-      dependencies,
       annotations,
     };
   }
@@ -555,6 +676,39 @@ function mapReferentialAction(rule: string): SqlReferentialAction | undefined {
  * Groups an array of objects by a specified key.
  * Returns a Map for O(1) lookup by group key.
  */
+/**
+ * Parses a `pg_class.reloptions` array into a `Record<string, string>`.
+ *
+ * Postgres returns reloptions as a `text[]` whose entries are `key=value`
+ * strings; the value side is always a string regardless of the underlying
+ * scalar type. The verifier compares contract options to introspected
+ * options after coercing both sides to strings, so keeping the raw text
+ * here is correct.
+ *
+ * Returns `undefined` when the input is null/empty (no WITH clause).
+ */
+export function parsePgReloptions(
+  reloptions: readonly string[] | null,
+  indexName: string,
+): Record<string, string> | undefined {
+  if (!reloptions || reloptions.length === 0) {
+    return undefined;
+  }
+  const result: Record<string, string> = {};
+  for (const entry of reloptions) {
+    const eq = entry.indexOf('=');
+    if (eq === -1) {
+      throw new Error(
+        `Postgres introspection: malformed reloption entry "${entry}" on index "${indexName}" (expected "key=value")`,
+      );
+    }
+    const key = entry.slice(0, eq);
+    const value = entry.slice(eq + 1);
+    result[key] = value;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
 function groupBy<T, K extends keyof T>(items: readonly T[], key: K): Map<T[K], T[]> {
   const map = new Map<T[K], T[]>();
   for (const item of items) {

package/src/core/control-mutation-defaults.ts

@@ -1,4 +1,5 @@
 import type { ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import { timestampNowControlDescriptor } from '@prisma-next/family-sql/control';
 import type {
   ControlMutationDefaultEntry,
   DefaultFunctionLoweringContext,
@@ -301,25 +302,30 @@ export function createPostgresDefaultFunctionRegistry(): ReadonlyMap<
 }
 
 export function createPostgresMutationDefaultGeneratorDescriptors(): readonly MutationDefaultGeneratorDescriptor[] {
-  return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
-    id,
-    applicableCodecIds,
-    resolveGeneratedColumnDescriptor: ({ generated }) => {
-      if (generated.kind !== 'generator' || generated.id !== id) {
-        return undefined;
-      }
-      const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+  return [
+    ...builtinGeneratorRegistryMetadata.map(
+      ({ id, applicableCodecIds }): MutationDefaultGeneratorDescriptor => ({
         id,
-        ...(generated.params ? { params: generated.params } : {}),
-      });
-      return {
-        codecId: descriptor.type.codecId,
-        nativeType: descriptor.type.nativeType,
-        ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
-        ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
-      };
-    },
-  }));
+        applicableCodecIds,
+        resolveGeneratedColumnDescriptor: ({ generated }) => {
+          if (generated.kind !== 'generator' || generated.id !== id) {
+            return undefined;
+          }
+          const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+            id,
+            ...(generated.params ? { params: generated.params } : {}),
+          });
+          return {
+            codecId: descriptor.type.codecId,
+            nativeType: descriptor.type.nativeType,
+            ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
+            ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
+          };
+        },
+      }),
+    ),
+    timestampNowControlDescriptor(),
+  ];
 }
 
 export function createPostgresScalarTypeDescriptors(): ReadonlyMap<string, string> {

package/src/core/descriptor-meta.ts

@@ -1,8 +1,9 @@
 import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';
-import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import { buildOperation, refsOf, toExpr } from '@prisma-next/sql-relational-core/expression';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
+  PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
   PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
@@ -30,12 +31,11 @@ import {
   SQL_TIMESTAMP_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
 } from '@prisma-next/target-postgres/codec-ids';
-import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
+import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
+import type { QueryOperationTypes } from '../types/operation-types';
 import { pgEnumControlHooks } from './enum-control-hooks';
 
-// ============================================================================
-// Helper functions for reducing boilerplate
-// ============================================================================
+// ============================================================================ Helper functions for reducing boilerplate ============================================================================
 
 /** Creates a type import spec for codec types */
 const codecTypeImport = (named: string) =>
@@ -124,21 +124,26 @@ const precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };
 const numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };
 const identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };
 
-// ============================================================================
-// Descriptor metadata
-// ============================================================================
+// ============================================================================ Descriptor metadata ============================================================================
 
-export const postgresQueryOperations: readonly SqlOperationDescriptor[] = [
-  {
-    method: 'ilike',
-    args: [
-      { traits: ['textual'], nullable: false },
-      { codecId: PG_TEXT_CODEC_ID, nullable: false },
-    ],
-    returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
-    lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
-  },
-];
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export function postgresQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {
+  return {
+    ilike: {
+      self: { traits: ['textual'] },
+      impl: (self, pattern) => {
+        const selfRefs = refsOf(self);
+        return buildOperation({
+          method: 'ilike',
+          args: [toExpr(self), toExpr(pattern, PG_TEXT_CODEC_ID, selfRefs)],
+          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
+        });
+      },
+    },
+  };
+}
 
 export const postgresAdapterDescriptorMeta = {
   kind: 'adapter',
@@ -162,7 +167,7 @@ export const postgresAdapterDescriptorMeta = {
   },
   types: {
     codecTypes: {
-      codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
+      codecDescriptors: Array.from(postgresCodecRegistry.values()),
       import: {
         package: '@prisma-next/target-postgres/codec-types',
         named: 'CodecTypes',
@@ -202,6 +207,7 @@ export const postgresAdapterDescriptorMeta = {
         [PG_ENUM_CODEC_ID]: pgEnumControlHooks,
         [PG_JSON_CODEC_ID]: identityHooks,
         [PG_JSONB_CODEC_ID]: identityHooks,
+        [PG_BYTEA_CODEC_ID]: identityHooks,
       },
     },
     storage: [
@@ -267,6 +273,7 @@ export const postgresAdapterDescriptorMeta = {
       },
       { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },
       { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },
+      { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },
     ],
     queryOperationTypes: {
       import: {