neon 8.4.5 → 8.5.0

package/dist/vendor/postgres-meta/lib/sql/column_privileges.sql.js

@@ -0,0 +1,154 @@
+//#region src/vendor/postgres-meta/lib/sql/column_privileges.sql.ts
+const COLUMN_PRIVILEGES_SQL = (props) => `
+-- Lists each column's privileges in the form of:
+--
+-- [
+--   {
+--     "column_id": "12345.1",
+--     "relation_schema": "public",
+--     "relation_name": "mytable",
+--     "column_name": "mycolumn",
+--     "privileges": [
+--       {
+--         "grantor": "postgres",
+--         "grantee": "myrole",
+--         "privilege_type": "SELECT",
+--         "is_grantable": false
+--       },
+--       ...
+--     ]
+--   },
+--   ...
+-- ]
+--
+-- Modified from information_schema.column_privileges. We try to be as close as
+-- possible to the view definition, obtained from:
+--
+-- select pg_get_viewdef('information_schema.column_privileges');
+--
+-- The main differences are:
+-- - we include column privileges for materialized views
+--   (reason for exclusion in information_schema.column_privileges:
+--    https://www.postgresql.org/message-id/9136.1502740844%40sss.pgh.pa.us)
+-- - we query a.attrelid and a.attnum to generate \`column_id\`
+-- - \`table_catalog\` is omitted
+-- - table_schema -> relation_schema, table_name -> relation_name
+--
+-- Column privileges are intertwined with table privileges in that table
+-- privileges override column privileges. E.g. if we do:
+--
+-- grant all on mytable to myrole;
+--
+-- Then \`myrole\` is granted privileges for ALL columns. Likewise, if we do:
+--
+-- grant all (id) on mytable to myrole;
+-- revoke all on mytable from myrole;
+--
+-- Then the grant on the \`id\` column is revoked.
+--
+-- This is unlike how grants for schemas and tables interact, where you need
+-- privileges for BOTH the schema the table is in AND the table itself in order
+-- to access the table.
+
+select (x.attrelid || '.' || x.attnum) as column_id,
+       nc.nspname as relation_schema,
+       x.relname as relation_name,
+       x.attname as column_name,
+       coalesce(
+         jsonb_agg(
+           jsonb_build_object(
+             'grantor', u_grantor.rolname,
+             'grantee', grantee.rolname,
+             'privilege_type', x.prtype,
+             'is_grantable', x.grantable
+           )
+         ),
+         '[]'
+       ) as privileges
+from
+  (select pr_c.grantor,
+          pr_c.grantee,
+          a.attrelid,
+          a.attnum,
+          a.attname,
+          pr_c.relname,
+          pr_c.relnamespace,
+          pr_c.prtype,
+          pr_c.grantable,
+          pr_c.relowner
+   from
+     (select pg_class.oid,
+             pg_class.relname,
+             pg_class.relnamespace,
+             pg_class.relowner,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).grantor as grantor,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).grantee as grantee,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).privilege_type as privilege_type,
+             (aclexplode(coalesce(pg_class.relacl, acldefault('r', pg_class.relowner)))).is_grantable as is_grantable
+      from pg_class
+      where (pg_class.relkind = any (array['r',
+                                           'v',
+                                           'm',
+                                           'f',
+                                           'p'])) ) pr_c(oid, relname, relnamespace, relowner, grantor, grantee, prtype, grantable),
+                                                    pg_attribute a
+   where ((a.attrelid = pr_c.oid)
+          and (a.attnum > 0)
+          and (not a.attisdropped))
+   union select pr_a.grantor,
+                pr_a.grantee,
+                pr_a.attrelid,
+                pr_a.attnum,
+                pr_a.attname,
+                c.relname,
+                c.relnamespace,
+                pr_a.prtype,
+                pr_a.grantable,
+                c.relowner
+   from
+     (select a.attrelid,
+             a.attnum,
+             a.attname,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).grantor as grantor,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).grantee as grantee,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).privilege_type as privilege_type,
+             (aclexplode(coalesce(a.attacl, acldefault('c', cc.relowner)))).is_grantable as is_grantable
+      from (pg_attribute a
+            join pg_class cc on ((a.attrelid = cc.oid)))
+      where ((a.attnum > 0)
+             and (not a.attisdropped))) pr_a(attrelid, attnum, attname, grantor, grantee, prtype, grantable),
+                                        pg_class c
+   where ((pr_a.attrelid = c.oid)
+          and (c.relkind = any (ARRAY['r',
+                                      'v',
+                                      'm',
+                                      'f',
+                                      'p'])))) x,
+     pg_namespace nc,
+     pg_authid u_grantor,
+  (select pg_authid.oid,
+          pg_authid.rolname
+   from pg_authid
+   union all select (0)::oid as oid,
+                    'PUBLIC') grantee(oid, rolname)
+where ((x.relnamespace = nc.oid)
+       ${props.schemaFilter ? `and nc.nspname ${props.schemaFilter}` : ""}
+       ${props.columnIdsFilter ? `and (x.attrelid || '.' || x.attnum) ${props.columnIdsFilter}` : ""}
+       and (x.grantee = grantee.oid)
+       and (x.grantor = u_grantor.oid)
+       and (x.prtype = any (ARRAY['INSERT',
+                                  'SELECT',
+                                  'UPDATE',
+                                  'REFERENCES']))
+       and (pg_has_role(u_grantor.oid, 'USAGE')
+            or pg_has_role(grantee.oid, 'USAGE')
+            or (grantee.rolname = 'PUBLIC')))
+group by column_id,
+         nc.nspname,
+         x.relname,
+         x.attname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { COLUMN_PRIVILEGES_SQL };

package/dist/vendor/postgres-meta/lib/sql/columns.sql.js

@@ -0,0 +1,123 @@
+//#region src/vendor/postgres-meta/lib/sql/columns.sql.ts
+const COLUMNS_SQL = (props) => `
+-- Adapted from information_schema.columns
+
+SELECT
+  c.oid :: int8 AS table_id,
+  nc.nspname AS schema,
+  c.relname AS table,
+  (c.oid || '.' || a.attnum) AS id,
+  a.attnum AS ordinal_position,
+  a.attname AS name,
+  CASE
+    WHEN a.atthasdef THEN pg_get_expr(ad.adbin, ad.adrelid)
+    ELSE NULL
+  END AS default_value,
+  CASE
+    WHEN t.typtype = 'd' THEN CASE
+      WHEN bt.typelem <> 0 :: oid
+      AND bt.typlen = -1 THEN 'ARRAY'
+      WHEN nbt.nspname = 'pg_catalog' THEN format_type(t.typbasetype, NULL)
+      ELSE 'USER-DEFINED'
+    END
+    ELSE CASE
+      WHEN t.typelem <> 0 :: oid
+      AND t.typlen = -1 THEN 'ARRAY'
+      WHEN nt.nspname = 'pg_catalog' THEN format_type(a.atttypid, NULL)
+      ELSE 'USER-DEFINED'
+    END
+  END AS data_type,
+  COALESCE(bt.typname, t.typname) AS format,
+  a.attidentity IN ('a', 'd') AS is_identity,
+  CASE
+    a.attidentity
+    WHEN 'a' THEN 'ALWAYS'
+    WHEN 'd' THEN 'BY DEFAULT'
+    ELSE NULL
+  END AS identity_generation,
+  a.attgenerated IN ('s') AS is_generated,
+  NOT (
+    a.attnotnull
+    OR t.typtype = 'd' AND t.typnotnull
+  ) AS is_nullable,
+  (
+    c.relkind IN ('r', 'p')
+    OR c.relkind IN ('v', 'f') AND pg_column_is_updatable(c.oid, a.attnum, FALSE)
+  ) AS is_updatable,
+  uniques.table_id IS NOT NULL AS is_unique,
+  check_constraints.definition AS "check",
+  array_to_json(
+    array(
+      SELECT
+        enumlabel
+      FROM
+        pg_catalog.pg_enum enums
+      WHERE
+        enums.enumtypid = coalesce(bt.oid, t.oid)
+        OR enums.enumtypid = coalesce(bt.typelem, t.typelem)
+      ORDER BY
+        enums.enumsortorder
+    )
+  ) AS enums,
+  col_description(c.oid, a.attnum) AS comment
+FROM
+  pg_attribute a
+  LEFT JOIN pg_attrdef ad ON a.attrelid = ad.adrelid
+  AND a.attnum = ad.adnum
+  JOIN (
+    pg_class c
+    JOIN pg_namespace nc ON c.relnamespace = nc.oid
+  ) ON a.attrelid = c.oid
+  JOIN (
+    pg_type t
+    JOIN pg_namespace nt ON t.typnamespace = nt.oid
+  ) ON a.atttypid = t.oid
+  LEFT JOIN (
+    pg_type bt
+    JOIN pg_namespace nbt ON bt.typnamespace = nbt.oid
+  ) ON t.typtype = 'd'
+  AND t.typbasetype = bt.oid
+  LEFT JOIN (
+    SELECT DISTINCT ON (table_id, ordinal_position)
+      conrelid AS table_id,
+      conkey[1] AS ordinal_position
+    FROM pg_catalog.pg_constraint
+    WHERE contype = 'u' AND cardinality(conkey) = 1
+  ) AS uniques ON uniques.table_id = c.oid AND uniques.ordinal_position = a.attnum
+  LEFT JOIN (
+    -- We only select the first column check
+    SELECT DISTINCT ON (table_id, ordinal_position)
+      conrelid AS table_id,
+      conkey[1] AS ordinal_position,
+      substring(
+        pg_get_constraintdef(pg_constraint.oid, true),
+        8,
+        length(pg_get_constraintdef(pg_constraint.oid, true)) - 8
+      ) AS "definition"
+    FROM pg_constraint
+    WHERE contype = 'c' AND cardinality(conkey) = 1
+    ORDER BY table_id, ordinal_position, oid asc
+  ) AS check_constraints ON check_constraints.table_id = c.oid AND check_constraints.ordinal_position = a.attnum
+WHERE
+  ${props.schemaFilter ? `nc.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `(c.oid || '.' || a.attnum) ${props.idsFilter} AND` : ""}
+  ${props.columnNameFilter ? `(c.relname || '.' || a.attname) ${props.columnNameFilter} AND` : ""}
+  ${props.tableIdFilter ? `c.oid ${props.tableIdFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `nc.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+  NOT pg_is_other_temp_schema(nc.oid)
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+  AND (c.relkind IN ('r', 'v', 'm', 'f', 'p'))
+  AND (
+    pg_has_role(c.relowner, 'USAGE')
+    OR has_column_privilege(
+      c.oid,
+      a.attnum,
+      'SELECT, INSERT, UPDATE, REFERENCES'
+    )
+  )
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { COLUMNS_SQL };

package/dist/vendor/postgres-meta/lib/sql/common.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/postgres-meta/lib/sql/config.sql.js

@@ -0,0 +1,32 @@
+//#region src/vendor/postgres-meta/lib/sql/config.sql.ts
+const CONFIG_SQL = (props) => `
+SELECT
+  name,
+  setting,
+  category,
+  TRIM(split_part(category, '/', 1)) AS group,
+  TRIM(split_part(category, '/', 2)) AS subgroup,
+  unit,
+  short_desc,
+  extra_desc,
+  context,
+  vartype,
+  source,
+  min_val,
+  max_val,
+  enumvals,
+  boot_val,
+  reset_val,
+  sourcefile,
+  sourceline,
+  pending_restart
+FROM
+  pg_settings
+ORDER BY
+  category,
+  name
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { CONFIG_SQL };

package/dist/vendor/postgres-meta/lib/sql/extensions.sql.js

@@ -0,0 +1,20 @@
+//#region src/vendor/postgres-meta/lib/sql/extensions.sql.ts
+const EXTENSIONS_SQL = (props) => `
+SELECT
+  e.name,
+  n.nspname AS schema,
+  e.default_version,
+  x.extversion AS installed_version,
+  e.comment
+FROM
+  pg_available_extensions() e(name, default_version, comment)
+  LEFT JOIN pg_extension x ON e.name = x.extname
+  LEFT JOIN pg_namespace n ON x.extnamespace = n.oid
+WHERE
+  true
+  ${props.nameFilter ? `AND e.name ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { EXTENSIONS_SQL };

package/dist/vendor/postgres-meta/lib/sql/foreign_tables.sql.js

@@ -0,0 +1,20 @@
+//#region src/vendor/postgres-meta/lib/sql/foreign_tables.sql.ts
+const FOREIGN_TABLES_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS name,
+  obj_description(c.oid) AS comment
+FROM
+  pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.tableIdentifierFilter} AND` : ""}
+  c.relkind = 'f'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { FOREIGN_TABLES_SQL };

package/dist/vendor/postgres-meta/lib/sql/functions.sql.js

@@ -0,0 +1,141 @@
+//#region src/vendor/postgres-meta/lib/sql/functions.sql.ts
+const FUNCTIONS_SQL = (props) => `
+-- CTE with sane arg_modes, arg_names, and arg_types.
+-- All three are always of the same length.
+-- All three include all args, including OUT and TABLE args.
+with functions as (
+  select
+    p.*,
+    -- proargmodes is null when all arg modes are IN
+    coalesce(
+      p.proargmodes,
+      array_fill('i'::text, array[cardinality(coalesce(p.proallargtypes, p.proargtypes))])
+    ) as arg_modes,
+    -- proargnames is null when all args are unnamed
+    coalesce(
+      p.proargnames,
+      array_fill(''::text, array[cardinality(coalesce(p.proallargtypes, p.proargtypes))])
+    ) as arg_names,
+    -- proallargtypes is null when all arg modes are IN
+    coalesce(p.proallargtypes, p.proargtypes) as arg_types,
+    array_cat(
+      array_fill(false, array[pronargs - pronargdefaults]),
+      array_fill(true, array[pronargdefaults])) as arg_has_defaults
+  from
+    pg_proc as p
+    ${props.schemaFilter ? `join pg_namespace n on p.pronamespace = n.oid` : ""}
+  where
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+    ${props.idsFilter ? `p.oid ${props.idsFilter} AND` : ""}
+    ${props.nameFilter ? `p.proname ${props.nameFilter} AND` : ""}
+    ${props.args === void 0 ? "" : props.args.length > 0 ? `p.proargtypes::text = ${props.args.length ? `(
+          SELECT STRING_AGG(type_oid::text, ' ') FROM (
+            SELECT (
+              split_args.arr[
+                array_length(
+                  split_args.arr,
+                  1
+                )
+              ]::regtype::oid
+            ) AS type_oid FROM (
+              SELECT STRING_TO_ARRAY(
+                UNNEST(
+                  ARRAY[${props.args}]
+                ),
+                ' '
+              ) AS arr
+            ) AS split_args
+          ) args
+    )` : "''"} AND` : ""}
+    p.prokind = 'f'
+)
+select
+  f.oid::int8 as id,
+  n.nspname as schema,
+  f.proname as name,
+  l.lanname as language,
+  case
+    when l.lanname = 'internal' then ''
+    else f.prosrc
+  end as definition,
+  case
+    when l.lanname = 'internal' then f.prosrc
+    else pg_get_functiondef(f.oid)
+  end as complete_statement,
+  coalesce(f_args.args, '[]') as args,
+  pg_get_function_arguments(f.oid) as argument_types,
+  pg_get_function_identity_arguments(f.oid) as identity_argument_types,
+  f.prorettype::int8 as return_type_id,
+  pg_get_function_result(f.oid) as return_type,
+  nullif(rt.typrelid::int8, 0) as return_type_relation_id,
+  f.proretset as is_set_returning_function,
+  case
+    when f.proretset then nullif(f.prorows, 0)
+    else null
+  end as prorows,
+  case
+    when f.provolatile = 'i' then 'IMMUTABLE'
+    when f.provolatile = 's' then 'STABLE'
+    when f.provolatile = 'v' then 'VOLATILE'
+  end as behavior,
+  f.prosecdef as security_definer,
+  f_config.config_params as config_params
+from
+  functions f
+  left join pg_namespace n on f.pronamespace = n.oid
+  left join pg_language l on f.prolang = l.oid
+  left join pg_type rt on rt.oid = f.prorettype
+  left join (
+    select
+      oid,
+      jsonb_object_agg(param, value) filter (where param is not null) as config_params
+    from
+      (
+        select
+          oid,
+          (string_to_array(unnest(proconfig), '='))[1] as param,
+          (string_to_array(unnest(proconfig), '='))[2] as value
+        from
+          functions
+      ) as t
+    group by
+      oid
+  ) f_config on f_config.oid = f.oid
+  left join (
+    select
+      oid,
+      jsonb_agg(jsonb_build_object(
+        'mode', t2.mode,
+        'name', name,
+        'type_id', type_id,
+        'has_default', has_default
+      )) as args
+    from
+      (
+        select
+          oid,
+          unnest(arg_modes) as mode,
+          unnest(arg_names) as name,
+          unnest(arg_types)::int8 as type_id,
+          unnest(arg_has_defaults) as has_default
+        from
+          functions
+      ) as t1,
+      lateral (
+        select
+          case
+            when t1.mode = 'i' then 'in'
+            when t1.mode = 'o' then 'out'
+            when t1.mode = 'b' then 'inout'
+            when t1.mode = 'v' then 'variadic'
+            else 'table'
+          end as mode
+      ) as t2
+    group by
+      t1.oid
+  ) f_args on f_args.oid = f.oid
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { FUNCTIONS_SQL };

package/dist/vendor/postgres-meta/lib/sql/indexes.sql.js

@@ -0,0 +1,51 @@
+//#region src/vendor/postgres-meta/lib/sql/indexes.sql.ts
+const INDEXES_SQL = (props) => `
+SELECT
+    idx.indexrelid::int8 AS id,
+    idx.indrelid::int8 AS table_id,
+    n.nspname AS schema,
+    idx.indnatts AS number_of_attributes,
+    idx.indnkeyatts AS number_of_key_attributes,
+    idx.indisunique AS is_unique,
+    idx.indisprimary AS is_primary,
+    idx.indisexclusion AS is_exclusion,
+    idx.indimmediate AS is_immediate,
+    idx.indisclustered AS is_clustered,
+    idx.indisvalid AS is_valid,
+    idx.indcheckxmin AS check_xmin,
+    idx.indisready AS is_ready,
+    idx.indislive AS is_live,
+    idx.indisreplident AS is_replica_identity,
+    idx.indkey::smallint[] AS key_attributes,
+    idx.indcollation::integer[] AS collation,
+    idx.indclass::integer[] AS class,
+    idx.indoption::smallint[] AS options,
+    idx.indpred AS index_predicate,
+    obj_description(idx.indexrelid, 'pg_class') AS comment,
+    ix.indexdef as index_definition,
+    am.amname AS access_method,
+    jsonb_agg(
+      jsonb_build_object(
+        'attribute_number', a.attnum,
+        'attribute_name', a.attname,
+        'data_type', format_type(a.atttypid, a.atttypmod)
+      )
+      ORDER BY a.attnum
+    ) AS index_attributes
+  FROM
+    pg_index idx
+    JOIN pg_class c ON c.oid = idx.indexrelid
+    JOIN pg_namespace n ON c.relnamespace = n.oid
+    JOIN pg_am am ON c.relam = am.oid
+    JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = ANY(idx.indkey)
+    JOIN pg_indexes ix ON c.relname = ix.indexname
+  WHERE
+    ${props.schemaFilter ? `n.nspname ${props.schemaFilter}` : "true"}
+    ${props.idsFilter ? `AND idx.indexrelid ${props.idsFilter}` : ""}
+  GROUP BY
+    idx.indexrelid, idx.indrelid, n.nspname, idx.indnatts, idx.indnkeyatts, idx.indisunique, idx.indisprimary, idx.indisexclusion, idx.indimmediate, idx.indisclustered, idx.indisvalid, idx.indcheckxmin, idx.indisready, idx.indislive, idx.indisreplident, idx.indkey, idx.indcollation, idx.indclass, idx.indoption, idx.indexprs, idx.indpred, ix.indexdef, am.amname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { INDEXES_SQL };

package/dist/vendor/postgres-meta/lib/sql/materialized_views.sql.js

@@ -0,0 +1,21 @@
+//#region src/vendor/postgres-meta/lib/sql/materialized_views.sql.ts
+const MATERIALIZED_VIEWS_SQL = (props) => `
+select
+  c.oid::int8 as id,
+  n.nspname as schema,
+  c.relname as name,
+  c.relispopulated as is_populated,
+  obj_description(c.oid) as comment
+from
+  pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+where
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.materializedViewIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.materializedViewIdentifierFilter} AND` : ""}
+  c.relkind = 'm'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { MATERIALIZED_VIEWS_SQL };

package/dist/vendor/postgres-meta/lib/sql/policies.sql.js

@@ -0,0 +1,53 @@
+//#region src/vendor/postgres-meta/lib/sql/policies.sql.ts
+const POLICIES_SQL = (props) => `
+SELECT
+  pol.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS table,
+  c.oid :: int8 AS table_id,
+  pol.polname AS name,
+  CASE
+    WHEN pol.polpermissive THEN 'PERMISSIVE' :: text
+    ELSE 'RESTRICTIVE' :: text
+  END AS action,
+  CASE
+    WHEN pol.polroles = '{0}' :: oid [] THEN array_to_json(
+      string_to_array('public' :: text, '' :: text) :: name []
+    )
+    ELSE array_to_json(
+      ARRAY(
+        SELECT
+          pg_roles.rolname
+        FROM
+          pg_roles
+        WHERE
+          pg_roles.oid = ANY (pol.polroles)
+        ORDER BY
+          pg_roles.rolname
+      )
+    )
+  END AS roles,
+  CASE
+    pol.polcmd
+    WHEN 'r' :: "char" THEN 'SELECT' :: text
+    WHEN 'a' :: "char" THEN 'INSERT' :: text
+    WHEN 'w' :: "char" THEN 'UPDATE' :: text
+    WHEN 'd' :: "char" THEN 'DELETE' :: text
+    WHEN '*' :: "char" THEN 'ALL' :: text
+    ELSE NULL :: text
+  END AS command,
+  pg_get_expr(pol.polqual, pol.polrelid) AS definition,
+  pg_get_expr(pol.polwithcheck, pol.polrelid) AS check
+FROM
+  pg_policy pol
+  JOIN pg_class c ON c.oid = pol.polrelid
+  LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+WHERE
+  ${props.schemaFilter ? `n.nspname ${props.schemaFilter}` : "true"}
+  ${props.idsFilter ? `AND pol.oid ${props.idsFilter}` : ""}
+  ${props.functionNameIdentifierFilter ? `AND (c.relname || '.' || pol.polname) ${props.functionNameIdentifierFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { POLICIES_SQL };

package/dist/vendor/postgres-meta/lib/sql/publications.sql.js

@@ -0,0 +1,46 @@
+//#region src/vendor/postgres-meta/lib/sql/publications.sql.ts
+const PUBLICATIONS_SQL = (props) => `
+SELECT
+  p.oid :: int8 AS id,
+  p.pubname AS name,
+  p.pubowner::regrole::text AS owner,
+  p.pubinsert AS publish_insert,
+  p.pubupdate AS publish_update,
+  p.pubdelete AS publish_delete,
+  p.pubtruncate AS publish_truncate,
+  CASE
+    WHEN p.puballtables THEN NULL
+    ELSE pr.tables
+  END AS tables
+FROM
+  pg_catalog.pg_publication AS p
+  LEFT JOIN LATERAL (
+    SELECT
+      COALESCE(
+        array_agg(
+          json_build_object(
+            'id',
+            c.oid :: int8,
+            'name',
+            c.relname,
+            'schema',
+            nc.nspname
+          )
+        ),
+        '{}'
+      ) AS tables
+    FROM
+      pg_catalog.pg_publication_rel AS pr
+      JOIN pg_class AS c ON pr.prrelid = c.oid
+      join pg_namespace as nc on c.relnamespace = nc.oid
+    WHERE
+      pr.prpubid = p.oid
+  ) AS pr ON 1 = 1
+WHERE
+  ${props.idsFilter ? `p.oid ${props.idsFilter}` : "true"}
+  ${props.nameFilter ? `AND p.pubname ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { PUBLICATIONS_SQL };