@supabase/postgrest-typegen 0.2.0 → 0.2.2

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";
 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/helpers.d.ts

@@ -6,7 +6,7 @@ export declare const DEFAULT_SYSTEM_SCHEMAS: string[];
 /**
  * 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
+ * with the inlined pg-format `literal`. Returns an empty string when there is nothing to
  * filter, so callers interpolate it conditionally.
  */
 export declare const filterByList: (include?: (string | number)[], exclude?: (string | number)[], defaultExclude?: (string | number)[]) => string;

package/dist/introspection/sql/helpers.js

@@ -1,4 +1,4 @@
-import { literal } from "pg-format";
+import { literal } from "./pg-format.js";
 /**
  * Schemas that postgres-meta excludes by default when `includeSystemSchemas`
  * is false. Ported from `postgres-meta/src/lib/constants.ts`.
@@ -11,7 +11,7 @@ export const DEFAULT_SYSTEM_SCHEMAS = [
 /**
  * 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
+ * with the inlined pg-format `literal`. Returns an empty string when there is nothing to
  * filter, so callers interpolate it conditionally.
  */
 export const filterByList = (include, exclude, defaultExclude) => {

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";
 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/pg-format.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Minimal inline port of the `pg-format` helpers this package uses, so the
+ * package carries no runtime dependency for them (the CommonJS-only
+ * `pg-format` package is awkward to consume from ESM/bundled CLIs).
+ *
+ * Mirrors `pg-format@1.0.4` byte-for-byte for the inputs postgres-meta feeds
+ * it — in particular numbers are quoted (`literal(10)` is `'10'`), because
+ * that is what postgres-meta's SQL emits and this package is byte-parity
+ * constrained against it. The `supabase/supabase` `packages/pg-meta` port
+ * deliberately diverges here (unquoted numbers); do not "fix" this to match it.
+ *
+ * Originally ported from PostgreSQL's `src/interfaces/libpq/fe-exec.c`.
+ */
+/**
+ * Quote a value as a SQL literal. `null`/`undefined` become `NULL`, booleans
+ * `'t'`/`'f'`, dates ISO 8601 strings, arrays comma-separated lists (nested
+ * arrays become parenthesised groups), plain objects `'…'::jsonb`, and
+ * everything else — including numbers — a single-quoted string with embedded
+ * quotes doubled. Strings containing a backslash use the `E'…'` form.
+ */
+export declare function literal(value?: unknown): string;

package/dist/introspection/sql/pg-format.js

@@ -0,0 +1,92 @@
+/**
+ * Minimal inline port of the `pg-format` helpers this package uses, so the
+ * package carries no runtime dependency for them (the CommonJS-only
+ * `pg-format` package is awkward to consume from ESM/bundled CLIs).
+ *
+ * Mirrors `pg-format@1.0.4` byte-for-byte for the inputs postgres-meta feeds
+ * it — in particular numbers are quoted (`literal(10)` is `'10'`), because
+ * that is what postgres-meta's SQL emits and this package is byte-parity
+ * constrained against it. The `supabase/supabase` `packages/pg-meta` port
+ * deliberately diverges here (unquoted numbers); do not "fix" this to match it.
+ *
+ * Originally ported from PostgreSQL's `src/interfaces/libpq/fe-exec.c`.
+ */
+/** Convert a JS ISO string to Postgres' default ISO 8601 form. */
+function formatDate(date) {
+    return date.replace("T", " ").replace("Z", "+00");
+}
+function arrayToList(useSpace, array, formatter) {
+    let sql = useSpace ? " (" : "(";
+    for (const [index, element] of array.entries()) {
+        sql += (index === 0 ? "" : ", ") + formatter(element);
+    }
+    sql += ")";
+    return sql;
+}
+/**
+ * Quote a value as a SQL literal. `null`/`undefined` become `NULL`, booleans
+ * `'t'`/`'f'`, dates ISO 8601 strings, arrays comma-separated lists (nested
+ * arrays become parenthesised groups), plain objects `'…'::jsonb`, and
+ * everything else — including numbers — a single-quoted string with embedded
+ * quotes doubled. Strings containing a backslash use the `E'…'` form.
+ */
+export function literal(value) {
+    let text;
+    let explicitCast;
+    if (value === undefined || value === null) {
+        return "NULL";
+    }
+    if (value === false) {
+        return "'f'";
+    }
+    if (value === true) {
+        return "'t'";
+    }
+    if (value instanceof Date) {
+        return `'${formatDate(value.toISOString())}'`;
+    }
+    if (Array.isArray(value)) {
+        const parts = [];
+        for (const [index, element] of value.entries()) {
+            if (Array.isArray(element)) {
+                parts.push(arrayToList(index !== 0, element, literal));
+            }
+            else {
+                parts.push(literal(element));
+            }
+        }
+        return parts.toString();
+    }
+    if (typeof value === "string") {
+        text = value;
+    }
+    else if (typeof value === "number" || typeof value === "bigint") {
+        text = value.toString();
+    }
+    else {
+        explicitCast = "jsonb";
+        text = JSON.stringify(value);
+    }
+    let hasBackslash = false;
+    let quoted = "'";
+    for (const c of text) {
+        if (c === "'") {
+            quoted += c + c;
+        }
+        else if (c === "\\") {
+            quoted += c + c;
+            hasBackslash = true;
+        }
+        else {
+            quoted += c;
+        }
+    }
+    quoted += "'";
+    if (hasBackslash) {
+        quoted = `E${quoted}`;
+    }
+    if (explicitCast) {
+        quoted += `::${explicitCast}`;
+    }
+    return quoted;
+}

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";
 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";
 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";
 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";
-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";
 export const VIEWS_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -6,15 +5,17 @@ SELECT
   c.relname AS name,
   -- See definition of information_schema.views
   (pg_relation_is_updatable(c.oid, false) & 20) = 20 AS is_updatable,
+  -- Passing include_triggers => true also counts views made writable by
+  -- INSTEAD OF triggers (and INSTEAD rules), which PostgREST can write
+  -- through even when the view is not auto-updatable. Bit 8 is INSERT,
+  -- bit 4 is UPDATE (see information_schema.views).
+  (pg_relation_is_updatable(c.oid, true) & 8) = 8 AS is_insert_enabled,
+  (pg_relation_is_updatable(c.oid, true) & 4) = 4 AS is_update_enabled,
   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/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");
+}

