@supabase/postgrest-typegen 0.3.0 → 0.4.0

package/README.md

@@ -127,6 +127,9 @@ import {
 | `generatePython`     | —                                                                              |
 | `generateSwift`      | `{ accessControl?: 'internal' \| 'public' \| 'private' \| 'package' }`         |
 
+Every generator returns the complete contents of the generated file, ending
+with a single newline, so consumers write the result as-is.
+
 `generateTypescript` formats its output with `oxfmt` unless `format` is
 supplied. `oxfmt` is an optional peer dependency, imported only when that
 default runs: install it to use the default formatter, or pass your own
@@ -148,7 +151,7 @@ npm install oxfmt@0.66.0
 
 ## Releasing
 
-Unlike the rest of this repo, merging a change here does not open a release pull request on its own. Releases are cut on demand: run the `Release postgrest-typegen` workflow from the Actions tab, which runs release-please against `release-please-config.postgrest-typegen.json` and opens (or updates) the release pull request for this package. Merging that pull request tags the release and publishes to npm.
+Unlike the rest of this repo, merging a change here does not open a release pull request on its own. Releases are cut on demand: run the `Release postgrest-typegen` workflow from the Actions tab, which runs release-please against `release-please-config.postgrest-typegen.json` and opens (or updates) the release pull request for this package. Merging that pull request tags the release and publishes to npm. Once npm serves the new version, the same workflow opens a pull request that bumps the exact pin in `packages/typegen`.
 
 ## License
 

package/dist/generation/go.js

@@ -8,8 +8,7 @@ export const generateGo = ({ schemas, tables, views, materializedViews, columns,
         return acc;
     }, {});
     const compositeTypes = types.filter((type) => type.attributes.length > 0);
-    let output = `
-package database
+    let output = `package database
 
 ${tables
         .filter((table) => schemas.some((schema) => schema.name === table.schema))
@@ -30,8 +29,8 @@ ${compositeTypes
         .filter((compositeType) => schemas.some((schema) => schema.name === compositeType.schema))
         .map((compositeType) => generateCompositeTypeStruct(schemas.find((schema) => schema.name === compositeType.schema), compositeType, types))
         .join("\n\n")}
-`.trim();
-    return output;
+`.trimEnd();
+    return `${output}\n`;
 };
 /**
  * Converts a Postgres name to PascalCase.

package/dist/generation/python.js

@@ -16,8 +16,7 @@ export const generatePython = ({ schemas, tables, views, materializedViews, colu
         .map((type) => ctx.typeToClass(type));
     const py_views = views.map((view) => ctx.viewToClass(view));
     const py_matviews = materializedViews.map((matview) => ctx.matViewToClass(matview));
-    let output = `
-from __future__ import annotations
+    let output = `from __future__ import annotations
 
 import datetime
 import uuid
@@ -43,8 +42,8 @@ ${concatLines(py_matviews)}
 
 ${concatLines(composite_types)}
 
-`.trim();
-    return output;
+`.trimEnd();
+    return `${output}\n`;
 };
 class PythonContext {
     types;

package/dist/generation/swift.js

@@ -216,7 +216,7 @@ export const generateSwift = (metadata, opts = {}) => {
             ];
         }),
     ];
-    return output.join("\n");
+    return `${output.join("\n")}\n`;
 };
 // TODO: Make this more robust. Currently doesn't handle range types - returns them as string.
 const pgTypeToSwiftType = (pgType, nullable, { types, views, tables, }) => {

package/dist/generation/typescript.js

@@ -359,6 +359,27 @@ export const generateTypescript = async (metadata, opts = {}) => {
         }
         return null;
     };
+    const getArgTsType = (schema, { name, type_id }) => {
+        const type = typesById.get(type_id);
+        if (!type) {
+            return "unknown";
+        }
+        const tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
+        // A row-typed parameter takes the relation's columns: PostgREST fills the
+        // keys it does not receive with NULL, and the computed fields are never
+        // input. A named parameter is typed without them. An unnamed one keeps the
+        // plain `Row` reference, which is how postgrest-js versions predating
+        // `ComputedFields` recognise the function as a computed field.
+        if (name === "") {
+            return tsType;
+        }
+        const relationReference = findRelationReference(type.name, typeContext, type.schema);
+        if (relationReference && tsType === `${relationReference}['Row']`) {
+            return `Omit<${tsType}, ${relationReference}['ComputedFields']>`;
+        }
+        return tsType;
+    };
+    const getArgsTsType = (schema, inArgs) => `{ ${inArgs.map((arg) => `${JSON.stringify(arg.name)}${arg.has_default ? "?" : ""}: ${getArgTsType(schema, arg)}`)} }`;
     const getFunctionSignatures = (schema, fns) => {
         return fns
             .map(({ fn, inArgs }) => {
@@ -368,50 +389,19 @@ export const generateTypescript = async (metadata, opts = {}) => {
             // `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>";
+            const argsType = inArgs.length > 0
+                ? getArgsTsType(schema, inArgs)
+                : "Record<PropertyKey, never>";
             let returnType = getFunctionReturnType(schema, fn);
             // Check for specific error cases
             const conflictError = getConflictError(schema, fns, fn, inArgs);
             if (conflictError) {
-                if (inArgs.length > 0) {
-                    const argsNameAndType = inArgs.map(({ name, type_id, has_default }) => {
-                        const type = typesById.get(type_id);
-                        let tsType = "unknown";
-                        if (type) {
-                            tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
-                        }
-                        return { name, type: tsType, has_default };
-                    });
-                    argsType = `{ ${argsNameAndType.map(({ name, type, has_default }) => `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`)} }`;
-                }
                 returnType = `{ error: true } & ${JSON.stringify(conflictError)}`;
             }
             else if (hasTableRowError(fn, inArgs)) {
                 // Special case for computed fields returning scalars functions
-                if (inArgs.length > 0) {
-                    const argsNameAndType = inArgs.map(({ name, type_id, has_default }) => {
-                        const type = typesById.get(type_id);
-                        let tsType = "unknown";
-                        if (type) {
-                            tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
-                        }
-                        return { name, type: tsType, has_default };
-                    });
-                    argsType = `{ ${argsNameAndType.map(({ name, type, has_default }) => `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`)} }`;
-                }
                 returnType = `{ error: true } & ${JSON.stringify(`the function ${schema.name}.${fn.name} with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache`)}`;
             }
-            else if (inArgs.length > 0) {
-                const argsNameAndType = inArgs.map(({ name, type_id, has_default }) => {
-                    const type = typesById.get(type_id);
-                    let tsType = "unknown";
-                    if (type) {
-                        tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
-                    }
-                    return { name, type: tsType, has_default };
-                });
-                argsType = `{ ${argsNameAndType.map(({ name, type, has_default }) => `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`)} }`;
-            }
             return `{ Args: ${argsType}; Returns: ${getFunctionTsReturnType(fn, returnType)} }`;
         })
             .join(" |\n");
@@ -471,6 +461,30 @@ export const generateTypescript = async (metadata, opts = {}) => {
         // field that resolved before keeps resolving.
         return fn.argument_types === relation.name;
     };
+    /**
+     * The computed fields of a relation, in `schemaFunctions` order. A function
+     * named like one of the relation's columns is left out: PostgREST resolves
+     * the name to the column, so it is neither selectable nor part of `Row`.
+     */
+    const computedFieldsOf = (schemaFunctions, relation) => {
+        const columnNames = new Set(getColumns(relation.id).map((column) => column.name));
+        const seen = new Set();
+        return schemaFunctions.filter(({ fn, inArgs }) => {
+            if (!isComputedFieldOf(fn, inArgs, relation) ||
+                columnNames.has(fn.name) ||
+                seen.has(fn.name)) {
+                return false;
+            }
+            seen.add(fn.name);
+            return true;
+        });
+    };
+    const computedFieldTsDefinition = (schema, { fn }) => `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`;
+    // `ComputedFields` names the `Row` keys PostgREST leaves out of `select('*')`,
+    // so postgrest-js does not have to infer them from `Functions`.
+    const computedFieldsTsType = (computedFields) => computedFields.length === 0
+        ? "never"
+        : computedFields.map(({ fn }) => JSON.stringify(fn.name)).join(" | ");
     let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
 
@@ -482,117 +496,119 @@ export type Database = {
           Tables: {
             ${schemaTables.length === 0
             ? "[_ in never]: never"
-            : schemaTables.map(({ table, relationships, }) => `${JSON.stringify(table.name)}: {
+            : schemaTables.map(({ table, relationships }) => {
+                const computedFields = computedFieldsOf(schemaFunctions, table);
+                return `${JSON.stringify(table.name)}: {
                   Row: {
                     ${[
-                ...getColumns(table.id).map((column) => generateColumnTsDefinition(schema, {
-                    name: column.name,
-                    format: column.format,
-                    type_schema: column.type_schema,
-                    is_nullable: column.is_nullable,
-                    is_optional: false,
-                }, typeContext)),
-                ...schemaFunctions
-                    .filter(({ fn, inArgs }) => isComputedFieldOf(fn, inArgs, table))
-                    .map(({ fn }) => {
-                    return `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`;
-                }),
-            ]}
+                    ...getColumns(table.id).map((column) => generateColumnTsDefinition(schema, {
+                        name: column.name,
+                        format: column.format,
+                        type_schema: column.type_schema,
+                        is_nullable: column.is_nullable,
+                        is_optional: false,
+                    }, typeContext)),
+                    ...computedFields.map((computedField) => computedFieldTsDefinition(schema, computedField)),
+                ]}
                   }
+                  ComputedFields: ${computedFieldsTsType(computedFields)}
                   Insert: {
                     ${getColumns(table.id).map((column) => {
-                if (column.identity_generation === "ALWAYS" ||
-                    column.is_generated) {
-                    return `${JSON.stringify(column.name)}?: never`;
-                }
-                return generateColumnTsDefinition(schema, {
-                    name: column.name,
-                    format: column.format,
-                    type_schema: column.type_schema,
-                    is_nullable: column.is_nullable,
-                    is_optional: column.is_nullable ||
-                        column.is_identity ||
-                        column.default_value !== null,
-                }, typeContext);
-            })}
+                    if (column.identity_generation === "ALWAYS" ||
+                        column.is_generated) {
+                        return `${JSON.stringify(column.name)}?: never`;
+                    }
+                    return generateColumnTsDefinition(schema, {
+                        name: column.name,
+                        format: column.format,
+                        type_schema: column.type_schema,
+                        is_nullable: column.is_nullable,
+                        is_optional: column.is_nullable ||
+                            column.is_identity ||
+                            column.default_value !== null,
+                    }, typeContext);
+                })}
                   }
                   Update: {
                     ${getColumns(table.id).map((column) => {
-                if (column.identity_generation === "ALWAYS" ||
-                    column.is_generated) {
-                    return `${JSON.stringify(column.name)}?: never`;
-                }
-                return generateColumnTsDefinition(schema, {
-                    name: column.name,
-                    format: column.format,
-                    type_schema: column.type_schema,
-                    is_nullable: column.is_nullable,
-                    is_optional: true,
-                }, typeContext);
-            })}
+                    if (column.identity_generation === "ALWAYS" ||
+                        column.is_generated) {
+                        return `${JSON.stringify(column.name)}?: never`;
+                    }
+                    return generateColumnTsDefinition(schema, {
+                        name: column.name,
+                        format: column.format,
+                        type_schema: column.type_schema,
+                        is_nullable: column.is_nullable,
+                        is_optional: true,
+                    }, typeContext);
+                })}
                   }
                   Relationships: [
                     ${relationships.map(generateRelationshiptTsDefinition)}
                   ]
