pg-migration-engine 0.1.0

package/src/introspection/introspector.js

@@ -0,0 +1,250 @@
+import { detectPgVersion, majorVersion } from './version-detector.js';
+import { translateSnapshot } from './translator.js';
+import * as queries from './queries/index.js';
+
+const SYSTEM_SCHEMAS = ['pg_catalog', 'information_schema', 'pg_toast'];
+
+export class SchemaIntrospector {
+  /** @param {import('pg').Pool} pool */
+  constructor(pool) {
+    this.pool = pool;
+    this.logger = console;
+  }
+
+  /**
+   * @param {Object} [options]
+   * @param {string[]} [options.schemas] - Specific schemas to introspect (default: all user schemas)
+   * @returns {Promise<import('../types/schema.js').SchemaSnapshot>}
+   */
+  async introspect(options = {}) {
+    const version = await detectPgVersion(this.pool);
+    const pgMajor = majorVersion(version);
+    const versionStr = await this.detectVersionString();
+
+    // Resolve target schemas
+    const targetSchemas = options.schemas || await this.resolveUserSchemas();
+
+    // Database-level objects (queried once, not per-schema)
+    const [
+      roles,
+      tablespaces,
+      accessMethods,
+      databases,
+      casts,
+      proceduralLanguages,
+      defaultPrivileges,
+      foreignDataWrappers,
+      foreignServers,
+      userMappings,
+      eventTriggers,
+      publications,
+      subscriptions,
+    ] = await Promise.all([
+      queries.queryRoles(this.pool).catch(() => []),
+      queries.queryInterfaceTablespaces(this.pool).catch(() => []),
+      queries.queryInterfaceAccessMethods(this.pool).catch(() => []),
+      queries.queryInterfaceDatabases(this.pool).catch(() => []),
+      queries.queryCasts(this.pool).catch(() => []),
+      queries.queryProceduralLanguages(this.pool).catch(() => []),
+      queries.queryDefaultPrivileges(this.pool).catch(() => []),
+      queries.queryForeignDataWrappers(this.pool).catch(() => []),
+      queries.queryForeignServers(this.pool).catch(() => []),
+      queries.queryUserMappings(this.pool).catch(() => []),
+      queries.queryEventTriggers(this.pool, version).catch(() => []),
+      queries.queryPublications(this.pool, version).catch(() => []),
+      queries.querySubscriptions(this.pool, version).catch(() => []),
+    ]);
+
+    // Per-schema queries (parallelized)
+    const [
+      schemasResult,
+      tables,
+      columns,
+      constraints,
+      indexes,
+      indexColumns,
+      functions,
+      triggers,
+      typesResult,
+      viewsResult,
+      sequences,
+      partitions,
+      policies,
+      extensions,
+      inheritance,
+      comments,
+      grants,
+      statistics,
+      collations,
+      conversions,
+      operators,
+      operatorClasses,
+      operatorFamilies,
+      textSearchConfigs,
+      textSearchDictionaries,
+      textSearchParsers,
+      textSearchTemplates,
+      foreignTables,
+      multiranges,
+      rules,
+      aggregates,
+      procedures,
+      toastOptions,
+    ] = await Promise.all([
+      queries.querySchemas(this.pool).then(r => r.filter(s => targetSchemas.includes(s.name))).catch(() => []),
+      queries.queryTables(this.pool, version).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+      queries.queryColumns(this.pool, version).then(r => r.filter(c => targetSchemas.includes(c.schema))).catch(() => []),
+      queries.queryConstraints(this.pool).then(r => r.filter(c => targetSchemas.includes(c.schema))).catch(() => []),
+      queries.queryIndexes(this.pool).then(r => r.filter(i => targetSchemas.includes(i.schema))).catch(() => []),
+      queries.queryIndexColumns(this.pool).then(r => r.filter(i => targetSchemas.includes(i.schema))).catch(() => []),
+      queries.queryFunctions(this.pool).then(r => r.filter(f => targetSchemas.includes(f.schema))).catch(() => []),
+      queries.queryTriggers(this.pool).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+      queries.queryTypes(this.pool).then(r => ({
+        enums: (r.enums || []).filter(e => targetSchemas.includes(e.schema)),
+        composites: (r.composites || []).filter(c => targetSchemas.includes(c.schema)),
+        domains: (r.domains || []).filter(d => targetSchemas.includes(d.schema)),
+        ranges: (r.ranges || []).filter(r => targetSchemas.includes(r.schema)),
+      })).catch(() => ({ enums: [], composites: [], domains: [], ranges: [] })),
+      queries.queryViews(this.pool).then(r => r).catch(() => ({ views: [], materializedViews: [] })),
+      queries.querySequences(this.pool).then(r => r.filter(s => targetSchemas.includes(s.schema))).catch(() => []),
+      queries.queryPartitions(this.pool).then(r => r.filter(p => targetSchemas.includes(p.child_schema))).catch(() => []),
+      queries.queryPolicies(this.pool).then(r => r.filter(p => targetSchemas.includes(p.schema))).catch(() => []),
+      queries.queryExtensions(this.pool).catch(() => []),
+      queries.queryInheritance(this.pool).then(r => r.filter(i => targetSchemas.includes(i.child_schema))).catch(() => []),
+      queries.queryComments(this.pool).catch(() => ({})),
+      queries.queryGrants(this.pool).then(r => r.filter(g => targetSchemas.includes(g.schema))).catch(() => []),
+      queries.queryStatistics(this.pool, version).then(r => r.filter(s => targetSchemas.includes(s.schema))).catch(() => []),
+      queries.queryCollations(this.pool).then(r => r.filter(c => targetSchemas.includes(c.schema))).catch(() => []),
+      queries.queryConversions(this.pool).then(r => r.filter(c => targetSchemas.includes(c.schema))).catch(() => []),
+      queries.queryOperators(this.pool).then(r => r.filter(o => targetSchemas.includes(o.schema))).catch(() => []),
+      queries.queryOperatorClasses(this.pool).then(r => r.filter(o => targetSchemas.includes(o.schema))).catch(() => []),
+      queries.queryOperatorFamilies(this.pool).then(r => r.filter(o => targetSchemas.includes(o.schema))).catch(() => []),
+      queries.queryTextSearchConfigs(this.pool).then(r => ({
+        configs: (r.configs || []).filter(t => targetSchemas.includes(t.schema)),
+        tokenMappings: (r.tokenMappings || []).filter(t => targetSchemas.includes(t.schema)),
+      })).catch(() => ({ configs: [], tokenMappings: [] })),
+      queries.queryTextSearchDictionaries(this.pool).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+      queries.queryTextSearchParsers(this.pool).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+      queries.queryTextSearchTemplates(this.pool).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+      queries.queryForeignTables(this.pool).then(r => ({
+        tables: (r.tables || []).filter(f => targetSchemas.includes(f.schema)),
+        columnOptions: (r.columnOptions || []).filter(c => targetSchemas.includes(c.schema)),
+      })).catch(() => ({ tables: [], columnOptions: [] })),
+      queries.queryMultiranges(this.pool, version).then(r => r.filter(m => targetSchemas.includes(m.schema))).catch(() => []),
+      queries.queryRules(this.pool).then(r => r.filter(r => targetSchemas.includes(r.schema))).catch(() => []),
+      queries.queryFunctions(this.pool).then(r => r.filter(f => targetSchemas.includes(f.schema) && f.kind === 'AGGREGATE')).catch(() => []),
+      queries.queryFunctions(this.pool).then(r => r.filter(f => targetSchemas.includes(f.schema) && f.kind === 'PROCEDURE')).catch(() => []),
+      queries.queryToastOptions(this.pool).then(r => r.filter(t => targetSchemas.includes(t.schema))).catch(() => []),
+    ]);
+
+    // PG18+ features
+    let pg18Features = { notEnforced: [], virtualColumns: [] };
+    if (pgMajor >= 18) {
+      pg18Features = await queries.queryPg18Features(this.pool).catch(() => ({ notEnforced: [], virtualColumns: [] }));
+    }
+
+    // Current database info
+    let databaseInfo = null;
+    try {
+      const dbResult = await this.pool.query(`
+        SELECT 
+          current_database() AS name,
+          pg_catalog.pg_get_userbyid(datdba) AS owner,
+          pg_catalog.pg_encoding_to_char(encoding) AS encoding,
+          datcollate AS collate,
+          datctype AS ctype
+        FROM pg_catalog.pg_database 
+        WHERE datname = current_database()
+      `);
+      databaseInfo = dbResult.rows[0] || null;
+    } catch {
+      databaseInfo = null;
+    }
+
+    // Translate raw results to SchemaSnapshot
+    const snapshot = translateSnapshot({
+      version: { numeric: version, major: pgMajor, string: versionStr },
+      database: databaseInfo,
+      schemas: schemasResult,
+      tables,
+      columns,
+      constraints,
+      indexes,
+      indexColumns,
+      functions,
+      triggers,
+      types: {
+        ...typesResult,
+        multiranges,
+      },
+      views: viewsResult.views || [],
+      materializedViews: viewsResult.materializedViews || [],
+      sequences,
+      partitions,
+      policies,
+      extensions,
+      inheritance,
+      comments,
+      grants,
+      pg18Features,
+      // New object types
+      publications,
+      subscriptions,
+      statistics,
+      collations,
+      conversions,
+      operators,
+      operatorClasses,
+      operatorFamilies,
+      textSearchConfigs,
+      textSearchDictionaries,
+      textSearchParsers,
+      textSearchTemplates,
+      foreignDataWrappers,
+      foreignServers,
+      userMappings,
+      foreignTables,
+      casts,
+      eventTriggers,
+      rules,
+      roles,
+      tablespaces,
+      accessMethods,
+      proceduralLanguages,
+      defaultPrivileges,
+      databases,
+      aggregates,
+      procedures,
+      toastOptions,
+    });
+
+    return snapshot;
+  }
+
+  /**
+   * Resolve user schemas (excluding system schemas).
+   * @returns {Promise<string[]>}
+   */
+  async resolveUserSchemas() {
+    const result = await this.pool.query(`
+      SELECT n.nspname AS name
+      FROM pg_catalog.pg_namespace n
+      WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+        AND n.nspname NOT LIKE 'pg_temp_%'
+        AND n.nspname NOT LIKE 'pg_toast_temp_%'
+      ORDER BY n.nspname
+    `);
+    return result.rows.map(r => r.name);
+  }
+
+  /** @returns {Promise<number>} */
+  async detectVersion() {
+    return detectPgVersion(this.pool);
+  }
+
+  /** @returns {Promise<string>} */
+  async detectVersionString() {
+    const result = await this.pool.query("SELECT current_setting('server_version') AS version");
+    return result.rows[0].version;
+  }
+}

