@supabase/postgrest-typegen 0.0.1

package/dist/generation/typescript.js

@@ -0,0 +1,796 @@
+// oxlint-disable typescript/restrict-template-expressions -- this is a verbatim port of
+// postgres-meta's template, which intentionally interpolates arrays/values into template
+// literals (relying on Array#toString) to build the output. Preserving that is required for
+// byte-parity, and the offending expressions sit inside template literals where a targeted
+// disable comment would corrupt the emitted string.
+import prettier from "prettier";
+import { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./constants.js";
+/**
+ * Does not re-sort collections; pass input pre-sorted with
+ * `sortGeneratorMetadata` first. Still merge-sorts tables+foreign tables and
+ * views+materialized views per schema, since that cross-collection grouping
+ * 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 { detectOneToOneRelationships = false, postgrestVersion, defaultSchema = "public", } = opts;
+    // Ordering of all collections (incl. relationships, columns, args below) is
+    // provided by `sortGeneratorMetadata`; this generator no longer re-sorts.
+    const introspectionBySchema = Object.fromEntries(schemas.map((s) => [
+        s.name,
+        { tables: [], views: [], functions: [], enums: [], compositeTypes: [] },
+    ]));
+    const columnsByTableId = {};
+    const tablesNamesByTableId = {};
+    const relationTypeByIds = new Map();
+    // group types by id for quicker lookup
+    const typesById = new Map();
+    const tablesLike = [
+        ...tables,
+        ...foreignTables,
+        ...views,
+        ...materializedViews,
+    ];
+    for (const tableLike of tablesLike) {
+        columnsByTableId[tableLike.id] = [];
+        tablesNamesByTableId[tableLike.id] = tableLike.name;
+    }
+    for (const column of columns) {
+        if (column.table_id in columnsByTableId) {
+            columnsByTableId[column.table_id].push(column);
+        }
+    }
+    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.schema in introspectionBySchema) {
+            if (type.enums.length > 0) {
+                introspectionBySchema[type.schema].enums.push(type);
+            }
+            if (type.attributes.length > 0) {
+                introspectionBySchema[type.schema].compositeTypes.push(type);
+            }
+        }
+    }
+    const relationshipsByRelation = new Map();
+    for (const relationship of relationships) {
+        const key = `${relationship.schema}.${relationship.relation}`;
+        let bucket = relationshipsByRelation.get(key);
+        if (!bucket) {
+            bucket = [];
+            relationshipsByRelation.set(key, bucket);
+        }
+        bucket.push(relationship);
+    }
+    function getRelationships(object) {
+        const candidates = relationshipsByRelation.get(`${object.schema}.${object.name}`);
+        if (!candidates)
+            return [];
+        return candidates.filter((relationship) => relationship.referenced_schema === object.schema);
+    }
+    function generateRelationshiptTsDefinition(relationship) {
+        return `{
+      foreignKeyName: ${JSON.stringify(relationship.foreign_key_name)}
+      columns: ${JSON.stringify(relationship.columns)}${detectOneToOneRelationships
+            ? `\nisOneToOne: ${relationship.is_one_to_one}`
+            : ""}
+      referencedRelation: ${JSON.stringify(relationship.referenced_relation)}
+      referencedColumns: ${JSON.stringify(relationship.referenced_columns)}
+    }`;
+    }
+    for (const table of tables) {
+        if (table.schema in introspectionBySchema) {
+            introspectionBySchema[table.schema].tables.push({
+                table,
+                relationships: getRelationships(table),
+            });
+        }
+    }
+    for (const table of foreignTables) {
+        if (table.schema in introspectionBySchema) {
+            introspectionBySchema[table.schema].tables.push({
+                table,
+                relationships: getRelationships(table),
+            });
+        }
+    }
+    for (const view of views) {
+        if (view.schema in introspectionBySchema) {
+            introspectionBySchema[view.schema].views.push({
+                view,
+                relationships: getRelationships(view),
+            });
+        }
+    }
+    for (const materializedView of materializedViews) {
+        if (materializedView.schema in introspectionBySchema) {
+            introspectionBySchema[materializedView.schema].views.push({
+                view: {
+                    ...materializedView,
+                    is_updatable: false,
+                },
+                relationships: getRelationships(materializedView),
+            });
+        }
+    }
+    // Helper function to get table/view name from relation id
+    const getTableNameFromRelationId = (relationId, returnTypeId) => {
+        if (!relationId)
+            return null;
+        if (tablesNamesByTableId[relationId])
+            return tablesNamesByTableId[relationId];
+        // 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) {
+        if (func.schema in introspectionBySchema) {
+            // Get all input args (in, inout, variadic modes)
+            const inArgs = func.args.filter(({ mode }) => VALID_FUNCTION_ARGS_MODE.has(mode));
+            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
+                (inArgs.length === 1 &&
+                    inArgs[0].name === "" &&
+                    (VALID_UNNAMED_FUNCTION_ARG_TYPES.has(inArgs[0].type_id) ||
+                        // OR if the function have a single unnamed args which is another table (embeded function)
+                        (relationTypeByIds.get(inArgs[0].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(inArgs[0].type_id) &&
+                            !getTableNameFromRelationId(func.return_type_relation_id, func.return_type_id))))) {
+                introspectionBySchema[func.schema].functions.push({ fn: func, inArgs });
+            }
+        }
+    }
+    // These per-schema groups MERGE multiple metadata collections — `.tables`
+    // combines tables + foreign tables, `.views` combines views + materialized
+    // views — so the cross-collection name sort can't be expressed by the
+    // single-collection `sortGeneratorMetadata` pass and stays here.
+    for (const schema in introspectionBySchema) {
+        introspectionBySchema[schema].tables.sort((a, b) => a.table.name.localeCompare(b.table.name));
+        introspectionBySchema[schema].views.sort((a, b) => a.view.name.localeCompare(b.view.name));
+        introspectionBySchema[schema].functions.sort((a, b) => a.fn.name.localeCompare(b.fn.name));
+        introspectionBySchema[schema].enums.sort((a, b) => a.name.localeCompare(b.name));
+        introspectionBySchema[schema].compositeTypes.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    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
+        if (fn.args.length === 1) {
+            const relationType = relationTypeByIds.get(fn.args[0].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 getFunctionReturnType = (schema, fn) => {
+        // 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, {
+                        types,
+                        schemas,
+                        tables,
+                        views,
+                    });
+                }
+                return { name, type: tsType };
+            });
+            return `{
+              ${argsNameAndType.map(({ name, type }) => `${JSON.stringify(name)}: ${type}`)}
+            }`;
+        }
+        // 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) {
+            return `{
+              ${columnsByTableId[relation.id]
+                .map((column) => generateColumnTsDefinition(schema, {
+                name: column.name,
+                format: column.format,
+                type_schema: column.type_schema,
+                is_nullable: column.is_nullable,
+                is_optional: false,
+            }, {
+                types,
+                schemas,
+                tables,
+                views,
+            }))
+                .join(",\n")}
+            }`;
+        }
+        // Case 3: returns base/array/composite/enum type.
+        const type = typesById.get(fn.return_type_id);
+        if (type) {
+            return pgTypeToTsType(schema, type.name, {
+                types,
+                schemas,
+                tables,
+                views,
+            });
+        }
+        return "unknown";
+    };
+    // Special error case for functions that take table row but don't qualify as embedded functions
+    const hasTableRowError = (fn, inArgs) => {
+        if (inArgs.length === 1 &&
+            inArgs[0].name === "" &&
+            relationTypeByIds.get(inArgs[0].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;
+        // 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;
+                return (otherInArgs.length === 1 &&
+                    otherInArgs[0].name === "" &&
+                    otherInArgs[0].has_default);
+            });
+            if (conflictingFns.length > 0) {
+                const conflictingFn = conflictingFns[0];
+                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 (inArgs.length === 1 && inArgs[0].name !== "") {
+            const conflictingFns = fns.filter(({ fn: otherFn, inArgs: otherInArgs }) => {
+                if (otherFn === fn)
+                    return false;
+                return (otherInArgs.length === 1 &&
+                    otherInArgs[0].name === inArgs[0].name &&
+                    otherInArgs[0].type_id !== inArgs[0].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 getFunctionSignatures = (schema, fns) => {
+        return fns
+            .map(({ fn, inArgs }) => {
+            let argsType = "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, {
+                                types,
+                                schemas,
+                                tables,
+                                views,
+                            });
+                        }
+                        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, {
+                                types,
+                                schemas,
+                                tables,
+                                views,
+                            });
+                        }
+                        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, {
+                            types,
+                            schemas,
+                            tables,
+                            views,
+                        });
+                    }
+                    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");
+    };
+    const internal_supabase_schema = postgrestVersion
+        ? `// Allows to automatically instantiate createClient with right options
+  // instead of createClient<Database, { PostgrestVersion: 'XX' }>(URL, KEY)
+  __InternalSupabase: {
+    PostgrestVersion: '${postgrestVersion}'
+  }`
+        : "";
+    function generateNullableUnionTsType(tsType, isNullable) {
+        // Only add the null union if the type is not unknown as unknown already includes null
+        if (tsType === "unknown" || tsType === "any" || !isNullable) {
+            return tsType;
+        }
+        return `${tsType} | null`;
+    }
+    function generateColumnTsDefinition(schema, column, context) {
+        return `${JSON.stringify(column.name)}${column.is_optional ? "?" : ""}: ${generateNullableUnionTsType(pgTypeToTsType(schema, column.format, context, column.type_schema), column.is_nullable)}`;
+    }
+    let output = `
+export type Json = string | number | boolean | null | { [key: string]: Json | undefined } | Json[]
+
+export type Database = {
+  ${internal_supabase_schema}
+  ${schemas.map((schema) => {
+        const { tables: schemaTables, views: schemaViews, functions: schemaFunctions, enums: schemaEnums, compositeTypes: schemaCompositeTypes, } = introspectionBySchema[schema.name];
+        return `${JSON.stringify(schema.name)}: {
+          Tables: {
+            ${schemaTables.length === 0
+            ? "[_ in never]: never"
+            : schemaTables.map(({ table, relationships, }) => `${JSON.stringify(table.name)}: {
+                  Row: {
+                    ${[
+                ...columnsByTableId[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,
+                }, { types, schemas, tables, views })),
+                ...schemaFunctions
+                    .filter(({ fn }) => fn.argument_types === table.name)
+                    .map(({ fn }) => {
+                    return `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`;
+                }),
+            ]}
+                  }
+                  Insert: {
+                    ${columnsByTableId[table.id].map((column) => {
+                if (column.identity_generation === "ALWAYS") {
+                    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,
+                }, { types, schemas, tables, views });
+            })}
+                  }
+                  Update: {
+                    ${columnsByTableId[table.id].map((column) => {
+                if (column.identity_generation === "ALWAYS") {
+                    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,
+                }, { types, schemas, tables, views });
+            })}
+                  }
+                  Relationships: [
+                    ${relationships.map(generateRelationshiptTsDefinition)}
+                  ]
+                }`)}
+          }
+          Views: {
+            ${schemaViews.length === 0
+            ? "[_ in never]: never"
+            : schemaViews.map(({ view, relationships, }) => `${JSON.stringify(view.name)}: {
+                  Row: {
+                    ${[
+                ...columnsByTableId[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,
+                }, { types, schemas, tables, views })),
+                ...schemaFunctions
+                    .filter(({ fn }) => fn.argument_types === view.name)
+                    .map(({ fn }) => `${JSON.stringify(fn.name)}: ${generateNullableUnionTsType(getFunctionReturnType(schema, fn), true)}`),
+            ]}
+                  }
+                  ${view.is_updatable
+                ? `Insert: {
+                           ${columnsByTableId[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,
+                    }, { types, schemas, tables, views });
+                })}
+                         }
+                         Update: {
+                           ${columnsByTableId[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,
+                    }, { types, schemas, tables, views });
+                })}
+                         }
+                        `
+                : ""}Relationships: [
+                    ${relationships.map(generateRelationshiptTsDefinition)}
+                  ]
+                }`)}
+          }
+          Functions: {
+            ${(() => {
+            if (schemaFunctions.length === 0) {
+                return "[_ in never]: never";
+            }
+            const schemaFunctionsGroupedByName = schemaFunctions.reduce((acc, curr) => {
+                acc[curr.fn.name] ??= [];
+                acc[curr.fn.name].push(curr);
+                return acc;
+            }, {});
+            for (const fnName in schemaFunctionsGroupedByName) {
+                schemaFunctionsGroupedByName[fnName].sort((a, b) => a.fn.argument_types.localeCompare(b.fn.argument_types) ||
+                    a.fn.return_type.localeCompare(b.fn.return_type));
+            }
+            return Object.entries(schemaFunctionsGroupedByName)
+                .map(([fnName, fns]) => {
+                const functionSignatures = getFunctionSignatures(schema, fns);
+                return `${JSON.stringify(fnName)}:\n${functionSignatures}`;
+            })
+                .join(",\n");
+        })()}
+          }
+          Enums: {
+            ${schemaEnums.length === 0
+            ? "[_ in never]: never"
+            : schemaEnums.map((enum_) => `${JSON.stringify(enum_.name)}: ${enum_.enums
+                .map((variant) => JSON.stringify(variant))
+                .join("|")}`)}
+          }
+          CompositeTypes: {
+            ${schemaCompositeTypes.length === 0
+            ? "[_ in never]: never"
+            : schemaCompositeTypes.map(({ name, attributes }) => `${JSON.stringify(name)}: {
+                        ${attributes.map(({ name, type_id }) => {
+                const type = typesById.get(type_id);
+                let tsType = "unknown";
+                if (type) {
+                    tsType = `${generateNullableUnionTsType(pgTypeToTsType(schema, type.name, {
+                        types,
+                        schemas,
+                        tables,
+                        views,
+                    }), true)}`;
+                }
+                return `${JSON.stringify(name)}: ${tsType}`;
+            })}
+                      }`)}
+          }
+        }`;
+    })}
+}
+
+type DatabaseWithoutInternals = Omit<Database, '__InternalSupabase'>
+
+type DefaultSchema = DatabaseWithoutInternals[Extract<keyof Database, ${JSON.stringify(defaultSchema)}>]
+
+export type Tables<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof (DefaultSchema["Tables"] & DefaultSchema["Views"])
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+        DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])
+    : never = never
+> = DefaultSchemaTableNameOrOptions extends { schema: keyof DatabaseWithoutInternals }
+  ? (DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"] &
+      DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Views"])[TableName] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof (DefaultSchema["Tables"] & DefaultSchema["Views"])
+  ? (DefaultSchema["Tables"] & DefaultSchema["Views"])[DefaultSchemaTableNameOrOptions] extends {
+      Row: infer R
+    }
+    ? R
+    : never
+  : never
+
+export type TablesInsert<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
+    : never = never
+> = DefaultSchemaTableNameOrOptions extends { schema: keyof DatabaseWithoutInternals }
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+  ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
+      Insert: infer I
+    }
+    ? I
+    : never
+  : never
+
+export type TablesUpdate<
+  DefaultSchemaTableNameOrOptions extends
+    | keyof DefaultSchema["Tables"]
+    | { schema: keyof DatabaseWithoutInternals },
+  TableName extends DefaultSchemaTableNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"]
+    : never = never
+> = DefaultSchemaTableNameOrOptions extends { schema: keyof DatabaseWithoutInternals }
+  ? DatabaseWithoutInternals[DefaultSchemaTableNameOrOptions["schema"]]["Tables"][TableName] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : DefaultSchemaTableNameOrOptions extends keyof DefaultSchema["Tables"]
+  ? DefaultSchema["Tables"][DefaultSchemaTableNameOrOptions] extends {
+      Update: infer U
+    }
+    ? U
+    : never
+  : never
+
+export type Enums<
+  DefaultSchemaEnumNameOrOptions extends
+    | keyof DefaultSchema["Enums"]
+    | { schema: keyof DatabaseWithoutInternals },
+  EnumName extends DefaultSchemaEnumNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"]
+    : never = never
+> = DefaultSchemaEnumNameOrOptions extends { schema: keyof DatabaseWithoutInternals }
+  ? DatabaseWithoutInternals[DefaultSchemaEnumNameOrOptions["schema"]]["Enums"][EnumName]
+  : DefaultSchemaEnumNameOrOptions extends keyof DefaultSchema["Enums"]
+  ? DefaultSchema["Enums"][DefaultSchemaEnumNameOrOptions]
+  : never
+
+export type CompositeTypes<
+  PublicCompositeTypeNameOrOptions extends
+    | keyof DefaultSchema["CompositeTypes"]
+    | { schema: keyof DatabaseWithoutInternals },
+  CompositeTypeName extends PublicCompositeTypeNameOrOptions extends {
+    schema: keyof DatabaseWithoutInternals
+  }
+    ? keyof DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"]
+    : never = never
+> = PublicCompositeTypeNameOrOptions extends { schema: keyof DatabaseWithoutInternals }
+  ? DatabaseWithoutInternals[PublicCompositeTypeNameOrOptions["schema"]]["CompositeTypes"][CompositeTypeName]
+  : PublicCompositeTypeNameOrOptions extends keyof DefaultSchema["CompositeTypes"]
+  ? DefaultSchema["CompositeTypes"][PublicCompositeTypeNameOrOptions]
+  : never
+
+export const Constants = {
+  ${schemas.map((schema) => {
+        const schemaEnums = introspectionBySchema[schema.name].enums;
+        return `${JSON.stringify(schema.name)}: {
+          Enums: {
+            ${schemaEnums.map((enum_) => `${JSON.stringify(enum_.name)}: [${enum_.enums
+            .map((variant) => JSON.stringify(variant))
+            .join(", ")}]`)}
+          }
+        }`;
+    })}
+} as const
+`;
+    output = await prettier.format(output, {
+        parser: "typescript",
+        semi: false,
+    });
+    return output;
+};
+// TODO: Make this more robust. Currently doesn't handle range types - returns them as unknown.
+export const pgTypeToTsType = (schema, pgType, { types, schemas, tables, views, }, 
+// The schema that actually owns `pgType` (a column's `type_schema`), when
+// known. Disambiguates same-named enums/composites across schemas; falls
+// back to `schema.name` (the table's own schema) when not provided, e.g.
+// for function args/return types where no equivalent field exists yet.
+typeSchema) => {
+    if (pgType === "bool") {
+        return "boolean";
+    }
+    else if (["int2", "int4", "int8", "float4", "float8", "numeric"].includes(pgType)) {
+        return "number";
+    }
+    else if ([
+        "bytea",
+        "bpchar",
+        "varchar",
+        "date",
+        "text",
+        "citext",
+        "time",
+        "timetz",
+        "timestamp",
+        "timestamptz",
+        "uuid",
+        "vector",
+        "interval",
+    ].includes(pgType)) {
+        return "string";
+    }
+    else if (["json", "jsonb"].includes(pgType)) {
+        return "Json";
+    }
+    else if (pgType === "void") {
+        return "undefined";
+    }
+    else if (pgType === "record") {
+        return "Record<string, unknown>";
+    }
+    else if (pgType.startsWith("_")) {
+        return `(${pgTypeToTsType(schema, pgType.substring(1), { types, schemas, tables, views }, typeSchema)})[]`;
+    }
+    else {
+        const preferredSchema = typeSchema ?? schema.name;
+        const enumTypes = types.filter((type) => type.name === pgType && type.enums.length > 0);
+        if (enumTypes.length > 0) {
+            const enumType = enumTypes.find((type) => type.schema === preferredSchema) ||
+                enumTypes[0];
+            if (schemas.some(({ name }) => name === enumType.schema)) {
+                return `Database[${JSON.stringify(enumType.schema)}]['Enums'][${JSON.stringify(enumType.name)}]`;
+            }
+            return enumType.enums.map((variant) => JSON.stringify(variant)).join("|");
+        }
+        const compositeTypes = types.filter((type) => type.name === pgType && type.attributes.length > 0);
+        if (compositeTypes.length > 0) {
+            const compositeType = compositeTypes.find((type) => type.schema === preferredSchema) ||
+                compositeTypes[0];
+            if (schemas.some(({ name }) => name === compositeType.schema)) {
+                return `Database[${JSON.stringify(compositeType.schema)}]['CompositeTypes'][${JSON.stringify(compositeType.name)}]`;
+            }
+            return "unknown";
+        }
+        const tableRowTypes = tables.filter((table) => table.name === pgType);
+        if (tableRowTypes.length > 0) {
+            const tableRowType = tableRowTypes.find((type) => type.schema === preferredSchema) ||
+                tableRowTypes[0];
+            if (schemas.some(({ name }) => name === tableRowType.schema)) {
+                return `Database[${JSON.stringify(tableRowType.schema)}]['Tables'][${JSON.stringify(tableRowType.name)}]['Row']`;
+            }
+            return "unknown";
+        }
+        const viewRowTypes = views.filter((view) => view.name === pgType);
+        if (viewRowTypes.length > 0) {
+            const viewRowType = viewRowTypes.find((type) => type.schema === preferredSchema) ||
+                viewRowTypes[0];
+            if (schemas.some(({ name }) => name === viewRowType.schema)) {
+                return `Database[${JSON.stringify(viewRowType.schema)}]['Views'][${JSON.stringify(viewRowType.name)}]['Row']`;
+            }
+            return "unknown";
+        }
+        return "unknown";
+    }
+};