pg-migration-engine 0.1.0

package/src/introspection/queries/pg18-19.js

@@ -0,0 +1,43 @@
+/**
+ * PG18+ specific introspection queries.
+ * Only called when detected PG version >= 18.
+ */
+
+const PG18_NOT_ENFORCED_QUERY = `
+SELECT n.nspname AS schema,
+       c.conname AS name,
+       c.conrelid::regclass::text AS table_ref,
+       NOT c.conenforced AS not_enforced
+FROM pg_catalog.pg_constraint c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.connamespace
+WHERE c.conenforced = false
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+const PG18_VIRTUAL_COLUMNS_QUERY = `
+SELECT a.attrelid::regclass::text AS table_ref,
+       n.nspname AS schema,
+       c.relname AS table_name,
+       a.attname AS name,
+       a.attgenerated AS generated_type
+FROM pg_catalog.pg_attribute a
+JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE a.attgenerated = 'v'
+  AND NOT a.attisdropped
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<{notEnforced:Array,virtualColumns:Array}>}
+ */
+export async function queryPg18Features(pool) {
+  const [notEnforced, virtualColumns] = await Promise.all([
+    pool.query(PG18_NOT_ENFORCED_QUERY).then(r => r.rows),
+    pool.query(PG18_VIRTUAL_COLUMNS_QUERY).then(r => r.rows),
+  ]);
+  return { notEnforced, virtualColumns };
+}

package/src/introspection/queries/policies.js

