@supabase/postgrest-typegen 0.2.1 → 0.2.2

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");
+}

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

package/dist/types.js

@@ -139,12 +139,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(),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "arktype": "2.2.3",
-    "oxfmt": "0.65.0"
+    "oxfmt": "0.66.0"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -72,7 +72,7 @@
     "@types/node": "^26.3.0",
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
-    "oxlint": "1.80.0",
+    "oxlint": "1.81.0",
     "oxlint-tsgolint": "7.0.2001",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",

package/src/collation.ts

@@ -0,0 +1,16 @@
+/**
+ * The one string comparison every ordering in this package uses.
+ *
+ * Generated output is ordered by name, and `String.prototype.localeCompare`
+ * without a locale follows the host's default locale, so the same database
+ * produced differently ordered code on differently configured machines (a
+ * Swedish host sorts `ä` after `z`, an English one next to `a`). Pinning the
+ * collator to English keeps the order postgres-meta's output has on the
+ * English CI runners and makes it the same everywhere else.
+ */
+const collator = new Intl.Collator("en");
+
+/** Compare two strings with the pinned English collation. */
+export function compareStrings(a: string, b: string): number {
+  return collator.compare(a, b);
+}

package/src/generation/index.ts

@@ -5,6 +5,7 @@ export {
   generateTypescript,
   type GenerateTypescriptOptions,
   pgTypeToTsType,
+  type TypeResolutionContext,
 } from "./typescript.ts";
 export {
   type AccessControl,