@metaobjectsdev/migrate-ts 0.10.0 → 0.11.0-rc.1

package/src/introspect/postgres.ts

@@ -151,25 +151,36 @@ export function pgTypeToSqlType(dataType: string, maxLength?: number | null): Sq
  * Returns undefined if the default is absent or empty.
  *
  * Classification rules:
- *   - Expressions: now(), CURRENT_TIMESTAMP, CURRENT_DATE, CURRENT_TIME,
- *     nextval(...), and any value that starts with a non-quote character and
- *     contains a `::` cast (i.e. bare identifier with cast, like `NULL::text`).
+ *   - Expressions: now(), CURRENT_TIMESTAMP, CURRENT_DATE, CURRENT_TIME, and any
+ *     bare function-call (e.g. nextval(...), gen_random_uuid(), uuid_generate_v4()),
+ *     plus any value that starts with a non-quote character and contains a `::` cast
+ *     (i.e. bare identifier with cast, like `NULL::text`).
  *   - Literals: `'value'` (optionally followed by `::type` cast, which PG
  *     commonly appends for clarity). The cast is stripped; the value is unquoted.
  *
  * PG stores literal booleans as `'true'::boolean`, integers as `'42'::integer`,
  * strings as `'hello'::text` — all are literals after stripping the cast.
