@supabase/postgrest-typegen 0.2.2 → 0.2.3

package/README.md

@@ -17,19 +17,19 @@ JSON output, not inside `postgrest-typegen`.
 
 The TypeScript, Go, Python, and Swift generators bundled here are a
 **deliberate transition**, not the target architecture for new languages.
-They were ported byte-parity from postgres-meta's own templates so
-`supabase gen types` keeps working unchanged while postgres-meta's copies get
-deprecated in favor of this package. It's decided that all four eventually
-move out to their own SDK repos too (tracked in SDK-1641), not yet scheduled
-— sequenced after postgres-meta's cutover to this package settles.
+They were ported byte-for-byte from postgres-meta's own templates so
+`supabase gen types` kept working unchanged; postgres-meta has since deleted
+its copies and consumes this package instead. It's decided that all four
+eventually move out to their own SDK repos too (tracked in SDK-1641), not yet
+scheduled — sequenced after postgres-meta's cutover to this package settles.
 
 > [!IMPORTANT]
 > **We are no longer accepting contributions that fix the bundled generators.**
 > Because each of the four is moving out to its own language's SDK repository,
 > a fix landed here would have to be made a second time in the destination
-> repository, and it also breaks byte parity with postgres-meta until a release
-> propagates. Please open an issue describing the bug instead, so it can be
-> tracked and carried across the move.
+> repository, and postgres-meta and the CLI only pick it up once they bump
+> their pinned version of this package. Please open an issue describing the
+> bug instead, so it can be tracked and carried across the move.
 
 ## Design
 

package/dist/generation/python.js

@@ -53,7 +53,7 @@ class PythonContext {
     schemas;
     constructor(types, columns, schemas) {
         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] ??= [];
             acc[curr.table_id].push(curr);
@@ -61,30 +61,35 @@ 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) {
-        if (name in this.user_enums) {
-            return this.user_enums[name].name;
+    resolveTypeName(name, typeSchema) {
+        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) {
+    // Array types live in the schema of their element type, so `typeSchema`
+    // carries over to the element.
+    parsePgType(pg_type, typeSchema) {
         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);
         }
     }
@@ -98,7 +103,7 @@ class PythonContext {
             };
         });
         const attributeEntries = 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);
@@ -109,14 +114,14 @@ class PythonContext {
     columnsToClassAttrs(table_id) {
         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);
         });
     }
     columnsToDictAttrs(table_id, not_required) {
         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, col.is_nullable, not_required ||
                 col.is_nullable ||
                 col.is_identity ||
@@ -139,6 +144,7 @@ class PythonContext {
         return new PythonBaseModel(matview.name, this.schemas[matview.schema], attributes);
     }
 }
+const qualifiedTypeName = (schema, name) => `${schema}.${name}`;
 class PythonEnum {
     name;
     variants;

package/dist/sort.js

@@ -4,10 +4,25 @@ import { compareStrings } from "./collation.js";
 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`.
+// 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) ||
-    compareStrings(JSON.stringify(a.referenced_columns), JSON.stringify(b.referenced_columns));
+    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).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -72,8 +72,8 @@
     "@types/node": "^26.3.0",
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
-    "oxlint": "1.81.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/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/sort.ts

@@ -38,17 +38,31 @@ const bySchemaName = (
   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 =>
   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),
-  );
+  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