@supabase/postgrest-typegen 0.2.1 → 0.2.3

package/dist/sort.js

@@ -1,12 +1,28 @@
+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));
+// Column lists compare as their JSON text, matching the TypeScript generator's
+// historical `relationships.sort`.
+const compareColumns = (a, b) => 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, b) => 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
  * stable, total, semantic key (matching the TypeScript generator's ordering).
@@ -16,32 +32,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.3",
   "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,8 +72,8 @@
     "@types/node": "^26.3.0",
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
-    "oxlint": "1.80.0",
-    "oxlint-tsgolint": "7.0.2001",
+    "oxlint": "1.83.0",
+    "oxlint-tsgolint": "7.0.2002",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",
     "typescript": "7.0.2"

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,

package/src/generation/python.ts

@@ -88,7 +88,9 @@ class PythonContext {
     this.schemas = Object.fromEntries(
       schemas.map((schema) => [schema.name, schema]),
     );
-    this.types = Object.fromEntries(types.map((type) => [type.name, type]));
+    this.types = Object.fromEntries(
+      types.map((type) => [qualifiedTypeName(type.schema, type.name), type]),
+    );
     this.columns = columns.reduce(
       (acc, curr) => {
         acc[curr.table_id] ??= [];
@@ -100,32 +102,37 @@ class PythonContext {
     this.user_enums = Object.fromEntries(
       types
         .filter((type) => type.enums.length > 0)
-        .map((type) => [type.name, new PythonEnum(type)]),
+        .map((type) => [
+          qualifiedTypeName(type.schema, type.name),
+          new PythonEnum(type),
+        ]),
     );
   }
 
-  resolveTypeName(name: string): string {
-    if (name in this.user_enums) {
-      return this.user_enums[name].name;
+  resolveTypeName(name: string, typeSchema: string): string {
+    const qualified = qualifiedTypeName(typeSchema, name);
+    if (qualified in this.user_enums) {
+      return this.user_enums[qualified].name;
     }
     if (name in PY_TYPE_MAP) {
       return PY_TYPE_MAP[name];
     }
-    if (name in this.types) {
-      const type = this.types[name];
-      const schema = type!.schema;
-      return `${formatForPyClassName(schema)}${formatForPyClassName(type.name)}`;
+    if (qualified in this.types) {
+      const type = this.types[qualified];
+      return `${formatForPyClassName(type.schema)}${formatForPyClassName(type.name)}`;
     }
     return "Any";
   }
 
-  parsePgType(pg_type: string): PythonType {
+  // Array types live in the schema of their element type, so `typeSchema`
+  // carries over to the element.
+  parsePgType(pg_type: string, typeSchema: string): PythonType {
     if (pg_type.startsWith("_")) {
       const inner_str = pg_type.slice(1);
-      const inner = this.parsePgType(inner_str);
+      const inner = this.parsePgType(inner_str, typeSchema);
       return new PythonListType(inner);
     } else {
-      const type_name = this.resolveTypeName(pg_type);
+      const type_name = this.resolveTypeName(pg_type, typeSchema);
       return new PythonSimpleType(type_name);
     }
   }
@@ -141,7 +148,10 @@ class PythonContext {
     });
     const attributeEntries: PythonBaseModelAttr[] = attributes.map(
       (attribute) => {
-        const type = this.parsePgType(attribute.type!.name);
+        const type = this.parsePgType(
+          attribute.type!.name,
+          attribute.type!.schema,
+        );
         // Composite type attributes cannot carry NOT NULL constraints in
         // Postgres, so every field is inherently nullable.
         return new PythonBaseModelAttr(attribute.name, type, true);
@@ -155,7 +165,7 @@ class PythonContext {
   columnsToClassAttrs(table_id: number): PythonBaseModelAttr[] {
     const attrs = this.columns[table_id] ?? [];
     return attrs.map((col) => {
-      const type = this.parsePgType(col.format);
+      const type = this.parsePgType(col.format, col.type_schema);
       return new PythonBaseModelAttr(col.name, type, col.is_nullable);
     });
   }
@@ -166,7 +176,7 @@ class PythonContext {
   ): PythonTypedDictAttr[] {
     const attrs = this.columns[table_id] ?? [];
     return attrs.map((col) => {
-      const type = this.parsePgType(col.format);
+      const type = this.parsePgType(col.format, col.type_schema);
       return new PythonTypedDictAttr(
         col.name,
         type,
@@ -222,6 +232,9 @@ class PythonContext {
   }
 }
 
+const qualifiedTypeName = (schema: string, name: string): string =>
+  `${schema}.${name}`;
+
 class PythonEnum implements Serializable {
   name: string;
   variants: string[];

package/src/generation/swift.ts

@@ -7,6 +7,7 @@ import type {
   PostgresType,
   PostgresView,
 } from "../types.ts";
+import { compareStrings } from "../collation.ts";
 
 type Operation = "Select" | "Insert" | "Update";
 export type AccessControl = "internal" | "public" | "private" | "package";
@@ -313,11 +314,11 @@ export const generateSwift = (
     ...schemas.flatMap((schema) => {
       const schemaTables = [...tables, ...foreignTables]
         .filter((table) => table.schema === schema.name)
-        .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+        .sort(({ name: a }, { name: b }) => compareStrings(a, b));
 
       const schemaViews = [...views, ...materializedViews]
         .filter((table) => table.schema === schema.name)
-        .sort(({ name: a }, { name: b }) => a.localeCompare(b));
+        .sort(({ name: a }, { name: b }) => compareStrings(a, b));
 
       const schemaEnums = types.filter(
         (type) => type.schema === schema.name && type.enums.length > 0,
@@ -424,6 +425,12 @@ const pgTypeToSwiftType = (
     swiftType = "String";
   } else if (["json", "jsonb"].includes(pgType)) {
     swiftType = "AnyJSON";
+    // `void` and `record` are pseudo-types: Postgres rejects them as a column or
+    // composite attribute type ("column has pseudo-type void"), and this
+    // generator only renders columns and attributes, never functions. So these
+    // two arms are unreachable today and deliberately untested. They are kept
+    // because they are the mappings to use if Swift ever emits functions, which
+    // is where these types do appear.
   } else if (pgType === "void") {
     swiftType = "Void";
   } else if (pgType === "record") {