pg-migration-engine 0.1.0

package/src/introspection/queries/tables.js

@@ -0,0 +1,151 @@
+const SCHEMAS_QUERY = `
+SELECT n.nspname AS name,
+       n.nspowner::regrole::text AS owner,
+       n.nspacl AS privileges,
+       pg_catalog.obj_description(n.oid, 'pg_namespace') AS comment
+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
+`;
+
+const TABLES_QUERY = `
+SELECT c.oid,
+       n.nspname AS schema,
+       c.relname AS name,
+       c.relkind AS kind,
+       c.relowner::regrole::text AS owner,
+       c.relpersistence AS persistence,
+       c.relrowsecurity AS rls_enabled,
+       c.relforcerowsecurity AS rls_forced,
+       c.reloptions AS storage_options,
+       CASE WHEN c.reltablespace != 0 THEN c.reltablespace::regrole::text ELSE NULL END AS tablespace,
+       CASE WHEN c.relkind = 'p' THEN pt.partstrat ELSE NULL END AS partition_strategy,
+       pg_catalog.pg_get_expr(c.relpartbound, c.oid) AS partition_bound,
+       c.relreplident AS replica_identity,
+       (SELECT idx.relname FROM pg_catalog.pg_index i JOIN pg_catalog.pg_class idx ON idx.oid = i.indexrelid WHERE i.indrelid = c.oid AND i.indisreplident = true LIMIT 1) AS replica_identity_index,
+       pg_catalog.pg_get_partkeydef(c.oid) AS partition_key_def,
+       /* HAS_OIDS_PLACEHOLDER */,
+       EXISTS (SELECT 1 FROM pg_catalog.pg_class tc JOIN pg_catalog.pg_namespace tn ON tn.oid = tc.relnamespace JOIN pg_catalog.pg_depend d ON d.objid = tc.oid WHERE tc.relkind = 't' AND tn.nspname = 'pg_toast' AND d.refobjid = c.oid AND d.classid = 'pg_class'::regclass) AS has_toast_table,
+       EXISTS (SELECT 1 FROM pg_catalog.pg_depend d WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.refclassid = 'pg_class'::regclass AND d.deptype = 'e') AS user_catalog_table,
+       am.amname AS access_method
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+LEFT JOIN pg_catalog.pg_partitioned_table pt ON pt.partrelid = c.oid
+LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam
+WHERE c.relkind IN ('r', 'p', 'f')
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname
+`;
+
+const TOAST_OPTIONS_QUERY = `
+SELECT 
+       n.nspname AS schema,
+       c.relname AS table_name,
+       tc.relname AS toast_table_name,
+       tc.reloptions AS toast_storage_options
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_depend d ON d.refobjid = c.oid AND d.classid = 'pg_class'::regclass
+JOIN pg_catalog.pg_class tc ON tc.oid = d.objid AND tc.relkind = 't'
+JOIN pg_catalog.pg_namespace tn ON tn.oid = tc.relnamespace AND tn.nspname = 'pg_toast'
+WHERE c.relkind IN ('r', 'p')
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname
+`;
+
+const COLUMNS_QUERY = `
+SELECT a.attrelid::regclass::text AS table_ref,
+       n.nspname AS schema,
+       c.relname AS table_name,
+       a.attname AS name,
+       a.attnum AS ordinal_position,
+       format_type(a.atttypid, a.atttypmod) AS data_type,
+       NOT a.attnotnull AS is_nullable,
+       a.attgenerated AS generated,
+       CASE WHEN a.attgenerated IN ('s', 'v') AND d.adbin IS NOT NULL
+            THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid) 
+            ELSE NULL END AS generated_expression,
+       CASE WHEN (a.attgenerated IS NULL OR a.attgenerated = '') AND d.adbin IS NOT NULL
+            THEN pg_catalog.pg_get_expr(d.adbin, d.adrelid) 
+            ELSE NULL END AS default_value,
+       a.attidentity AS identity,
+       CASE WHEN a.attcollation != 0 AND a.attcollation != 100
+            THEN a.attcollation::regcollation::text ELSE NULL END AS collation,
+       a.attstorage::text AS storage,
+       pg_catalog.col_description(a.attrelid, a.attnum) AS comment,
+       a.attstattarget AS statistics_target,
+       /* COMPRESSION_PLACEHOLDER */
+       s.seqstart AS identity_start,
+       s.seqincrement AS identity_increment,
+       s.seqmin AS identity_min,
+       s.seqmax AS identity_max,
+       s.seqcycle AS identity_cycle,
+        s.seqcache AS identity_cache,
+        a.attinhcount AS inherited_count,
+        a.attislocal AS is_local,
+        a.attacl AS privileges,
+        EXISTS (SELECT 1 FROM pg_catalog.pg_constraint con WHERE con.conrelid = a.attrelid AND con.contype = 'p' AND a.attnum = ANY(con.conkey)) AS is_primary_key,
+        EXISTS (SELECT 1 FROM pg_catalog.pg_index idx WHERE idx.indrelid = a.attrelid AND idx.indisunique AND a.attnum = ANY(idx.indkey) AND NOT idx.indisprimary) AS is_unique,
+        a.attlen AS length,
+        a.attndims AS array_dimensions
+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
+LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+LEFT JOIN pg_catalog.pg_sequence s ON s.seqrelid = (
+  SELECT seq.oid FROM pg_catalog.pg_class seq 
+  JOIN pg_catalog.pg_namespace seqn ON seqn.oid = seq.relnamespace
+  JOIN pg_catalog.pg_depend dep ON dep.objid = seq.oid AND dep.classid = 'pg_class'::regclass
+  WHERE seq.relkind = 'S' AND dep.refobjid = a.attrelid AND dep.refobjsubid = a.attnum
+    AND seqn.nspname NOT LIKE 'pg_temp_%'
+  LIMIT 1
+)
+WHERE a.attnum > 0
+  AND NOT a.attisdropped
+  AND c.relkind IN ('r', 'p', 'f')
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, a.attnum
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array<{name:string,owner:string}>>}
+ */
+export async function querySchemas(pool) {
+  const result = await pool.query(SCHEMAS_QUERY);
+  return result.rows;
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryTables(pool, version = 150000) {
+  const hasOidsCol = (version < 120000) ? 'c.relhasoids' : 'false';
+  const query = TABLES_QUERY.replace('/* HAS_OIDS_PLACEHOLDER */', `${hasOidsCol} AS has_oids`);
+  const result = await pool.query(query);
+  return result.rows;
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @param {number} version
+ * @returns {Promise<Array>}
+ */
+export async function queryColumns(pool, version = 150000) {
+  const hasCompression = (version >= 140000) ? "a.attcompression::text AS compression," : "NULL AS compression,";
+  const query = COLUMNS_QUERY.replace('/* COMPRESSION_PLACEHOLDER */', hasCompression);
+  const result = await pool.query(query);
+  return result.rows;
+}
+
+export async function queryToastOptions(pool) {
+  const result = await pool.query(TOAST_OPTIONS_QUERY);
+  return result.rows;
+}

package/src/introspection/queries/tablespaces.js

@@ -0,0 +1,36 @@
+const TABLESPACES_QUERY = `
+SELECT
+  t.oid,
+  t.spcname AS name,
+  pg_catalog.pg_get_userbyid(t.spcowner) AS owner,
+  t.spclocation AS location,
+  t.spcdefault AS is_default,
+  t.spcacl AS acl,
+  t.spcoptions AS options
+FROM pg_catalog.pg_tablespace t
+WHERE t.spcname NOT LIKE 'pg_%'
+ORDER BY t.spcname
+`;
+
+const DEFAULT_TABLESPACES = ['pg_default', 'pg_global'];
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryInterfaceTablespaces(pool) {
+  try {
+    const result = await pool.query(TABLESPACES_QUERY);
+    
+    return result.rows.map(row => ({
+      name: row.name,
+      owner: row.owner,
+      location: row.location || undefined,
+      is_default: row.is_default || DEFAULT_TABLESPACES.includes(row.name),
+      acl: row.acl || undefined,
+      options: row.options || undefined,
+    }));
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/text-search.js

@@ -0,0 +1,146 @@
+const TEXT_SEARCH_CONFIGS_QUERY = `
+SELECT
+  t.oid,
+  n.nspname AS schema,
+  t.cfgname AS name,
+  pg_catalog.pg_get_userbyid(t.cfgowner) AS owner,
+  format_type(t.cfgparser, NULL) AS parser,
+  n2.nspname AS parser_schema,
+  pg_catalog.obj_description(t.oid, 'pg_ts_config') AS comment
+FROM pg_catalog.pg_ts_config t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.cfgnamespace
+LEFT JOIN pg_catalog.pg_ts_parser p ON p.oid = t.cfgparser
+LEFT JOIN pg_catalog.pg_namespace n2 ON n2.oid = p.prsnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, t.cfgname
+`;
+
+const TEXT_SEARCH_CONFIG_MAP_QUERY = `
+SELECT
+  n.nspname AS schema,
+  t.cfgname AS config_name,
+  m.maptokentype AS token_type,
+  m.mapseqno AS seq,
+  d.dictname AS dictionary,
+  nd.nspname AS dict_schema,
+  m.mapdict AS dict_oid
+FROM pg_catalog.pg_ts_config_map m
+JOIN pg_catalog.pg_ts_config t ON t.oid = m.mapcfg
+JOIN pg_catalog.pg_namespace n ON n.oid = t.cfgnamespace
+JOIN pg_catalog.pg_ts_dict d ON d.oid = m.mapdict
+JOIN pg_catalog.pg_namespace nd ON nd.oid = d.dictnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, t.cfgname, m.mapseqno
+`;
+
+const TEXT_SEARCH_DICTIONARIES_QUERY = `
+SELECT
+  d.oid,
+  n.nspname AS schema,
+  d.dictname AS name,
+  pg_catalog.pg_get_userbyid(d.dictowner) AS owner,
+  format_type(d.dicttemplate, NULL) AS template,
+  n2.nspname AS template_schema,
+  d.dictinitoption AS options,
+  pg_catalog.obj_description(d.oid, 'pg_ts_dict') AS comment
+FROM pg_catalog.pg_ts_dict d
+JOIN pg_catalog.pg_namespace n ON n.oid = d.dictnamespace
+LEFT JOIN pg_catalog.pg_ts_template t ON t.oid = d.dicttemplate
+LEFT JOIN pg_catalog.pg_namespace n2 ON n2.oid = t.tmplnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, d.dictname
+`;
+
+const TEXT_SEARCH_PARSERS_QUERY = `
+SELECT
+  p.oid,
+  n.nspname AS schema,
+  p.prsname AS name,
+  pg_catalog.pg_get_userbyid(p.prsowner) AS owner,
+  p.prsstart::regproc::text AS start,
+  p.prstoken::regproc::text AS get_token,
+  p.prsend::regproc::text AS end,
+  p.prsheadline::regproc::text AS headline,
+  p.prslextype::regproc::text AS lextypes,
+  pg_catalog.obj_description(p.oid, 'pg_ts_parser') AS comment
+FROM pg_catalog.pg_ts_parser p
+JOIN pg_catalog.pg_namespace n ON n.oid = p.prsnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, p.prsname
+`;
+
+const TEXT_SEARCH_TEMPLATES_QUERY = `
+SELECT
+  t.oid,
+  n.nspname AS schema,
+  t.tmplname AS name,
+  pg_catalog.pg_get_userbyid(t.tmplowner) AS owner,
+  t.tmplinit::regproc::text AS init,
+  t.tmpllexize::regproc::text AS lexize,
+  pg_catalog.obj_description(t.oid, 'pg_ts_template') AS comment
+FROM pg_catalog.pg_ts_template t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.tmplnamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+ORDER BY n.nspname, t.tmplname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<{configs: Array, tokenMappings: Array}>}
+ */
+export async function queryTextSearchConfigs(pool) {
+  try {
+    const configsResult = await pool.query(TEXT_SEARCH_CONFIGS_QUERY);
+    let mappingsResult = { rows: [] };
+    try {
+      mappingsResult = await pool.query(TEXT_SEARCH_CONFIG_MAP_QUERY);
+    } catch (e) {
+      // May fail on older versions
+    }
+    return {
+      configs: configsResult.rows,
+      tokenMappings: mappingsResult.rows,
+    };
+  } catch (error) {
+    return { configs: [], tokenMappings: [] };
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryTextSearchDictionaries(pool) {
+  try {
+    const result = await pool.query(TEXT_SEARCH_DICTIONARIES_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryTextSearchParsers(pool) {
+  try {
+    const result = await pool.query(TEXT_SEARCH_PARSERS_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryTextSearchTemplates(pool) {
+  try {
+    const result = await pool.query(TEXT_SEARCH_TEMPLATES_QUERY);
+    return result.rows;
+  } catch (error) {
+    return [];
+  }
+}

package/src/introspection/queries/triggers.js

@@ -0,0 +1,61 @@
+const TRIGGERS_QUERY = `
+SELECT t.tgname AS name,
+       n.nspname AS schema,
+       c.relname AS table_name,
+       tn.nspname AS table_schema,
+       CASE
+         WHEN (t.tgtype::int & 2) != 0 THEN 'BEFORE'
+         WHEN (t.tgtype::int & 64) != 0 THEN 'INSTEAD OF'
+         ELSE 'AFTER'
+       END AS timing,
+       array_remove(ARRAY[
+         CASE WHEN (t.tgtype::int & 4) != 0 THEN 'INSERT' ELSE NULL END,
+         CASE WHEN (t.tgtype::int & 8) != 0 THEN 'DELETE' ELSE NULL END,
+         CASE WHEN (t.tgtype::int & 16) != 0 THEN 'UPDATE' ELSE NULL END,
+         CASE WHEN (t.tgtype::int & 32) != 0 THEN 'TRUNCATE' ELSE NULL END
+       ], NULL) AS events,
+       CASE WHEN (t.tgtype::int & 1) != 0 THEN 'ROW' ELSE 'STATEMENT' END AS level,
+       (t.tgtype::int & 1) != 0 AS is_for_each_row,
+        pg_catalog.pg_get_triggerdef(t.oid) AS definition,
+        CASE t.tgenabled
+          WHEN 'O' THEN 'ENABLED'
+          WHEN 'D' THEN 'DISABLED'
+          WHEN 'R' THEN 'REPLICA'
+          WHEN 'A' THEN 'ALWAYS'
+        END AS enabled,
+        p.proname AS function_name,
+        pn.nspname AS function_schema,
+        NULL AS when_condition,
+        t.tgconstraint IS NOT NULL AS is_constraint,
+       t.tgdeferrable AS is_deferrable,
+       t.tginitdeferred AS is_deferred,
+       (SELECT array_agg(a.attname)
+        FROM unnest(t.tgattr) AS uattnum
+        JOIN pg_attribute a ON a.attrelid = t.tgrelid AND a.attnum = uattnum
+       ) AS update_of_columns,
+       t.tgoldtable AS old_table_name,
+       t.tgnewtable AS new_table_name,
+       pg_catalog.obj_description(t.oid, 'pg_trigger') AS comment
+FROM pg_catalog.pg_trigger t
+JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_namespace tn ON tn.oid = c.relnamespace
+JOIN pg_catalog.pg_proc p ON p.oid = t.tgfoid
+JOIN pg_catalog.pg_namespace pn ON pn.oid = p.pronamespace
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY tn.nspname, c.relname, t.tgname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<Array>}
+ */
+export async function queryTriggers(pool) {
+  const result = await pool.query(TRIGGERS_QUERY);
+  return result.rows.map(row => ({
+    ...row,
+    events: (row.events || []).filter(Boolean),
+    function_call: `${row.function_schema}.${row.function_name}`,
+  }));
+}

package/src/introspection/queries/types.js

@@ -0,0 +1,106 @@
+const ENUMS_QUERY = `
+SELECT t.typname AS name,
+       n.nspname AS schema,
+       t.typowner::regrole::text AS owner,
+       array_agg(e.enumlabel ORDER BY e.enumsortorder)::text[] AS enum_values,
+       pg_catalog.obj_description(t.oid, 'pg_type') AS comment,
+       t.typacl AS privileges,
+       t.typarray::regtype AS array_type
+FROM pg_catalog.pg_type t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+JOIN pg_catalog.pg_enum e ON e.enumtypid = t.oid
+WHERE t.typtype = 'e'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+GROUP BY t.oid, t.typname, n.nspname, t.typowner, t.typacl, t.typarray
+ORDER BY n.nspname, t.typname
+`;
+
+const COMPOSITES_QUERY = `
+SELECT t.typname AS name,
+       n.nspname AS schema,
+       t.typowner::regrole::text AS owner,
+       array_agg(
+         json_build_object(
+           'name', a.attname, 
+           'type', format_type(a.atttypid, a.atttypmod),
+           'collation', COALESCE(coll.collname, NULL)
+         )
+         ORDER BY a.attnum
+       ) AS attributes,
+       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
+JOIN pg_catalog.pg_class c ON c.oid = t.typrelid
+JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+LEFT JOIN pg_catalog.pg_collation coll ON coll.oid = a.attcollation
+WHERE t.typtype = 'c'
+  AND c.relkind = 'c'
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+GROUP BY t.oid, t.typname, n.nspname, t.typowner
+ORDER BY n.nspname, t.typname
+`;
+
+const DOMAINS_QUERY = `
+SELECT t.typname AS name,
+       n.nspname AS schema,
+       t.typowner::regrole::text AS owner,
+       format_type(t.typbasetype, t.typtypmod) AS base_type,
+       (SELECT n2.nspname FROM pg_type bt JOIN pg_namespace n2 ON n2.oid = bt.typnamespace WHERE bt.oid = t.typbasetype) AS base_type_schema,
+       t.typnotnull AS not_null,
+       pg_catalog.pg_get_expr(t.typdefaultbin, t.typbasetype) AS default_value,
+       pg_catalog.pg_get_constraintdef(con.oid) AS check_constraint,
+       pg_catalog.obj_description(t.oid, 'pg_type') AS comment,
+       CASE WHEN t.typcollation != 0 THEN t.typcollation::regcollation::text ELSE NULL END AS collation,
+       t.typacl AS privileges,
+       COALESCE(con.convalidated, true) AS is_validated,
+       t.typtypmod AS typmod,
+       bt.typlen AS length
+FROM pg_catalog.pg_type t
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+LEFT JOIN pg_catalog.pg_constraint con ON con.contypid = t.oid AND con.contype = 'c'
+LEFT JOIN pg_catalog.pg_type bt ON bt.oid = t.typbasetype
+WHERE t.typtype = 'd'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, t.typname
+`;
+
+const RANGES_QUERY = `
+SELECT t.typname AS name,
+       n.nspname AS schema,
+       t.typowner::regrole::text AS owner,
+       format_type(r.rngsubtype, NULL) AS subtype,
+       (SELECT n2.nspname FROM pg_type st JOIN pg_namespace n2 ON n2.oid = st.typnamespace WHERE st.oid = r.rngsubtype) AS subtype_schema,
+       r.rngmultitypid::regtype AS multirange_type,
+       CASE WHEN r.rngcollation != 0 THEN r.rngcollation::regcollation::text ELSE NULL END AS collation,
+       opc.opcname AS subtype_opclass,
+       CASE WHEN r.rngsubdiff != 0 THEN r.rngsubdiff::regproc::text ELSE NULL END AS subtype_diff,
+       CASE WHEN r.rngcanonical != 0 THEN r.rngcanonical::regproc::text ELSE NULL END AS canonical_function,
+       pg_catalog.obj_description(t.oid, 'pg_type') AS comment,
+       t.typacl AS privileges
+FROM pg_catalog.pg_range r
+JOIN pg_catalog.pg_type t ON t.oid = r.rngtypid
+JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+LEFT JOIN pg_catalog.pg_opclass opc ON opc.oid = r.rngsubopc
+WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, t.typname
+`;
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<{enums:Array,composites:Array,domains:Array,ranges:Array}>}
+ */
+export async function queryTypes(pool) {
+  const [enums, composites, domains, ranges] = await Promise.all([
+    pool.query(ENUMS_QUERY).then(r => r.rows),
+    pool.query(COMPOSITES_QUERY).then(r => r.rows),
+    pool.query(DOMAINS_QUERY).then(r => r.rows),
+    pool.query(RANGES_QUERY).then(r => r.rows),
+  ]);
+  return { enums, composites, domains, ranges };
+}

package/src/introspection/queries/views.js

@@ -0,0 +1,146 @@
+const VIEWS_QUERY = `
+SELECT c.relname AS name,
+       n.nspname AS schema,
+       c.relowner::regrole::text AS owner,
+       pg_catalog.pg_get_viewdef(c.oid, true) AS definition,
+       CASE c.relkind WHEN 'v' THEN 'VIEW' ELSE 'MATERIALIZED_VIEW' END AS kind,
+       CASE
+         WHEN c.relkind = 'v' AND c.relchecks > 0 THEN
+           CASE WHEN EXISTS (
+             SELECT 1 FROM pg_catalog.pg_rewrite r
+             WHERE r.ev_class = c.oid AND r.ev_type = '1'
+             AND pg_catalog.pg_get_expr(r.ev_qual, r.ev_class) LIKE '%check_option=cascaded%'
+           ) THEN 'CASCADED'
+           WHEN EXISTS (
+             SELECT 1 FROM pg_catalog.pg_rewrite r
+             WHERE r.ev_class = c.oid AND r.ev_type = '1'
+             AND pg_catalog.pg_get_expr(r.ev_qual, r.ev_class) LIKE '%check_option=local%'
+           ) THEN 'LOCAL'
+           ELSE NULL
+           END
+         ELSE NULL
+       END AS check_option,
+       c.reloptions AS rel_options,
+       c.relacl AS privileges,
+       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 ('v', 'm')
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname
+`;
+
+const VIEW_COLUMNS_QUERY = `
+SELECT n.nspname AS schema,
+       c.relname AS name,
+       a.attname AS column_name,
+       pg_catalog.format_type(a.atttypid, a.atttypmod) AS column_type,
+       NOT a.attnotnull AS nullable,
+       pg_catalog.pg_get_expr(d.adbin, d.adrelid) AS default_value
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+WHERE c.relkind = 'v'
+  AND a.attnum > 0 AND NOT a.attisdropped
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, a.attnum
+`;
+
+const MATVIEW_EXTRA_QUERY = `
+SELECT c.relname AS name,
+       n.nspname AS schema,
+       c.relispopulated AS is_populated,
+       ts.spcname AS tablespace,
+       c.reloptions AS storage_options,
+       c.relacl AS privileges
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+LEFT JOIN pg_catalog.pg_tablespace ts ON ts.oid = c.reltablespace
+WHERE c.relkind = 'm'
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+`;
+
+const MATVIEW_COLUMNS_QUERY = `
+SELECT n.nspname AS schema,
+       c.relname AS name,
+       a.attname AS column_name,
+       pg_catalog.format_type(a.atttypid, a.atttypmod) AS column_type,
+       NOT a.attnotnull AS nullable
+FROM pg_catalog.pg_class c
+JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid
+WHERE c.relkind = 'm'
+  AND a.attnum > 0 AND NOT a.attisdropped
+  AND n.nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+  AND n.nspname NOT LIKE 'pg_temp_%'
+ORDER BY n.nspname, c.relname, a.attnum
+`;
+
+
+/**
+ * @param {import('pg').Pool} pool
+ * @returns {Promise<{views:Array,materializedViews:Array}>}
+ */
+export async function queryViews(pool) {
+  const viewResult = await pool.query(VIEWS_QUERY);
+  const matResult = await pool.query(MATVIEW_EXTRA_QUERY);
+  const viewColsResult = await pool.query(VIEW_COLUMNS_QUERY);
+  const matColsResult = await pool.query(MATVIEW_COLUMNS_QUERY);
+
+  const matExtras = new Map();
+  for (const row of matResult.rows) {
+    matExtras.set(`${row.schema}.${row.name}`, row);
+  }
+
+  const viewColumns = new Map();
+  for (const row of viewColsResult.rows) {
+    const key = `${row.schema}.${row.name}`;
+    if (!viewColumns.has(key)) viewColumns.set(key, []);
+    viewColumns.get(key).push({
+      name: row.column_name,
+      type: row.column_type,
+      nullable: row.nullable,
+      default: row.default_value || undefined,
+    });
+  }
+
+  const matColumns = new Map();
+  for (const row of matColsResult.rows) {
+    const key = `${row.schema}.${row.name}`;
+    if (!matColumns.has(key)) matColumns.set(key, []);
+    matColumns.get(key).push({
+      name: row.column_name,
+      type: row.column_type,
+      nullable: row.nullable,
+    });
+  }
+
+  const views = [];
+  const materializedViews = [];
+
+  for (const row of viewResult.rows) {
+    const key = `${row.schema}.${row.name}`;
+    if (row.kind === 'VIEW') {
+      views.push({
+        ...row,
+        columns: viewColumns.get(key) || [],
+      });
+    } else {
+      const extra = matExtras.get(key) || {};
+      materializedViews.push({
+        ...row,
+        is_populated: extra.is_populated ?? true,
+        tablespace: extra.tablespace ?? null,
+        storage_options: extra.storage_options ?? null,
+        columns: matColumns.get(key) || [],
+        privileges: extra.privileges ?? null,
+      });
+    }
+  }
+
+  return { views, materializedViews };
+}