@supabase/postgrest-typegen 0.2.1 → 0.2.3

package/src/introspection/sql/common.ts

@@ -1,18 +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/src/introspection/sql/foreign_tables.sql.ts

@@ -1,13 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryProps } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const FOREIGN_TABLES_SQL = (
-  props: SQLQueryProps & {
-    schemaFilter?: string;
-    idsFilter?: string;
-    tableIdentifierFilter?: string;
-  },
-) => /* SQL */ `
+export const FOREIGN_TABLES_SQL = (props: SchemaFilterProps) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
   n.nspname AS schema,
@@ -18,9 +11,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/src/introspection/sql/functions.sql.ts

@@ -1,15 +1,6 @@
-// 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.ts";
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const FUNCTIONS_SQL = (
-  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    nameFilter?: string;
-    args?: string[];
-  },
-) => /* SQL */ `
+export const FUNCTIONS_SQL = (props: SchemaFilterProps) => /* 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.
@@ -36,37 +27,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
@@ -154,6 +114,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/src/introspection/sql/materialized_views.sql.ts

@@ -1,11 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const MATERIALIZED_VIEWS_SQL = (
-  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    materializedViewIdentifierFilter?: string;
-  },
-) => /* SQL */ `
+export const MATERIALIZED_VIEWS_SQL = (props: SchemaFilterProps) => /* SQL */ `
 select
   c.oid::int8 as id,
   n.nspname as schema,
@@ -17,9 +12,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/src/introspection/sql/primary_keys.sql.ts

@@ -1,11 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const PRIMARY_KEYS_SQL = (
-  props: SQLQueryPropsWithSchemaFilter & {
-    tableIdentifierFilter?: string;
-  },
-) => /* SQL */ `
+export const PRIMARY_KEYS_SQL = (props: SchemaFilterProps) => /* SQL */ `
 SELECT
   c.oid :: int8 AS table_id,
   n.nspname AS schema,
@@ -18,7 +13,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)
@@ -33,6 +27,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/src/introspection/sql/schemas.sql.ts

@@ -1,13 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryProps } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const SCHEMAS_SQL = (
-  props: SQLQueryProps & {
-    nameFilter?: string;
-    idsFilter?: string;
-    includeSystemSchemas?: boolean;
-  },
-) => /* SQL */ `
+export const SCHEMAS_SQL = (props: SchemaFilterProps) => /* SQL */ `
 -- Adapted from information_schema.schemata
 select
   n.oid::int8 as id,
@@ -18,15 +11,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/src/introspection/sql/table.sql.ts

@@ -1,11 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const TABLES_SQL = (
-  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    tableIdentifierFilter?: string;
-  },
-) => /* SQL */ `
+export const TABLES_SQL = (props: SchemaFilterProps) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
   nc.nspname AS schema,
@@ -30,8 +25,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 (
@@ -42,6 +35,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/src/introspection/sql/table_relationships.sql.ts

@@ -1,8 +1,6 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const TABLE_RELATIONSHIPS_SQL = (
-  props: SQLQueryPropsWithSchemaFilter,
-) => /* SQL */ `
+export const TABLE_RELATIONSHIPS_SQL = (props: SchemaFilterProps) => /* SQL */ `
 -- Adapted from
 -- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L722
 WITH

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

@@ -1,12 +1,8 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-
-export const TYPES_SQL = (
-  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    includeTableTypes?: boolean;
-    includeArrayTypes?: boolean;
-  },
-) => /* 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,
@@ -48,27 +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/src/introspection/sql/views.sql.ts

@@ -1,11 +1,6 @@
-import { literal } from "./pg-format.ts";
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
 
-export const VIEWS_SQL = (
-  props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    viewIdentifierFilter?: string;
-  },
-) => /* SQL */ `
+export const VIEWS_SQL = (props: SchemaFilterProps) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
   n.nspname AS schema,
@@ -24,9 +19,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/src/introspection/sql/views_key_dependencies.sql.ts

@@ -1,7 +1,8 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
+import type { SchemaFilterProps } from "./common.ts";
+import { literal } from "./pg-format.ts";
 
 export const VIEWS_KEY_DEPENDENCIES_SQL = (
-  props: SQLQueryPropsWithSchemaFilter,
+  props: SchemaFilterProps,
 ) => /* SQL */ `
 -- Adapted from
 -- https://github.com/PostgREST/postgrest/blob/f9f0f79fa914ac00c11fbf7f4c558e14821e67e2/src/PostgREST/SchemaCache.hs#L820
@@ -47,81 +48,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(
@@ -197,3 +124,82 @@ 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)
 `;
