@supabase/postgrest-typegen 0.2.0 → 0.2.2

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) => [
@@ -123,6 +134,8 @@ export const generateTypescript = async (metadata, opts = {}) => {
                 view: {
                     ...materializedView,
                     is_updatable: false,
+                    is_insert_enabled: false,
+                    is_update_enabled: false,
                 },
                 relationships: getRelationships(materializedView),
             });
@@ -176,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
@@ -242,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 };
             });
@@ -267,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";
     };
@@ -351,7 +349,13 @@ export const generateTypescript = async (metadata, opts = {}) => {
     const getFunctionSignatures = (schema, fns) => {
         return fns
             .map(({ fn, inArgs }) => {
-            let argsType = "never";
+            // `never` would be wrong here: postgrest-js treats `Args extends { '': Row }`
+            // as a computed field (`never extends T` is always true, so same-named table
+            // columns get omitted from select results), and an object type with a required
+            // `never` property is uninhabited for any tool doing sound type math on the
+            // generated types. `Record<PropertyKey, never>` is the accurate type for
+            // "callable with no arguments".
+            let argsType = "Record<PropertyKey, never>";
             let returnType = getFunctionReturnType(schema, fn);
             // Check for specific error cases
             const conflictError = getConflictError(schema, fns, fn, inArgs);
@@ -361,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 };
                     });
@@ -381,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 };
                     });
@@ -399,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 };
                 });
@@ -422,6 +411,11 @@ export const generateTypescript = async (metadata, opts = {}) => {
   }`
         : "";
     function generateNullableUnionTsType(tsType, isNullable) {
+        // The generated Json type includes null, so a NOT NULL json/jsonb column
+        // has to be narrowed with NonNullable to reflect the database constraint.
+        if (tsType === "Json" && !isNullable) {
+            return `NonNullable<${tsType}>`;
+        }
         // Only add the null union if the type is not unknown as unknown already includes null
         if (tsType === "unknown" || tsType === "any" || !isNullable) {
             return tsType;
@@ -431,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[]
 
@@ -451,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)}`;
                 }),
@@ -461,7 +487,8 @@ export type Database = {
                   }
                   Insert: {
                     ${columnsByTableId[table.id].map((column) => {
-                if (column.identity_generation === "ALWAYS") {
+                if (column.identity_generation === "ALWAYS" ||
+                    column.is_generated) {
                     return `${JSON.stringify(column.name)}?: never`;
                 }
                 return generateColumnTsDefinition(schema, {
@@ -472,12 +499,13 @@ export type Database = {
                     is_optional: column.is_nullable ||
                         column.is_identity ||
                         column.default_value !== null,
-                }, { types, schemas, tables, views });
+                }, typeContext);
             })}
                   }
                   Update: {
                     ${columnsByTableId[table.id].map((column) => {
-                if (column.identity_generation === "ALWAYS") {
+                if (column.identity_generation === "ALWAYS" ||
+                    column.is_generated) {
                     return `${JSON.stringify(column.name)}?: never`;
                 }
                 return generateColumnTsDefinition(schema, {
@@ -486,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: [
@@ -506,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_updatable
+                  ${
+            // 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) {
@@ -524,10 +555,12 @@ export type Database = {
                         type_schema: column.type_schema,
                         is_nullable: true,
                         is_optional: true,
-                    }, { types, schemas, tables, views });
+                    }, typeContext);
                 })}
                          }
-                         Update: {
+                        `
+                : ""}${(view.is_update_enabled ?? view.is_updatable)
+                ? `Update: {
                            ${columnsByTableId[view.id].map((column) => {
                     if (!column.is_updatable) {
                         return `${JSON.stringify(column.name)}?: never`;
@@ -538,7 +571,7 @@ export type Database = {
                         type_schema: column.type_schema,
                         is_nullable: true,
                         is_optional: true,
-                    }, { types, schemas, tables, views });
+                    }, typeContext);
                 })}
                          }
                         `
@@ -558,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]) => {
@@ -584,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}`;
             })}
@@ -721,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";
     }
@@ -760,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;
@@ -782,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";
 export const COLUMNS_SQL = (props) => /* SQL */ `
 -- Adapted from information_schema.columns
 
@@ -36,14 +35,44 @@ 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')
-    OR c.relkind IN ('v', 'f') AND pg_column_is_updatable(c.oid, a.attnum, FALSE)
+    -- 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, FALSE)
+      OR EXISTS (
+        SELECT 1 FROM pg_trigger tg
+        WHERE tg.tgrelid = c.oid
+          AND tg.tgtype & 64 <> 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,
   check_constraints.definition AS "check",
@@ -101,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
@@ -117,6 +142,4 @@ WHERE
       'SELECT, INSERT, UPDATE, REFERENCES'
     )
   )
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

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

@@ -1,16 +1,8 @@
-/**
- * Shared prop shapes for the SQL builders, ported from
- * `postgres-meta/src/lib/sql/common.ts`. Only the variants used by the
- * typegen introspection path are kept.
- */
-export type SQLQueryProps = {
-    limit?: number;
-    offset?: number;
-};
-export type SQLQueryPropsWithSchemaFilter = SQLQueryProps & {
-    schemaFilter?: string;
-};
-export type SQLQueryPropsWithSchemaFilterAndIdsFilter = SQLQueryProps & {
-    schemaFilter?: string;
-    idsFilter?: string;
+/** The only option the introspection passes to its SQL builders. */
+export type SchemaFilterProps = {
+    /**
+     * An `IN (…)` or `NOT IN (…)` fragment from `filterByList`, or the empty
+     * string for no filter.
+     */
+    schemaFilter: string;
 };

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

@@ -1,6 +1,2 @@
-import type { SQLQueryProps } from "./common.ts";
-export declare const FOREIGN_TABLES_SQL: (props: SQLQueryProps & {
-    schemaFilter?: string;
-    idsFilter?: string;
-    tableIdentifierFilter?: string;
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const FOREIGN_TABLES_SQL: (props: SchemaFilterProps) => string;

package/dist/introspection/sql/foreign_tables.sql.js

@@ -1,4 +1,3 @@
-import { literal } from "pg-format";
 export const FOREIGN_TABLES_SQL = (props) => /* SQL */ `
 SELECT
   c.oid :: int8 AS id,
@@ -10,9 +9,5 @@ FROM
   JOIN pg_namespace n ON n.oid = c.relnamespace
 WHERE
   ${props.schemaFilter ? `n.nspname ${props.schemaFilter} AND` : ""}
-  ${props.idsFilter ? `c.oid ${props.idsFilter} AND` : ""}
-  ${props.tableIdentifierFilter ? `(n.nspname || '.' || c.relname) ${props.tableIdentifierFilter} AND` : ""}
   c.relkind = 'f'
-${props.limit ? `limit ${literal(props.limit)}` : ""}
-${props.offset ? `offset ${literal(props.offset)}` : ""}
 `;

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

@@ -1,5 +1,2 @@
-import type { SQLQueryPropsWithSchemaFilterAndIdsFilter } from "./common.ts";
-export declare const FUNCTIONS_SQL: (props: SQLQueryPropsWithSchemaFilterAndIdsFilter & {
-    nameFilter?: string;
-    args?: string[];
-}) => string;
+import type { SchemaFilterProps } from "./common.ts";
+export declare const FUNCTIONS_SQL: (props: SchemaFilterProps) => string;