package/dist/sort.js

@@ -1,12 +1,13 @@
+import { compareStrings } from "./collation.js";
 // Relations (tables/views/materialized views/foreign tables) and types share a
 // (schema, name) identity within a database; `id` breaks any residual tie.
-const bySchemaName = (a, b) => a.schema.localeCompare(b.schema) ||
-    a.name.localeCompare(b.name) ||
+const bySchemaName = (a, b) => compareStrings(a.schema, b.schema) ||
+    compareStrings(a.name, b.name) ||
     a.id - b.id;
 // Mirrors the TypeScript generator's historical `relationships.sort`.
-const byRelationship = (a, b) => a.foreign_key_name.localeCompare(b.foreign_key_name) ||
-    a.referenced_relation.localeCompare(b.referenced_relation) ||
-    JSON.stringify(a.referenced_columns).localeCompare(JSON.stringify(b.referenced_columns));
+const byRelationship = (a, b) => compareStrings(a.foreign_key_name, b.foreign_key_name) ||
+    compareStrings(a.referenced_relation, b.referenced_relation) ||
+    compareStrings(JSON.stringify(a.referenced_columns), JSON.stringify(b.referenced_columns));
 /**
  * Return a new {@link GeneratorMetadata} with every collection ordered by a
  * stable, total, semantic key (matching the TypeScript generator's ordering).
@@ -16,32 +17,32 @@ const byRelationship = (a, b) => a.foreign_key_name.localeCompare(b.foreign_key_
 export function sortGeneratorMetadata(metadata) {
     return {
         version: metadata.version,
-        schemas: [...metadata.schemas].sort((a, b) => a.name.localeCompare(b.name) || a.id - b.id),
+        schemas: [...metadata.schemas].sort((a, b) => compareStrings(a.name, b.name) || a.id - b.id),
         tables: [...metadata.tables].sort(bySchemaName),
         foreignTables: [...metadata.foreignTables].sort(bySchemaName),
         views: [...metadata.views].sort(bySchemaName),
         materializedViews: [...metadata.materializedViews].sort(bySchemaName),
         // Group columns by their table's (schema, name); name-order within a table
         // (matches the TypeScript generator's per-table `columns.sort(by name)`).
-        columns: [...metadata.columns].sort((a, b) => a.schema.localeCompare(b.schema) ||
-            a.table.localeCompare(b.table) ||
-            a.name.localeCompare(b.name)),
+        columns: [...metadata.columns].sort((a, b) => compareStrings(a.schema, b.schema) ||
+            compareStrings(a.table, b.table) ||
+            compareStrings(a.name, b.name)),
         // Grouped by table like `columns`; within a table the SQL's declared
         // column order (`array_position(indkey, attnum)`) is preserved by the
         // stable sort, since composite key order is meaningful.
-        primaryKeys: [...metadata.primaryKeys].sort((a, b) => a.schema.localeCompare(b.schema) ||
-            a.table_name.localeCompare(b.table_name)),
+        primaryKeys: [...metadata.primaryKeys].sort((a, b) => compareStrings(a.schema, b.schema) ||
+            compareStrings(a.table_name, b.table_name)),
         relationships: [...metadata.relationships].sort(byRelationship),
         // Functions can overload, so the signature is part of the identity. Args
         // are addressed by name in generated RPC types, so sort them by name too.
         functions: [...metadata.functions]
-            .sort((a, b) => a.schema.localeCompare(b.schema) ||
-            a.name.localeCompare(b.name) ||
-            a.identity_argument_types.localeCompare(b.identity_argument_types) ||
+            .sort((a, b) => compareStrings(a.schema, b.schema) ||
+            compareStrings(a.name, b.name) ||
+            compareStrings(a.identity_argument_types, b.identity_argument_types) ||
             a.id - b.id)
             .map((fn) => ({
             ...fn,
-            args: [...fn.args].sort((a, b) => a.name.localeCompare(b.name)),
+            args: [...fn.args].sort((a, b) => compareStrings(a.name, b.name)),
         })),
         types: [...metadata.types].sort(bySchemaName),
     };

package/dist/types.d.ts

@@ -182,6 +182,8 @@ declare const postgresViewSchema: import("arktype/internal/variants/object.ts").
     schema: string;
     name: string;
     is_updatable: boolean;
+    is_insert_enabled?: boolean | undefined;
+    is_update_enabled?: boolean | undefined;
     comment: string | null;
     columns?: {
         table_id: number;
@@ -250,7 +252,9 @@ export declare const generatorMetadataSchema: import("arktype/internal/variants/
     views: {
         comment: string | null;
         id: number;
+        is_insert_enabled?: boolean | undefined;
         is_updatable: boolean;
+        is_update_enabled?: boolean | undefined;
         name: string;
         schema: string;
     }[];