@supabase/postgrest-typegen 0.0.1

package/src/introspection/sql/functions.sql.ts

@@ -0,0 +1,159 @@
+// oxlint-disable typescript/restrict-template-expressions -- verbatim port of postgres-meta's
+// builder, which interpolates the `args` string[] into the SQL (relying on Array#toString). The
+// expression sits inside a template literal where a targeted disable comment would corrupt the SQL.
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+
+export const FUNCTIONS_SQL = (
+  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
+    nameFilter?: string;
+    args?: string[];
+  },
+) => /* SQL */ `
+-- 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 === undefined
+        ? ""
+        : 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 ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/helpers.ts

@@ -0,0 +1,33 @@
+import { literal } from "pg-format";
+
+/**
+ * Schemas that postgres-meta excludes by default when `includeSystemSchemas`
+ * is false. Ported from `postgres-meta/src/lib/constants.ts`.
+ */
+export const DEFAULT_SYSTEM_SCHEMAS = [
+  "information_schema",
+  "pg_catalog",
+  "pg_toast",
+];
+
+/**
+ * Build a SQL `IN (...)` / `NOT IN (...)` fragment for an include/exclude list,
+ * ported verbatim from `postgres-meta/src/lib/helpers.ts`. Values are escaped
+ * with pg-format's `literal`. Returns an empty string when there is nothing to
+ * filter, so callers interpolate it conditionally.
+ */
+export const filterByList = (
+  include?: (string | number)[],
+  exclude?: (string | number)[],
+  defaultExclude?: (string | number)[],
+) => {
+  if (defaultExclude) {
+    exclude = defaultExclude.concat(exclude ?? []);
+  }
+  if (include?.length) {
+    return `IN (${include.map(literal).join(",")})`;
+  } else if (exclude?.length) {
+    return `NOT IN (${exclude.map(literal).join(",")})`;
+  }
+  return "";
+};

package/src/introspection/sql/materialized_views.sql.ts

@@ -0,0 +1,25 @@
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+
+export const MATERIALIZED_VIEWS_SQL = (
+  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
+    materializedViewIdentifierFilter?: string;
+  },
+) => /* SQL */ `
+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 ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/primary_keys.sql.ts

@@ -0,0 +1,38 @@
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+
+export const PRIMARY_KEYS_SQL = (
+  props: SQLQueryPropsWithSchemaFilter & {
+    tableIdentifierFilter?: string;
+  },
+) => /* SQL */ `
+SELECT
+  c.oid :: int8 AS table_id,
+  n.nspname AS schema,
+  c.relname AS table_name,
+  a.attname AS name
+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
+  AND c.relkind IN ('r', 'p')
+  AND NOT pg_is_other_temp_schema(n.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')
+  )
+ORDER BY
+  c.oid,
+  array_position(i.indkey, a.attnum)
+${props.limit ? `limit ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/schemas.sql.ts

@@ -0,0 +1,32 @@
+import { literal } from "pg-format";
+import type { SQLQueryProps } from "./common.ts";
+
+export const SCHEMAS_SQL = (
+  props: SQLQueryProps & {
+    nameFilter?: string;
+    idsFilter?: string;
+    includeSystemSchemas?: boolean;
+  },
+) => /* SQL */ `
+-- 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 ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/table.sql.ts

@@ -0,0 +1,47 @@
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+
+export const TABLES_SQL = (
+  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
+    tableIdentifierFilter?: string;
+  },
+) => /* SQL */ `
+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
+FROM
+  pg_namespace nc
+  JOIN pg_class c ON nc.oid = c.relnamespace
+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')
+  )
+${props.limit ? `limit ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/table_relationships.sql.ts

@@ -0,0 +1,53 @@
+import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+
+export const TABLE_RELATIONSHIPS_SQL = (
+  props: SQLQueryPropsWithSchemaFilter,
+) => /* SQL */ `
+-- 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}` : ""}
+`;

package/src/introspection/sql/types.sql.ts

@@ -0,0 +1,74 @@
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+
+export const TYPES_SQL = (
+  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
+    includeTableTypes?: boolean;
+    includeArrayTypes?: boolean;
+  },
+) => /* SQL */ `
+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 ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/views.sql.ts

@@ -0,0 +1,26 @@
+import { literal } from "pg-format";
+import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+
+export const VIEWS_SQL = (
+  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
+    viewIdentifierFilter?: string;
+  },
+) => /* SQL */ `
+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 ${literal(props.limit)}` : ""}
+${props.offset ? `offset ${literal(props.offset)}` : ""}
+`;

package/src/introspection/sql/views_key_dependencies.sql.ts

@@ -0,0 +1,199 @@
+import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+
+export const VIEWS_KEY_DEPENDENCIES_SQL = (
+  props: SQLQueryPropsWithSchemaFilter,
+) => /* SQL */ `
+-- 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)
+`;