@supabase/postgrest-typegen 0.2.1 → 0.2.3

package/README.md

@@ -17,11 +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 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/collation.d.ts

@@ -0,0 +1,2 @@
+/** Compare two strings with the pinned English collation. */
+export declare function compareStrings(a: string, b: string): number;

package/dist/collation.js

@@ -0,0 +1,15 @@
+/**
+ * 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, b) {
+    return collator.compare(a, b);
+}

package/dist/generation/index.d.ts

@@ -1,5 +1,5 @@
 export { sortGeneratorMetadata } from "../sort.ts";
 export { generateGo } from "./go.ts";
 export { generatePython } from "./python.ts";
-export { generateTypescript, type GenerateTypescriptOptions, pgTypeToTsType, } from "./typescript.ts";
+export { generateTypescript, type GenerateTypescriptOptions, pgTypeToTsType, type TypeResolutionContext, } from "./typescript.ts";
 export { type AccessControl, generateSwift, type GenerateSwiftOptions, } from "./swift.ts";

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/generation/swift.js

@@ -1,3 +1,4 @@
+import { compareStrings } from "../collation.js";
 function formatForSwiftSchemaName(schema) {
     return `${formatForSwiftTypeName(schema)}Schema`;
 }
@@ -186,10 +187,10 @@ export const generateSwift = (metadata, opts = {}) => {
         ...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);
             const schemaCompositeTypes = types.filter((type) => type.schema === schema.name && type.attributes.length > 0);
             return [
@@ -262,6 +263,12 @@ const pgTypeToSwiftType = (pgType, nullable, { types, views, tables, }) => {
     }
     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";

package/dist/generation/typescript.d.ts

@@ -1,4 +1,4 @@
-import type { GeneratorMetadata, PostgresSchema, PostgresTable, PostgresType, PostgresView } from "../types.ts";
+import type { GeneratorMetadata, PostgresForeignTable, PostgresMaterializedView, PostgresSchema, PostgresTable, PostgresType, PostgresView } from "../types.ts";
 export interface GenerateTypescriptOptions {
     /**
      * Emit `isOneToOne` on each relationship entry. Mirrors postgres-meta's
@@ -24,6 +24,22 @@ export interface GenerateTypescriptOptions {
      */
     format?: (code: string) => Promise<string>;
 }
+/**
+ * Collections `pgTypeToTsType` resolves a relation-typed value against.
+ *
+ * Foreign tables are generated under `Tables` and materialized views under
+ * `Views`, exactly like their plain counterparts, so a value typed as one has
+ * a `Row` to point at and belongs here. Both are optional so the exported
+ * `pgTypeToTsType` signature stays backwards compatible.
+ */
+export type TypeResolutionContext = {
+    types: PostgresType[];
+    schemas: PostgresSchema[];
+    tables: PostgresTable[];
+    views: PostgresView[];
+    foreignTables?: PostgresForeignTable[];
+    materializedViews?: PostgresMaterializedView[];
+};
 /**
  * Does not re-sort collections; pass input pre-sorted with
  * `sortGeneratorMetadata` first. Still merge-sorts tables+foreign tables and
@@ -31,9 +47,4 @@ export interface GenerateTypescriptOptions {
  * can't be expressed by the single-collection `sortGeneratorMetadata` pass.
  */
 export declare const generateTypescript: (metadata: GeneratorMetadata, opts?: GenerateTypescriptOptions) => Promise<string>;
-export declare const pgTypeToTsType: (schema: PostgresSchema, pgType: string, { types, schemas, tables, views, }: {
-    types: PostgresType[];
-    schemas: PostgresSchema[];
-    tables: PostgresTable[];
-    views: PostgresView[];
-}, typeSchema?: string) => string;
+export declare const pgTypeToTsType: (schema: PostgresSchema, pgType: string, context: TypeResolutionContext, typeSchema?: string) => string;

package/dist/generation/typescript.js