+
+/**
+ * One text rewrite of the `pg_node_tree` to JSON conversion: a `replace`, or
+ * a global `regexp_replace` when `isRegex` is set.
+ */
+type NodeTreeRewrite = {
+  pattern: string;
+  replacement: string;
+  isRegex?: boolean;
+};
+
+/**
+ * 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: readonly NodeTreeRewrite[] = [
+  // `<>` 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: string): string {
+  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/src/sort.ts

@@ -26,6 +26,7 @@
  * addressed by name (the generated type is an object), matching TypeScript.
  */
 import type { GeneratorMetadata, PostgresRelationship } from "./types.ts";
+import { compareStrings } from "./collation.ts";
 
 // Relations (tables/views/materialized views/foreign tables) and types share a
 // (schema, name) identity within a database; `id` breaks any residual tie.
@@ -33,20 +34,35 @@ const bySchemaName = (
   a: { schema: string; name: string; id: number },
   b: { schema: string; name: string; id: number },
 ): number =>
-  a.schema.localeCompare(b.schema) ||
-  a.name.localeCompare(b.name) ||
+  compareStrings(a.schema, b.schema) ||
+  compareStrings(a.name, b.name) ||
   a.id - b.id;
 
-// Mirrors the TypeScript generator's historical `relationships.sort`.
+// Column lists compare as their JSON text, matching the TypeScript generator's
+// historical `relationships.sort`.
+const compareColumns = (a: string[], b: string[]): number =>
+  compareStrings(JSON.stringify(a), JSON.stringify(b));
+
+// The first three keys mirror the TypeScript generator's historical
+// `relationships.sort`. They are not total: `expandViewRelationships` in
+// `introspection/relationships.ts` copies one foreign key onto every view
+// exposing it, on either side, and onto every combination of view columns
+// carrying it. View-to-table copies share the referenced side and differ in
+// `schema`, `relation` and `columns`; table-to-view copies onto same-named
+// views in different schemas differ only in `referenced_schema`. The remaining
+// keys order those copies, since the view key dependency query does not order
+// the view columns it aggregates.
 const byRelationship = (
   a: PostgresRelationship,
   b: PostgresRelationship,
 ): number =>
-  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),
-  );
+  compareStrings(a.foreign_key_name, b.foreign_key_name) ||
+  compareStrings(a.referenced_relation, b.referenced_relation) ||
+  compareColumns(a.referenced_columns, b.referenced_columns) ||
+  compareStrings(a.referenced_schema, b.referenced_schema) ||
+  compareStrings(a.schema, b.schema) ||
+  compareStrings(a.relation, b.relation) ||
+  compareColumns(a.columns, b.columns);
 
 /**
  * Return a new {@link GeneratorMetadata} with every collection ordered by a
@@ -60,7 +76,7 @@ export function sortGeneratorMetadata(
   return {
     version: metadata.version,
     schemas: [...metadata.schemas].sort(
-      (a, b) => a.name.localeCompare(b.name) || a.id - b.id,
+      (a, b) => compareStrings(a.name, b.name) || a.id - b.id,
     ),
     tables: [...metadata.tables].sort(bySchemaName),
     foreignTables: [...metadata.foreignTables].sort(bySchemaName),
@@ -70,17 +86,17 @@ export function sortGeneratorMetadata(
     // (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),
+        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),
+        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
@@ -88,14 +104,17 @@ export function sortGeneratorMetadata(
     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) ||
+          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/src/types.ts

@@ -159,12 +159,14 @@ const postgresViewSchema = type({
   /**
    * Whether INSERT works through this view: auto-updatable per
    * `pg_relation_is_updatable`, or made insertable by an INSTEAD OF INSERT
-   * trigger. Tracked separately from `is_updatable` (which mirrors
-   * `information_schema.views` and ignores triggers).
+   * trigger or an unconditional INSTEAD rule. Tracked separately from
+   * `is_updatable` (which mirrors `information_schema.views` and ignores
+   * triggers). Optional because version 1 metadata predating this field is
+   * still valid; consumers fall back to `is_updatable` when absent.
    */
-  is_insert_enabled: "boolean",
+  "is_insert_enabled?": "boolean",
   /** Same as `is_insert_enabled`, for UPDATE. */
-  is_update_enabled: "boolean",
+  "is_update_enabled?": "boolean",
   comment: "string | null",
   "columns?": postgresColumnSchema.array(),
 });