+ *
+ * The bare function-call rule keeps this in lockstep with the metadata-side
+ * default classifier (expected-schema's EXPR_DEFAULT_PATTERNS, which treats any
+ * `()` default as an expression): without it, a `gen_random_uuid()` column default
+ * round-trips as a literal here but an expression there, producing a spurious
+ * column diff on every uuid-PK table.
  */
 export function parsePgDefault(raw: string | null | undefined): ColumnDefault | undefined {
   if (raw === undefined || raw === null || raw === "") return undefined;
 
-  // Function-call or keyword expressions
+  // Function-call or keyword expressions. The leading-identifier-then-"(" rule
+  // matches any bare function call (gen_random_uuid(), uuid_generate_v4(), …)
+  // while never matching a quoted literal (those start with a single quote and are
+  // handled below).
   if (
     /^now\(\)$/i.test(raw) ||
     /^current_timestamp\b/i.test(raw) ||
     /^current_date\b/i.test(raw) ||
     /^current_time\b/i.test(raw) ||
-    /^nextval\(/i.test(raw)
+    /^nextval\(/i.test(raw) ||
+    /^[a-zA-Z_][\w.]*\s*\(/.test(raw)
   ) {
     return { kind: "expr", value: raw };
   }
@@ -317,46 +328,132 @@ async function readPgIndexes(k: RawKysely, schema: string, table: string): Promi
   // pg-mem gap: array_position() is not implemented, so this query throws on
   // pg-mem. We catch and return [] so non-index tests still pass against pg-mem.
   // Real PG (Postgres 16) handles this correctly.
-  let rows: { rows: Array<{ index_name: string; is_unique: boolean; is_primary: boolean; column_name: string; ordinal: number }> };
+  // One row per index KEY, in key order, carrying: the column name (NULL for an
+  // expression key — attnum 0), the DESC bit from `indoption`, and the partial-index
+  // predicate (`indpred`, constant per index). unnest WITH ORDINALITY over indkey +
+  // indoption keeps the key order and pairs each key with its option flags.
+  let rows: {
+    rows: Array<{
+      index_name: string;
+      is_unique: boolean;
+      is_primary: boolean;
+      column_name: string | null;
+      ordinal: number;
+      is_desc: boolean;
+      predicate: string | null;
+      access_method: string;
+      indexdef: string;
+    }>;
+  };
   try {
     rows = await sql<{
       index_name: string;
       is_unique: boolean;
       is_primary: boolean;
-      column_name: string;
+      column_name: string | null;
       ordinal: number;
+      is_desc: boolean;
+      predicate: string | null;
+      access_method: string;
+      indexdef: string;
     }>`
       SELECT i.relname AS index_name,
              ix.indisunique AS is_unique,
              ix.indisprimary AS is_primary,
              a.attname AS column_name,
-             array_position(ix.indkey, a.attnum) AS ordinal
+             k.ord AS ordinal,
+             (COALESCE(opt.option, 0) & 1) = 1 AS is_desc,
+             pg_get_expr(ix.indpred, ix.indrelid) AS predicate,
+             am.amname AS access_method,
+             pg_get_indexdef(ix.indexrelid) AS indexdef
       FROM pg_index ix
       JOIN pg_class i ON i.oid = ix.indexrelid
       JOIN pg_class t ON t.oid = ix.indrelid
       JOIN pg_namespace n ON n.oid = t.relnamespace
-      JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey)
+      JOIN pg_am am ON am.oid = i.relam
+      CROSS JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord)
+      LEFT JOIN LATERAL unnest(ix.indoption) WITH ORDINALITY AS opt(option, oord)
+        ON opt.oord = k.ord
+      LEFT JOIN pg_attribute a ON a.attrelid = ix.indrelid AND a.attnum = k.attnum
       WHERE n.nspname = ${schema}
         AND t.relname = ${table}
-      ORDER BY i.relname, ordinal
+      ORDER BY i.relname, k.ord
     `.execute(k);
   } catch {
-    // pg-mem: array_position() not implemented — return empty index list.
+    // pg-mem: unnest WITH ORDINALITY / pg_get_expr unsupported — return empty list.
     return [];
   }
 
-  const byName = new Map<string, { isUnique: boolean; isPrimary: boolean; cols: string[] }>();
+  const byName = new Map<
+    string,
+    {
+      isUnique: boolean;
+      isPrimary: boolean;
+      cols: string[];
+      orders: ("asc" | "desc")[];
+      predicate: string | null;
+      hasExpressionKey: boolean;
+      accessMethod: string;
+      indexdef: string;
+    }
+  >();
   for (const r of rows.rows) {
     let entry = byName.get(r.index_name);
     if (!entry) {
-      entry = { isUnique: r.is_unique, isPrimary: r.is_primary, cols: [] };
+      entry = {
+        isUnique: r.is_unique,
+        isPrimary: r.is_primary,
+        cols: [],
+        orders: [],
+        predicate: r.predicate,
+        hasExpressionKey: false,
+        accessMethod: r.access_method,
+        indexdef: r.indexdef,
+      };
       byName.set(r.index_name, entry);
     }
-    entry.cols.push(r.column_name);
+    if (r.column_name === null) {
+      // Expression key (attnum 0) — captured from the index def below.
+      entry.hasExpressionKey = true;
+    } else {
+      entry.cols.push(r.column_name);
+      entry.orders.push(r.is_desc ? "desc" : "asc");
+    }
   }
   return Array.from(byName.entries())
-    .filter(([, v]) => !v.isPrimary)        // PK index excluded — PK lives in TableDescriptor.primaryKey
-    .map(([name, v]) => ({ name, columns: v.cols, unique: v.isUnique }));
+    .filter(([, v]) => !v.isPrimary) // PK index excluded — PK lives in TableDescriptor.primaryKey
+    .map(([name, v]) => {
+      const using = v.accessMethod !== "btree" ? v.accessMethod : undefined;
+      if (v.hasExpressionKey) {
+        // Functional/expression index: lift the raw key expression out of the
+        // index def (between `USING <am> (` and its matching `)`, before WHERE).
+        const ix: IndexDescriptor = { name, columns: [], unique: v.isUnique, expr: indexDefKeyExpr(v.indexdef) };
+        if (using) ix.using = using;
+        if (v.predicate !== null) ix.where = v.predicate;
+        return ix;
+      }
+      const ix: IndexDescriptor = { name, columns: v.cols, unique: v.isUnique };
+      if (using) ix.using = using;
+      if (v.orders.some((o) => o === "desc")) ix.orders = v.orders;
+      if (v.predicate !== null) ix.where = v.predicate;
+      return ix;
+    });
+}
+
+/** Extract the raw key-expression text from a pg index def — the balanced `(...)`
+ *  after `USING <method> `, stripped of a trailing partial-index `WHERE`. */
+function indexDefKeyExpr(indexdef: string): string {
+  const open = indexdef.indexOf("(", indexdef.indexOf(" USING "));
+  if (open === -1) return indexdef;
+  let depth = 0;
+  for (let i = open; i < indexdef.length; i++) {
+    if (indexdef[i] === "(") depth++;
+    else if (indexdef[i] === ")") {
+      depth--;
+      if (depth === 0) return indexdef.slice(open + 1, i).trim();
+    }
+  }
+  return indexdef.slice(open + 1).trim();
 }
 
 async function readPgForeignKeys(k: RawKysely, schema: string, table: string): Promise<FkDescriptor[]> {

package/src/types.ts

@@ -66,6 +66,31 @@ export interface IndexDescriptor {
   name: string;
   columns: string[];
   unique: boolean;
+  /**
+   * Per-column sort direction, positional to `columns`. Omitted (or "asc") = the
+   * default ascending order, which Postgres does not render in an index def. A
+   * "desc" entry emits `<col> DESC` and is compared against the introspected
+   * `pg_index.indoption` DESC bit. Absent ⇒ all-ascending.
+   */
+  orders?: ("asc" | "desc")[];
+  /**
+   * Partial-index predicate (raw SQL, e.g. `delivered_at IS NULL`). Emitted as a
+   * trailing `WHERE (<predicate>)`; compared against the introspected
+   * `pg_get_expr(indpred, …)` after expression normalization. Absent ⇒ full index.
+   */
+  where?: string;
+  /**
+   * Raw key EXPRESSION for a functional/expression index (e.g. `lower((email)::text)`).
+   * When present, the index key is this expression and `columns` is empty —
+   * emitted as `(<expr>)` and compared against the introspected `pg_get_indexdef`
+   * key after normalization.
+   */
+  expr?: string;
+  /**
+   * Index access method (`gin`, `gist`, `hash`, …). Absent / `btree` is the
+   * default and not rendered. Emitted as `USING <method>` before the key list.
+   */
+  using?: string;
 }
 
 export interface CheckDescriptor {