@@ -5,6 +5,7 @@
 // disable comment would corrupt the emitted string.
 import { format as oxfmtFormat } from "oxfmt";
 import { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./constants.js";
+import { compareStrings } from "../collation.js";
 const defaultFormat = async (code) => {
     const { code: formatted, errors } = await oxfmtFormat("output.ts", code, {
         semi: false,
@@ -26,6 +27,16 @@ const defaultFormat = async (code) => {
 export const generateTypescript = async (metadata, opts = {}) => {
     const { schemas, tables, foreignTables, views, materializedViews, columns, relationships, functions, types, } = metadata;
     const { detectOneToOneRelationships = false, postgrestVersion, defaultSchema = "public", format = defaultFormat, } = opts;
+    // Every relation-typed value resolves against the same collections, so build
+    // the lookup context once rather than reassembling it at each call site.
+    const typeContext = {
+        types,
+        schemas,
+        tables,
+        views,
+        foreignTables,
+        materializedViews,
+    };
     // Ordering of all collections (incl. relationships, columns, args below) is
     // provided by `sortGeneratorMetadata`; this generator no longer re-sorts.
     const introspectionBySchema = Object.fromEntries(schemas.map((s) => [
@@ -178,11 +189,11 @@ export const generateTypescript = async (metadata, opts = {}) => {
     // views — so the cross-collection name sort can't be expressed by the
     // single-collection `sortGeneratorMetadata` pass and stays here.
     for (const schema in introspectionBySchema) {
-        introspectionBySchema[schema].tables.sort((a, b) => a.table.name.localeCompare(b.table.name));
-        introspectionBySchema[schema].views.sort((a, b) => a.view.name.localeCompare(b.view.name));
-        introspectionBySchema[schema].functions.sort((a, b) => a.fn.name.localeCompare(b.fn.name));
-        introspectionBySchema[schema].enums.sort((a, b) => a.name.localeCompare(b.name));
-        introspectionBySchema[schema].compositeTypes.sort((a, b) => a.name.localeCompare(b.name));
+        introspectionBySchema[schema].tables.sort((a, b) => compareStrings(a.table.name, b.table.name));
+        introspectionBySchema[schema].views.sort((a, b) => compareStrings(a.view.name, b.view.name));
+        introspectionBySchema[schema].functions.sort((a, b) => compareStrings(a.fn.name, b.fn.name));
+        introspectionBySchema[schema].enums.sort((a, b) => compareStrings(a.name, b.name));
+        introspectionBySchema[schema].compositeTypes.sort((a, b) => compareStrings(a.name, b.name));
     }
     const getFunctionTsReturnType = (fn, returnType) => {
         // Determine if this function should have SetofOptions
@@ -244,12 +255,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
                 const type = typesById.get(type_id);
                 let tsType = "unknown";
                 if (type) {
-                    tsType = pgTypeToTsType(schema, type.name, {
-                        types,
-                        schemas,
-                        tables,
-                        views,
-                    });
+                    tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
                 }
                 return { name, type: tsType };
             });
@@ -269,24 +275,14 @@ export const generateTypescript = async (metadata, opts = {}) => {
                 type_schema: column.type_schema,
                 is_nullable: column.is_nullable,
                 is_optional: false,
-            }, {
-                types,
-                schemas,
-                tables,
-                views,
-            }))
+            }, typeContext))
                 .join(",\n")}
             }`;
         }
         // Case 3: returns base/array/composite/enum type.
         const type = typesById.get(fn.return_type_id);
         if (type) {
-            return pgTypeToTsType(schema, type.name, {
-                types,
-                schemas,
-                tables,
-                views,
-            });
+            return pgTypeToTsType(schema, type.name, typeContext, type.schema);
         }
         return "unknown";
     };
@@ -369,12 +365,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
                         const type = typesById.get(type_id);
                         let tsType = "unknown";
                         if (type) {
-                            tsType = pgTypeToTsType(schema, type.name, {
-                                types,
-                                schemas,
-                                tables,
-                                views,
-                            });
+                            tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
                         }
                         return { name, type: tsType, has_default };
                     });
@@ -389,12 +380,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
                         const type = typesById.get(type_id);
                         let tsType = "unknown";
                         if (type) {
-                            tsType = pgTypeToTsType(schema, type.name, {
-                                types,
-                                schemas,
-                                tables,
-                                views,
-                            });
+                            tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
                         }
                         return { name, type: tsType, has_default };
                     });
@@ -407,12 +393,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
                     const type = typesById.get(type_id);
                     let tsType = "unknown";
                     if (type) {
-                        tsType = pgTypeToTsType(schema, type.name, {
-                            types,
-                            schemas,
-                            tables,
-                            views,
-                        });
+                        tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
                     }
                     return { name, type: tsType, has_default };
                 });
@@ -444,6 +425,38 @@ export const generateTypescript = async (metadata, opts = {}) => {
     function generateColumnTsDefinition(schema, column, context) {
         return `${JSON.stringify(column.name)}${column.is_optional ? "?" : ""}: ${generateNullableUnionTsType(pgTypeToTsType(schema, column.format, context, column.type_schema), column.is_nullable)}`;
     }
+    /**
+     * Is `fn` a PostgREST computed field on `relation` (a table or view)?
+     *
+     * A computed field is a function taking a single argument of the relation's
+     * own composite type, so it is selectable as if it were a column and belongs
+     * in `Row`.
+     *
+     * Matching on the argument's type OID rather than on `argument_types` is what
+     * makes named parameters work. `argument_types` is
+     * `pg_get_function_arguments()`, which renders the parameter *name* when the
+     * parameter has one — `category category` rather than `category` — and
+     * schema-qualifies the type when it is not visible in `search_path`. Both
+     * forms failed a bare string comparison against the relation name, so
+     * `create function name_translated(category category)` silently lost its
+     * computed field while the unnamed `name_translated(category)` kept it.
+     * See supabase/postgres-meta#1034.
+     */
+    const isComputedFieldOf = (fn, inArgs, relation) => {
+        if (inArgs.length === 1) {
+            // `relationTypeByIds` is already "types backed by a relation", so a hit
+            // identifies the relation regardless of how the argument was spelled.
+            // A `variadic` argument is an array type and never appears here.
+            const argType = relationTypeByIds.get(inArgs[0].type_id);
+            if (argType) {
+                return argType.type_relation_id === relation.id;
+            }
+        }
+        // Fall back to the historical comparison when the argument's type is not in
+        // the metadata (callers may pass a reduced `types` list), so a computed
+        // field that resolved before keeps resolving.
+        return fn.argument_types === relation.name;
+    };
     let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
 
@@ -464,9 +477,9 @@ export type Database = {
                     type_schema: column.type_schema,
                     is_nullable: column.is_nullable,
                     is_optional: false,
-                }, { types, schemas, tables, views })),
+                }, typeContext)),
                 ...schemaFunctions
-                    .filter(({ fn }) => fn.argument_types === table.name)
+                    .filter(({ fn, inArgs }) => isComputedFieldOf(fn, inArgs, table))
                     .map(({ fn }) => {
                     return `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`;
                 }),
@@ -486,7 +499,7 @@ export type Database = {
                     is_optional: column.is_nullable ||
                         column.is_identity ||
                         column.default_value !== null,
-                }, { types, schemas, tables, views });
+                }, typeContext);
             })}
                   }
                   Update: {
@@ -501,7 +514,7 @@ export type Database = {
                     type_schema: column.type_schema,
                     is_nullable: column.is_nullable,
                     is_optional: true,
-                }, { types, schemas, tables, views });
+                }, typeContext);
             })}
                   }
                   Relationships: [
@@ -521,13 +534,16 @@ export type Database = {
                     type_schema: column.type_schema,
                     is_nullable: column.is_nullable,
                     is_optional: false,
-                }, { types, schemas, tables, views })),
+                }, typeContext)),
                 ...schemaFunctions
-                    .filter(({ fn }) => fn.argument_types === view.name)
+                    .filter(({ fn, inArgs }) => isComputedFieldOf(fn, inArgs, view))
                     .map(({ fn }) => `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`),
             ]}
                   }
-                  ${view.is_insert_enabled
+                  ${
+            // Metadata predating the trigger-aware flags (still valid
+            // version 1 documents) falls back to the old gate.
+            (view.is_insert_enabled ?? view.is_updatable)
                 ? `Insert: {
                            ${columnsByTableId[view.id].map((column) => {
                     if (!column.is_updatable) {
@@ -539,11 +555,11 @@ export type Database = {
                         type_schema: column.type_schema,
                         is_nullable: true,
                         is_optional: true,
-                    }, { types, schemas, tables, views });
+                    }, typeContext);
                 })}
                          }
                         `
-                : ""}${view.is_update_enabled
+                : ""}${(view.is_update_enabled ?? view.is_updatable)
                 ? `Update: {
                            ${columnsByTableId[view.id].map((column) => {
                     if (!column.is_updatable) {
@@ -555,7 +571,7 @@ export type Database = {
                         type_schema: column.type_schema,
                         is_nullable: true,
                         is_optional: true,
-                    }, { types, schemas, tables, views });
+                    }, typeContext);
                 })}
                          }
                         `
@@ -575,8 +591,8 @@ export type Database = {
                 return acc;
             }, {});
             for (const fnName in schemaFunctionsGroupedByName) {
-                schemaFunctionsGroupedByName[fnName].sort((a, b) => a.fn.argument_types.localeCompare(b.fn.argument_types) ||
-                    a.fn.return_type.localeCompare(b.fn.return_type));
+                schemaFunctionsGroupedByName[fnName].sort((a, b) => compareStrings(a.fn.argument_types, b.fn.argument_types) ||
+                    compareStrings(a.fn.return_type, b.fn.return_type));
             }
             return Object.entries(schemaFunctionsGroupedByName)
                 .map(([fnName, fns]) => {
@@ -601,12 +617,7 @@ export type Database = {
                 const type = typesById.get(type_id);
                 let tsType = "unknown";
                 if (type) {
-                    tsType = `${generateNullableUnionTsType(pgTypeToTsType(schema, type.name, {
-                        types,
-                        schemas,
-                        tables,
-                        views,
-                    }), true)}`;
+                    tsType = `${generateNullableUnionTsType(pgTypeToTsType(schema, type.name, typeContext, type.schema), true)}`;
                 }
                 return `${JSON.stringify(name)}: ${tsType}`;
             })}
@@ -738,12 +749,14 @@ export const Constants = {
     return output;
 };
 // TODO: Make this more robust. Currently doesn't handle range types - returns them as unknown.
-export const pgTypeToTsType = (schema, pgType, { types, schemas, tables, views, }, 
-// The schema that actually owns `pgType` (a column's `type_schema`), when
-// known. Disambiguates same-named enums/composites across schemas; falls
-// back to `schema.name` (the table's own schema) when not provided, e.g.
-// for function args/return types where no equivalent field exists yet.
+export const pgTypeToTsType = (schema, pgType, context, 
+// The schema that actually owns `pgType`, from the column's `type_schema` or
+// the resolved `PostgresType.schema`. Disambiguates same-named enums,
+// composites and relations across schemas. Falls back to `schema.name` (the
+// schema being generated) when not provided, which is only a guess, so pass
+// it whenever the owning schema is known.
 typeSchema) => {
+    const { types, schemas, tables, views, foreignTables = [], materializedViews = [], } = context;
     if (pgType === "bool") {
         return "boolean";
     }
@@ -777,7 +790,7 @@ typeSchema) => {
         return "Record<string, unknown>";
     }
     else if (pgType.startsWith("_")) {
-        return `(${pgTypeToTsType(schema, pgType.substring(1), { types, schemas, tables, views }, typeSchema)})[]`;
+        return `(${pgTypeToTsType(schema, pgType.substring(1), context, typeSchema)})[]`;
     }
     else {
         const preferredSchema = typeSchema ?? schema.name;
@@ -799,21 +812,31 @@ typeSchema) => {
             }
             return "unknown";
         }
-        const tableRowTypes = tables.filter((table) => table.name === pgType);
-        if (tableRowTypes.length > 0) {
-            const tableRowType = tableRowTypes.find((type) => type.schema === preferredSchema) ||
-                tableRowTypes[0];
-            if (schemas.some(({ name }) => name === tableRowType.schema)) {
-                return `Database[${JSON.stringify(tableRowType.schema)}]['Tables'][${JSON.stringify(tableRowType.name)}]['Row']`;
+        // A relation-typed value carries only a bare type name, so several relations
+        // can share it and `preferredSchema` is what disambiguates them. Match on
+        // the schema across every relation kind before falling back to kind order,
+        // otherwise a relation in an unrelated schema outranks the one the caller
+        // meant. Foreign tables are generated under `Tables` and materialized views
+        // under `Views`, alongside their plain counterparts.
+        const relationKinds = [
+            ["Tables", tables],
+            ["Tables", foreignTables],
+            ["Views", views],
+            ["Views", materializedViews],
+        ];
+        const findRelation = (matches) => {
+            for (const [kind, relations] of relationKinds) {
+                const relation = relations.find(matches);
+                if (relation)
+                    return { kind, relation };
             }
-            return "unknown";
-        }
-        const viewRowTypes = views.filter((view) => view.name === pgType);
-        if (viewRowTypes.length > 0) {
-            const viewRowType = viewRowTypes.find((type) => type.schema === preferredSchema) ||
-                viewRowTypes[0];
-            if (schemas.some(({ name }) => name === viewRowType.schema)) {
-                return `Database[${JSON.stringify(viewRowType.schema)}]['Views'][${JSON.stringify(viewRowType.name)}]['Row']`;
+            return undefined;
+        };
+        const match = findRelation(({ name, schema: relationSchema }) => name === pgType && relationSchema === preferredSchema) ?? findRelation(({ name }) => name === pgType);
+        if (match) {
+            const { kind, relation } = match;
+            if (schemas.some(({ name }) => name === relation.schema)) {
+                return `Database[${JSON.stringify(relation.schema)}]['${kind}'][${JSON.stringify(relation.name)}]['Row']`;
             }
             return "unknown";
         }

package/dist/introspection/index.js

@@ -22,47 +22,30 @@ import { VIEWS_SQL } from "./sql/views.sql.js";
  * responsibility — unlike `getGeneratorMetadata`, this does not end the pool.
  */
 export async function introspect(db, opts = {}) {
-    const includedSchemas = opts.includedSchemas ?? [];
-    const excludedSchemas = opts.excludedSchemas ?? [];
-    // Managers receive `undefined` (not an empty array) when no filter is set.
-    const included = includedSchemas.length > 0 ? includedSchemas : undefined;
-    const excluded = excludedSchemas.length > 0 ? excludedSchemas : undefined;
     // Most queries exclude the system schemas by default; foreign tables and
     // materialized views do not (matching the respective manager `list()` calls).
-    const systemExcludingFilter = filterByList(included, excluded, DEFAULT_SYSTEM_SCHEMAS);
-    const plainFilter = filterByList(included, excluded);
+    const systemExcludingFilter = filterByList(opts.includedSchemas, opts.excludedSchemas, DEFAULT_SYSTEM_SCHEMAS);
+    const plainFilter = filterByList(opts.includedSchemas, opts.excludedSchemas);
     const queryRows = async (sql) => normalizeRows((await db.query(sql)).rows);
     // Issued concurrently, matching postgres-meta's CLI path which ran its nine
     // introspection queries under Promise.all. A pooled Queryable runs them in
     // parallel; a single-connection one pipelines them, which is no worse than
     // awaiting each in turn.
     const [schemas, tables, foreignTables, views, materializedViews, columns, primaryKeys, relationships, functions, types,] = await Promise.all([
-        queryRows(SCHEMAS_SQL({
-            includeSystemSchemas: false,
-            nameFilter: systemExcludingFilter,
-        })),
+        queryRows(SCHEMAS_SQL({ schemaFilter: systemExcludingFilter })),
         queryRows(TABLES_SQL({ schemaFilter: systemExcludingFilter })),
         queryRows(FOREIGN_TABLES_SQL({ schemaFilter: plainFilter })),
         queryRows(VIEWS_SQL({ schemaFilter: systemExcludingFilter })),
         queryRows(MATERIALIZED_VIEWS_SQL({ schemaFilter: plainFilter })),
         queryRows(COLUMNS_SQL({ schemaFilter: systemExcludingFilter })),
         queryRows(PRIMARY_KEYS_SQL({ schemaFilter: systemExcludingFilter })),
-        listRelationships(db, {
-            includedSchemas: included,
-            excludedSchemas: excluded,
-        }),
+        listRelationships(db, systemExcludingFilter),
         queryRows(FUNCTIONS_SQL({ schemaFilter: systemExcludingFilter })),
-        // types: includeSystemSchemas true (no schema filter), table + array types included.
-        queryRows(TYPES_SQL({
-            schemaFilter: "",
-            includeTableTypes: true,
-            includeArrayTypes: true,
-        })),
+        queryRows(TYPES_SQL),
     ]);
     return {
         version: GENERATOR_METADATA_VERSION,
-        schemas: schemas.filter(({ name }) => !excludedSchemas.includes(name) &&
-            (includedSchemas.length === 0 || includedSchemas.includes(name))),
+        schemas,
         tables,
         foreignTables,
         views,

package/dist/introspection/relationships.d.ts

@@ -1,5 +1,5 @@
 import type { PostgresRelationship } from "../types.ts";
-import type { IntrospectOptions, Queryable } from "./index.ts";
+import type { Queryable } from "./index.ts";
 /**
  * Port of `postgres-meta/src/lib/PostgresMetaRelationships.ts`.
  *
@@ -39,9 +39,9 @@ export type ViewKeyDependency = {
 export declare function expandViewRelationships(allTableM2oAndO2oRelationships: PostgresRelationship[], viewsKeyDependencies: ViewKeyDependency[]): PostgresRelationship[];
 /**
  * List all relationships (table↔table plus the view-derived ones) for the
- * given schema filter. Mirrors `PostgresMetaRelationships.list()` with the
- * generator path's defaults (`includeSystemSchemas: false`). Errors from the
+ * schemas selected by `schemaFilter`, the `IN (…)`/`NOT IN (…)` fragment
+ * `introspect()` builds with the system schemas excluded. Errors from the
  * injected `Queryable` propagate by throwing — callers adapt.
  */
-export declare function listRelationships(db: Queryable, { includedSchemas, excludedSchemas }?: IntrospectOptions): Promise<PostgresRelationship[]>;
+export declare function listRelationships(db: Queryable, schemaFilter: string): Promise<PostgresRelationship[]>;
 export {};