neon 8.4.4 → 8.5.0

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

@@ -0,0 +1,40 @@
+//#region src/vendor/postgres-meta/lib/sql/roles.sql.ts
+const ROLES_SQL = (props) => `
+-- TODO: Consider using pg_authid vs. pg_roles for unencrypted password field
+SELECT
+  oid :: int8 AS id,
+  rolname AS name,
+  rolsuper AS is_superuser,
+  rolcreatedb AS can_create_db,
+  rolcreaterole AS can_create_role,
+  rolinherit AS inherit_role,
+  rolcanlogin AS can_login,
+  rolreplication AS is_replication_role,
+  rolbypassrls AS can_bypass_rls,
+  (
+    SELECT
+      COUNT(*)
+    FROM
+      pg_stat_activity
+    WHERE
+      pg_roles.rolname = pg_stat_activity.usename
+  ) AS active_connections,
+  CASE WHEN rolconnlimit = -1 THEN current_setting('max_connections') :: int8
+       ELSE rolconnlimit
+  END AS connection_limit,
+  rolpassword AS password,
+  rolvaliduntil AS valid_until,
+  rolconfig AS config
+FROM
+  pg_roles
+WHERE
+  ${props.idsFilter ? `oid ${props.idsFilter}` : "true"}
+  -- All default/predefined roles start with pg_: https://www.postgresql.org/docs/15/predefined-roles.html
+  -- The pg_ prefix is also reserved.
+  ${!props.includeDefaultRoles ? `AND NOT pg_catalog.starts_with(rolname, 'pg_')` : ""}
+  ${props.nameFilter ? `AND rolname ${props.nameFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { ROLES_SQL };

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

@@ -0,0 +1,26 @@
+//#region src/vendor/postgres-meta/lib/sql/schemas.sql.ts
+const SCHEMAS_SQL = (props) => `
+-- Adapted from information_schema.schemata
+select
+  n.oid::int8 as id,
+  n.nspname as name,
+  u.rolname as owner
+from
+  pg_namespace n,
+  pg_roles u
+where
+  n.nspowner = u.oid
+  ${props.idsFilter ? `and n.oid ${props.idsFilter}` : ""}
+  ${props.nameFilter ? `and n.nspname ${props.nameFilter}` : ""}
+  ${!props.includeSystemSchemas ? `and not pg_catalog.starts_with(n.nspname, 'pg_')` : ""}
+  and (
+    pg_has_role(n.nspowner, 'USAGE')
+    or has_schema_privilege(n.oid, 'CREATE, USAGE')
+  )
+  and not pg_catalog.starts_with(n.nspname, 'pg_temp_')
+  and not pg_catalog.starts_with(n.nspname, 'pg_toast_temp_')
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { SCHEMAS_SQL };

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

@@ -0,0 +1,109 @@
+//#region src/vendor/postgres-meta/lib/sql/table.sql.ts
+const TABLES_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  nc.nspname AS schema,
+  c.relname AS name,
+  c.relrowsecurity AS rls_enabled,
+  c.relforcerowsecurity AS rls_forced,
+  CASE
+    WHEN c.relreplident = 'd' THEN 'DEFAULT'
+    WHEN c.relreplident = 'i' THEN 'INDEX'
+    WHEN c.relreplident = 'f' THEN 'FULL'
+    ELSE 'NOTHING'
+  END AS replica_identity,
+  pg_total_relation_size(format('%I.%I', nc.nspname, c.relname)) :: int8 AS bytes,
+  pg_size_pretty(
+    pg_total_relation_size(format('%I.%I', nc.nspname, c.relname))
+  ) AS size,
+  pg_stat_get_live_tuples(c.oid) AS live_rows_estimate,
+  pg_stat_get_dead_tuples(c.oid) AS dead_rows_estimate,
+  obj_description(c.oid) AS comment,
+  coalesce(pk.primary_keys, '[]') as primary_keys,
+  coalesce(
+    jsonb_agg(relationships) filter (where relationships is not null),
+    '[]'
+  ) as relationships
+FROM
+  pg_namespace nc
+  JOIN pg_class c ON nc.oid = c.relnamespace
+  left join (
+    select
+      c.oid::int8 as table_id,
+      jsonb_agg(
+        jsonb_build_object(
+          'table_id', c.oid::int8,
+          'schema', n.nspname,
+          'table_name', c.relname,
+          'name', a.attname
+        )
+        order by array_position(i.indkey, a.attnum)
+      ) as primary_keys
+    from
+      pg_index i
+      join pg_class c on i.indrelid = c.oid
+      join pg_namespace n on c.relnamespace = n.oid
+      join pg_attribute a on a.attrelid = c.oid and a.attnum = any(i.indkey)
+    where
+      ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
+      ${props.tableIdentifierFilter ? `n.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+      i.indisprimary
+    group by c.oid
+  ) as pk
+  on pk.table_id = c.oid
+  left join (
+    select
+      c.oid :: int8 as id,
+      c.conname as constraint_name,
+      nsa.nspname as source_schema,
+      csa.relname as source_table_name,
+      sa.attname as source_column_name,
+      nta.nspname as target_table_schema,
+      cta.relname as target_table_name,
+      ta.attname as target_column_name
+    from
+      pg_constraint c
+    join (
+      pg_attribute sa
+      join pg_class csa on sa.attrelid = csa.oid
+      join pg_namespace nsa on csa.relnamespace = nsa.oid
+    ) on sa.attrelid = c.conrelid and sa.attnum = any (c.conkey)
+    join (
+      pg_attribute ta
+      join pg_class cta on ta.attrelid = cta.oid
+      join pg_namespace nta on cta.relnamespace = nta.oid
+    ) on ta.attrelid = c.confrelid and ta.attnum = any (c.confkey)
+    where
+      ${props.schemaFilter ? `nsa.nspname ${props.schemaFilter} OR nta.nspname ${props.schemaFilter} AND` : ""}
+      ${props.tableIdentifierFilter ? `(nsa.nspname || '.' || csa.relname) ${props.tableIdentifierFilter} OR (nta.nspname || '.' || cta.relname) ${props.tableIdentifierFilter} AND` : ""}
+      c.contype = 'f'
+  ) as relationships
+  on (relationships.source_schema = nc.nspname and relationships.source_table_name = c.relname)
+  or (relationships.target_table_schema = nc.nspname and relationships.target_table_name = c.relname)
+WHERE
+  ${props.schemaFilter ? `nc.nspname ${props.schemaFilter} AND` : ""}
+  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
+  ${props.tableIdentifierFilter ? `nc.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
+  c.relkind IN ('r', 'p')
+  AND NOT pg_is_other_temp_schema(nc.oid)
+  AND (
+    pg_has_role(c.relowner, 'USAGE')
+    OR has_table_privilege(
+      c.oid,
+      'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER'
+    )
+    OR has_any_column_privilege(c.oid, 'SELECT, INSERT, UPDATE, REFERENCES')
+  )
+group by
+  c.oid,
+  c.relname,
+  c.relrowsecurity,
+  c.relforcerowsecurity,
+  c.relreplident,
+  nc.nspname,
+  pk.primary_keys
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TABLES_SQL };

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

@@ -0,0 +1,85 @@
+//#region src/vendor/postgres-meta/lib/sql/table_privileges.sql.ts
+const TABLE_PRIVILEGES_SQL = (props) => `
+-- Despite the name \`table_privileges\`, this includes other kinds of relations:
+-- views, matviews, etc. "Relation privileges" just doesn't roll off the tongue.
+--
+-- For each relation, get its relacl in a jsonb format,
+-- e.g.
+--
+-- '{postgres=arwdDxt/postgres}'
+--
+-- becomes
+--
+-- [
+--   {
+--     "grantee": "postgres",
+--     "grantor": "postgres",
+--     "is_grantable": false,
+--     "privilege_type": "INSERT"
+--   },
+--   ...
+-- ]
+select
+  c.oid as relation_id,
+  nc.nspname as schema,
+  c.relname as name,
+  case
+    when c.relkind = 'r' then 'table'
+    when c.relkind = 'v' then 'view'
+    when c.relkind = 'm' then 'materialized_view'
+    when c.relkind = 'f' then 'foreign_table'
+    when c.relkind = 'p' then 'partitioned_table'
+  end as kind,
+  coalesce(
+    jsonb_agg(
+      jsonb_build_object(
+        'grantor', grantor.rolname,
+        'grantee', grantee.rolname,
+        'privilege_type', _priv.privilege_type,
+        'is_grantable', _priv.is_grantable
+      )
+    ) filter (where _priv is not null),
+    '[]'
+  ) as privileges
+from pg_class c
+join pg_namespace as nc
+  on nc.oid = c.relnamespace
+left join lateral (
+  select grantor, grantee, privilege_type, is_grantable
+  from aclexplode(coalesce(c.relacl, acldefault('r', c.relowner)))
+) as _priv on true
+left join pg_roles as grantor
+  on grantor.oid = _priv.grantor
+left join (
+  select
+    pg_roles.oid,
+    pg_roles.rolname
+  from pg_roles
+  union all
+  select
+    (0)::oid as oid, 'PUBLIC'
+) as grantee (oid, rolname)
+  on grantee.oid = _priv.grantee
+where c.relkind in ('r', 'v', 'm', 'f', 'p')
+  ${props.schemaFilter ? `and nc.nspname ${props.schemaFilter}` : ""}
+  ${props.idsFilter ? `and c.oid ${props.idsFilter}` : ""}
+  ${props.nameIdentifierFilter ? `and (nc.nspname || '.' || c.relname) ${props.nameIdentifierFilter}` : ""}
+  and not pg_is_other_temp_schema(c.relnamespace)
+  and (
+    pg_has_role(c.relowner, 'USAGE')
+    or has_table_privilege(
+      c.oid,
+      'SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER, MAINTAIN'
+    )
+    or has_any_column_privilege(c.oid, 'SELECT, INSERT, UPDATE, REFERENCES')
+  )
+group by
+  c.oid,
+  nc.nspname,
+  c.relname,
+  c.relkind
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TABLE_PRIVILEGES_SQL };

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

@@ -0,0 +1,52 @@
+//#region src/vendor/postgres-meta/lib/sql/table_relationships.sql.ts
+const TABLE_RELATIONSHIPS_SQL = (props) => `
+-- Adapted from
+-- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L722
+WITH
+pks_uniques_cols AS (
+  SELECT
+    connamespace,
+    conrelid,
+    jsonb_agg(column_info.cols) as cols
+  FROM pg_constraint
+  JOIN lateral (
+    SELECT array_agg(cols.attname order by cols.attnum) as cols
+    FROM ( select unnest(conkey) as col) _
+    JOIN pg_attribute cols on cols.attrelid = conrelid and cols.attnum = col
+  ) column_info ON TRUE
+  WHERE
+    contype IN ('p', 'u') and
+    connamespace::regnamespace::text <> 'pg_catalog'
+    ${props.schemaFilter ? `and connamespace::regnamespace::text ${props.schemaFilter}` : ""}
+  GROUP BY connamespace, conrelid
+)
+SELECT
+  traint.conname AS foreign_key_name,
+  ns1.nspname AS schema,
+  tab.relname AS relation,
+  column_info.cols AS columns,
+  ns2.nspname AS referenced_schema,
+  other.relname AS referenced_relation,
+  column_info.refs AS referenced_columns,
+  (column_info.cols IN (SELECT * FROM jsonb_array_elements(pks_uqs.cols))) AS is_one_to_one
+FROM pg_constraint traint
+JOIN LATERAL (
+  SELECT
+    jsonb_agg(cols.attname order by ord) AS cols,
+    jsonb_agg(refs.attname order by ord) AS refs
+  FROM unnest(traint.conkey, traint.confkey) WITH ORDINALITY AS _(col, ref, ord)
+  JOIN pg_attribute cols ON cols.attrelid = traint.conrelid AND cols.attnum = col
+  JOIN pg_attribute refs ON refs.attrelid = traint.confrelid AND refs.attnum = ref
+  WHERE ${props.schemaFilter ? `traint.connamespace::regnamespace::text ${props.schemaFilter}` : "true"}
+) AS column_info ON TRUE
+JOIN pg_namespace ns1 ON ns1.oid = traint.connamespace
+JOIN pg_class tab ON tab.oid = traint.conrelid
+JOIN pg_class other ON other.oid = traint.confrelid
+JOIN pg_namespace ns2 ON ns2.oid = other.relnamespace
+LEFT JOIN pks_uniques_cols pks_uqs ON pks_uqs.connamespace = traint.connamespace AND pks_uqs.conrelid = traint.conrelid
+WHERE traint.contype = 'f'
+AND traint.conparentid = 0
+${props.schemaFilter ? `and ns1.nspname ${props.schemaFilter}` : ""}
+`;
+//#endregion
+export { TABLE_RELATIONSHIPS_SQL };

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

@@ -0,0 +1,64 @@
+//#region src/vendor/postgres-meta/lib/sql/triggers.sql.ts
+const TRIGGERS_SQL = (props) => `
+SELECT
+  pg_t.oid AS id,
+  pg_t.tgrelid AS table_id,
+  CASE
+    WHEN pg_t.tgenabled = 'D' THEN 'DISABLED'
+    WHEN pg_t.tgenabled = 'O' THEN 'ORIGIN'
+    WHEN pg_t.tgenabled = 'R' THEN 'REPLICA'
+    WHEN pg_t.tgenabled = 'A' THEN 'ALWAYS'
+    END AS enabled_mode,
+  (
+    STRING_TO_ARRAY(
+      ENCODE(pg_t.tgargs, 'escape'), '\\000'
+    )
+  )[:pg_t.tgnargs] AS function_args,
+  is_t.trigger_name AS name,
+  is_t.event_object_table AS table,
+  is_t.event_object_schema AS schema,
+  is_t.action_condition AS condition,
+  is_t.action_orientation AS orientation,
+  is_t.action_timing AS activation,
+  ARRAY_AGG(is_t.event_manipulation)::text[] AS events,
+  pg_p.proname AS function_name,
+  pg_n.nspname AS function_schema
+FROM
+  pg_trigger AS pg_t
+JOIN
+  pg_class AS pg_c
+ON pg_t.tgrelid = pg_c.oid
+JOIN pg_namespace AS table_ns
+ON pg_c.relnamespace = table_ns.oid
+JOIN information_schema.triggers AS is_t
+ON is_t.trigger_name = pg_t.tgname
+AND pg_c.relname = is_t.event_object_table
+AND pg_c.relnamespace = (quote_ident(is_t.event_object_schema))::regnamespace
+JOIN pg_proc AS pg_p
+ON pg_t.tgfoid = pg_p.oid
+JOIN pg_namespace AS pg_n
+ON pg_p.pronamespace = pg_n.oid
+WHERE
+  ${props.schemaFilter ? `table_ns.nspname ${props.schemaFilter}` : "true"}
+  ${props.tableNameFilter ? `AND pg_c.relname ${props.tableNameFilter}` : ""}
+  ${props.nameFilter ? `AND is_t.trigger_name ${props.nameFilter}` : ""}
+  ${props.idsFilter ? `AND pg_t.oid ${props.idsFilter}` : ""}
+GROUP BY
+  pg_t.oid,
+  pg_t.tgrelid,
+  pg_t.tgenabled,
+  pg_t.tgargs,
+  pg_t.tgnargs,
+  is_t.trigger_name,
+  is_t.event_object_table,
+  is_t.event_object_schema,
+  is_t.action_condition,
+  is_t.action_orientation,
+  is_t.action_timing,
+  pg_p.proname,
+  pg_n.nspname
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TRIGGERS_SQL };

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

