@supabase/postgrest-typegen 0.2.1 → 0.2.3

package/dist/introspection/relationships.js

@@ -1,4 +1,3 @@
-import { DEFAULT_SYSTEM_SCHEMAS, filterByList } from "./sql/helpers.js";
 import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.js";
 import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.js";
 /**
@@ -13,12 +12,7 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
     return allTableM2oAndO2oRelationships.flatMap((r) => {
         const expandKeyDepCols = (colDeps) => {
             const tableColumns = colDeps.map(({ table_column }) => table_column);
-            // https://gist.github.com/ssippe/1f92625532eef28be6974f898efb23ef?permalink_comment_id=3474581#gistcomment-3474581
-            const cartesianProduct = (allEntries) => {
-                return allEntries.reduce((results, entries) => results
-                    .map((result) => entries.map((entry) => result.concat(entry)))
-                    .reduce((subResults, result) => subResults.concat(result), []), [[]]);
-            };
+            const cartesianProduct = (lists) => lists.reduce((combinations, entries) => combinations.flatMap((combination) => entries.map((entry) => [...combination, entry])), [[]]);
             const viewColumnsPermutations = cartesianProduct(colDeps.map((cd) => cd.view_columns));
             return viewColumnsPermutations.map((viewColumns) => ({
                 tableColumns,
@@ -72,12 +66,11 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
 }
 /**
  * List all relationships (table↔table plus the view-derived ones) for the
- * given schema filter. Mirrors `PostgresMetaRelationships.list()` with the
- * generator path's defaults (`includeSystemSchemas: false`). Errors from the
+ * schemas selected by `schemaFilter`, the `IN (…)`/`NOT IN (…)` fragment
+ * `introspect()` builds with the system schemas excluded. Errors from the
  * injected `Queryable` propagate by throwing — callers adapt.
  */
-export async function listRelationships(db, { includedSchemas, excludedSchemas } = {}) {
-    const schemaFilter = filterByList(includedSchemas, excludedSchemas, DEFAULT_SYSTEM_SCHEMAS);
+export async function listRelationships(db, schemaFilter) {
     const { rows: allTableM2oAndO2oRelationships } = await db.query(TABLE_RELATIONSHIPS_SQL({ schemaFilter }));
     const { rows: viewsKeyDependencies } = await db.query(VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter }));
     const allViewM2oAndO2oRelationships = expandViewRelationships(allTableM2oAndO2oRelationships, viewsKeyDependencies);

package/dist/introspection/sql/columns.sql.d.ts