@@ -0,0 +1,35 @@
+const POLICIES_QUERY = `
+SELECT pol.polname AS name,
+       n.nspname AS schema,
+       c.relname AS table_name,
+       CASE pol.polcmd
+         WHEN '*' THEN 'ALL'
+         WHEN 'r' THEN 'SELECT'
+         WHEN 'a' THEN 'INSERT'
+         WHEN 'w' THEN 'UPDATE'
+         WHEN 'd' THEN 'DELETE'
+       END AS command,
+       pol.polpermissive AS is_permissive,
+       CASE
+         WHEN pol.polroles = '{0}' THEN ARRAY['PUBLIC']
+         ELSE ARRAY(SELECT rolname FROM pg_catalog.pg_roles WHERE oid = ANY(pol.polroles))
+       END AS roles,
+       pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS using_expression,
+       pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS with_check_expression,
+       pg_catalog.obj_description(pol.oid, 'pg_policy') AS comment
+FROM pg_catalog.pg_policy pol
+JOIN pg_catalog.pg_class c ON c.oid = pol.polrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, pol.polname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryPolicies(pool) {
+  const result = await pool.query(POLICIES_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/procedural-languages.js

@@ -0,0 +1,36 @@
+const LANGUAGES_QUERY = `
+SELECT
+  l.oid,
+  l.lanname AS name,
+  pg_catalog.pg_get_userbyid(l.lanowner) AS owner,
+  l.lanispl AS is_pl,
+  l.lanpltrusted AS is_trusted,
+  CASE WHEN l.lanplcallfoid = 0 THEN NULL ELSE l.lanplcallfoid::regproc::text END AS handler,
+  CASE WHEN l.laninline = 0 THEN NULL ELSE l.laninline::regproc::text END AS inline,
+  CASE WHEN l.lanvalidator = 0 THEN NULL ELSE l.lanvalidator::regproc::text END AS validator
+FROM pg_catalog.pg_language l
+WHERE l.lanispl OR l.lanname NOT IN ('internal', 'sql', 'c')
+ORDER BY l.lanname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryProceduralLanguages(pool) {
+  try {
+    const result = await pool.query(LANGUAGES_QUERY);
+    
+    return result.rows.map(row => ({
+      name: row.name,
+      owner: row.owner,
+      is_pl: row.is_pl,
+      is_trusted: row.is_trusted,
+      handler: row.handler,
+      inline: row.inline,
+      validator: row.validator,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/publications.js

@@ -0,0 +1,114 @@
+const PUBLICATIONS_QUERY = `
+SELECT
+  p.oid,
+  p.pubname AS name,
+  pg_catalog.pg_get_userbyid(p.pubowner) AS owner,
+  p.puballtables AS all_tables,
+  p.pubinsert AS insert,
+  p.pubupdate AS update,
+  p.pubdelete AS delete,
+  p.pubtruncate AS truncate,
+  p.pubviaroot AS via_root,
+  pg_catalog.obj_description(p.oid, 'pg_publication') AS comment
+FROM pg_catalog.pg_publication p
+ORDER BY p.pubname
+`;
+
+const PUBLICATION_TABLES_QUERY = `
+SELECT
+  p.pubname AS publication,
+  n.nspname AS table_schema,
+  c.relname AS table_name,
+  pg_catalog.pg_get_expr(pr.prqual, c.oid) AS row_filter,
+  pr.prattrs AS column_attnums
+FROM pg_catalog.pg_publication_rel pr
+JOIN pg_catalog.pg_publication p ON p.oid = pr.prpubid
+JOIN pg_catalog.pg_class c ON c.oid = pr.prrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind IN ('r', 'p')
+ORDER BY p.pubname, n.nspname, c.relname
+`;
+
+const PUBLICATION_SCHEMAS_QUERY = `
+SELECT
+  p.pubname AS publication,
+  n.nspname AS schema_name
+FROM pg_catalog.pg_publication_namespace pn
+JOIN pg_catalog.pg_publication p ON p.oid = pn.pnpubid
+JOIN pg_catalog.pg_namespace n ON n.oid = pn.pnnspid
+ORDER BY p.pubname, n.nspname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryPublications(pool, version) {
+  if (version < 100000) return [];
+
+  try {
+    const pubsResult = await pool.query(PUBLICATIONS_QUERY);
+    const tablesResult = await pool.query(PUBLICATION_TABLES_QUERY);
+    
+    let schemasResult = { rows: [] };
+    if (version >= 150000) {
+      try {
+        schemasResult = await pool.query(PUBLICATION_SCHEMAS_QUERY);
+      } catch (e) {
+        // pg_publication_namespace doesn't exist before PG15
+      }
+    }
+
+    const publicationMap = new Map();
+    
+    for (const row of pubsResult.rows) {
+      publicationMap.set(row.name, {
+        name: row.name,
+        owner: row.owner,
+        all_tables: row.all_tables,
+        insert: row.insert,
+        update: row.update,
+        delete: row.delete,
+        truncate: row.truncate,
+        via_root: row.via_root,
+        comment: row.comment,
+        tables: [],
+        schemas: [],
+      });
+    }
+
+    for (const row of tablesResult.rows) {
+      const pub = publicationMap.get(row.publication);
+      if (pub) {
+        const tableEntry = {
+          table: `${row.table_schema}.${row.table_name}`,
+        };
+        if (row.row_filter) {
+          tableEntry.rowFilter = row.row_filter;
+        }
+        if (row.column_attnums) {
+          // Parse column attnums to get column names from the table
+          try {
+            const attnums = row.column_attnums;
+            if (attnums && attnums.length > 0) {
+              tableEntry.columns = attnums;
+            }
+          } catch (e) {}
+        }
+        pub.tables.push(tableEntry);
+      }
+    }
+
+    for (const row of schemasResult.rows) {
+      const pub = publicationMap.get(row.publication);
+      if (pub) {
+        pub.schemas.push(row.schema_name);
+      }
+    }
+
+    return Array.from(publicationMap.values());
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/roles.js

@@ -0,0 +1,66 @@
+const ROLES_QUERY = `
+SELECT
+  r.oid,
+  r.rolname AS name,
+  r.rolsuper AS is_superuser,
+  r.rolinherit AS inherit,
+  r.rolcreaterole AS can_create_role,
+  r.rolcreatedb AS can_create_db,
+  r.rolcanlogin AS can_login,
+  r.rolreplication AS is_replication,
+  r.rolconnlimit AS conn_limit,
+  r.rolvaliduntil AS valid_until,
+  pg_catalog.shobj_description(r.oid, 'pg_authid') AS comment
+FROM pg_catalog.pg_roles r
+WHERE r.rolname NOT LIKE 'pg_%'
+ORDER BY r.rolname
+`;
+
+const ROLE_MEMBERSHIPS_QUERY = `
+SELECT
+  m.roleid::regrole::text AS role,
+  m.member::regrole::text AS member,
+  m.admin_option AS admin_option
+FROM pg_catalog.pg_auth_members m
+ORDER BY m.roleid, m.member
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryRoles(pool) {
+  try {
+    const [rolesResult, membershipsResult] = await Promise.all([
+      pool.query(ROLES_QUERY),
+      pool.query(ROLE_MEMBERSHIPS_QUERY),
+    ]);
+
+    const membershipMap = new Map();
+    for (const m of membershipsResult.rows) {
+      if (!membershipMap.has(m.role)) {
+        membershipMap.set(m.role, []);
+      }
+      membershipMap.get(m.role).push({
+        member: m.member,
+        admin_option: m.admin_option,
+      });
+    }
+
+    return rolesResult.rows.map(row => ({
+      name: row.name,
+      is_superuser: row.is_superuser,
+      inherit: row.inherit,
+      can_create_role: row.can_create_role,
+      can_create_db: row.can_create_db,
+      can_login: row.can_login,
+      is_replication: row.is_replication,
+      conn_limit: row.conn_limit,
+      valid_until: row.valid_until,
+      comment: row.comment || undefined,
+      memberships: membershipMap.get(row.name) || [],
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/rules.js

@@ -0,0 +1,49 @@
+const RULES_QUERY = `
+SELECT
+  r.oid,
+  n.nspname AS schema,
+  c.relname AS table,
+  r.rulename AS name,
+  pg_catalog.pg_get_ruledef(r.oid) AS definition,
+  CASE r.ev_type
+    WHEN '1' THEN 'SELECT'
+    WHEN '2' THEN 'UPDATE'
+    WHEN '3' THEN 'INSERT'
+    WHEN '4' THEN 'DELETE'
+  END AS event,
+  r.is_instead AS is_instead,
+  r.ev_enabled AS is_enabled,
+  pg_catalog.pg_get_expr(r.ev_qual, r.ev_class) AS qual,
+  pg_catalog.obj_description(r.oid, 'pg_rewrite') AS comment
+FROM pg_catalog.pg_rewrite r
+JOIN pg_catalog.pg_class c ON c.oid = r.ev_class
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE r.rulename != '_RETURN'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, r.rulename
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryRules(pool) {
+  try {
+    const result = await pool.query(RULES_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema,
+      table: row.table,
+      name: row.name,
+      definition: row.definition,
+      event: row.event,
+      is_instead: row.is_instead,
+      is_enabled: row.is_enabled === 'O' || row.is_enabled === 'A',
+      qual: row.qual,
+      comment: row.comment,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/sequences.js

@@ -0,0 +1,37 @@
+const SEQUENCES_QUERY = `
+SELECT s.relname AS name,
+       n.nspname AS schema,
+       s.relowner::regrole::text AS owner,
+       seq.seqtypid::regtype::text AS data_type,
+       seq.seqstart AS start_value,
+       seq.seqincrement AS increment,
+       seq.seqmin AS min_value,
+       seq.seqmax AS max_value,
+       seq.seqcache AS cache,
+       seq.seqcycle AS cycle,
+       CASE
+         WHEN d.refobjid IS NOT NULL THEN
+           d.refobjid::regclass::text || '.' || a.attname
+         ELSE NULL
+       END AS owned_by,
+       CASE WHEN s.reltablespace != 0 THEN (SELECT spcname FROM pg_catalog.pg_tablespace WHERE oid = s.reltablespace) ELSE NULL END AS tablespace,
+       pg_catalog.obj_description(s.oid, 'pg_class') AS comment,
+       pg_catalog.pg_sequence_last_value(seq.seqrelid) AS current_value
+FROM pg_catalog.pg_sequence seq
+JOIN pg_catalog.pg_class s ON s.oid = seq.seqrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = s.relnamespace
+LEFT JOIN pg_catalog.pg_depend d ON d.objid = s.oid AND d.deptype = 'a' AND d.classid = 'pg_class'::regclass
+LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = d.refobjid AND a.attnum = d.refobjsubid
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, s.relname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function querySequences(pool) {
+  const result = await pool.query(SEQUENCES_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/statistics.js

@@ -0,0 +1,74 @@
+const STATISTICS_QUERY = `
+SELECT
+  s.oid,
+  n.nspname AS schema,
+  s.stxname AS name,
+  pg_catalog.pg_get_userbyid(s.stxowner) AS owner,
+  s.stxkind AS kinds,
+  s.stxkeys AS columns_raw,
+  c.relname AS table_name,
+  n2.nspname AS table_schema,
+  pg_catalog.pg_get_statisticsobjdef(s.oid) AS definition,
+  s.stxstattarget AS statistics_target,
+  pg_catalog.obj_description(s.oid, 'pg_statistic_ext') AS comment,
+  pg_catalog.pg_relation_size(s.oid) AS size
+FROM pg_catalog.pg_statistic_ext s
+JOIN pg_catalog.pg_namespace n ON n.oid = s.stxnamespace
+JOIN pg_catalog.pg_class c ON c.oid = s.stxrelid
+JOIN pg_catalog.pg_namespace n2 ON n2.oid = c.relnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, s.stxname
+`;
+
+const KIND_MAP = {
+  'd': 'ndistinct',
+  'f': 'dependencies',
+  'm': 'mcv',
+};
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryStatistics(pool, version) {
+  if (version < 100000) return [];
+
+  try {
+    const result = await pool.query(STATISTICS_QUERY);
+    
+    return result.rows.map(row => {
+      let kinds = [];
+      if (row.kinds && typeof row.kinds === 'string') {
+        kinds = row.kinds.split('').map(k => KIND_MAP[k] || k);
+      } else if (Array.isArray(row.kinds)) {
+        kinds = row.kinds.map(k => KIND_MAP[k] || k);
+      }
+
+      let columns = [];
+      if (row.columns_raw) {
+        if (typeof row.columns_raw === 'string') {
+          columns = row.columns_raw.split(' ').filter(Boolean);
+        } else if (Array.isArray(row.columns_raw)) {
+          columns = row.columns_raw.map(String);
+        }
+      }
+
+      return {
+        schema: row.schema,
+        name: row.name,
+        owner: row.owner,
+        kinds,
+        columns,
+        table_name: row.table_name,
+        table_schema: row.table_schema,
+        definition: row.definition,
+        statisticsTarget: row.statistics_target ?? undefined,
+        comment: row.comment || undefined,
+        size: row.size ?? undefined,
+      };
+    });
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/subscriptions.js

@@ -0,0 +1,99 @@
+const SUBSCRIPTIONS_QUERY = `
+SELECT
+  s.oid,
+  s.subname AS name,
+  pg_catalog.pg_get_userbyid(s.subowner) AS owner,
+  s.subconninfo AS conninfo,
+  s.subslotname AS slot_name,
+  s.subsynccommit AS sync_commit,
+  s.subenabled AS enabled,
+  s.subpublications AS publications,
+  s.subbinary AS binary_transfer,
+  s.substream AS streaming,
+  s.subtwophasestate AS two_phase_state,
+  CASE WHEN s.subdisableonerr THEN true ELSE false END AS disable_on_error,
+  s.suborigin AS origin,
+  pg_catalog.obj_description(s.oid, 'pg_subscription') AS comment
+FROM pg_catalog.pg_subscription s
+ORDER BY s.subname
+`;
+
+const SUBSCRIPTION_TABLES_QUERY = `
+SELECT
+  s.subname AS subscription,
+  n.nspname AS table_schema,
+  c.relname AS table_name,
+  sr.srsubstate AS state
+FROM pg_catalog.pg_subscription_rel sr
+JOIN pg_catalog.pg_subscription s ON s.oid = sr.srsubid
+JOIN pg_catalog.pg_class c ON c.oid = sr.srrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+ORDER BY s.subname, n.nspname, c.relname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function querySubscriptions(pool, version) {
+  if (version < 100000) return [];
+
+  try {
+    const subsResult = await pool.query(SUBSCRIPTIONS_QUERY);
+    let tablesResult = { rows: [] };
+    
+    try {
+      tablesResult = await pool.query(SUBSCRIPTION_TABLES_QUERY);
+    } catch (e) {
+      // Table may not exist if no subscription tables
+    }
+
+    const subMap = new Map();
+    
+    for (const row of subsResult.rows) {
+      let publications = [];
+      if (row.publications && typeof row.publications === 'string') {
+        try {
+          const parsed = JSON.parse(row.publications);
+          publications = Array.isArray(parsed) ? parsed : [parsed];
+        } catch {
+          publications = row.publications.split(',').map(s => s.trim()).filter(Boolean);
+        }
+      } else if (Array.isArray(row.publications)) {
+        publications = row.publications;
+      }
+
+      subMap.set(row.name, {
+        name: row.name,
+        owner: row.owner,
+        conninfo: row.conninfo,
+        slot_name: row.slot_name,
+        sync_commit: row.sync_commit,
+        enabled: row.enabled,
+        publications,
+        binary_transfer: row.binary_transfer || false,
+        streaming: row.streaming || false,
+        two_phase: row.two_phase_state && row.two_phase_state !== 'd',
+        disable_on_error: row.disable_on_error || false,
+        origin: row.origin || 'any',
+        comment: row.comment,
+        tables: [],
+      });
+    }
+
+    for (const row of tablesResult.rows) {
+      const sub = subMap.get(row.subscription);
+      if (sub) {
+        sub.tables.push({
+          table: `${row.table_schema}.${row.table_name}`,
+          state: row.state,
+        });
+      }
+    }
+
+    return Array.from(subMap.values());
+  } catch (error) {
+    return [];
+  }
+}