-                }`)}
+                }`;
+            })}
           }
           Views: {
             ${schemaViews.length === 0
             ? "[_ in never]: never"
-            : schemaViews.map(({ view, relationships, }) => `${JSON.stringify(view.name)}: {
+            : schemaViews.map(({ view, relationships }) => {
+                const computedFields = computedFieldsOf(schemaFunctions, view);
+                return `${JSON.stringify(view.name)}: {
                   Row: {
                     ${[
-                ...getColumns(view.id).map((column) => generateColumnTsDefinition(schema, {
-                    name: column.name,
-                    format: column.format,
-                    type_schema: column.type_schema,
-                    is_nullable: column.is_nullable,
-                    is_optional: false,
-                }, typeContext)),
-                ...schemaFunctions
-                    .filter(({ fn, inArgs }) => isComputedFieldOf(fn, inArgs, view))
-                    .map(({ fn }) => `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`),
-            ]}
-                  }
-                  ${
-            // 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: {
-                           ${getColumns(view.id).map((column) => {
-                    if (!column.is_updatable) {
-                        return `${JSON.stringify(column.name)}?: never`;
-                    }
-                    return generateColumnTsDefinition(schema, {
+                    ...getColumns(view.id).map((column) => generateColumnTsDefinition(schema, {
                         name: column.name,
                         format: column.format,
                         type_schema: column.type_schema,
-                        is_nullable: true,
-                        is_optional: true,
-                    }, typeContext);
-                })}
+                        is_nullable: column.is_nullable,
+                        is_optional: false,
+                    }, typeContext)),
+                    ...computedFields.map((computedField) => computedFieldTsDefinition(schema, computedField)),
+                ]}
+                  }
+                  ComputedFields: ${computedFieldsTsType(computedFields)}
+                  ${
+                // 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: {
+                           ${getColumns(view.id).map((column) => {
+                        if (!column.is_updatable) {
+                            return `${JSON.stringify(column.name)}?: never`;
+                        }
+                        return generateColumnTsDefinition(schema, {
+                            name: column.name,
+                            format: column.format,
+                            type_schema: column.type_schema,
+                            is_nullable: true,
+                            is_optional: true,
+                        }, typeContext);
+                    })}
                          }
                         `
-                : ""}${(view.is_update_enabled ?? view.is_updatable)
-                ? `Update: {
+                    : ""}${(view.is_update_enabled ?? view.is_updatable)
+                    ? `Update: {
                            ${getColumns(view.id).map((column) => {
-                    if (!column.is_updatable) {
-                        return `${JSON.stringify(column.name)}?: never`;
-                    }
-                    return generateColumnTsDefinition(schema, {
-                        name: column.name,
-                        format: column.format,
-                        type_schema: column.type_schema,
-                        is_nullable: true,
-                        is_optional: true,
-                    }, typeContext);
-                })}
+                        if (!column.is_updatable) {
+                            return `${JSON.stringify(column.name)}?: never`;
+                        }
+                        return generateColumnTsDefinition(schema, {
+                            name: column.name,
+                            format: column.format,
+                            type_schema: column.type_schema,
+                            is_nullable: true,
+                            is_optional: true,
+                        }, typeContext);
+                    })}
                          }
                         `
-                : ""}Relationships: [
+                    : ""}Relationships: [
                     ${relationships.map(generateRelationshiptTsDefinition)}
                   ]
-                }`)}
+                }`;
+            })}
           }
           Functions: {
             ${(() => {
@@ -769,7 +785,7 @@ export const pgTypeToTsType = (schema, pgType, context,
 // 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;
+    const { types, schemas } = context;
     if (pgType === "bool") {
         return "boolean";
     }
@@ -824,34 +840,41 @@ typeSchema) => {
             }
             return "unknown";
         }
-        // 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 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";
+        const relationReference = findRelationReference(pgType, context, preferredSchema);
+        return relationReference ? `${relationReference}['Row']` : "unknown";
+    }
+};
+/**
+ * The `Database[schema][kind][name]` reference of the relation whose row type
+ * is `pgType`, or `undefined` when no generated relation has that type.
+ *
+ * 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 findRelationReference = (pgType, context, preferredSchema) => {
+    const { schemas, tables, views, foreignTables = [], materializedViews = [], } = context;
+    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";
+        return undefined;
+    };
+    const match = findRelation(({ name, schema: relationSchema }) => name === pgType && relationSchema === preferredSchema) ?? findRelation(({ name }) => name === pgType);
+    if (!match || !schemas.some(({ name }) => name === match.relation.schema)) {
+        return undefined;
     }
+    const { kind, relation } = match;
+    return `Database[${JSON.stringify(relation.schema)}]['${kind}'][${JSON.stringify(relation.name)}]`;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -62,7 +62,7 @@
     "test": "bun scripts/run-tests.ts test/"
   },
   "dependencies": {
-    "arktype": "2.2.3"
+    "arktype": "2.2.5"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
@@ -74,8 +74,8 @@
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
     "oxfmt": "0.66.0",
-    "oxlint": "1.83.0",
-    "oxlint-tsgolint": "7.0.2002",
+    "oxlint": "1.85.0",
+    "oxlint-tsgolint": "7.0.2003",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",
     "typescript": "7.0.2"

package/src/generation/go.ts

@@ -32,8 +32,7 @@ export const generateGo = ({
 
   const compositeTypes = types.filter((type) => type.attributes.length > 0);
 
-  let output = `
-package database
+  let output = `package database
 
 ${tables
   .filter((table) => schemas.some((schema) => schema.name === table.schema))
@@ -88,9 +87,9 @@ ${compositeTypes
     ),
   )
   .join("\n\n")}
-`.trim();
+`.trimEnd();
 
-  return output;
+  return `${output}\n`;
 };
 
 /**

package/src/generation/python.ts

@@ -38,8 +38,7 @@ export const generatePython = ({
     ctx.matViewToClass(matview),
   );
 
-  let output = `
-from __future__ import annotations
+  let output = `from __future__ import annotations
 
 import datetime
 import uuid
@@ -65,9 +64,9 @@ ${concatLines(py_matviews)}
 
 ${concatLines(composite_types)}
 
-`.trim();
+`.trimEnd();
 
-  return output;
+  return `${output}\n`;
 };
 
 interface Serializable {

package/src/generation/swift.ts

@@ -375,7 +375,7 @@ export const generateSwift = (
     }),
   ];
 
-  return output.join("\n");
+  return `${output.join("\n")}\n`;
 };
 
 // TODO: Make this more robust. Currently doesn't handle range types - returns them as string.

package/src/generation/typescript.ts

@@ -584,6 +584,43 @@ export const generateTypescript = async (
     return null;
   };
 
+  const getArgTsType = (
+    schema: PostgresSchema,
+    { name, type_id }: PostgresFunction["args"][number],
+  ) => {
+    const type = typesById.get(type_id);
+    if (!type) {
+      return "unknown";
+    }
+    const tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
+    // A row-typed parameter takes the relation's columns: PostgREST fills the
+    // keys it does not receive with NULL, and the computed fields are never
+    // input. A named parameter is typed without them. An unnamed one keeps the
+    // plain `Row` reference, which is how postgrest-js versions predating
+    // `ComputedFields` recognise the function as a computed field.
+    if (name === "") {
+      return tsType;
+    }
+    const relationReference = findRelationReference(
+      type.name,
+      typeContext,
+      type.schema,
+    );
+    if (relationReference && tsType === `${relationReference}['Row']`) {
+      return `Omit<${tsType}, ${relationReference}['ComputedFields']>`;
+    }
+    return tsType;
+  };
+
+  const getArgsTsType = (
+    schema: PostgresSchema,
+    inArgs: PostgresFunction["args"],
+  ) =>
+    `{ ${inArgs.map(
+      (arg) =>
+        `${JSON.stringify(arg.name)}${arg.has_default ? "?" : ""}: ${getArgTsType(schema, arg)}`,
+    )} }`;
+
   const getFunctionSignatures = (
     schema: PostgresSchema,
     fns: Array<{ fn: PostgresFunction; inArgs: PostgresFunction["args"] }>,
@@ -596,80 +633,21 @@ export const generateTypescript = async (
         // `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>";
+        const argsType =
+          inArgs.length > 0
+            ? getArgsTsType(schema, inArgs)
+            : "Record<PropertyKey, never>";
         let returnType = getFunctionReturnType(schema, fn);
 
         // Check for specific error cases
         const conflictError = getConflictError(schema, fns, fn, inArgs);
         if (conflictError) {
-          if (inArgs.length > 0) {
-            const argsNameAndType = inArgs.map(
-              ({ name, type_id, has_default }) => {
-                const type = typesById.get(type_id);
-                let tsType = "unknown";
-                if (type) {
-                  tsType = pgTypeToTsType(
-                    schema,
-                    type.name,
-                    typeContext,
-                    type.schema,
-                  );
-                }
-                return { name, type: tsType, has_default };
-              },
-            );
-            argsType = `{ ${argsNameAndType.map(
-              ({ name, type, has_default }) =>
-                `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`,
-            )} }`;
-          }
           returnType = `{ error: true } & ${JSON.stringify(conflictError)}`;
         } else if (hasTableRowError(fn, inArgs)) {
           // Special case for computed fields returning scalars functions
-          if (inArgs.length > 0) {
-            const argsNameAndType = inArgs.map(
-              ({ name, type_id, has_default }) => {
-                const type = typesById.get(type_id);
-                let tsType = "unknown";
-                if (type) {
-                  tsType = pgTypeToTsType(
-                    schema,
-                    type.name,
-                    typeContext,
-                    type.schema,
-                  );
-                }
-                return { name, type: tsType, has_default };
-              },
-            );
-            argsType = `{ ${argsNameAndType.map(
-              ({ name, type, has_default }) =>
-                `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`,
-            )} }`;
-          }
           returnType = `{ error: true } & ${JSON.stringify(
             `the function ${schema.name}.${fn.name} with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache`,
           )}`;
-        } else if (inArgs.length > 0) {
-          const argsNameAndType = inArgs.map(
-            ({ name, type_id, has_default }) => {
-              const type = typesById.get(type_id);
-              let tsType = "unknown";
-              if (type) {
-                tsType = pgTypeToTsType(
-                  schema,
-                  type.name,
-                  typeContext,
-                  type.schema,
-                );
-              }
-              return { name, type: tsType, has_default };
-            },
-          );
-          argsType = `{ ${argsNameAndType.map(
-            ({ name, type, has_default }) =>
-              `${JSON.stringify(name)}${has_default ? "?" : ""}: ${type}`,
-          )} }`;
         }
 
         return `{ Args: ${argsType}; Returns: ${getFunctionTsReturnType(fn, returnType)} }`;
@@ -753,6 +731,51 @@ export const generateTypescript = async (
     return fn.argument_types === relation.name;
   };
 
+  /**
+   * The computed fields of a relation, in `schemaFunctions` order. A function
+   * named like one of the relation's columns is left out: PostgREST resolves
+   * the name to the column, so it is neither selectable nor part of `Row`.
+   */
+  const computedFieldsOf = (
+    schemaFunctions: {
+      fn: PostgresFunction;
+      inArgs: PostgresFunction["args"];
+    }[],
+    relation: { id: number; name: string },
+  ) => {
+    const columnNames = new Set(
+      getColumns(relation.id).map((column) => column.name),
+    );
+    const seen = new Set<string>();
+    return schemaFunctions.filter(({ fn, inArgs }) => {
+      if (
+        !isComputedFieldOf(fn, inArgs, relation) ||
+        columnNames.has(fn.name) ||
+        seen.has(fn.name)
+      ) {
+        return false;
+      }
+      seen.add(fn.name);
+      return true;
+    });
+  };
+
+  const computedFieldTsDefinition = (
+    schema: PostgresSchema,
+    { fn }: { fn: PostgresFunction },
+  ) =>
+    `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(
+      getFunctionReturnType(schema, fn),
+      true,
+    )}`;
+
+  // `ComputedFields` names the `Row` keys PostgREST leaves out of `select('*')`,
+  // so postgrest-js does not have to infer them from `Functions`.
+  const computedFieldsTsType = (computedFields: { fn: PostgresFunction }[]) =>
+    computedFields.length === 0
+      ? "never"
+      : computedFields.map(({ fn }) => JSON.stringify(fn.name)).join(" | ");
+
   let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
 
@@ -771,11 +794,12 @@ export type Database = {
             ${
               schemaTables.length === 0
                 ? "[_ in never]: never"
-                : schemaTables.map(
-                    ({
+                : schemaTables.map(({ table, relationships }) => {
+                    const computedFields = computedFieldsOf(
+                      schemaFunctions,
                       table,
-                      relationships,
-                    }) => `${JSON.stringify(table.name)}: {
+                    );
+                    return `${JSON.stringify(table.name)}: {
                   Row: {
                     ${[
                       ...getColumns(table.id).map((column) =>
@@ -791,18 +815,12 @@ export type Database = {
                           typeContext,
                         ),
                       ),
-                      ...schemaFunctions
-                        .filter(({ fn, inArgs }) =>
-                          isComputedFieldOf(fn, inArgs, table),
-                        )
-                        .map(({ fn }) => {
-                          return `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(
-                            getFunctionReturnType(schema, fn),
-                            true,
-                          )}`;
-                        }),
+                      ...computedFields.map((computedField) =>
+                        computedFieldTsDefinition(schema, computedField),
+                      ),
                     ]}
                   }
+                  ComputedFields: ${computedFieldsTsType(computedFields)}
                   Insert: {
                     ${getColumns(table.id).map((column) => {
                       if (
@@ -852,19 +870,20 @@ export type Database = {
                   Relationships: [
                     ${relationships.map(generateRelationshiptTsDefinition)}
                   ]
-                }`,
-                  )
+                }`;
+                  })
             }
           }
           Views: {
             ${
               schemaViews.length === 0
                 ? "[_ in never]: never"
-                : schemaViews.map(
-                    ({
+                : schemaViews.map(({ view, relationships }) => {
+                    const computedFields = computedFieldsOf(
+                      schemaFunctions,
                       view,
-                      relationships,
-                    }) => `${JSON.stringify(view.name)}: {
+                    );
+                    return `${JSON.stringify(view.name)}: {
                   Row: {
                     ${[
                       ...getColumns(view.id).map((column) =>
@@ -880,19 +899,12 @@ export type Database = {
                           typeContext,
                         ),
                       ),
-                      ...schemaFunctions
-                        .filter(({ fn, inArgs }) =>
-                          isComputedFieldOf(fn, inArgs, view),
-                        )
-                        .map(
-                          ({ fn }) =>
-                            `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(
-                              getFunctionReturnType(schema, fn),
-                              true,
-                            )}`,
-                        ),
+                      ...computedFields.map((computedField) =>
+                        computedFieldTsDefinition(schema, computedField),
+                      ),
                     ]}
                   }
+                  ComputedFields: ${computedFieldsTsType(computedFields)}
                   ${
                     // Metadata predating the trigger-aware flags (still valid
                     // version 1 documents) falls back to the old gate.
@@ -942,8 +954,8 @@ export type Database = {
                   }Relationships: [
                     ${relationships.map(generateRelationshiptTsDefinition)}
                   ]
-                }`,
-                  )
+                }`;
+                  })
             }
           }
           Functions: {
@@ -1157,14 +1169,7 @@ export const pgTypeToTsType = (
   // it whenever the owning schema is known.
   typeSchema?: string,
 ): string => {
-  const {
-    types,
-    schemas,
-    tables,
-    views,
-    foreignTables = [],
-    materializedViews = [],
-  } = context;
+  const { types, schemas } = context;
   if (pgType === "bool") {
     return "boolean";
   } else if (
@@ -1228,42 +1233,63 @@ export const pgTypeToTsType = (
       return "unknown";
     }
 
-    // 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 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";
-    }
+    const relationReference = findRelationReference(
+      pgType,
+      context,
+      preferredSchema,
+    );
+    return relationReference ? `${relationReference}['Row']` : "unknown";
+  }
+};
 
-    return "unknown";
+/**
+ * The `Database[schema][kind][name]` reference of the relation whose row type
+ * is `pgType`, or `undefined` when no generated relation has that type.
+ *
+ * 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 findRelationReference = (
+  pgType: string,
+  context: TypeResolutionContext,
+  preferredSchema: string,
+): string | undefined => {
+  const {
+    schemas,
+    tables,
+    views,
+    foreignTables = [],
+    materializedViews = [],
+  } = context;
+  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 undefined;
+  };
+  const match =
+    findRelation(
+      ({ name, schema: relationSchema }) =>
+        name === pgType && relationSchema === preferredSchema,
+    ) ?? findRelation(({ name }) => name === pgType);
+  if (!match || !schemas.some(({ name }) => name === match.relation.schema)) {
+    return undefined;
   }
+  const { kind, relation } = match;
+  return `Database[${JSON.stringify(relation.schema)}]['${kind}'][${JSON.stringify(
+    relation.name,
+  )}]`;
 };