@@ -1,7 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
-export declare const COLUMNS_SQL: (props: SQLQueryPropsWithSchemaFilter & {
-    tableIdFilter?: string;
-    tableIdentifierFilter?: string;
-    columnNameFilter?: string;
-    idsFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const COLUMNS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/columns.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const COLUMNS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.columns
 
@@ -36,30 +35,43 @@ SELECT
     WHEN 'd' THEN 'BY DEFAULT'
     ELSE NULL
   END AS identity_generation,
-  a.attgenerated IN ('s') AS is_generated,
+  -- 's' = stored, 'v' = virtual (PostgreSQL 18+); neither accepts writes.
+  a.attgenerated IN ('s', 'v') AS is_generated,
   NOT (
     a.attnotnull
     OR t.typtype = 'd' AND t.typnotnull
   ) AS is_nullable,
   (
     c.relkind IN ('r', 'p')
-    -- Columns of views made writable by INSTEAD OF triggers can be written
-    -- through PostgREST even though the view is not auto-updatable, so they
-    -- must not degrade to \`?: never\` in generated Insert/Update types.
-    -- include_triggers => TRUE covers INSTEAD OF UPDATE triggers, but
-    -- pg_column_is_updatable only considers the UPDATE event, so INSTEAD OF
-    -- INSERT triggers (tgtype bits: 64 = INSTEAD, 4 = INSERT) are checked
-    -- separately. Which events a view accepts is gated per view via
+    -- Columns of views made writable by INSTEAD OF triggers or unconditional
+    -- INSTEAD rules can be written through PostgREST even though the view is
+    -- not auto-updatable, so they must not degrade to \`?: never\` in generated
+    -- Insert/Update types. pg_column_is_updatable cannot express this: it
+    -- requires the relation to support both UPDATE and DELETE, so a view with
+    -- only an INSTEAD OF INSERT or only an INSTEAD OF UPDATE trigger reports
+    -- every column as non-updatable regardless of include_triggers. Triggers
+    -- and rules rewrite whole rows, so their presence makes every column
+    -- writable (tgtype bits: 64 = INSTEAD, 4 = INSERT, 16 = UPDATE;
+    -- pg_rewrite ev_type: '2' = UPDATE, '3' = INSERT; ev_qual is '<>' for
+    -- unconditional rules, and only unconditional INSTEAD rules make a view
+    -- writable). Which events a view accepts is gated per view via
     -- is_insert_enabled / is_update_enabled.
     OR c.relkind IN ('v', 'f') AND (
-      pg_column_is_updatable(c.oid, a.attnum, TRUE)
+      pg_column_is_updatable(c.oid, a.attnum, FALSE)
       OR EXISTS (
         SELECT 1 FROM pg_trigger tg
         WHERE tg.tgrelid = c.oid
           AND tg.tgtype & 64 <> 0
-          AND tg.tgtype & 4 <> 0
+          AND tg.tgtype & 20 <> 0
           AND NOT tg.tgisinternal
       )
+      OR EXISTS (
+        SELECT 1 FROM pg_rewrite rw
+        WHERE rw.ev_class = c.oid
+          AND rw.is_instead
+          AND rw.ev_type IN ('2', '3')
+          AND rw.ev_qual :: text = '<>'
+      )
     )
   ) AS is_updatable,
   uniques.table_id IS NOT NULL AS is_unique,
@@ -118,10 +130,6 @@ FROM
   ) 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
@@ -134,6 +142,4 @@ WHERE
       'SELECT, INSERT, UPDATE, REFERENCES'
     )
   )
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

package/dist/introspection/sql/common.d.ts

@@ -1,16 +1,8 @@
-/**
- * Shared prop shapes for the SQL builders, ported from
- * `postgres-meta/src/lib/sql/common.ts`. Only the variants used by the
- * typegen introspection path are kept.
- */
-export type SQLQueryProps = {
-    limit?: number;
-    offset?: number;
-};
-export type SQLQueryPropsWithSchemaFilter = SQLQueryProps & {
-    schemaFilter?: string;
-};
-export type SQLQueryPropsWithSchemaFilterAndIdsFilter = SQLQueryProps & {
-    schemaFilter?: string;
-    idsFilter?: string;
+/** The only option the introspection passes to its SQL builders. */
+export type SchemaFilterProps = {
+    /**
+     * An `IN (…)` or `NOT IN (…)` fragment from `filterByList`, or the empty
+     * string for no filter.
+     */
+    schemaFilter: string;
 };

package/dist/introspection/sql/foreign_tables.sql.d.ts

@@ -1,6 +1,2 @@
-import type { SQLQueryProps } from "./common.ts";
-export declare const FOREIGN_TABLES_SQL: (props: SQLQueryProps & {
-    schemaFilter?: string;
-    idsFilter?: string;
-    tableIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const FOREIGN_TABLES_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/foreign_tables.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const FOREIGN_TABLES_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -10,9 +9,5 @@ FROM
   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 ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

package/dist/introspection/sql/functions.sql.d.ts

@@ -1,5 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const FUNCTIONS_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    nameFilter?: string;
-    args?: string[];
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const FUNCTIONS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/functions.sql.js

@@ -1,7 +1,3 @@
-// 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.js";
 export const FUNCTIONS_SQL = (props) => /* SQL */ `
 -- CTE with sane arg_modes, arg_names, and arg_types.
 -- All three are always of the same length.
@@ -29,33 +25,6 @@ with functions as (
     ${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
@@ -143,6 +112,4 @@ from
     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/dist/introspection/sql/materialized_views.sql.d.ts

@@ -1,4 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const MATERIALIZED_VIEWS_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    materializedViewIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const MATERIALIZED_VIEWS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/materialized_views.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const MATERIALIZED_VIEWS_SQL = (props) => /* SQL */ `
 select
   c.oid::int8 as id,
@@ -11,9 +10,5 @@ from
   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/dist/introspection/sql/primary_keys.sql.d.ts

@@ -1,4 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
-export declare const PRIMARY_KEYS_SQL: (props: SQLQueryPropsWithSchemaFilter & {
-    tableIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const PRIMARY_KEYS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/primary_keys.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const PRIMARY_KEYS_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS table_id,
@@ -12,7 +11,6 @@ FROM
   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)
@@ -27,6 +25,4 @@ WHERE
 ORDER BY
   c.oid,
   array_position(i.indkey, a.attnum)
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

package/dist/introspection/sql/schemas.sql.d.ts

@@ -1,6 +1,2 @@
-import type { SQLQueryProps } from "./common.ts";
-export declare const SCHEMAS_SQL: (props: SQLQueryProps & {
-    nameFilter?: string;
-    idsFilter?: string;
-    includeSystemSchemas?: boolean;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const SCHEMAS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/schemas.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const SCHEMAS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.schemata
 select
@@ -10,15 +9,12 @@ from
   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_')` : ""}
+  ${props.schemaFilter ? `and n.nspname ${props.schemaFilter}` : ""}
+  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/dist/introspection/sql/table.sql.d.ts

@@ -1,4 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const TABLES_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    tableIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const TABLES_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/table.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const TABLES_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -24,8 +23,6 @@ FROM
   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 (
@@ -36,6 +33,4 @@ WHERE
     )
     OR has_any_column_privilege(c.oid, 'SELECT, INSERT, UPDATE, REFERENCES')
   )
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

package/dist/introspection/sql/table_relationships.sql.d.ts

@@ -1,2 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
-export declare const TABLE_RELATIONSHIPS_SQL: (props: SQLQueryPropsWithSchemaFilter) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const TABLE_RELATIONSHIPS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/types.sql.d.ts

@@ -1,5 +1,5 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const TYPES_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    includeTableTypes?: boolean;
-    includeArrayTypes?: boolean;
-}) => string;
+/**
+ * Every type of every schema, including the row types of tables and views
+ * and the array types, since a column of any schema may use them.
+ */
+export declare const TYPES_SQL = "\nselect\n  t.oid::int8 as id,\n  t.typname as name,\n  n.nspname as schema,\n  format_type (t.oid, null) as format,\n  coalesce(t_enums.enums, '[]') as enums,\n  coalesce(t_attributes.attributes, '[]') as attributes,\n  obj_description (t.oid, 'pg_type') as comment,\n  nullif(t.typrelid::int8, 0) as type_relation_id\nfrom\n  pg_type t\n  left join pg_namespace n on n.oid = t.typnamespace\n  left join (\n    select\n      enumtypid,\n      jsonb_agg(enumlabel order by enumsortorder) as enums\n    from\n      pg_enum\n    group by\n      enumtypid\n  ) as t_enums on t_enums.enumtypid = t.oid\n  left join (\n    select\n      oid,\n      jsonb_agg(\n        jsonb_build_object('name', a.attname, 'type_id', a.atttypid::int8)\n        order by a.attnum asc\n      ) as attributes\n    from\n      pg_class c\n      join pg_attribute a on a.attrelid = c.oid\n    where\n      c.relkind = 'c' and not a.attisdropped\n    group by\n      c.oid\n  ) as t_attributes on t_attributes.oid = t.typrelid\n  where\n      (\n        t.typrelid = 0\n        or (\n          select\n            c.relkind in ('c', 'r', 'v', 'm', 'p', 'f')\n          from\n            pg_class c\n          where\n            c.oid = t.typrelid\n        )\n      )\n";

package/dist/introspection/sql/types.sql.js

@@ -1,5 +1,8 @@
-import { literal } from "./pg-format.js";
-export const TYPES_SQL = (props) => /* SQL */ `
+/**
+ * Every type of every schema, including the row types of tables and views
+ * and the array types, since a column of any schema may use them.
+ */
+export const TYPES_SQL = /* SQL */ `
 select
   t.oid::int8 as id,
   t.typname as name,
@@ -41,25 +44,11 @@ from
         t.typrelid = 0
         or (
           select
-            c.relkind ${props.includeTableTypes ? `in ('c', 'r', 'v', 'm', 'p')` : `= 'c'`}
+            c.relkind in ('c', 'r', 'v', 'm', 'p', 'f')
           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/dist/introspection/sql/views.sql.d.ts

@@ -1,4 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const VIEWS_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    viewIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const VIEWS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/views.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const VIEWS_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -18,9 +17,5 @@ FROM
   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/dist/introspection/sql/views_key_dependencies.sql.d.ts

@@ -1,2 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
-export declare const VIEWS_KEY_DEPENDENCIES_SQL: (props: SQLQueryPropsWithSchemaFilter) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const VIEWS_KEY_DEPENDENCIES_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/views_key_dependencies.sql.js

@@ -1,3 +1,4 @@
+import { literal } from "./pg-format.js";
 export const VIEWS_KEY_DEPENDENCIES_SQL = (props) => /* SQL */ `
 -- Adapted from
 -- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
@@ -43,81 +44,7 @@ views as (
 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
+${nodeTreeToJson("view_definition::text")}::json as view_definition
   from views
 ),
 target_entries as(
@@ -193,3 +120,65 @@ group by sch.nspname, tbl.relname,  rep.view_schema, rep.view_name, pks_fks.conn
 -- 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)
 `;
+/**
+ * The rewrites, innermost first, that turn the `pg_node_tree` text of a view
+ * definition into JSON exposing only `targetList`, `resno`, `resorigtbl` and
+ * `resorigcol`. Ported from PostgREST's schema cache query, which keeps them
+ * as plain `replace` calls with a single `regexp_replace` for speed; the
+ * order matters, and the comments carry PostgREST's reasoning.
+ */
+const NODE_TREE_TO_JSON_REWRITES = [
+    // `<>` is pg_node_tree's null. json_typeof is too slow to special-case it,
+    // so it becomes an empty list, which also keeps the node protection below
+    // working for lists that start with null, such as coldefexprs whose first
+    // column has no default.
+    { pattern: "<>", replacement: "()" },
+    // `,`, `{` and `}` are used by the JSON conversion; drop the ones that may
+    // be part of column names (`{` and `}` are escaped there).
+    { pattern: ",", replacement: "" },
+    { pattern: "\\{", replacement: "" },
+    { pattern: "\\}", replacement: "" },
+    // Format the fields we need as JSON keys so the regex below leaves them.
+    { pattern: " :targetList ", replacement: ',"targetList":' },
+    { pattern: " :resno ", replacement: ',"resno":' },
+    { pattern: " :resorigtbl ", replacement: ',"resorigtbl":' },
+    { pattern: " :resorigcol ", replacement: ',"resorigcol":' },
+    // Make the regex also match the node type, e.g. `{QUERY ...`.
+    { pattern: "{", replacement: "{ :" },
+    // Protect node lists, which start with `({` or `((`, from the greedy regex.
+    // The extra `{` is removed again below.
+    { pattern: "((", replacement: "{((" },
+    { pattern: "({", replacement: "{({" },
+    // Remove every unused field. Removal stops at `,` for the kept fields, at
+    // `}` for the end of the node and at `{` for a nested node, leaving an empty
+    // key for the following node.
+    { pattern: " :[^}{,]+", replacement: ',"":', isRegex: true },
+    // The regex also added those empty keys before `}` and `,`.
+    { pattern: ',"":}', replacement: "}" },
+    { pattern: ',"":,', replacement: "," },
+    // Undo the node list protection.
+    { pattern: "{(", replacement: "(" },
+    // Every key was added with a leading `,`; the first key of an object does
+    // not need it.
+    { pattern: "{,", replacement: "{" },
+    // pg_node_tree lists use `( )` with space separated items; JSON uses `[ ]`
+    // with commas.
+    { pattern: "(", replacement: "[" },
+    { pattern: ")", replacement: "]" },
+    { pattern: " ", replacement: "," },
+];
+/**
+ * Render {@link NODE_TREE_TO_JSON_REWRITES} applied to `expression` as nested
+ * SQL calls: the opening calls stacked, then each rewrite's arguments on the
+ * line that closes it.
+ */
+function nodeTreeToJson(expression) {
+    const lines = NODE_TREE_TO_JSON_REWRITES.toReversed().map((rewrite) => `    ${rewrite.isRegex ? "regexp_replace" : "replace"}(`);
+    lines.push(`      ${expression},`);
+    NODE_TREE_TO_JSON_REWRITES.forEach((rewrite, index) => {
+        const flags = rewrite.isRegex ? ", 'g'" : "";
+        const closing = index === NODE_TREE_TO_JSON_REWRITES.length - 1 ? ")" : "),";
+        lines.push(`      ${literal(rewrite.pattern)}, ${literal(rewrite.replacement)}${flags}${closing}`);
+    });
+    return lines.join("\n");
+}