@supabase/postgrest-typegen 0.4.0 → 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,120 +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`;
-            }
-        }
-        // 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`;
-            }
-        }
-        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);
+    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 (name === "") {
+        if (arg.name === "" || arg.format === null || arg.type_schema === null) {
             return tsType;
         }
-        const relationReference = findRelationReference(type.name, typeContext, type.schema);
+        const relationReference = findRelationReference(arg.format, typeContext, arg.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 }) => {
+    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".
-            const argsType = inArgs.length > 0
-                ? getArgsTsType(schema, inArgs)
+            const argsType = overload.args.length > 0
+                ? getArgsTsType(schema, overload.args)
                 : "Record<PropertyKey, never>";
-            let returnType = getFunctionReturnType(schema, fn);
-            // Check for specific error cases
-            const conflictError = getConflictError(schema, fns, fn, inArgs);
-            if (conflictError) {
-                returnType = `{ error: true } & ${JSON.stringify(conflictError)}`;
-            }
-            else if (hasTableRowError(fn, inArgs)) {
-                // Special case for computed fields returning scalars functions
-                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`)}`;
-            }
-            return `{ Args: ${argsType}; Returns: ${getFunctionTsReturnType(fn, returnType)} }`;
+            const returnType = overload.error === null
+                ? getFunctionReturnType(schema, overload)
+                : `{ error: true } & ${JSON.stringify(overload.error)}`;
+            return `{ Args: ${argsType}; Returns: ${getFunctionTsReturnType(overload, returnType)} }`;
         })
             .join(" |\n");
     };
@@ -429,62 +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;
-    };
-    /**
-     * 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)}`;
+    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(({ fn }) => JSON.stringify(fn.name)).join(" | ");
+        : computedFields.map(({ name }) => JSON.stringify(name)).join(" | ");
     let output = `
 export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
 
@@ -611,25 +407,11 @@ export type Database = {
             })}
           }
           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
@@ -658,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

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./types.ts";
 export * from "./sort.ts";
+export * from "./rpc.ts";
 export * from "./introspection/index.ts";
 export * from "./generation/index.ts";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./types.js";
 export * from "./sort.js";
+export * from "./rpc.js";
 export * from "./introspection/index.js";
 export * from "./generation/index.js";

package/dist/introspection/index.js

@@ -1,4 +1,5 @@
 import { GENERATOR_METADATA_VERSION, } from "../types.js";
+import { resolveRpcFunctions } from "../rpc.js";
 import { normalizeRows } from "./normalize.js";
 import { listRelationships } from "./relationships.js";
 import { COLUMNS_SQL } from "./sql/columns.sql.js";
@@ -43,7 +44,7 @@ export async function introspect(db, opts = {}) {
         queryRows(FUNCTIONS_SQL({ schemaFilter: systemExcludingFilter })),
         queryRows(TYPES_SQL),
     ]);
-    return {
+    const metadata = {
         version: GENERATOR_METADATA_VERSION,
         schemas,
         tables,
@@ -56,4 +57,5 @@ export async function introspect(db, opts = {}) {
         functions: functions.filter(({ return_type }) => !["trigger", "event_trigger"].includes(return_type)),
         types,
     };
+    return { ...metadata, rpcFunctions: resolveRpcFunctions(metadata) };
 }

package/dist/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { GeneratorMetadata, RpcFunction } from "./types.ts";
+export declare function resolveRpcFunctions(metadata: GeneratorMetadata): RpcFunction[];