@supabase/postgrest-typegen 0.2.1 → 0.2.2

package/README.md

@@ -23,6 +23,14 @@ 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.
 
+> [!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.
+
 ## Design
 
 There is a hard split between **introspection** (database → metadata) and

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/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 {};

package/dist/introspection/relationships.js

@@ -1,4 +1,3 @@
-import { DEFAULT_SYSTEM_SCHEMAS, filterByList } from "./sql/helpers.js";
 import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.js";
 import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.js";
 /**
@@ -13,12 +12,7 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
     return allTableM2oAndO2oRelationships.flatMap((r) => {
         const expandKeyDepCols = (colDeps) => {
             const tableColumns = colDeps.map(({ table_column }) => table_column);
-            // https://gist.github.com/ssippe/1f92625532eef28be6974f898efb23ef?permalink_comment_id=3474581#gistcomment-3474581
-            const cartesianProduct = (allEntries) => {
-                return allEntries.reduce((results, entries) => results
-                    .map((result) => entries.map((entry) => result.concat(entry)))
-                    .reduce((subResults, result) => subResults.concat(result), []), [[]]);
-            };
+            const cartesianProduct = (lists) => lists.reduce((combinations, entries) => combinations.flatMap((combination) => entries.map((entry) => [...combination, entry])), [[]]);
             const viewColumnsPermutations = cartesianProduct(colDeps.map((cd) => cd.view_columns));
             return viewColumnsPermutations.map((viewColumns) => ({
                 tableColumns,
@@ -72,12 +66,11 @@ export function expandViewRelationships(allTableM2oAndO2oRelationships, viewsKey
 }
 /**
  * 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 async function listRelationships(db, { includedSchemas, excludedSchemas } = {}) {
-    const schemaFilter = filterByList(includedSchemas, excludedSchemas, DEFAULT_SYSTEM_SCHEMAS);
+export async function listRelationships(db, schemaFilter) {
     const { rows: allTableM2oAndO2oRelationships } = await db.query(TABLE_RELATIONSHIPS_SQL({ schemaFilter }));
     const { rows: viewsKeyDependencies } = await db.query(VIEWS_KEY_DEPENDENCIES_SQL({ schemaFilter }));
     const allViewM2oAndO2oRelationships = expandViewRelationships(allTableM2oAndO2oRelationships, viewsKeyDependencies);

package/dist/introspection/sql/columns.sql.d.ts

@@ -1,7 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilter } from "./common.ts";
-export declare const COLUMNS_SQL: (props: SQLQueryPropsWithSchemaFilter & {
-    tableIdFilter?: string;
-    tableIdentifierFilter?: string;
-    columnNameFilter?: string;
-    idsFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const COLUMNS_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/columns.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "./pg-format.js";
 export const COLUMNS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.columns
 
@@ -36,30 +35,43 @@ SELECT
     WHEN 'd' THEN 'BY DEFAULT'
     ELSE NULL
   END AS identity_generation,
-  a.attgenerated IN ('s') AS is_generated,
+  -- 's' = stored, 'v' = virtual (PostgreSQL 18+); neither accepts writes.
+  a.attgenerated IN ('s', 'v') AS is_generated,
   NOT (
     a.attnotnull
     OR t.typtype = 'd' AND t.typnotnull
   ) AS is_nullable,
   (
     c.relkind IN ('r', 'p')
-    -- Columns of views made writable by INSTEAD OF triggers can be written
-    -- through PostgREST even though the view is not auto-updatable, so they
-    -- must not degrade to \`?: never\` in generated Insert/Update types.
-    -- include_triggers => TRUE covers INSTEAD OF UPDATE triggers, but
-    -- pg_column_is_updatable only considers the UPDATE event, so INSTEAD OF
-    -- INSERT triggers (tgtype bits: 64 = INSTEAD, 4 = INSERT) are checked
-    -- separately. Which events a view accepts is gated per view via
+    -- Columns of views made writable by INSTEAD OF triggers or unconditional
+    -- INSTEAD rules can be written through PostgREST even though the view is
+    -- not auto-updatable, so they must not degrade to \`?: never\` in generated
+    -- Insert/Update types. pg_column_is_updatable cannot express this: it
+    -- requires the relation to support both UPDATE and DELETE, so a view with
+    -- only an INSTEAD OF INSERT or only an INSTEAD OF UPDATE trigger reports
+    -- every column as non-updatable regardless of include_triggers. Triggers
+    -- and rules rewrite whole rows, so their presence makes every column
+    -- writable (tgtype bits: 64 = INSTEAD, 4 = INSERT, 16 = UPDATE;
+    -- pg_rewrite ev_type: '2' = UPDATE, '3' = INSERT; ev_qual is '<>' for
+    -- unconditional rules, and only unconditional INSTEAD rules make a view
+    -- writable). Which events a view accepts is gated per view via
     -- is_insert_enabled / is_update_enabled.
     OR c.relkind IN ('v', 'f') AND (
-      pg_column_is_updatable(c.oid, a.attnum, TRUE)
+      pg_column_is_updatable(c.oid, a.attnum, FALSE)
       OR EXISTS (
         SELECT 1 FROM pg_trigger tg
         WHERE tg.tgrelid = c.oid
           AND tg.tgtype & 64 <> 0
-          AND tg.tgtype & 4 <> 0
+          AND tg.tgtype & 20 <> 0
           AND NOT tg.tgisinternal
       )
+      OR EXISTS (
+        SELECT 1 FROM pg_rewrite rw
+        WHERE rw.ev_class = c.oid
+          AND rw.is_instead
+          AND rw.ev_type IN ('2', '3')
+          AND rw.ev_qual :: text = '<>'
+      )
     )
   ) AS is_updatable,
   uniques.table_id IS NOT NULL AS is_unique,
@@ -118,10 +130,6 @@ FROM
   ) AS check_constraints ON check_constraints.table_id = c.oid AND check_constraints.ordinal_position = a.attnum
 WHERE
   ${props.schemaFilter ? `nc.nspname ${props.schemaFilter} AND` : ""}
-  ${props.idsFilter ? `(c.oid || '.' || a.attnum) ${props.idsFilter} AND` : ""}
-  ${props.columnNameFilter ? `(c.relname || '.' || a.attname) ${props.columnNameFilter} AND` : ""}
-  ${props.tableIdFilter ? `c.oid ${props.tableIdFilter} AND` : ""}
-  ${props.tableIdentifierFilter ? `nc.nspname || '.' || c.relname ${props.tableIdentifierFilter} AND` : ""}
   NOT pg_is_other_temp_schema(nc.oid)
   AND a.attnum > 0
   AND NOT a.attisdropped
@@ -134,6 +142,4 @@ WHERE
       'SELECT, INSERT, UPDATE, REFERENCES'
     )
   )
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;