@supabase/postgrest-typegen 0.3.1 → 0.5.0

package/dist/generation/typescript.js

@@ -1,5 +1,5 @@
-import { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./constants.js";
 import { compareStrings } from "../collation.js";
+import { resolveRpcFunctions } from "../rpc.js";
 const loadOxfmt = async () => {
     try {
         return await import("oxfmt");
@@ -28,8 +28,13 @@ const defaultFormat = async (code) => {
  * can't be expressed by the single-collection `sortGeneratorMetadata` pass.
  */
 export const generateTypescript = async (metadata, opts = {}) => {
-    const { schemas, tables, foreignTables, views, materializedViews, columns, relationships, functions, types, } = metadata;
+    const { schemas, tables, foreignTables, views, materializedViews, columns, relationships, types, } = metadata;
+    // Documents predating the collection (still valid version 1) resolve it here.
+    const rpcFunctions = metadata.rpcFunctions ?? resolveRpcFunctions(metadata);
     const { detectOneToOneRelationships = false, postgrestVersion, defaultSchema = "public", format = defaultFormat, } = opts;
+    const resolvedDefaultSchema = schemas.some(({ name }) => name === defaultSchema) || !schemas[0]
+        ? defaultSchema
+        : schemas[0].name;
     // 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 = {
@@ -47,8 +52,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
         { tables: [], views: [], functions: [], enums: [], compositeTypes: [] },
     ]));
     const columnsByTableId = {};
-    const tablesNamesByTableId = {};
-    const relationTypeByIds = new Map();
+    const relationsById = new Map();
     // group types by id for quicker lookup
     const typesById = new Map();
     const tablesLike = [
@@ -59,7 +63,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
     ];
     for (const tableLike of tablesLike) {
         columnsByTableId[tableLike.id] = [];
-        tablesNamesByTableId[tableLike.id] = tableLike.name;
+        relationsById.set(tableLike.id, tableLike);
     }
     for (const column of columns) {
         columnsByTableId[column.table_id]?.push(column);
@@ -80,10 +84,6 @@ export const generateTypescript = async (metadata, opts = {}) => {
     };
     for (const type of types) {
         typesById.set(type.id, type);
-        // Save all the types that are relation types for quicker lookup
-        if (type.type_relation_id) {
-            relationTypeByIds.set(type.id, type);
-        }
         if (type.enums.length > 0) {
             introspectionBySchema[type.schema]?.enums.push(type);
         }
@@ -146,51 +146,8 @@ export const generateTypescript = async (metadata, opts = {}) => {
             relationships: getRelationships(materializedView),
         });
     }
-    // Helper function to get table/view name from relation id
-    const getTableNameFromRelationId = (relationId, returnTypeId) => {
-        if (!relationId)
-            return null;
-        const tableName = tablesNamesByTableId[relationId];
-        if (tableName)
-            return tableName;
-        // if it's a composite type we use the type name as relation name to allow sub-selecting fields of the composite type
-        const reltype = returnTypeId ? relationTypeByIds.get(returnTypeId) : null;
-        return reltype ? reltype.name : null;
-    };
-    for (const func of functions) {
-        const schemaIntrospection = introspectionBySchema[func.schema];
-        if (schemaIntrospection) {
-            // Get all input args (in, inout, variadic modes)
-            const inArgs = func.args.filter(({ mode }) => VALID_FUNCTION_ARGS_MODE.has(mode));
-            const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
-            if (
-            // Case 1: Function has no parameters
-            inArgs.length === 0 ||
-                // Case 2: All input args are named
-                !inArgs.some(({ name }) => name === "") ||
-                // Case 3: All unnamed args have default values AND are valid types
-                inArgs.every((arg) => {
-                    if (arg.name === "") {
-                        return (arg.has_default &&
-                            VALID_UNNAMED_FUNCTION_ARG_TYPES.has(arg.type_id));
-                    }
-                    return true;
-                }) ||
-                // Case 4: Single unnamed parameter of valid type (json, jsonb, text)
-                // Exclude all functions definitions that have only one single argument unnamed argument that isn't
-                // a json/jsonb/text as it won't be considered by PostgREST
-                (soleInArg &&
-                    soleInArg.name === "" &&
-                    (VALID_UNNAMED_FUNCTION_ARG_TYPES.has(soleInArg.type_id) ||
-                        // OR if the function have a single unnamed args which is another table (embeded function)
-                        (relationTypeByIds.get(soleInArg.type_id) &&
-                            getTableNameFromRelationId(func.return_type_relation_id, func.return_type_id)) ||
-                        // OR if the function takes a table row but doesn't qualify as embedded (for error reporting)
-                        (relationTypeByIds.get(soleInArg.type_id) &&
-                            !getTableNameFromRelationId(func.return_type_relation_id, func.return_type_id))))) {
-                schemaIntrospection.functions.push({ fn: func, inArgs });
-            }
-        }
+    for (const fn of rpcFunctions) {
+        introspectionBySchema[fn.schema]?.functions.push(fn);
     }
     // These per-schema groups MERGE multiple metadata collections — `.tables`
     // combines tables + foreign tables, `.views` combines views + materialized
@@ -199,83 +156,42 @@ export const generateTypescript = async (metadata, opts = {}) => {
     for (const schemaIntrospection of Object.values(introspectionBySchema)) {
         schemaIntrospection.tables.sort((a, b) => compareStrings(a.table.name, b.table.name));
         schemaIntrospection.views.sort((a, b) => compareStrings(a.view.name, b.view.name));
-        schemaIntrospection.functions.sort((a, b) => compareStrings(a.fn.name, b.fn.name));
         schemaIntrospection.enums.sort((a, b) => compareStrings(a.name, b.name));
         schemaIntrospection.compositeTypes.sort((a, b) => compareStrings(a.name, b.name));
     }
-    const getFunctionTsReturnType = (fn, returnType) => {
-        // Determine if this function should have SetofOptions
-        let setofOptionsInfo = "";
-        const returnTableName = getTableNameFromRelationId(fn.return_type_relation_id, fn.return_type_id);
-        const returnsSetOfTable = fn.is_set_returning_function && fn.return_type_relation_id !== null;
-        const returnsMultipleRows = fn.prorows !== null && fn.prorows > 1;
-        // Case 1: if the function returns a table, we need to add SetofOptions to allow selecting sub fields of the table
-        // Those can be used in rpc to select sub fields of a table
-        if (returnTableName) {
-            setofOptionsInfo = `SetofOptions: {
-        from: "*"
-        to: ${JSON.stringify(returnTableName)}
-        isOneToOne: ${Boolean(!returnsMultipleRows)}
-        isSetofReturn: ${fn.is_set_returning_function}
-      }`;
-        }
-        // Case 2: if the function has a single table argument, we need to add SetofOptions to allow selecting sub fields of the table
-        // and set the right "from" and "to" values to allow selecting from a table row
-        const soleArg = fn.args.length === 1 ? fn.args[0] : undefined;
-        if (soleArg) {
-            const relationType = relationTypeByIds.get(soleArg.type_id);
-            // Only add SetofOptions for functions with table arguments (embedded functions)
-            // or specific functions that RETURNS table-name
-            if (relationType) {
-                const sourceTable = relationType.format;
-                // Case 1: Standard embedded function with proper setof detection
-                if (returnsSetOfTable && returnTableName) {
-                    setofOptionsInfo = `SetofOptions: {
-          from: ${JSON.stringify(sourceTable)}
-          to: ${JSON.stringify(returnTableName)}
-          isOneToOne: ${Boolean(!returnsMultipleRows)}
-          isSetofReturn: true
-        }`;
-                } // Case 2: Handle RETURNS table-name those are always a one to one relationship
-                else if (returnTableName && !returnsSetOfTable) {
-                    const targetTable = returnTableName;
-                    setofOptionsInfo = `SetofOptions: {
-            from: ${JSON.stringify(sourceTable)}
-            to: ${JSON.stringify(targetTable)}
-            isOneToOne: true
-            isSetofReturn: false
-          }`;
-                }
-            }
-        }
-        // A ROWS 1 estimate may only collapse the array type when SetofOptions is also emitted
-        // (returnTableName resolved): postgrest-js relies on isOneToOne to restore the array shape
-        // for direct RPC calls. Without that metadata PostgREST still returns an array, so the
-        // collapse would make the type diverge from the actual response.
-        const collapsibleSingleRow = !returnsMultipleRows && returnTableName !== null;
-        return `${returnType}${fn.is_set_returning_function && !collapsibleSingleRow ? "[]" : ""}
-                          ${setofOptionsInfo ? `${setofOptionsInfo}` : ""}`;
+    const referencedTsType = (schema, { format, type_schema }) => format === null || type_schema === null
+        ? "unknown"
+        : pgTypeToTsType(schema, format, typeContext, type_schema);
+    const getFunctionTsReturnType = (overload, returnType) => {
+        const { setof_options } = overload;
+        const setofOptionsInfo = setof_options
+            ? `SetofOptions: {
+        from: ${JSON.stringify(setof_options.from)}
+        to: ${JSON.stringify(setof_options.to)}
+        isOneToOne: ${setof_options.is_one_to_one}
+        isSetofReturn: ${setof_options.is_setof_return}
+      }`
+            : "";
+        // A ROWS 1 estimate may only collapse the array type when SetofOptions is also emitted:
+        // postgrest-js relies on isOneToOne to restore the array shape for direct RPC calls.
+        // Without that metadata PostgREST still returns an array, so the collapse would make
+        // the type diverge from the actual response.
+        const collapsibleSingleRow = setof_options?.is_one_to_one === true;
+        return `${returnType}${overload.is_set_returning && !collapsibleSingleRow ? "[]" : ""}
+                          ${setofOptionsInfo}`;
     };
-    const getFunctionReturnType = (schema, fn) => {
+    const getFunctionReturnType = (schema, { returns }) => {
         // Case 1: `returns table`.
-        const tableArgs = fn.args.filter(({ mode }) => mode === "table");
-        if (tableArgs.length > 0) {
-            const argsNameAndType = tableArgs.map(({ name, type_id }) => {
-                const type = typesById.get(type_id);
-                let tsType = "unknown";
-                if (type) {
-                    tsType = pgTypeToTsType(schema, type.name, typeContext, type.schema);
-                }
-                return { name, type: tsType };
-            });
+        if (returns.columns) {
             return `{
-              ${argsNameAndType.map(({ name, type }) => `${JSON.stringify(name)}: ${type}`)}
+              ${returns.columns.map((column) => `${JSON.stringify(column.name)}: ${referencedTsType(schema, column)}`)}
             }`;
         }
-        // Case 2: returns a relation's row type.
-        const relation = introspectionBySchema[schema.name]?.tables.find(({ table: { id } }) => id === fn.return_type_relation_id)?.table ||
-            introspectionBySchema[schema.name]?.views.find(({ view: { id } }) => id === fn.return_type_relation_id)?.view;
-        if (relation) {
+        // Case 2: returns a row type of a relation in this schema.
+        const relation = returns.relation_id === null
+            ? undefined
+            : relationsById.get(returns.relation_id);
+        if (relation && relation.schema === schema.name) {
             return `{
               ${getColumns(relation.id)
                 .map((column) => generateColumnTsDefinition(schema, {
@@ -289,130 +205,41 @@ export const generateTypescript = async (metadata, opts = {}) => {
             }`;
         }
         // Case 3: returns base/array/composite/enum type.
-        const type = typesById.get(fn.return_type_id);
-        if (type) {
-            return pgTypeToTsType(schema, type.name, typeContext, type.schema);
-        }
-        return "unknown";
+        return referencedTsType(schema, returns);
     };
-    // Special error case for functions that take table row but don't qualify as embedded functions
-    const hasTableRowError = (fn, inArgs) => {
-        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
-        if (soleInArg &&
-            soleInArg.name === "" &&
-            relationTypeByIds.get(soleInArg.type_id) &&
-            !getTableNameFromRelationId(fn.return_type_relation_id, fn.return_type_id)) {
-            return true;
-        }
-        return false;
-    };
-    // Check for generic conflict cases that need error reporting
-    const getConflictError = (schema, fns, fn, inArgs) => {
-        // If there is a single function definition, there is no conflict
-        if (fns.length <= 1)
-            return null;
-        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
-        // Generic conflict detection patterns
-        // Pattern 1: No-args vs default-args conflicts
-        if (inArgs.length === 0) {
-            const conflictingFns = fns.filter(({ fn: otherFn, inArgs: otherInArgs }) => {
-                if (otherFn === fn)
-                    return false;
-                const otherSoleInArg = otherInArgs.length === 1 ? otherInArgs[0] : undefined;
-                return (otherSoleInArg &&
-                    otherSoleInArg.name === "" &&
-                    otherSoleInArg.has_default);
-            });
-            const conflictingFn = conflictingFns[0];
-            if (conflictingFn) {
-                const returnTypeName = typesById.get(conflictingFn.fn.return_type_id)?.name || "unknown";
-                return `Could not choose the best candidate function between: ${schema.name}.${fn.name}(), ${schema.name}.${fn.name}( => ${returnTypeName}). Try renaming the parameters or the function itself in the database so function overloading can be resolved`;
-            }
+    const getArgTsType = (schema, arg) => {
+        const tsType = referencedTsType(schema, arg);
+        // 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 (arg.name === "" || arg.format === null || arg.type_schema === null) {
+            return tsType;
         }
-        // Pattern 2: Same parameter name but different types (unresolvable overloads)
-        if (soleInArg && soleInArg.name !== "") {
-            const conflictingFns = fns.filter(({ fn: otherFn, inArgs: otherInArgs }) => {
-                if (otherFn === fn)
-                    return false;
-                const otherSoleInArg = otherInArgs.length === 1 ? otherInArgs[0] : undefined;
-                return (otherSoleInArg &&
-                    otherSoleInArg.name === soleInArg.name &&
-                    otherSoleInArg.type_id !== soleInArg.type_id);
-            });
-            if (conflictingFns.length > 0) {
-                const allConflictingFunctions = [{ fn, inArgs }, ...conflictingFns];
-                const conflictList = allConflictingFunctions
-                    .sort((a, b) => {
-                    const aArgs = a.inArgs;
-                    const bArgs = b.inArgs;
-                    return (aArgs[0]?.type_id || 0) - (bArgs[0]?.type_id || 0);
-                })
-                    .map((f) => {
-                    const args = f.inArgs;
-                    return `${schema.name}.${fn.name}(${args
-                        .map((a) => `${a.name || ""} => ${typesById.get(a.type_id)?.name || "unknown"}`)
-                        .join(", ")})`;
-                })
-                    .join(", ");
-                return `Could not choose the best candidate function between: ${conflictList}. Try renaming the parameters or the function itself in the database so function overloading can be resolved`;
-            }
+        const relationReference = findRelationReference(arg.format, typeContext, arg.type_schema);
+        if (relationReference && tsType === `${relationReference}['Row']`) {
+            return `Omit<${tsType}, ${relationReference}['ComputedFields']>`;
         }
-        return null;
+        return tsType;
     };
-    const getFunctionSignatures = (schema, fns) => {
-        return fns
-            .map(({ fn, inArgs }) => {
+    const getArgsTsType = (schema, args) => `{ ${args.map((arg) => `${JSON.stringify(arg.name)}${arg.has_default ? "?" : ""}: ${getArgTsType(schema, arg)}`)} }`;
+    const getFunctionSignatures = (schema, fn) => {
+        return fn.overloads
+            .map((overload) => {
             // `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);
-            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)} }`;
+            const argsType = overload.args.length > 0
+                ? getArgsTsType(schema, overload.args)
+                : "Record<PropertyKey, never>";
+            const returnType = overload.error === null
+                ? getFunctionReturnType(schema, overload)
+                : `{ error: true } & ${JSON.stringify(overload.error)}`;
+            return `{ Args: ${argsType}; Returns: ${getFunctionTsReturnType(overload, returnType)} }`;
         })
             .join(" |\n");
     };
@@ -439,38 +266,21 @@ export const generateTypescript = async (metadata, opts = {}) => {
         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.
+     * The computed fields of a relation, in function name order. 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`; `resolveRpcFunctions` marks them with `computed_field_of`.
      */
-    const isComputedFieldOf = (fn, inArgs, relation) => {
-        const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
-        if (soleInArg) {
-            // `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(soleInArg.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;
-    };
+    const computedFieldsOf = (schemaFunctions, relation) => schemaFunctions.flatMap((fn) => {
+        const overload = fn.overloads.find(({ computed_field_of }) => computed_field_of === relation.id);
+        return overload ? [{ name: fn.name, overload }] : [];
+    });
+    const computedFieldTsDefinition = (schema, { name, overload }) => `${JSON.stringify(name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, overload), 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(({ name }) => JSON.stringify(name)).join(" | ");
     let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
 
@@ -482,138 +292,126 @@ 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: {
-            ${(() => {
-            if (schemaFunctions.length === 0) {
-                return "[_ in never]: never";
-            }
-            const schemaFunctionsGroupedByName = schemaFunctions.reduce((acc, curr) => {
-                (acc[curr.fn.name] ??= []).push(curr);
-                return acc;
-            }, {});
-            for (const fns of Object.values(schemaFunctionsGroupedByName)) {
-                fns.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]) => {
-                const functionSignatures = getFunctionSignatures(schema, fns);
-                return `${JSON.stringify(fnName)}:\n${functionSignatures}`;
-            })
-                .join(",\n");
-        })()}
+            ${schemaFunctions.length === 0
+            ? "[_ in never]: never"
+            : schemaFunctions
+                .map((fn) => `${JSON.stringify(fn.name)}:\n${getFunctionSignatures(schema, fn)}`)
+                .join(",\n")}
           }
           Enums: {
             ${schemaEnums.length === 0
@@ -642,7 +440,7 @@ export type Database = {
 
 type DatabaseWithoutInternals = Omit<Database, '__InternalSupabase'>
 
-type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, ${JSON.stringify(defaultSchema)}>]
+type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, ${JSON.stringify(resolvedDefaultSchema)}>]
 
 export type Tables<
   DefaultSchemaTableNameOrOptions extends
@@ -769,7 +567,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 +622,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)}]`;
 };