@supabase/postgrest-typegen 0.2.1 → 0.2.2

package/src/generation/swift.ts

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

package/src/generation/typescript.ts

@@ -7,7 +7,9 @@ import { format as oxfmtFormat } from "oxfmt";
 import type {
   GeneratorMetadata,
   PostgresColumn,
+  PostgresForeignTable,
   PostgresFunction,
+  PostgresMaterializedView,
   PostgresSchema,
   PostgresTable,
   PostgresType,
@@ -17,6 +19,7 @@ import {
   VALID_FUNCTION_ARGS_MODE,
   VALID_UNNAMED_FUNCTION_ARG_TYPES,
 } from "./constants.ts";
+import { compareStrings } from "../collation.ts";
 
 export interface GenerateTypescriptOptions {
   /**
@@ -59,6 +62,23 @@ const defaultFormat = async (code: string): Promise<string> => {
   return formatted;
 };
 
+/**
+ * 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[];
+};
+
 type TsRelationship = Pick<
   GeneratorMetadata["relationships"][number],
   | "foreign_key_name"
@@ -95,6 +115,16 @@ export const generateTypescript = async (
     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: TypeResolutionContext = {
+    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<{
@@ -304,19 +334,19 @@ export const generateTypescript = async (
   // 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),
+      compareStrings(a.table.name, b.table.name),
     );
     introspectionBySchema[schema].views.sort((a, b) =>
-      a.view.name.localeCompare(b.view.name),
+      compareStrings(a.view.name, b.view.name),
     );
     introspectionBySchema[schema].functions.sort((a, b) =>
-      a.fn.name.localeCompare(b.fn.name),
+      compareStrings(a.fn.name, b.fn.name),
     );
     introspectionBySchema[schema].enums.sort((a, b) =>
-      a.name.localeCompare(b.name),
+      compareStrings(a.name, b.name),
     );
     introspectionBySchema[schema].compositeTypes.sort((a, b) =>
-      a.name.localeCompare(b.name),
+      compareStrings(a.name, b.name),
     );
   }
 
@@ -395,12 +425,7 @@ export const generateTypescript = async (
         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 };
       });
@@ -431,12 +456,7 @@ export const generateTypescript = async (
                       is_nullable: column.is_nullable,
                       is_optional: false,
                     },
-                    {
-                      types,
-                      schemas,
-                      tables,
-                      views,
-                    },
+                    typeContext,
                   ),
                 )
                 .join(",\n")}
@@ -446,12 +466,7 @@ export const generateTypescript = async (
     // 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";
@@ -567,12 +582,12 @@ export const generateTypescript = async (
                 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 };
               },
@@ -591,12 +606,12 @@ export const generateTypescript = async (
                 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 };
               },
@@ -615,12 +630,12 @@ export const generateTypescript = async (
               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 };
             },
@@ -666,12 +681,7 @@ export const generateTypescript = async (
       is_nullable: boolean;
       is_optional: boolean;
     },
-    context: {
-      types: PostgresType[];
-      schemas: PostgresSchema[];
-      tables: PostgresTable[];
-      views: PostgresView[];
-    },
+    context: TypeResolutionContext,
   ) {
     return `${JSON.stringify(column.name)}${column.is_optional ? "?" : ""}: ${generateNullableUnionTsType(
       pgTypeToTsType(schema, column.format, context, column.type_schema),
@@ -679,6 +689,43 @@ export const generateTypescript = async (
     )}`;
   }
 
+  /**
+   * 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: PostgresFunction,
+    inArgs: PostgresFunction["args"],
+    relation: { id: number; name: string },
+  ) => {
+    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[]
 
@@ -714,11 +761,13 @@ export type Database = {
                             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),
@@ -747,7 +796,7 @@ export type Database = {
                             column.is_identity ||
                             column.default_value !== null,
                         },
-                        { types, schemas, tables, views },
+                        typeContext,
                       );
                     })}
                   }
@@ -769,7 +818,7 @@ export type Database = {
                           is_nullable: column.is_nullable,
                           is_optional: true,
                         },
-                        { types, schemas, tables, views },
+                        typeContext,
                       );
                     })}
                   }
@@ -801,11 +850,13 @@ export type Database = {
                             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(
@@ -816,7 +867,9 @@ export type Database = {
                     ]}
                   }
                   ${
-                    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) {
@@ -831,14 +884,14 @@ export type Database = {
                                  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) {
@@ -853,7 +906,7 @@ export type Database = {
                                  is_nullable: true,
                                  is_optional: true,
                                },
-                               { types, schemas, tables, views },
+                               typeContext,
                              );
                            })}
                          }
@@ -882,8 +935,8 @@ export type Database = {
               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),
+                    compareStrings(a.fn.argument_types, b.fn.argument_types) ||
+                    compareStrings(a.fn.return_type, b.fn.return_type),
                 );
               }
 
@@ -919,12 +972,12 @@ export type Database = {
                           let tsType = "unknown";
                           if (type) {
                             tsType = `${generateNullableUnionTsType(
-                              pgTypeToTsType(schema, type.name, {
-                                types,
-                                schemas,
-                                tables,
-                                views,
-                              }),
+                              pgTypeToTsType(
+                                schema,
+                                type.name,
+                                typeContext,
+                                type.schema,
+                              ),
                               true,
                             )}`;
                           }
@@ -1070,23 +1123,22 @@ export const Constants = {
 export const pgTypeToTsType = (
   schema: PostgresSchema,
   pgType: string,
-  {
+  context: TypeResolutionContext,
+  // 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?: string,
+): string => {
+  const {
     types,
     schemas,
     tables,
     views,
-  }: {
-    types: PostgresType[];
-    schemas: PostgresSchema[];
-    tables: PostgresTable[];
-    views: PostgresView[];
-  },
-  // 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.
-  typeSchema?: string,
-): string => {
+    foreignTables = [],
+    materializedViews = [],
+  } = context;
   if (pgType === "bool") {
     return "boolean";
   } else if (
@@ -1118,12 +1170,7 @@ export const pgTypeToTsType = (
   } else if (pgType === "record") {
     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;
     const enumTypes = types.filter(
@@ -1156,27 +1203,37 @@ export const pgTypeToTsType = (
       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],
+    ] as const;
+    const findRelation = (
+      matches: (relation: { name: string; schema: string }) => boolean,
+    ) => {
+      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,
+      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/src/introspection/index.ts

@@ -44,20 +44,14 @@ export async function introspect(
   db: Queryable,
   opts: IntrospectOptions = {},
 ): Promise<GeneratorMetadata> {
-  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,
+    opts.includedSchemas,
+    opts.excludedSchemas,
     DEFAULT_SYSTEM_SCHEMAS,
   );
-  const plainFilter = filterByList(included, excluded);
+  const plainFilter = filterByList(opts.includedSchemas, opts.excludedSchemas);
 
   const queryRows = async (sql: string) =>
     normalizeRows((await db.query(sql)).rows);
@@ -78,40 +72,21 @@ export async function introspect(
     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/src/introspection/relationships.ts

@@ -1,6 +1,5 @@
 import type { PostgresRelationship } from "../types.ts";
-import type { IntrospectOptions, Queryable } from "./index.ts";
-import { DEFAULT_SYSTEM_SCHEMAS, filterByList } from "./sql/helpers.ts";
+import type { Queryable } from "./index.ts";
 import { TABLE_RELATIONSHIPS_SQL } from "./sql/table_relationships.sql.ts";
 import { VIEWS_KEY_DEPENDENCIES_SQL } from "./sql/views_key_dependencies.sql.ts";
 
@@ -52,16 +51,14 @@ export function expandViewRelationships(
       colDeps: ColDep[],
     ): { tableColumns: string[]; viewColumns: string[] }[] => {
       const tableColumns = colDeps.map(({ table_column }) => table_column);
-      // https://gist.github.com/ssippe/1f92625532eef28be6974f898efb23ef?permalink_comment_id=3474581#gistcomment-3474581
-      const cartesianProduct = <T>(allEntries: T[][]): T[][] => {
-        return allEntries.reduce<T[][]>(
-          (results, entries) =>
-            results
-              .map((result) => entries.map((entry) => result.concat(entry)))
-              .reduce((subResults, result) => subResults.concat(result), []),
+      const cartesianProduct = <T>(lists: T[][]): T[][] =>
+        lists.reduce<T[][]>(
+          (combinations, entries) =>
+            combinations.flatMap((combination) =>
+              entries.map((entry) => [...combination, entry]),
+            ),
           [[]],
         );
-      };
       const viewColumnsPermutations = cartesianProduct(
         colDeps.map((cd) => cd.view_columns),
       );
@@ -141,20 +138,14 @@ export function expandViewRelationships(
 
 /**
  * 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: Queryable,
-  { includedSchemas, excludedSchemas }: IntrospectOptions = {},
+  schemaFilter: string,
 ): Promise<PostgresRelationship[]> {
-  const schemaFilter = filterByList(
-    includedSchemas,
-    excludedSchemas,
-    DEFAULT_SYSTEM_SCHEMAS,
-  );
-
   const { rows: allTableM2oAndO2oRelationships } = await db.query(
     TABLE_RELATIONSHIPS_SQL({ schemaFilter }),
   );