@@ -0,0 +1,65 @@
+//#region src/vendor/postgres-meta/lib/sql/types.sql.ts
+const TYPES_SQL = (props) => `
+select
+  t.oid::int8 as id,
+  t.typname as name,
+  n.nspname as schema,
+  format_type (t.oid, null) as format,
+  coalesce(t_enums.enums, '[]') as enums,
+  coalesce(t_attributes.attributes, '[]') as attributes,
+  obj_description (t.oid, 'pg_type') as comment,
+  nullif(t.typrelid::int8, 0) as type_relation_id
+from
+  pg_type t
+  left join pg_namespace n on n.oid = t.typnamespace
+  left join (
+    select
+      enumtypid,
+      jsonb_agg(enumlabel order by enumsortorder) as enums
+    from
+      pg_enum
+    group by
+      enumtypid
+  ) as t_enums on t_enums.enumtypid = t.oid
+  left join (
+    select
+      oid,
+      jsonb_agg(
+        jsonb_build_object('name', a.attname, 'type_id', a.atttypid::int8)
+        order by a.attnum asc
+      ) as attributes
+    from
+      pg_class c
+      join pg_attribute a on a.attrelid = c.oid
+    where
+      c.relkind = 'c' and not a.attisdropped
+    group by
+      c.oid
+  ) as t_attributes on t_attributes.oid = t.typrelid
+  where
+      (
+        t.typrelid = 0
+        or (
+          select
+            c.relkind ${props.includeTableTypes ? `in ('c', 'r', 'v', 'm', 'p')` : `= 'c'`}
+          from
+            pg_class c
+          where
+            c.oid = t.typrelid
+        )
+      )
+      ${!props.includeArrayTypes ? `and not exists (
+                 select
+                 from
+                   pg_type el
+                 where
+                   el.oid = t.typelem
+                   and el.typarray = t.oid
+               )` : ""}
+      ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+      ${props.idsFilter ? `and t.oid ${props.idsFilter}` : ""}
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { TYPES_SQL };

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

@@ -0,0 +1,15 @@
+//#region src/vendor/postgres-meta/lib/sql/version.sql.ts
+const VERSION_SQL = () => `
+SELECT
+  version(),
+  current_setting('server_version_num') :: int8 AS version_number,
+  (
+    SELECT
+      COUNT(*) AS active_connections
+    FROM
+      pg_stat_activity
+  ) AS active_connections,
+  current_setting('max_connections') :: int8 AS max_connections
+`;
+//#endregion
+export { VERSION_SQL };

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

@@ -0,0 +1,22 @@
+//#region src/vendor/postgres-meta/lib/sql/views.sql.ts
+const VIEWS_SQL = (props) => `
+SELECT
+  c.oid :: int8 AS id,
+  n.nspname AS schema,
+  c.relname AS name,
+  -- See definition of information_schema.views
+  (pg_relation_is_updatable(c.oid, false) & 20) = 20 AS is_updatable,
+  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.viewIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.viewIdentifierFilter} AND` : ""}
+  c.relkind = 'v'
+${props.limit ? `limit ${props.limit}` : ""}
+${props.offset ? `offset ${props.offset}` : ""}
+`;
+//#endregion
+export { VIEWS_SQL };

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

