@prisma-next/adapter-postgres 0.3.0-dev.11 → 0.3.0-dev.113

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":["tables: Record<string, SqlTableIR>","columns: Record<string, SqlColumnIR>","primaryKey: PrimaryKey | undefined","foreignKeys: readonly SqlForeignKeyIR[]","uniques: readonly SqlUniqueIR[]","indexes: readonly SqlIndexIR[]","dependencies: readonly DependencyIR[]","TYPE_PREFIX_MAP: ReadonlyMap<string, string>","PG_REFERENTIAL_ACTION_MAP: Record<PgReferentialActionRule, SqlReferentialAction>","postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>"],"sources":["../src/core/default-normalizer.ts","../src/core/control-adapter.ts","../src/core/control-mutation-defaults.ts","../src/exports/control.ts"],"sourcesContent":["import type { ColumnDefault } from '@prisma-next/contract/types';\n\n/**\n * Pre-compiled regex patterns for performance.\n * These are compiled once at module load time rather than on each function call.\n */\nconst NEXTVAL_PATTERN = /^nextval\\s*\\(/i;\nconst NOW_FUNCTION_PATTERN = /^(now\\s*\\(\\s*\\)|CURRENT_TIMESTAMP)$/i;\nconst CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\\s*\\(\\s*\\)$/i;\nconst TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\\s+(?:with|without)\\s+time\\s+zone)?$/i;\nconst TEXT_CAST_SUFFIX = /::text$/i;\nconst NOW_LITERAL_PATTERN = /^'now'$/i;\nconst UUID_PATTERN = /^gen_random_uuid\\s*\\(\\s*\\)$/i;\nconst UUID_OSSP_PATTERN = /^uuid_generate_v4\\s*\\(\\s*\\)$/i;\nconst NULL_PATTERN = /^NULL(?:::.+)?$/i;\nconst TRUE_PATTERN = /^true$/i;\nconst FALSE_PATTERN = /^false$/i;\nconst NUMERIC_PATTERN = /^-?\\d+(\\.\\d+)?$/;\nconst STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:\"[^\"]+\"|[\\w\\s]+)(?:\\(\\d+\\))?)?$/;\n\n/**\n * Returns the canonical expression for a timestamp default function, or undefined\n * if the expression is not a recognized timestamp default.\n *\n * Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:\n * - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'\n * - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'\n *\n * These are semantically different in Postgres: now() returns the transaction\n * start time (constant within a transaction), while clock_timestamp() returns\n * the actual wall-clock time (can differ across rows in a single INSERT).\n */\nfunction canonicalizeTimestampDefault(expr: string): string | undefined {\n  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';\n\n  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;\n\n  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();\n\n  // Strip outer parentheses\n  if (inner.startsWith('(') && inner.endsWith(')')) {\n    inner = inner.slice(1, -1).trim();\n  }\n\n  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';\n\n  // Handle 'now'::text form (Postgres casts the string literal 'now' through ::text)\n  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();\n  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';\n\n  return undefined;\n}\n\n/**\n * Parses a raw Postgres column default expression into a normalized ColumnDefault.\n * This enables semantic comparison between contract defaults and introspected schema defaults.\n *\n * Used by the migration diff layer to normalize raw database defaults during comparison,\n * keeping the introspection layer focused on faithful data capture.\n *\n * @param rawDefault - Raw default expression from information_schema.columns.column_default\n * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)\n * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed\n */\nexport function parsePostgresDefault(\n  rawDefault: string,\n  nativeType?: string,\n): ColumnDefault | undefined {\n  const trimmed = rawDefault.trim();\n  const normalizedType = nativeType?.toLowerCase();\n  const isBigInt = normalizedType === 'bigint' || normalizedType === 'int8';\n\n  // Autoincrement: nextval('tablename_column_seq'::regclass)\n  if (NEXTVAL_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'autoincrement()' };\n  }\n\n  // Timestamp defaults: now()/CURRENT_TIMESTAMP → 'now()', clock_timestamp() → 'clock_timestamp()'\n  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);\n  if (canonicalTimestamp) {\n    return { kind: 'function', expression: canonicalTimestamp };\n  }\n\n  // gen_random_uuid()\n  if (UUID_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  // uuid_generate_v4() from uuid-ossp extension\n  if (UUID_OSSP_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  // NULL or NULL::type — explicit null default\n  if (NULL_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: null };\n  }\n\n  // Boolean literals\n  if (TRUE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: true };\n  }\n  if (FALSE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: false };\n  }\n\n  // Numeric literals (integer or decimal)\n  if (NUMERIC_PATTERN.test(trimmed)) {\n    if (isBigInt) {\n      return { kind: 'literal', value: { $type: 'bigint', value: trimmed } };\n    }\n    const num = Number(trimmed);\n    if (!Number.isFinite(num)) return undefined;\n    return { kind: 'literal', value: num };\n  }\n\n  // String literals: 'value'::type or just 'value'\n  // Match: 'some text'::text, 'hello'::character varying, 'value', etc.\n  // Strip the ::type cast so the normalized expression matches what contract authors write.\n  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);\n  if (stringMatch?.[1] !== undefined) {\n    const unescaped = stringMatch[1].replace(/''/g, \"'\");\n    if (normalizedType === 'json' || normalizedType === 'jsonb') {\n      try {\n        return { kind: 'literal', value: JSON.parse(unescaped) };\n      } catch {\n        // Keep legacy behavior for malformed/non-JSON string content.\n      }\n    }\n    return { kind: 'literal', value: unescaped };\n  }\n\n  // Unrecognized expression - return as a function with the raw expression\n  // This preserves the information for debugging while still being comparable\n  return { kind: 'function', expression: trimmed };\n}\n","import type { ControlDriverInstance } from '@prisma-next/core-control-plane/types';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport type {\n  DependencyIR,\n  PrimaryKey,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlReferentialAction,\n  SqlSchemaIR,\n  SqlTableIR,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { parsePostgresDefault } from './default-normalizer';\nimport { pgEnumControlHooks } from './enum-control-hooks';\n\n/**\n * Postgres control plane adapter for control-plane operations like introspection.\n * Provides target-specific implementations for control-plane domain actions.\n */\nexport class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {\n  readonly familyId = 'sql' as const;\n  readonly targetId = 'postgres' as const;\n  /**\n   * @deprecated Use targetId instead\n   */\n  readonly target = 'postgres' as const;\n\n  /**\n   * Target-specific normalizer for raw Postgres default expressions.\n   * Used by schema verification to normalize raw defaults before comparison.\n   */\n  readonly normalizeDefault = parsePostgresDefault;\n\n  /**\n   * Target-specific normalizer for Postgres schema native type names.\n   * Used by schema verification to normalize introspected type names\n   * before comparison with contract native types.\n   */\n  readonly normalizeNativeType = normalizeSchemaNativeType;\n\n  /**\n   * Introspects a Postgres database schema and returns a raw SqlSchemaIR.\n   *\n   * This is a pure schema discovery operation that queries the Postgres catalog\n   * and returns the schema structure without type mapping or contract enrichment.\n   * Type mapping and enrichment are handled separately by enrichment helpers.\n   *\n   * Uses batched queries to minimize database round trips (7 queries instead of 5T+3).\n   *\n   * @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries\n   * @param contractIR - Optional contract IR for contract-guided introspection (filtering, optimization)\n   * @param schema - Schema name to introspect (defaults to 'public')\n   * @returns Promise resolving to SqlSchemaIR representing the live database schema\n   */\n  async introspect(\n    driver: ControlDriverInstance<'sql', 'postgres'>,\n    _contractIR?: unknown,\n    schema = 'public',\n  ): Promise<SqlSchemaIR> {\n    // Execute all queries in parallel for efficiency (7 queries instead of 5T+3)\n    const [\n      tablesResult,\n      columnsResult,\n      pkResult,\n      fkResult,\n      uniqueResult,\n      indexResult,\n      extensionsResult,\n    ] = await Promise.all([\n      // Query all tables\n      driver.query<{ table_name: string }>(\n        `SELECT table_name\n         FROM information_schema.tables\n         WHERE table_schema = $1\n           AND table_type = 'BASE TABLE'\n         ORDER BY table_name`,\n        [schema],\n      ),\n      // Query all columns for all tables in schema\n      driver.query<{\n        table_name: string;\n        column_name: string;\n        data_type: string;\n        udt_name: string;\n        is_nullable: string;\n        character_maximum_length: number | null;\n        numeric_precision: number | null;\n        numeric_scale: number | null;\n        column_default: string | null;\n        formatted_type: string | null;\n      }>(\n        `SELECT\n           c.table_name,\n           column_name,\n           data_type,\n           udt_name,\n           is_nullable,\n           character_maximum_length,\n           numeric_precision,\n           numeric_scale,\n           column_default,\n           format_type(a.atttypid, a.atttypmod) AS formatted_type\n         FROM information_schema.columns c\n         JOIN pg_catalog.pg_class cl\n           ON cl.relname = c.table_name\n         JOIN pg_catalog.pg_namespace ns\n           ON ns.nspname = c.table_schema\n           AND ns.oid = cl.relnamespace\n         JOIN pg_catalog.pg_attribute a\n           ON a.attrelid = cl.oid\n           AND a.attname = c.column_name\n           AND a.attnum > 0\n           AND NOT a.attisdropped\n         WHERE c.table_schema = $1\n         ORDER BY c.table_name, c.ordinal_position`,\n        [schema],\n      ),\n      // Query all primary keys for all tables in schema\n      driver.query<{\n        table_name: string;\n        constraint_name: string;\n        column_name: string;\n        ordinal_position: number;\n      }>(\n        `SELECT\n           tc.table_name,\n           tc.constraint_name,\n           kcu.column_name,\n           kcu.ordinal_position\n         FROM information_schema.table_constraints tc\n         JOIN information_schema.key_column_usage kcu\n           ON tc.constraint_name = kcu.constraint_name\n           AND tc.table_schema = kcu.table_schema\n           AND tc.table_name = kcu.table_name\n         WHERE tc.table_schema = $1\n           AND tc.constraint_type = 'PRIMARY KEY'\n         ORDER BY tc.table_name, kcu.ordinal_position`,\n        [schema],\n      ),\n      // Query all foreign keys for all tables in schema, including referential actions.\n      // Uses pg_catalog for correct positional pairing of composite FK columns\n      // (information_schema.constraint_column_usage lacks ordinal_position,\n      // which causes Cartesian products for multi-column FKs).\n      driver.query<{\n        table_name: string;\n        constraint_name: string;\n        column_name: string;\n        ordinal_position: number;\n        referenced_table_schema: string;\n        referenced_table_name: string;\n        referenced_column_name: string;\n        delete_rule: string;\n        update_rule: string;\n      }>(\n        `SELECT\n           tc.table_name,\n           tc.constraint_name,\n           kcu.column_name,\n           kcu.ordinal_position,\n           ref_ns.nspname AS referenced_table_schema,\n           ref_cl.relname AS referenced_table_name,\n           ref_att.attname AS referenced_column_name,\n           rc.delete_rule,\n           rc.update_rule\n         FROM information_schema.table_constraints tc\n         JOIN information_schema.key_column_usage kcu\n           ON tc.constraint_name = kcu.constraint_name\n           AND tc.table_schema = kcu.table_schema\n           AND tc.table_name = kcu.table_name\n         JOIN pg_catalog.pg_constraint pgc\n           ON pgc.conname = tc.constraint_name\n           AND pgc.connamespace = (\n             SELECT oid FROM pg_catalog.pg_namespace WHERE nspname = tc.table_schema\n           )\n         JOIN pg_catalog.pg_class ref_cl\n           ON ref_cl.oid = pgc.confrelid\n         JOIN pg_catalog.pg_namespace ref_ns\n           ON ref_ns.oid = ref_cl.relnamespace\n         JOIN pg_catalog.pg_attribute ref_att\n           ON ref_att.attrelid = pgc.confrelid\n           AND ref_att.attnum = pgc.confkey[kcu.ordinal_position]\n         JOIN information_schema.referential_constraints rc\n           ON rc.constraint_name = tc.constraint_name\n           AND rc.constraint_schema = tc.table_schema\n         WHERE tc.table_schema = $1\n           AND tc.constraint_type = 'FOREIGN KEY'\n         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`,\n        [schema],\n      ),\n      // Query all unique constraints for all tables in schema (excluding PKs)\n      driver.query<{\n        table_name: string;\n        constraint_name: string;\n        column_name: string;\n        ordinal_position: number;\n      }>(\n        `SELECT\n           tc.table_name,\n           tc.constraint_name,\n           kcu.column_name,\n           kcu.ordinal_position\n         FROM information_schema.table_constraints tc\n         JOIN information_schema.key_column_usage kcu\n           ON tc.constraint_name = kcu.constraint_name\n           AND tc.table_schema = kcu.table_schema\n           AND tc.table_name = kcu.table_name\n         WHERE tc.table_schema = $1\n           AND tc.constraint_type = 'UNIQUE'\n         ORDER BY tc.table_name, tc.constraint_name, kcu.ordinal_position`,\n        [schema],\n      ),\n      // Query all indexes for all tables in schema (excluding constraints)\n      driver.query<{\n        tablename: string;\n        indexname: string;\n        indisunique: boolean;\n        attname: string;\n        attnum: number;\n      }>(\n        `SELECT\n           i.tablename,\n           i.indexname,\n           ix.indisunique,\n           a.attname,\n           a.attnum\n         FROM pg_indexes i\n         JOIN pg_class ic ON ic.relname = i.indexname\n         JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1\n         JOIN pg_index ix ON ix.indexrelid = ic.oid\n         JOIN pg_class t ON t.oid = ix.indrelid\n         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1\n         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey) AND a.attnum > 0\n         WHERE i.schemaname = $1\n           AND NOT EXISTS (\n             SELECT 1\n             FROM information_schema.table_constraints tc\n             WHERE tc.table_schema = $1\n               AND tc.table_name = i.tablename\n               AND tc.constraint_name = i.indexname\n           )\n         ORDER BY i.tablename, i.indexname, a.attnum`,\n        [schema],\n      ),\n      // Query extensions\n      driver.query<{ extname: string }>(\n        `SELECT extname\n         FROM pg_extension\n         ORDER BY extname`,\n        [],\n      ),\n    ]);\n\n    // Group results by table name for efficient lookup\n    const columnsByTable = groupBy(columnsResult.rows, 'table_name');\n    const pksByTable = groupBy(pkResult.rows, 'table_name');\n    const fksByTable = groupBy(fkResult.rows, 'table_name');\n    const uniquesByTable = groupBy(uniqueResult.rows, 'table_name');\n    const indexesByTable = groupBy(indexResult.rows, 'tablename');\n\n    // Get set of PK constraint names per table (to exclude from uniques)\n    const pkConstraintsByTable = new Map<string, Set<string>>();\n    for (const row of pkResult.rows) {\n      let constraints = pkConstraintsByTable.get(row.table_name);\n      if (!constraints) {\n        constraints = new Set();\n        pkConstraintsByTable.set(row.table_name, constraints);\n      }\n      constraints.add(row.constraint_name);\n    }\n\n    const tables: Record<string, SqlTableIR> = {};\n\n    for (const tableRow of tablesResult.rows) {\n      const tableName = tableRow.table_name;\n\n      // Process columns for this table\n      const columns: Record<string, SqlColumnIR> = {};\n      for (const colRow of columnsByTable.get(tableName) ?? []) {\n        let nativeType = colRow.udt_name;\n        const formattedType = colRow.formatted_type\n          ? normalizeFormattedType(colRow.formatted_type, colRow.data_type, colRow.udt_name)\n          : null;\n        if (formattedType) {\n          nativeType = formattedType;\n        } else if (colRow.data_type === 'character varying' || colRow.data_type === 'character') {\n          if (colRow.character_maximum_length) {\n            nativeType = `${colRow.data_type}(${colRow.character_maximum_length})`;\n          } else {\n            nativeType = colRow.data_type;\n          }\n        } else if (colRow.data_type === 'numeric' || colRow.data_type === 'decimal') {\n          if (colRow.numeric_precision && colRow.numeric_scale !== null) {\n            nativeType = `${colRow.data_type}(${colRow.numeric_precision},${colRow.numeric_scale})`;\n          } else if (colRow.numeric_precision) {\n            nativeType = `${colRow.data_type}(${colRow.numeric_precision})`;\n          } else {\n            nativeType = colRow.data_type;\n          }\n        } else {\n          nativeType = colRow.udt_name || colRow.data_type;\n        }\n\n        columns[colRow.column_name] = {\n          name: colRow.column_name,\n          nativeType,\n          nullable: colRow.is_nullable === 'YES',\n          ...ifDefined('default', colRow.column_default ?? undefined),\n        };\n      }\n\n      // Process primary key\n      const pkRows = [...(pksByTable.get(tableName) ?? [])];\n      const primaryKeyColumns = pkRows\n        .sort((a, b) => a.ordinal_position - b.ordinal_position)\n        .map((row) => row.column_name);\n      const primaryKey: PrimaryKey | undefined =\n        primaryKeyColumns.length > 0\n          ? {\n              columns: primaryKeyColumns,\n              ...(pkRows[0]?.constraint_name ? { name: pkRows[0].constraint_name } : {}),\n            }\n          : undefined;\n\n      // Process foreign keys\n      const foreignKeysMap = new Map<\n        string,\n        {\n          columns: string[];\n          referencedTable: string;\n          referencedColumns: string[];\n          name: string;\n          deleteRule: string;\n          updateRule: string;\n        }\n      >();\n      for (const fkRow of fksByTable.get(tableName) ?? []) {\n        const existing = foreignKeysMap.get(fkRow.constraint_name);\n        if (existing) {\n          existing.columns.push(fkRow.column_name);\n          existing.referencedColumns.push(fkRow.referenced_column_name);\n        } else {\n          foreignKeysMap.set(fkRow.constraint_name, {\n            columns: [fkRow.column_name],\n            referencedTable: fkRow.referenced_table_name,\n            referencedColumns: [fkRow.referenced_column_name],\n            name: fkRow.constraint_name,\n            deleteRule: fkRow.delete_rule,\n            updateRule: fkRow.update_rule,\n          });\n        }\n      }\n      const foreignKeys: readonly SqlForeignKeyIR[] = Array.from(foreignKeysMap.values()).map(\n        (fk) => ({\n          columns: Object.freeze([...fk.columns]) as readonly string[],\n          referencedTable: fk.referencedTable,\n          referencedColumns: Object.freeze([...fk.referencedColumns]) as readonly string[],\n          name: fk.name,\n          ...ifDefined('onDelete', mapReferentialAction(fk.deleteRule)),\n          ...ifDefined('onUpdate', mapReferentialAction(fk.updateRule)),\n        }),\n      );\n\n      // Process unique constraints (excluding those that are also PKs)\n      const pkConstraints = pkConstraintsByTable.get(tableName) ?? new Set();\n      const uniquesMap = new Map<string, { columns: string[]; name: string }>();\n      for (const uniqueRow of uniquesByTable.get(tableName) ?? []) {\n        // Skip if this constraint is also a primary key\n        if (pkConstraints.has(uniqueRow.constraint_name)) {\n          continue;\n        }\n        const existing = uniquesMap.get(uniqueRow.constraint_name);\n        if (existing) {\n          existing.columns.push(uniqueRow.column_name);\n        } else {\n          uniquesMap.set(uniqueRow.constraint_name, {\n            columns: [uniqueRow.column_name],\n            name: uniqueRow.constraint_name,\n          });\n        }\n      }\n      const uniques: readonly SqlUniqueIR[] = Array.from(uniquesMap.values()).map((uq) => ({\n        columns: Object.freeze([...uq.columns]) as readonly string[],\n        name: uq.name,\n      }));\n\n      // Process indexes\n      const indexesMap = new Map<string, { columns: string[]; name: string; unique: boolean }>();\n      for (const idxRow of indexesByTable.get(tableName) ?? []) {\n        if (!idxRow.attname) {\n          continue;\n        }\n        const existing = indexesMap.get(idxRow.indexname);\n        if (existing) {\n          existing.columns.push(idxRow.attname);\n        } else {\n          indexesMap.set(idxRow.indexname, {\n            columns: [idxRow.attname],\n            name: idxRow.indexname,\n            unique: idxRow.indisunique,\n          });\n        }\n      }\n      const indexes: readonly SqlIndexIR[] = Array.from(indexesMap.values()).map((idx) => ({\n        columns: Object.freeze([...idx.columns]) as readonly string[],\n        name: idx.name,\n        unique: idx.unique,\n      }));\n\n      tables[tableName] = {\n        name: tableName,\n        columns,\n        ...ifDefined('primaryKey', primaryKey),\n        foreignKeys,\n        uniques,\n        indexes,\n      };\n    }\n\n    const dependencies: readonly DependencyIR[] = extensionsResult.rows.map((row) => ({\n      id: `postgres.extension.${row.extname}`,\n    }));\n\n    const storageTypes =\n      (await pgEnumControlHooks.introspectTypes?.({ driver, schemaName: schema })) ?? {};\n\n    const annotations = {\n      pg: {\n        schema,\n        version: await this.getPostgresVersion(driver),\n        ...ifDefined(\n          'storageTypes',\n          Object.keys(storageTypes).length > 0 ? storageTypes : undefined,\n        ),\n      },\n    };\n\n    return {\n      tables,\n      dependencies,\n      annotations,\n    };\n  }\n\n  /**\n   * Gets the Postgres version from the database.\n   */\n  private async getPostgresVersion(\n    driver: ControlDriverInstance<'sql', 'postgres'>,\n  ): Promise<string> {\n    const result = await driver.query<{ version: string }>('SELECT version() AS version', []);\n    const versionString = result.rows[0]?.version ?? '';\n    // Extract version number from \"PostgreSQL 15.1 ...\" format\n    const match = versionString.match(/PostgreSQL (\\d+\\.\\d+)/);\n    return match?.[1] ?? 'unknown';\n  }\n}\n\n/**\n * Pre-computed lookup map for simple prefix-based type normalization.\n * Maps short Postgres type names to their canonical SQL names.\n * Using a Map for O(1) lookup instead of multiple startsWith checks.\n */\nconst TYPE_PREFIX_MAP: ReadonlyMap<string, string> = new Map([\n  ['varchar', 'character varying'],\n  ['bpchar', 'character'],\n  ['varbit', 'bit varying'],\n]);\n\n/**\n * Normalizes a Postgres schema native type to its canonical form for comparison.\n *\n * Uses a pre-computed lookup map for simple prefix replacements (O(1))\n * and handles complex temporal type normalization separately.\n */\nexport function normalizeSchemaNativeType(nativeType: string): string {\n  const trimmed = nativeType.trim();\n\n  // Fast path: check simple prefix replacements using the lookup map\n  for (const [prefix, replacement] of TYPE_PREFIX_MAP) {\n    if (trimmed.startsWith(prefix)) {\n      return replacement + trimmed.slice(prefix.length);\n    }\n  }\n\n  // Temporal types with time zone handling\n  // Check for 'with time zone' suffix first (more specific)\n  if (trimmed.includes(' with time zone')) {\n    if (trimmed.startsWith('timestamp')) {\n      return `timestamptz${trimmed.slice(9).replace(' with time zone', '')}`;\n    }\n    if (trimmed.startsWith('time')) {\n      return `timetz${trimmed.slice(4).replace(' with time zone', '')}`;\n    }\n  }\n\n  // Handle 'without time zone' suffix - just strip it\n  if (trimmed.includes(' without time zone')) {\n    return trimmed.replace(' without time zone', '');\n  }\n\n  return trimmed;\n}\n\nfunction normalizeFormattedType(formattedType: string, dataType: string, udtName: string): string {\n  if (formattedType === 'integer') {\n    return 'int4';\n  }\n  if (formattedType === 'smallint') {\n    return 'int2';\n  }\n  if (formattedType === 'bigint') {\n    return 'int8';\n  }\n  if (formattedType === 'real') {\n    return 'float4';\n  }\n  if (formattedType === 'double precision') {\n    return 'float8';\n  }\n  if (formattedType === 'boolean') {\n    return 'bool';\n  }\n  if (formattedType.startsWith('varchar')) {\n    return formattedType.replace('varchar', 'character varying');\n  }\n  if (formattedType.startsWith('bpchar')) {\n    return formattedType.replace('bpchar', 'character');\n  }\n  if (formattedType.startsWith('varbit')) {\n    return formattedType.replace('varbit', 'bit varying');\n  }\n  if (dataType === 'timestamp with time zone' || udtName === 'timestamptz') {\n    return formattedType.replace('timestamp', 'timestamptz').replace(' with time zone', '').trim();\n  }\n  if (dataType === 'timestamp without time zone' || udtName === 'timestamp') {\n    return formattedType.replace(' without time zone', '').trim();\n  }\n  if (dataType === 'time with time zone' || udtName === 'timetz') {\n    return formattedType.replace('time', 'timetz').replace(' with time zone', '').trim();\n  }\n  if (dataType === 'time without time zone' || udtName === 'time') {\n    return formattedType.replace(' without time zone', '').trim();\n  }\n  // Only dataType === 'USER-DEFINED' should ever be quoted, but this should be safe without\n  // checking that explicitly either way\n  if (formattedType.startsWith('\"') && formattedType.endsWith('\"')) {\n    return formattedType.slice(1, -1);\n  }\n  return formattedType;\n}\n\n/**\n * The five standard PostgreSQL referential action rules as returned by\n * `information_schema.referential_constraints.delete_rule` / `update_rule`.\n */\ntype PgReferentialActionRule = 'NO ACTION' | 'RESTRICT' | 'CASCADE' | 'SET NULL' | 'SET DEFAULT';\n\nconst PG_REFERENTIAL_ACTION_MAP: Record<PgReferentialActionRule, SqlReferentialAction> = {\n  'NO ACTION': 'noAction',\n  RESTRICT: 'restrict',\n  CASCADE: 'cascade',\n  'SET NULL': 'setNull',\n  'SET DEFAULT': 'setDefault',\n};\n\n/**\n * Maps a Postgres referential action rule to the canonical SqlReferentialAction.\n * Returns undefined for 'NO ACTION' (the database default) to keep the IR sparse.\n * Throws for unrecognized rules to prevent silent data loss.\n */\nfunction mapReferentialAction(rule: string): SqlReferentialAction | undefined {\n  const mapped = PG_REFERENTIAL_ACTION_MAP[rule as PgReferentialActionRule];\n  if (mapped === undefined) {\n    throw new Error(\n      `Unknown PostgreSQL referential action rule: \"${rule}\". Expected one of: NO ACTION, RESTRICT, CASCADE, SET NULL, SET DEFAULT.`,\n    );\n  }\n  if (mapped === 'noAction') return undefined;\n  return mapped;\n}\n\n/**\n * Groups an array of objects by a specified key.\n * Returns a Map for O(1) lookup by group key.\n */\nfunction groupBy<T, K extends keyof T>(items: readonly T[], key: K): Map<T[K], T[]> {\n  const map = new Map<T[K], T[]>();\n  for (const item of items) {\n    const groupKey = item[key];\n    let group = map.get(groupKey);\n    if (!group) {\n      group = [];\n      map.set(groupKey, group);\n    }\n    group.push(item);\n  }\n  return map;\n}\n","import type { ExecutionMutationDefaultValue } from '@prisma-next/contract/types';\nimport type {\n  ControlMutationDefaultFunctionEntry,\n  ControlMutationDefaultGeneratorDescriptor,\n  PslScalarTypeDescriptor,\n} from '@prisma-next/family-sql/control';\nimport {\n  builtinGeneratorRegistryMetadata,\n  resolveBuiltinGeneratedColumnDescriptor,\n} from '@prisma-next/ids';\nimport type {\n  DefaultFunctionLoweringContext,\n  DefaultFunctionLoweringHandler,\n} from '@prisma-next/sql-contract-psl';\n\ntype LoweredDefaultResult = ReturnType<DefaultFunctionLoweringHandler>;\ntype ParsedDefaultFunctionCall = Parameters<DefaultFunctionLoweringHandler>[0]['call'];\n\nfunction invalidArgumentDiagnostic(input: {\n  readonly context: DefaultFunctionLoweringContext;\n  readonly span: ParsedDefaultFunctionCall['span'];\n  readonly message: string;\n}): LoweredDefaultResult {\n  return {\n    ok: false,\n    diagnostic: {\n      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',\n      message: input.message,\n      sourceId: input.context.sourceId,\n      span: input.span,\n    },\n  };\n}\n\nfunction executionGenerator(\n  id: ExecutionMutationDefaultValue['id'],\n  params?: Record<string, unknown>,\n): LoweredDefaultResult {\n  return {\n    ok: true,\n    value: {\n      kind: 'execution',\n      generated: {\n        kind: 'generator',\n        id,\n        ...(params ? { params } : {}),\n      },\n    },\n  };\n}\n\nfunction expectNoArgs(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n  readonly usage: string;\n}): LoweredDefaultResult | undefined {\n  if (input.call.args.length === 0) {\n    return undefined;\n  }\n  return invalidArgumentDiagnostic({\n    context: input.context,\n    span: input.call.span,\n    message: `Default function \"${input.call.name}\" does not accept arguments. Use ${input.usage}.`,\n  });\n}\n\nfunction parseIntegerArgument(raw: string): number | undefined {\n  const trimmed = raw.trim();\n  if (!/^-?\\d+$/.test(trimmed)) {\n    return undefined;\n  }\n  const value = Number(trimmed);\n  if (!Number.isInteger(value)) {\n    return undefined;\n  }\n  return value;\n}\n\nfunction parseStringLiteral(raw: string): string | undefined {\n  const match = raw.trim().match(/^(['\"])(.*)\\1$/s);\n  if (!match) {\n    return undefined;\n  }\n  return match[2] ?? '';\n}\n\nfunction lowerAutoincrement(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  const maybeNoArgs = expectNoArgs({\n    call: input.call,\n    context: input.context,\n    usage: '`autoincrement()`',\n  });\n  if (maybeNoArgs) {\n    return maybeNoArgs;\n  }\n  return {\n    ok: true,\n    value: {\n      kind: 'storage',\n      defaultValue: {\n        kind: 'function',\n        expression: 'autoincrement()',\n      },\n    },\n  };\n}\n\nfunction lowerNow(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  const maybeNoArgs = expectNoArgs({\n    call: input.call,\n    context: input.context,\n    usage: '`now()`',\n  });\n  if (maybeNoArgs) {\n    return maybeNoArgs;\n  }\n  return {\n    ok: true,\n    value: {\n      kind: 'storage',\n      defaultValue: {\n        kind: 'function',\n        expression: 'now()',\n      },\n    },\n  };\n}\n\nfunction lowerUuid(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  if (input.call.args.length === 0) {\n    return executionGenerator('uuidv4');\n  }\n  if (input.call.args.length !== 1) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.span,\n      message:\n        'Default function \"uuid\" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`.',\n    });\n  }\n  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');\n  if (version === 4) {\n    return executionGenerator('uuidv4');\n  }\n  if (version === 7) {\n    return executionGenerator('uuidv7');\n  }\n  return invalidArgumentDiagnostic({\n    context: input.context,\n    span: input.call.args[0]?.span ?? input.call.span,\n    message:\n      'Default function \"uuid\" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1.',\n  });\n}\n\nfunction lowerCuid(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  if (input.call.args.length === 0) {\n    return {\n      ok: false,\n      diagnostic: {\n        code: 'PSL_UNKNOWN_DEFAULT_FUNCTION',\n        message:\n          'Default function \"cuid()\" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.',\n        sourceId: input.context.sourceId,\n        span: input.call.span,\n      },\n    };\n  }\n  if (input.call.args.length !== 1) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.span,\n      message: 'Default function \"cuid\" accepts exactly one version argument: `cuid(2)`.',\n    });\n  }\n  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');\n  if (version === 2) {\n    return executionGenerator('cuid2');\n  }\n  return invalidArgumentDiagnostic({\n    context: input.context,\n    span: input.call.args[0]?.span ?? input.call.span,\n    message: 'Default function \"cuid\" supports only `cuid(2)` in SQL PSL provider v1.',\n  });\n}\n\nfunction lowerUlid(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  const maybeNoArgs = expectNoArgs({\n    call: input.call,\n    context: input.context,\n    usage: '`ulid()`',\n  });\n  if (maybeNoArgs) {\n    return maybeNoArgs;\n  }\n  return executionGenerator('ulid');\n}\n\nfunction lowerNanoid(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  if (input.call.args.length === 0) {\n    return executionGenerator('nanoid');\n  }\n  if (input.call.args.length !== 1) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.span,\n      message:\n        'Default function \"nanoid\" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`.',\n    });\n  }\n  const size = parseIntegerArgument(input.call.args[0]?.raw ?? '');\n  if (size !== undefined && size >= 2 && size <= 255) {\n    return executionGenerator('nanoid', { size });\n  }\n  return invalidArgumentDiagnostic({\n    context: input.context,\n    span: input.call.args[0]?.span ?? input.call.span,\n    message: 'Default function \"nanoid\" size argument must be an integer between 2 and 255.',\n  });\n}\n\nfunction lowerDbgenerated(input: {\n  readonly call: ParsedDefaultFunctionCall;\n  readonly context: DefaultFunctionLoweringContext;\n}): LoweredDefaultResult {\n  if (input.call.args.length !== 1) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.span,\n      message:\n        'Default function \"dbgenerated\" requires exactly one string argument: `dbgenerated(\"...\")`.',\n    });\n  }\n  const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? '');\n  if (rawExpression === undefined) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.args[0]?.span ?? input.call.span,\n      message: 'Default function \"dbgenerated\" argument must be a string literal.',\n    });\n  }\n  if (rawExpression.trim().length === 0) {\n    return invalidArgumentDiagnostic({\n      context: input.context,\n      span: input.call.args[0]?.span ?? input.call.span,\n      message: 'Default function \"dbgenerated\" argument cannot be empty.',\n    });\n  }\n  return {\n    ok: true,\n    value: {\n      kind: 'storage',\n      defaultValue: {\n        kind: 'function',\n        expression: rawExpression,\n      },\n    },\n  };\n}\n\nconst postgresDefaultFunctionRegistryEntries = [\n  ['autoincrement', { lower: lowerAutoincrement, usageSignatures: ['autoincrement()'] }],\n  ['now', { lower: lowerNow, usageSignatures: ['now()'] }],\n  ['uuid', { lower: lowerUuid, usageSignatures: ['uuid()', 'uuid(4)', 'uuid(7)'] }],\n  ['cuid', { lower: lowerCuid, usageSignatures: ['cuid(2)'] }],\n  ['ulid', { lower: lowerUlid, usageSignatures: ['ulid()'] }],\n  ['nanoid', { lower: lowerNanoid, usageSignatures: ['nanoid()', 'nanoid(<2-255>)'] }],\n  ['dbgenerated', { lower: lowerDbgenerated, usageSignatures: ['dbgenerated(\"...\")'] }],\n] satisfies ReadonlyArray<readonly [string, ControlMutationDefaultFunctionEntry]>;\n\nconst postgresPslScalarTypeDescriptors = new Map<string, PslScalarTypeDescriptor>([\n  ['String', { codecId: 'pg/text@1', nativeType: 'text' }],\n  ['Boolean', { codecId: 'pg/bool@1', nativeType: 'bool' }],\n  ['Int', { codecId: 'pg/int4@1', nativeType: 'int4' }],\n  ['BigInt', { codecId: 'pg/int8@1', nativeType: 'int8' }],\n  ['Float', { codecId: 'pg/float8@1', nativeType: 'float8' }],\n  ['Decimal', { codecId: 'pg/numeric@1', nativeType: 'numeric' }],\n  ['DateTime', { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' }],\n  ['Json', { codecId: 'pg/jsonb@1', nativeType: 'jsonb' }],\n  ['Bytes', { codecId: 'pg/bytea@1', nativeType: 'bytea' }],\n]);\n\nexport function createPostgresDefaultFunctionRegistry(): ReadonlyMap<\n  string,\n  ControlMutationDefaultFunctionEntry\n> {\n  return new Map(postgresDefaultFunctionRegistryEntries);\n}\n\nexport function createPostgresMutationDefaultGeneratorDescriptors(): readonly ControlMutationDefaultGeneratorDescriptor[] {\n  return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({\n    id,\n    applicableCodecIds,\n    resolveGeneratedColumnDescriptor: ({ generated }) => {\n      if (generated.kind !== 'generator' || generated.id !== id) {\n        return undefined;\n      }\n      const descriptor = resolveBuiltinGeneratedColumnDescriptor({\n        id,\n        ...(generated.params ? { params: generated.params } : {}),\n      });\n      return {\n        codecId: descriptor.type.codecId,\n        nativeType: descriptor.type.nativeType,\n        ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),\n        ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),\n      };\n    },\n  }));\n}\n\nexport function createPostgresPslScalarTypeDescriptors(): ReadonlyMap<\n  string,\n  PslScalarTypeDescriptor\n> {\n  return new Map(postgresPslScalarTypeDescriptors);\n}\n","import type { SqlControlAdapterDescriptor } from '@prisma-next/family-sql/control';\nimport type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';\nimport { PostgresControlAdapter } from '../core/control-adapter';\nimport {\n  createPostgresDefaultFunctionRegistry,\n  createPostgresMutationDefaultGeneratorDescriptors,\n  createPostgresPslScalarTypeDescriptors,\n} from '../core/control-mutation-defaults';\nimport { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';\nimport { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError } from '../core/sql-utils';\n\nconst postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {\n  ...postgresAdapterDescriptorMeta,\n  operationSignatures: () => [],\n  pslTypeDescriptors: () => ({\n    scalarTypeDescriptors: createPostgresPslScalarTypeDescriptors(),\n  }),\n  controlMutationDefaults: () => ({\n    defaultFunctionRegistry: createPostgresDefaultFunctionRegistry(),\n    generatorDescriptors: createPostgresMutationDefaultGeneratorDescriptors(),\n  }),\n  create(): SqlControlAdapter<'postgres'> {\n    return new PostgresControlAdapter();\n  },\n};\n\nexport default postgresAdapterDescriptor;\n\nexport { normalizeSchemaNativeType } from '../core/control-adapter';\nexport { parsePostgresDefault } from '../core/default-normalizer';\nexport { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError };\n"],"mappings":"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"}