package/src/introspection/queries/access-methods.js

@@ -0,0 +1,29 @@
+const ACCESS_METHODS_QUERY = `
+SELECT
+  a.oid,
+  a.amname AS name,
+  a.amtype AS type,
+  a.amhandler::regproc::text AS handler
+FROM pg_catalog.pg_am a
+WHERE a.amname NOT IN ('heap', 'btree', 'hash', 'gist', 'gin', 'spgist', 'brin')
+  OR a.amtype = 't'
+ORDER BY a.amname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryInterfaceAccessMethods(pool) {
+  try {
+    const result = await pool.query(ACCESS_METHODS_QUERY);
+    
+    return result.rows.map(row => ({
+      name: row.name,
+      type: row.type === 't' ? 'TABLE' : 'INDEX',
+      handler: row.handler || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/casts.js

@@ -0,0 +1,38 @@
+const CASTS_QUERY = `
+SELECT
+  c.oid,
+  format_type(c.castsource, NULL) AS source_type,
+  format_type(c.casttarget, NULL) AS target_type,
+  CASE WHEN c.castfunc = 0 THEN NULL ELSE c.castfunc::regproc::text END AS function,
+  CASE c.castcontext
+    WHEN 'e' THEN 'EXPLICIT'
+    WHEN 'a' THEN 'ASSIGNMENT'
+    WHEN 'i' THEN 'IMPLICIT'
+  END AS context,
+  CASE c.castmethod
+    WHEN 'f' THEN 'FUNCTION'
+    WHEN 'i' THEN 'INOUT'
+    WHEN 'b' THEN 'BINARY'
+  END AS method,
+  pg_catalog.obj_description(c.oid, 'pg_cast') AS comment
+FROM pg_catalog.pg_cast c
+WHERE c.castsource NOT IN (
+  SELECT oid FROM pg_type WHERE typnamespace = 'pg_catalog'::regnamespace
+) AND c.casttarget NOT IN (
+  SELECT oid FROM pg_type WHERE typnamespace = 'pg_catalog'::regnamespace
+)
+ORDER BY source_type, target_type
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryCasts(pool) {
+  try {
+    const result = await pool.query(CASTS_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/collations.js

@@ -0,0 +1,51 @@
+const COLLATIONS_QUERY = `
+SELECT
+  c.oid,
+  n.nspname AS schema,
+  c.collname AS name,
+  pg_catalog.pg_get_userbyid(c.collowner) AS owner,
+  CASE c.collprovider
+    WHEN 'd' THEN 'icu'
+    WHEN 'c' THEN 'libc'
+    WHEN 'i' THEN 'icu'
+  END AS provider,
+  c.collcollate AS lc_collate,
+  c.collctype AS lc_ctype,
+  c.collcollate AS locale,
+  c.collencoding AS encoding,
+  COALESCE(c.collisdeterministic, true) AS is_deterministic,
+  c.collversion AS version,
+  pg_catalog.obj_description(c.oid, 'pg_collation') AS comment
+FROM pg_catalog.pg_collation c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.collnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND c.collname NOT LIKE 'pg_%'
+ORDER BY n.nspname, c.collname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryCollations(pool, version) {
+  try {
+    const result = await pool.query(COLLATIONS_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema,
+      name: row.name,
+      owner: row.owner,
+      provider: row.provider,
+      locale: row.locale,
+      lcCollate: row.lc_collate || undefined,
+      lcCtype: row.lc_ctype || undefined,
+      encoding: row.encoding,
+      isDeterministic: row.is_deterministic,
+      version: row.version || undefined,
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/comments.js

@@ -0,0 +1,66 @@
+const TABLE_COMMENTS_QUERY = `
+SELECT n.nspname || '.' || c.relname AS object_key,
+       pg_catalog.obj_description(c.oid, 'pg_class') AS comment
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+WHERE c.relkind IN ('r', 'p', 'v', 'm', 'f')
+  AND pg_catalog.obj_description(c.oid, 'pg_class') IS NOT NULL
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+const COLUMN_COMMENTS_QUERY = `
+SELECT n.nspname || '.' || c.relname || '.' || a.attname AS object_key,
+       pg_catalog.col_description(a.attrelid, a.attnum) AS comment
+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.attnum > 0
+  AND NOT a.attisdropped
+  AND c.relkind IN ('r', 'p', 'v', 'm')
+  AND pg_catalog.col_description(a.attrelid, a.attnum) IS NOT NULL
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+const TYPE_COMMENTS_QUERY = `
+SELECT n.nspname || '.' || t.typname AS object_key,
+       pg_catalog.obj_description(t.oid, 'pg_type') AS comment
+FROM pg_catalog.pg_type t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+WHERE t.typtype IN ('e', 'c', 'd', 'r')
+  AND pg_catalog.obj_description(t.oid, 'pg_type') IS NOT NULL
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+const FUNCTION_COMMENTS_QUERY = `
+SELECT n.nspname || '.' || p.proname || '(' || pg_catalog.pg_get_function_identity_arguments(p.oid) || ')' AS object_key,
+       pg_catalog.obj_description(p.oid, 'pg_proc') AS comment
+FROM pg_catalog.pg_proc p
+JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+WHERE pg_catalog.obj_description(p.oid, 'pg_proc') IS NOT NULL
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Record<string,string>>}
+ */
+export async function queryComments(pool) {
+  const [tables, columns, types, functions] = await Promise.all([
+    pool.query(TABLE_COMMENTS_QUERY).then(r => r.rows),
+    pool.query(COLUMN_COMMENTS_QUERY).then(r => r.rows),
+    pool.query(TYPE_COMMENTS_QUERY).then(r => r.rows),
+    pool.query(FUNCTION_COMMENTS_QUERY).then(r => r.rows),
+  ]);
+
+  const comments = {};
+  for (const row of [...tables, ...columns, ...types, ...functions]) {
+    if (row.comment) {
+      comments[row.object_key] = row.comment;
+    }
+  }
+  return comments;
+}

package/src/introspection/queries/constraints.js

@@ -0,0 +1,65 @@
+const CONSTRAINTS_QUERY = `
+SELECT c.oid,
+       n.nspname AS schema,
+       c.conname AS name,
+       c.contype AS type,
+       c.conrelid::regclass::text AS table_ref,
+       CASE WHEN c.confrelid != 0 THEN c.confrelid::regclass::text ELSE NULL END AS foreign_table,
+       pg_catalog.pg_get_constraintdef(c.oid, true) AS definition,
+       c.convalidated AS is_validated,
+       c.condeferrable AS deferrable,
+       c.condeferred AS initially_deferred,
+       c.conkey AS column_indices,
+       c.confkey AS foreign_column_indices,
+       c.confupdtype AS on_update,
+       c.confdeltype AS on_delete,
+       c.confmatchtype AS match_type,
+       c.coninhcount > 0 AS is_inherited,
+       c.conislocal AS is_local,
+       c.connoinherit AS no_inherit,
+       pg_catalog.col_description(c.oid, 0) AS comment,
+       CASE WHEN c.contype = 'x' THEN pg_catalog.pg_get_expr(c.conbin, c.conrelid) ELSE NULL END AS exclusion_expression
+FROM pg_catalog.pg_constraint c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.connamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.conrelid::regclass::text, c.conname
+`;
+
+const FK_ACTION_MAP = {
+  'a': 'NO ACTION',
+  'r': 'RESTRICT',
+  'c': 'CASCADE',
+  'n': 'SET NULL',
+  'd': 'SET DEFAULT',
+};
+
+const FK_MATCH_MAP = {
+  'f': 'FULL',
+  'p': 'PARTIAL',
+  's': 'SIMPLE',
+};
+
+const CONTYPE_MAP = {
+  'p': 'PRIMARY_KEY',
+  'u': 'UNIQUE',
+  'f': 'FOREIGN_KEY',
+  'c': 'CHECK',
+  'x': 'EXCLUSION',
+  'n': 'NOT_NULL',
+};
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryConstraints(pool) {
+  const result = await pool.query(CONSTRAINTS_QUERY);
+  return result.rows.map(row => ({
+    ...row,
+    type: CONTYPE_MAP[row.type] || row.type,
+    on_update: FK_ACTION_MAP[row.on_update] || row.on_update,
+    on_delete: FK_ACTION_MAP[row.on_delete] || row.on_delete,
+    match_type: FK_MATCH_MAP[row.match_type] || row.match_type,
+  }));
+}

package/src/introspection/queries/conversions.js

@@ -0,0 +1,39 @@
+const CONVERSIONS_QUERY = `
+SELECT
+  c.oid,
+  n.nspname AS schema,
+  c.conname AS name,
+  pg_catalog.pg_get_userbyid(c.conowner) AS owner,
+  c.conproc::regproc::text AS proc,
+  c.condefault AS is_default,
+  pg_catalog.pg_encoding_to_char(c.conforencoding) AS source_encoding,
+  pg_catalog.pg_encoding_to_char(c.contoencoding) AS target_encoding,
+  pg_catalog.obj_description(c.oid, 'pg_conversion') AS comment
+FROM pg_catalog.pg_conversion c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.connamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, c.conname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryConversions(pool) {
+  try {
+    const result = await pool.query(CONVERSIONS_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema,
+      name: row.name,
+      owner: row.owner,
+      proc: row.proc,
+      is_default: row.is_default,
+      source_encoding: row.source_encoding,
+      target_encoding: row.target_encoding,
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/databases.js

@@ -0,0 +1,43 @@
+const DATABASES_QUERY = `
+SELECT
+  d.oid,
+  d.datname AS name,
+  pg_catalog.pg_get_userbyid(d.datdba) AS owner,
+  pg_catalog.pg_encoding_to_char(d.encoding) AS encoding,
+  d.datcollate AS collate,
+  d.datctype AS ctype,
+  d.datistemplate AS is_template,
+  d.datallowconn AS allow_conn,
+  d.datconnlimit AS conn_limit,
+  t.spcname AS tablespace,
+  pg_catalog.shobj_description(d.oid, 'pg_database') AS comment
+FROM pg_catalog.pg_database d
+LEFT JOIN pg_catalog.pg_tablespace t ON t.oid = d.dattablespace
+WHERE d.datname NOT LIKE 'template%'
+ORDER BY d.datname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryInterfaceDatabases(pool) {
+  try {
+    const result = await pool.query(DATABASES_QUERY);
+    
+    return result.rows.map(row => ({
+      name: row.name,
+      owner: row.owner,
+      encoding: row.encoding,
+      collate: row.collate,
+      ctype: row.ctype,
+      is_template: row.is_template,
+      allow_conn: row.allow_conn,
+      conn_limit: row.conn_limit,
+      tablespace: row.tablespace,
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/default-privileges.js

@@ -0,0 +1,37 @@
+const DEFAULT_PRIVILEGES_QUERY = `
+SELECT
+  n.nspname AS schema,
+  pg_catalog.pg_get_userbyid(d.defaclrole) AS role,
+  CASE d.defaclobjtype
+    WHEN 'r' THEN 'TABLE'
+    WHEN 'S' THEN 'SEQUENCE'
+    WHEN 'f' THEN 'FUNCTION'
+    WHEN 'T' THEN 'TYPE'
+    WHEN 's' THEN 'SCHEMA'
+    WHEN 'n' THEN 'SCHEMA'
+  END AS object_type,
+  d.defaclacl AS acl
+FROM pg_catalog.pg_default_acl d
+LEFT JOIN pg_catalog.pg_namespace n ON n.oid = d.defaclnamespace
+WHERE n.nspname IS NULL OR n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, d.defaclobjtype, pg_catalog.pg_get_userbyid(d.defaclrole)
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryDefaultPrivileges(pool) {
+  try {
+    const result = await pool.query(DEFAULT_PRIVILEGES_QUERY);
+    
+    return result.rows.map(row => ({
+      schema: row.schema || null,
+      role: row.role,
+      object_type: row.object_type,
+      acl: row.acl || [],
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/event-triggers.js

@@ -0,0 +1,43 @@
+const EVENT_TRIGGERS_QUERY = `
+SELECT
+  e.oid,
+  e.evtname AS name,
+  pg_catalog.pg_get_userbyid(e.evtowner) AS owner,
+  e.evtevent AS event,
+  e.evtfoid::regproc::text AS function,
+  CASE e.evtenabled
+    WHEN 'O' THEN 'ENABLED'
+    WHEN 'D' THEN 'DISABLED'
+    WHEN 'R' THEN 'REPLICA'
+    WHEN 'A' THEN 'ALWAYS'
+  END AS enabled,
+  e.evttags AS tags,
+  pg_catalog.obj_description(e.oid, 'pg_event_trigger') AS comment
+FROM pg_catalog.pg_event_trigger e
+ORDER BY e.evtname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryEventTriggers(pool, version) {
+  if (version < 90300) return [];
+
+  try {
+    const result = await pool.query(EVENT_TRIGGERS_QUERY);
+    
+    return result.rows.map(row => ({
+      name: row.name,
+      owner: row.owner,
+      event: row.event,
+      function: row.function,
+      enabled: row.enabled,
+      tags: row.tags || [],
+      comment: row.comment || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/extensions.js

@@ -0,0 +1,21 @@
+const EXTENSIONS_QUERY = `
+SELECT e.extname AS name,
+       n.nspname AS schema,
+       e.extversion AS version,
+       pg_catalog.pg_get_userbyid(e.extowner) AS owner,
+       e.extrelocatable AS is_relocatable,
+       pg_catalog.obj_description(e.oid, 'pg_extension') AS comment,
+       true AS is_available
+FROM pg_catalog.pg_extension e
+JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace
+ORDER BY e.extname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryExtensions(pool) {
+  const result = await pool.query(EXTENSIONS_QUERY);
+  return result.rows;
+}