@@ -0,0 +1,198 @@
+//#region src/vendor/postgres-meta/lib/sql/views_key_dependencies.sql.ts
+const VIEWS_KEY_DEPENDENCIES_SQL = (props) => `
+-- Adapted from
+-- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
+with recursive
+pks_fks as (
+  -- pk + fk referencing col
+  select
+    contype::text as contype,
+    conname,
+    array_length(conkey, 1) as ncol,
+    conrelid as resorigtbl,
+    col as resorigcol,
+    ord
+  from pg_constraint
+  left join lateral unnest(conkey) with ordinality as _(col, ord) on true
+  where contype IN ('p', 'f')
+  union
+  -- fk referenced col
+  select
+    concat(contype, '_ref') as contype,
+    conname,
+    array_length(confkey, 1) as ncol,
+    confrelid,
+    col,
+    ord
+  from pg_constraint
+  left join lateral unnest(confkey) with ordinality as _(col, ord) on true
+  where contype='f'
+  ${props.schemaFilter ? `and connamespace::regnamespace::text ${props.schemaFilter}` : ""}
+),
+views as (
+  select
+    c.oid       as view_id,
+    n.nspname   as view_schema,
+    c.relname   as view_name,
+    r.ev_action as view_definition
+  from pg_class c
+  join pg_namespace n on n.oid = c.relnamespace
+  join pg_rewrite r on r.ev_class = c.oid
+  where c.relkind in ('v', 'm') 
+    ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+),
+transform_json as (
+  select
+    view_id, view_schema, view_name,
+    -- the following formatting is without indentation on purpose
+    -- to allow simple diffs, with less whitespace noise
+    replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      regexp_replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+      replace(
+        view_definition::text,
+      -- This conversion to json is heavily optimized for performance.
+      -- The general idea is to use as few regexp_replace() calls as possible.
+      -- Simple replace() is a lot faster, so we jump through some hoops
+      -- to be able to use regexp_replace() only once.
+      -- This has been tested against a huge schema with 250+ different views.
+      -- The unit tests do NOT reflect all possible inputs. Be careful when changing this!
+      -- -----------------------------------------------
+      -- pattern           | replacement         | flags
+      -- -----------------------------------------------
+      -- <> in pg_node_tree is the same as null in JSON, but due to very poor performance of json_typeof
+      -- we need to make this an empty array here to prevent json_array_elements from throwing an error
+      -- when the targetList is null.
+      -- We'll need to put it first, to make the node protection below work for node lists that start with
+      -- null: (<> ..., too. This is the case for coldefexprs, when the first column does not have a default value.
+         '<>'              , '()'
+      -- , is not part of the pg_node_tree format, but used in the regex.
+      -- This removes all , that might be part of column names.
+      ), ','               , ''
+      -- The same applies for { and }, although those are used a lot in pg_node_tree.
+      -- We remove the escaped ones, which might be part of column names again.
+      ), E'\\\\{'            , ''
+      ), E'\\\\}'            , ''
+      -- The fields we need are formatted as json manually to protect them from the regex.
+      ), ' :targetList '   , ',"targetList":'
+      ), ' :resno '        , ',"resno":'
+      ), ' :resorigtbl '   , ',"resorigtbl":'
+      ), ' :resorigcol '   , ',"resorigcol":'
+      -- Make the regex also match the node type, e.g. \`{QUERY ...\`, to remove it in one pass.
+      ), '{'               , '{ :'
+      -- Protect node lists, which start with \`({\` or \`((\` from the greedy regex.
+      -- The extra \`{\` is removed again later.
+      ), '(('              , '{(('
+      ), '({'              , '{({'
+      -- This regex removes all unused fields to avoid the need to format all of them correctly.
+      -- This leads to a smaller json result as well.
+      -- Removal stops at \`,\` for used fields (see above) and \`}\` for the end of the current node.
+      -- Nesting can't be parsed correctly with a regex, so we stop at \`{\` as well and
+      -- add an empty key for the followig node.
+      ), ' :[^}{,]+'       , ',"":'              , 'g'
+      -- For performance, the regex also added those empty keys when hitting a \`,\` or \`}\`.
+      -- Those are removed next.
+      ), ',"":}'           , '}'
+      ), ',"":,'           , ','
+      -- This reverses the "node list protection" from above.
+      ), '{('              , '('
+      -- Every key above has been added with a \`,\` so far. The first key in an object doesn't need it.
+      ), '{,'              , '{'
+      -- pg_node_tree has \`()\` around lists, but JSON uses \`[]\`
+      ), '('               , '['
+      ), ')'               , ']'
+      -- pg_node_tree has \` \` between list items, but JSON uses \`,\`
+      ), ' '             , ','
+    )::json as view_definition
+  from views
+),
+target_entries as(
+  select
+    view_id, view_schema, view_name,
+    json_array_elements(view_definition->0->'targetList') as entry
+  from transform_json
+),
+results as(
+  select
+    view_id, view_schema, view_name,
+    (entry->>'resno')::int as view_column,
+    (entry->>'resorigtbl')::oid as resorigtbl,
+    (entry->>'resorigcol')::int as resorigcol
+  from target_entries
+),
+-- CYCLE detection according to PG docs: https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-CYCLE
+-- Can be replaced with CYCLE clause once PG v13 is EOL.
+recursion(view_id, view_schema, view_name, view_column, resorigtbl, resorigcol, is_cycle, path) as(
+  select
+    r.*,
+    false,
+    ARRAY[resorigtbl]
+  from results r
+  where ${props.schemaFilter ? `view_schema ${props.schemaFilter}` : "true"}
+  union all
+  select
+    view.view_id,
+    view.view_schema,
+    view.view_name,
+    view.view_column,
+    tab.resorigtbl,
+    tab.resorigcol,
+    tab.resorigtbl = ANY(path),
+    path || tab.resorigtbl
+  from recursion view
+  join results tab on view.resorigtbl=tab.view_id and view.resorigcol=tab.view_column
+  where not is_cycle
+),
+repeated_references as(
+  select
+    view_id,
+    view_schema,
+    view_name,
+    resorigtbl,
+    resorigcol,
+    array_agg(attname) as view_columns
+  from recursion
+  join pg_attribute vcol on vcol.attrelid = view_id and vcol.attnum = view_column
+  group by
+    view_id,
+    view_schema,
+    view_name,
+    resorigtbl,
+    resorigcol
+)
+select
+  sch.nspname as table_schema,
+  tbl.relname as table_name,
+  rep.view_schema,
+  rep.view_name,
+  pks_fks.conname as constraint_name,
+  pks_fks.contype as constraint_type,
+  jsonb_agg(
+    jsonb_build_object('table_column', col.attname, 'view_columns', view_columns) order by pks_fks.ord
+  ) as column_dependencies
+from repeated_references rep
+join pks_fks using (resorigtbl, resorigcol)
+join pg_class tbl on tbl.oid = rep.resorigtbl
+join pg_attribute col on col.attrelid = tbl.oid and col.attnum = rep.resorigcol
+join pg_namespace sch on sch.oid = tbl.relnamespace
+group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conname, pks_fks.contype, pks_fks.ncol
+-- make sure we only return key for which all columns are referenced in the view - no partial PKs or FKs
+having ncol = array_length(array_agg(row(col.attname, view_columns) order by pks_fks.ord), 1)
+`;
+//#endregion
+export { VIEWS_KEY_DEPENDENCIES_SQL };

package/dist/vendor/postgres-meta/lib/types.js

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