@supabase/postgrest-typegen 0.2.4 → 0.3.0

package/README.md

@@ -113,19 +113,27 @@ breaks at read time.
 
 ```ts
 import {
-  generateTypescript, // async (uses prettier)
+  generateTypescript, // async (formats its output)
   generateGo,
   generatePython,
   generateSwift,
 } from "@supabase/postgrest-typegen/generation";
 ```
 
-| Function             | Options                                                                 |
-| -------------------- | ----------------------------------------------------------------------- |
-| `generateTypescript` | `{ detectOneToOneRelationships?, postgrestVersion?, defaultSchema? }`    |
-| `generateGo`         | —                                                                       |
-| `generatePython`     | —                                                                       |
-| `generateSwift`      | `{ accessControl?: 'internal' \| 'public' \| 'private' \| 'package' }`   |
+| Function             | Options                                                                        |
+| -------------------- | ------------------------------------------------------------------------------ |
+| `generateTypescript` | `{ detectOneToOneRelationships?, postgrestVersion?, defaultSchema?, format? }` |
+| `generateGo`         | —                                                                              |
+| `generatePython`     | —                                                                              |
+| `generateSwift`      | `{ accessControl?: 'internal' \| 'public' \| 'private' \| 'package' }`         |
+
+`generateTypescript` formats its output with `oxfmt` unless `format` is
+supplied. `oxfmt` is an optional peer dependency, imported only when that
+default runs: install it to use the default formatter, or pass your own
+`format` (an identity function, for byte-identical unformatted output, or a
+worker-pool-backed formatter) and it is never loaded or needed. Calling
+`generateTypescript` without `format` when `oxfmt` is missing throws an error
+saying so.
 
 ## Installation
 
@@ -134,6 +142,8 @@ Not yet published; consumed in-repo for now (`packages/postgrest-typegen`).
 ```bash
 # pg is a peer of your application, not bundled here
 npm install pg
+# only if you rely on generateTypescript's default formatter
+npm install oxfmt@0.66.0
 ```
 
 ## Releasing

package/dist/generation/go.js

@@ -4,8 +4,7 @@
  */
 export const generateGo = ({ schemas, tables, views, materializedViews, columns, types, }) => {
     const columnsByTableId = columns.reduce((acc, curr) => {
-        acc[curr.table_id] ??= [];
-        acc[curr.table_id].push(curr);
+        (acc[curr.table_id] ??= []).push(curr);
         return acc;
     }, {});
     const compositeTypes = types.filter((type) => type.attributes.length > 0);
@@ -50,7 +49,7 @@ function formatForGoTypeName(name) {
         .split(/[^a-zA-Z0-9]/)
         .map((word) => {
         if (word) {
-            return `${word[0].toUpperCase()}${word.slice(1)}`;
+            return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
         }
         else {
             return "";

package/dist/generation/python.js

@@ -55,8 +55,7 @@ class PythonContext {
         this.schemas = Object.fromEntries(schemas.map((schema) => [schema.name, schema]));
         this.types = Object.fromEntries(types.map((type) => [qualifiedTypeName(type.schema, type.name), type]));
         this.columns = columns.reduce((acc, curr) => {
-            acc[curr.table_id] ??= [];
-            acc[curr.table_id].push(curr);
+            (acc[curr.table_id] ??= []).push(curr);
             return acc;
         }, {});
         this.user_enums = Object.fromEntries(types
@@ -66,16 +65,25 @@ class PythonContext {
             new PythonEnum(type),
         ]));
     }
+    getSchema(name) {
+        const schema = this.schemas[name];
+        if (!schema) {
+            throw new Error(`Schema ${JSON.stringify(name)} is missing from the generator metadata`);
+        }
+        return schema;
+    }
     resolveTypeName(name, typeSchema) {
         const qualified = qualifiedTypeName(typeSchema, name);
-        if (qualified in this.user_enums) {
-            return this.user_enums[qualified].name;
+        const userEnum = this.user_enums[qualified];
+        if (userEnum) {
+            return userEnum.name;
         }
-        if (name in PY_TYPE_MAP) {
-            return PY_TYPE_MAP[name];
+        const mappedType = PY_TYPE_MAP[name];
+        if (mappedType !== undefined) {
+            return mappedType;
         }
-        if (qualified in this.types) {
-            const type = this.types[qualified];
+        const type = this.types[qualified];
+        if (type) {
             return `${formatForPyClassName(type.schema)}${formatForPyClassName(type.name)}`;
         }
         return "Any";
@@ -108,7 +116,7 @@ class PythonContext {
             // Postgres, so every field is inherently nullable.
             return new PythonBaseModelAttr(attribute.name, type, true);
         });
-        const schema = this.schemas[type.schema];
+        const schema = this.getSchema(type.schema);
         return new PythonBaseModel(type.name, schema, attributeEntries);
     }
     columnsToClassAttrs(table_id) {
@@ -129,7 +137,7 @@ class PythonContext {
         });
     }
     tableToClass(table) {
-        const schema = this.schemas[table.schema];
+        const schema = this.getSchema(table.schema);
         const select = new PythonBaseModel(table.name, schema, this.columnsToClassAttrs(table.id));
         const insert = new PythonTypedDict(table.name, "Insert", schema, this.columnsToDictAttrs(table.id, false));
         const update = new PythonTypedDict(table.name, "Update", schema, this.columnsToDictAttrs(table.id, true));
@@ -137,11 +145,11 @@ class PythonContext {
     }
     viewToClass(view) {
         const attributes = this.columnsToClassAttrs(view.id);
-        return new PythonBaseModel(view.name, this.schemas[view.schema], attributes);
+        return new PythonBaseModel(view.name, this.getSchema(view.schema), attributes);
     }
     matViewToClass(matview) {
         const attributes = this.columnsToClassAttrs(matview.id);
-        return new PythonBaseModel(matview.name, this.schemas[matview.schema], attributes);
+        return new PythonBaseModel(matview.name, this.getSchema(matview.schema), attributes);
     }
 }
 const qualifiedTypeName = (schema, name) => `${schema}.${name}`;
@@ -332,7 +340,7 @@ function formatForPyClassName(name) {
         .split(/[^a-zA-Z0-9]/)
         .map((word) => {
         if (word) {
-            return `${word[0].toUpperCase()}${word.slice(1)}`;
+            return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
         }
         else {
             return "";

package/dist/generation/swift.js

@@ -177,9 +177,9 @@ export const generateSwift = (metadata, opts = {}) => {
         t.id,
         [],
     ]));
-    columns
-        .filter((c) => c.table_id in columnsByTableId)
-        .forEach((c) => columnsByTableId[c.table_id].push(c));
+    for (const column of columns) {
+        columnsByTableId[column.table_id]?.push(column);
+    }
     let output = [
         "import Foundation",
         "import Supabase",
@@ -322,7 +322,7 @@ function formatForSwiftTypeName(name) {
             .split(/[^a-zA-Z0-9]+/)
             .map((word) => {
             if (word) {
-                return `${word[0].toUpperCase()}${word.slice(1)}`;
+                return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
             }
             else {
                 return "";

package/dist/generation/typescript.d.ts

@@ -17,9 +17,11 @@ export interface GenerateTypescriptOptions {
      */
     defaultSchema?: string;
     /**
-     * Formatter used on the generated output. Defaults to `oxfmt`, called
-     * inline. Callers on a latency-sensitive request path (e.g. postgres-meta's
-     * hosted `/generators/typescript` route) can substitute a worker-pool-backed
+     * Formatter used on the generated output. Defaults to `oxfmt`, an optional
+     * peer dependency that is imported only when this default runs, so callers
+     * that always pass their own formatter need not install it. Callers on a
+     * latency-sensitive request path (e.g. postgres-meta's hosted
+     * `/generators/typescript` route) can substitute a worker-pool-backed
      * formatter here instead of blocking the event loop on every call.
      */
     format?: (code: string) => Promise<string>;

package/dist/generation/typescript.js

@@ -1,13 +1,16 @@
-// 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 { format as oxfmtFormat } from "oxfmt";
 import { VALID_FUNCTION_ARGS_MODE, VALID_UNNAMED_FUNCTION_ARG_TYPES, } from "./constants.js";
 import { compareStrings } from "../collation.js";
+const loadOxfmt = async () => {
+    try {
+        return await import("oxfmt");
+    }
+    catch (error) {
+        throw new Error("oxfmt is not installed. It is an optional peer dependency that only the default formatter needs: install it, or pass a `format` option to generateTypescript.", { cause: error });
+    }
+};
 const defaultFormat = async (code) => {
-    const { code: formatted, errors } = await oxfmtFormat("output.ts", code, {
+    const { format } = await loadOxfmt();
+    const { code: formatted, errors } = await format("output.ts", code, {
         semi: false,
         printWidth: 80,
     });
@@ -59,23 +62,33 @@ export const generateTypescript = async (metadata, opts = {}) => {
         tablesNamesByTableId[tableLike.id] = tableLike.name;
     }
     for (const column of columns) {
-        if (column.table_id in columnsByTableId) {
-            columnsByTableId[column.table_id].push(column);
-        }
+        columnsByTableId[column.table_id]?.push(column);
     }
+    const getColumns = (tableId) => {
+        const tableColumns = columnsByTableId[tableId];
+        if (!tableColumns) {
+            throw new Error(`Relation ${tableId} is missing from the generator metadata`);
+        }
+        return tableColumns;
+    };
+    const getSchemaIntrospection = (schemaName) => {
+        const schemaIntrospection = introspectionBySchema[schemaName];
+        if (!schemaIntrospection) {
+            throw new Error(`Schema ${JSON.stringify(schemaName)} is missing from the generator metadata`);
+        }
+        return schemaIntrospection;
+    };
     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);
-            }
+        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();
@@ -105,56 +118,51 @@ export const generateTypescript = async (metadata, opts = {}) => {
     }`;
     }
     for (const table of tables) {
-        if (table.schema in introspectionBySchema) {
-            introspectionBySchema[table.schema].tables.push({
-                table,
-                relationships: getRelationships(table),
-            });
-        }
+        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),
-            });
-        }
+        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),
-            });
-        }
+        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,
-                    is_insert_enabled: false,
-                    is_update_enabled: false,
-                },
-                relationships: getRelationships(materializedView),
-            });
-        }
+        introspectionBySchema[materializedView.schema]?.views.push({
+            view: {
+                ...materializedView,
+                is_updatable: false,
+                is_insert_enabled: false,
+                is_update_enabled: 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];
+        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) {
-        if (func.schema in introspectionBySchema) {
+        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 ||
@@ -171,16 +179,16 @@ export const generateTypescript = async (metadata, opts = {}) => {
                 // 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) ||
+                (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(inArgs[0].type_id) &&
+                        (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(inArgs[0].type_id) &&
+                        (relationTypeByIds.get(soleInArg.type_id) &&
                             !getTableNameFromRelationId(func.return_type_relation_id, func.return_type_id))))) {
-                introspectionBySchema[func.schema].functions.push({ fn: func, inArgs });
+                schemaIntrospection.functions.push({ fn: func, inArgs });
             }
         }
     }
@@ -188,12 +196,12 @@ export const generateTypescript = async (metadata, opts = {}) => {
     // 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) => compareStrings(a.table.name, b.table.name));
-        introspectionBySchema[schema].views.sort((a, b) => compareStrings(a.view.name, b.view.name));
-        introspectionBySchema[schema].functions.sort((a, b) => compareStrings(a.fn.name, b.fn.name));
-        introspectionBySchema[schema].enums.sort((a, b) => compareStrings(a.name, b.name));
-        introspectionBySchema[schema].compositeTypes.sort((a, b) => compareStrings(a.name, b.name));
+    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
@@ -213,8 +221,9 @@ export const generateTypescript = async (metadata, opts = {}) => {
         }
         // 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);
+        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) {
@@ -268,7 +277,7 @@ export const generateTypescript = async (metadata, opts = {}) => {
             introspectionBySchema[schema.name]?.views.find(({ view: { id } }) => id === fn.return_type_relation_id)?.view;
         if (relation) {
             return `{
-              ${columnsByTableId[relation.id]
+              ${getColumns(relation.id)
                 .map((column) => generateColumnTsDefinition(schema, {
                 name: column.name,
                 format: column.format,
@@ -288,9 +297,10 @@ export const generateTypescript = async (metadata, opts = {}) => {
     };
     // 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) &&
+        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;
         }
@@ -301,30 +311,33 @@ export const generateTypescript = async (metadata, opts = {}) => {
         // 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;
-                return (otherInArgs.length === 1 &&
-                    otherInArgs[0].name === "" &&
-                    otherInArgs[0].has_default);
+                const otherSoleInArg = otherInArgs.length === 1 ? otherInArgs[0] : undefined;
+                return (otherSoleInArg &&
+                    otherSoleInArg.name === "" &&
+                    otherSoleInArg.has_default);
             });
-            if (conflictingFns.length > 0) {
-                const conflictingFn = conflictingFns[0];
+            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 (inArgs.length === 1 && inArgs[0].name !== "") {
+        if (soleInArg && soleInArg.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);
+                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];
@@ -443,11 +456,12 @@ export const generateTypescript = async (metadata, opts = {}) => {
      * See supabase/postgres-meta#1034.
      */
     const isComputedFieldOf = (fn, inArgs, relation) => {
-        if (inArgs.length === 1) {
+        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(inArgs[0].type_id);
+            const argType = relationTypeByIds.get(soleInArg.type_id);
             if (argType) {
                 return argType.type_relation_id === relation.id;
             }
@@ -463,7 +477,7 @@ export type Json = string | number | boolean | null | { [key: string]: Json | un
 export type Database = {
   ${internal_supabase_schema}
   ${schemas.map((schema) => {
-        const { tables: schemaTables, views: schemaViews, functions: schemaFunctions, enums: schemaEnums, compositeTypes: schemaCompositeTypes, } = introspectionBySchema[schema.name];
+        const { tables: schemaTables, views: schemaViews, functions: schemaFunctions, enums: schemaEnums, compositeTypes: schemaCompositeTypes, } = getSchemaIntrospection(schema.name);
         return `${JSON.stringify(schema.name)}: {
           Tables: {
             ${schemaTables.length === 0
@@ -471,7 +485,7 @@ export type Database = {
             : schemaTables.map(({ table, relationships, }) => `${JSON.stringify(table.name)}: {
                   Row: {
                     ${[
-                ...columnsByTableId[table.id].map((column) => generateColumnTsDefinition(schema, {
+                ...getColumns(table.id).map((column) => generateColumnTsDefinition(schema, {
                     name: column.name,
                     format: column.format,
                     type_schema: column.type_schema,
@@ -486,7 +500,7 @@ export type Database = {
             ]}
                   }
                   Insert: {
-                    ${columnsByTableId[table.id].map((column) => {
+                    ${getColumns(table.id).map((column) => {
                 if (column.identity_generation === "ALWAYS" ||
                     column.is_generated) {
                     return `${JSON.stringify(column.name)}?: never`;
@@ -503,7 +517,7 @@ export type Database = {
             })}
                   }
                   Update: {
-                    ${columnsByTableId[table.id].map((column) => {
+                    ${getColumns(table.id).map((column) => {
                 if (column.identity_generation === "ALWAYS" ||
                     column.is_generated) {
                     return `${JSON.stringify(column.name)}?: never`;
@@ -528,7 +542,7 @@ export type Database = {
             : schemaViews.map(({ view, relationships, }) => `${JSON.stringify(view.name)}: {
                   Row: {
                     ${[
-                ...columnsByTableId[view.id].map((column) => generateColumnTsDefinition(schema, {
+                ...getColumns(view.id).map((column) => generateColumnTsDefinition(schema, {
                     name: column.name,
                     format: column.format,
                     type_schema: column.type_schema,
@@ -545,7 +559,7 @@ export type Database = {
             // version 1 documents) falls back to the old gate.
             (view.is_insert_enabled ?? view.is_updatable)
                 ? `Insert: {
-                           ${columnsByTableId[view.id].map((column) => {
+                           ${getColumns(view.id).map((column) => {
                     if (!column.is_updatable) {
                         return `${JSON.stringify(column.name)}?: never`;
                     }
@@ -561,7 +575,7 @@ export type Database = {
                         `
                 : ""}${(view.is_update_enabled ?? view.is_updatable)
                 ? `Update: {
-                           ${columnsByTableId[view.id].map((column) => {
+                           ${getColumns(view.id).map((column) => {
                     if (!column.is_updatable) {
                         return `${JSON.stringify(column.name)}?: never`;
                     }
@@ -586,12 +600,11 @@ export type Database = {
                 return "[_ in never]: never";
             }
             const schemaFunctionsGroupedByName = schemaFunctions.reduce((acc, curr) => {
-                acc[curr.fn.name] ??= [];
-                acc[curr.fn.name].push(curr);
+                (acc[curr.fn.name] ??= []).push(curr);
                 return acc;
             }, {});
-            for (const fnName in schemaFunctionsGroupedByName) {
-                schemaFunctionsGroupedByName[fnName].sort((a, b) => compareStrings(a.fn.argument_types, b.fn.argument_types) ||
+            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)
@@ -734,7 +747,7 @@ export type CompositeTypes<
 
 export const Constants = {
   ${schemas.map((schema) => {
-        const schemaEnums = introspectionBySchema[schema.name].enums;
+        const schemaEnums = getSchemaIntrospection(schema.name).enums;
         return `${JSON.stringify(schema.name)}: {
           Enums: {
             ${schemaEnums.map((enum_) => `${JSON.stringify(enum_.name)}: [${enum_.enums
@@ -795,18 +808,17 @@ 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];
+        const enumType = enumTypes.find((type) => type.schema === preferredSchema) ?? enumTypes[0];
+        if (enumType) {
             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];
+        const compositeType = compositeTypes.find((type) => type.schema === preferredSchema) ??
+            compositeTypes[0];
+        if (compositeType) {
             if (schemas.some(({ name }) => name === compositeType.schema)) {
                 return `Database[${JSON.stringify(compositeType.schema)}]['CompositeTypes'][${JSON.stringify(compositeType.name)}]`;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/postgrest-typegen",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Type generation for PostgREST from PostgreSQL schemas",
   "keywords": [
     "codegen",
@@ -55,29 +55,39 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "check-types": "tsc --noEmit",
+    "check-types:consumer": "tsc --project tsconfig.consumer.json",
     "format-and-lint": "oxfmt --check . && oxlint --deny-warnings src test scripts",
     "format-and-lint:fix": "oxfmt . && oxlint --fix src test scripts",
     "knip": "knip",
     "test": "bun scripts/run-tests.ts test/"
   },
   "dependencies": {
-    "arktype": "2.2.3",
-    "oxfmt": "0.66.0"
+    "arktype": "2.2.3"
   },
   "devDependencies": {
     "@testcontainers/postgresql": "^12.1.0",
+    "@tsconfig/bun": "^1.0.11",
     "@tsconfig/node-ts": "^23.6.4",
     "@tsconfig/node24": "^24.0.5",
     "@types/bun": "^1.4.0",
     "@types/node": "^26.3.0",
     "@types/pg": "^8.23.1",
     "knip": "^6.32.3",
+    "oxfmt": "0.66.0",
     "oxlint": "1.83.0",
     "oxlint-tsgolint": "7.0.2002",
     "pg": "^8.23.0",
     "testcontainers": "^12.1.0",
     "typescript": "7.0.2"
   },
+  "peerDependencies": {
+    "oxfmt": "0.66.0"
+  },
+  "peerDependenciesMeta": {
+    "oxfmt": {
+      "optional": true
+    }
+  },
   "engines": {
     "node": ">=22.12.0"
   }

package/src/generation/go.ts

@@ -24,8 +24,7 @@ export const generateGo = ({
 }: GeneratorMetadata): string => {
   const columnsByTableId = columns.reduce(
     (acc, curr) => {
-      acc[curr.table_id] ??= [];
-      acc[curr.table_id].push(curr);
+      (acc[curr.table_id] ??= []).push(curr);
       return acc;
     },
     {} as Record<string, PostgresColumn[]>,
@@ -110,7 +109,7 @@ function formatForGoTypeName(name: string): string {
     .split(/[^a-zA-Z0-9]/)
     .map((word) => {
       if (word) {
-        return `${word[0].toUpperCase()}${word.slice(1)}`;
+        return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
       } else {
         return "";
       }

package/src/generation/python.ts

@@ -93,8 +93,7 @@ class PythonContext {
     );
     this.columns = columns.reduce(
       (acc, curr) => {
-        acc[curr.table_id] ??= [];
-        acc[curr.table_id].push(curr);
+        (acc[curr.table_id] ??= []).push(curr);
         return acc;
       },
       {} as Record<number, PostgresColumn[]>,
@@ -109,16 +108,28 @@ class PythonContext {
     );
   }
 
+  getSchema(name: string): PostgresSchema {
+    const schema = this.schemas[name];
+    if (!schema) {
+      throw new Error(
+        `Schema ${JSON.stringify(name)} is missing from the generator metadata`,
+      );
+    }
+    return schema;
+  }
+
   resolveTypeName(name: string, typeSchema: string): string {
     const qualified = qualifiedTypeName(typeSchema, name);
-    if (qualified in this.user_enums) {
-      return this.user_enums[qualified].name;
+    const userEnum = this.user_enums[qualified];
+    if (userEnum) {
+      return userEnum.name;
     }
-    if (name in PY_TYPE_MAP) {
-      return PY_TYPE_MAP[name];
+    const mappedType = PY_TYPE_MAP[name];
+    if (mappedType !== undefined) {
+      return mappedType;
     }
-    if (qualified in this.types) {
-      const type = this.types[qualified];
+    const type = this.types[qualified];
+    if (type) {
       return `${formatForPyClassName(type.schema)}${formatForPyClassName(type.name)}`;
     }
     return "Any";
@@ -158,7 +169,7 @@ class PythonContext {
       },
     );
 
-    const schema = this.schemas[type.schema];
+    const schema = this.getSchema(type.schema);
     return new PythonBaseModel(type.name, schema, attributeEntries);
   }
 
@@ -192,7 +203,7 @@ class PythonContext {
   tableToClass(
     table: PostgresTable,
   ): [PythonBaseModel, PythonTypedDict, PythonTypedDict] {
-    const schema = this.schemas[table.schema];
+    const schema = this.getSchema(table.schema);
     const select = new PythonBaseModel(
       table.name,
       schema,
@@ -217,7 +228,7 @@ class PythonContext {
     const attributes = this.columnsToClassAttrs(view.id);
     return new PythonBaseModel(
       view.name,
-      this.schemas[view.schema],
+      this.getSchema(view.schema),
       attributes,
     );
   }
@@ -226,7 +237,7 @@ class PythonContext {
     const attributes = this.columnsToClassAttrs(matview.id);
     return new PythonBaseModel(
       matview.name,
-      this.schemas[matview.schema],
+      this.getSchema(matview.schema),
       attributes,
     );
   }
@@ -463,7 +474,7 @@ function formatForPyClassName(name: string): string {
     .split(/[^a-zA-Z0-9]/)
     .map((word) => {
       if (word) {
-        return `${word[0].toUpperCase()}${word.slice(1)}`;
+        return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
       } else {
         return "";
       }

package/src/generation/swift.ts

@@ -303,9 +303,9 @@ export const generateSwift = (
     ]),
   );
 
-  columns
-    .filter((c) => c.table_id in columnsByTableId)
-    .forEach((c) => columnsByTableId[c.table_id].push(c));
+  for (const column of columns) {
+    columnsByTableId[column.table_id]?.push(column);
+  }
 
   let output = [
     "import Foundation",
@@ -492,7 +492,7 @@ function formatForSwiftTypeName(name: string): string {
       .split(/[^a-zA-Z0-9]+/)
       .map((word) => {
         if (word) {
-          return `${word[0].toUpperCase()}${word.slice(1)}`;
+          return `${word.charAt(0).toUpperCase()}${word.slice(1)}`;
         } else {
           return "";
         }

package/src/generation/typescript.ts

@@ -3,7 +3,6 @@
 // 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 { format as oxfmtFormat } from "oxfmt";
 import type {
   GeneratorMetadata,
   PostgresColumn,
@@ -39,16 +38,30 @@ export interface GenerateTypescriptOptions {
    */
   defaultSchema?: string;
   /**
-   * Formatter used on the generated output. Defaults to `oxfmt`, called
-   * inline. Callers on a latency-sensitive request path (e.g. postgres-meta's
-   * hosted `/generators/typescript` route) can substitute a worker-pool-backed
+   * Formatter used on the generated output. Defaults to `oxfmt`, an optional
+   * peer dependency that is imported only when this default runs, so callers
+   * that always pass their own formatter need not install it. Callers on a
+   * latency-sensitive request path (e.g. postgres-meta's hosted
+   * `/generators/typescript` route) can substitute a worker-pool-backed
    * formatter here instead of blocking the event loop on every call.
    */
   format?: (code: string) => Promise<string>;
 }
 
+const loadOxfmt = async () => {
+  try {
+    return await import("oxfmt");
+  } catch (error) {
+    throw new Error(
+      "oxfmt is not installed. It is an optional peer dependency that only the default formatter needs: install it, or pass a `format` option to generateTypescript.",
+      { cause: error },
+    );
+  }
+};
+
 const defaultFormat = async (code: string): Promise<string> => {
-  const { code: formatted, errors } = await oxfmtFormat("output.ts", code, {
+  const { format } = await loadOxfmt();
+  const { code: formatted, errors } = await format("output.ts", code, {
     semi: false,
     printWidth: 80,
   });
@@ -162,10 +175,26 @@ export const generateTypescript = async (
     tablesNamesByTableId[tableLike.id] = tableLike.name;
   }
   for (const column of columns) {
-    if (column.table_id in columnsByTableId) {
-      columnsByTableId[column.table_id].push(column);
-    }
+    columnsByTableId[column.table_id]?.push(column);
   }
+  const getColumns = (tableId: number): PostgresColumn[] => {
+    const tableColumns = columnsByTableId[tableId];
+    if (!tableColumns) {
+      throw new Error(
+        `Relation ${tableId} is missing from the generator metadata`,
+      );
+    }
+    return tableColumns;
+  };
+  const getSchemaIntrospection = (schemaName: string) => {
+    const schemaIntrospection = introspectionBySchema[schemaName];
+    if (!schemaIntrospection) {
+      throw new Error(
+        `Schema ${JSON.stringify(schemaName)} is missing from the generator metadata`,
+      );
+    }
+    return schemaIntrospection;
+  };
 
   for (const type of types) {
     typesById.set(type.id, type);
@@ -173,13 +202,11 @@ export const generateTypescript = async (
     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);
-      }
+    if (type.enums.length > 0) {
+      introspectionBySchema[type.schema]?.enums.push(type);
+    }
+    if (type.attributes.length > 0) {
+      introspectionBySchema[type.schema]?.compositeTypes.push(type);
     }
   }
 
@@ -233,41 +260,33 @@ export const generateTypescript = async (
   }
 
   for (const table of tables) {
-    if (table.schema in introspectionBySchema) {
-      introspectionBySchema[table.schema].tables.push({
-        table,
-        relationships: getRelationships(table),
-      });
-    }
+    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),
-      });
-    }
+    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),
-      });
-    }
+    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,
-          is_insert_enabled: false,
-          is_update_enabled: false,
-        },
-        relationships: getRelationships(materializedView),
-      });
-    }
+    introspectionBySchema[materializedView.schema]?.views.push({
+      view: {
+        ...materializedView,
+        is_updatable: false,
+        is_insert_enabled: false,
+        is_update_enabled: false,
+      },
+      relationships: getRelationships(materializedView),
+    });
   }
   // Helper function to get table/view name from relation id
   const getTableNameFromRelationId = (
@@ -276,20 +295,22 @@ export const generateTypescript = async (
   ): string | null => {
     if (!relationId) return null;
 
-    if (tablesNamesByTableId[relationId])
-      return tablesNamesByTableId[relationId];
+    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) {
-    if (func.schema in introspectionBySchema) {
+    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 ||
@@ -308,23 +329,23 @@ export const generateTypescript = async (
         // 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) ||
+        (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(inArgs[0].type_id) &&
+            (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(inArgs[0].type_id) &&
+            (relationTypeByIds.get(soleInArg.type_id) &&
               !getTableNameFromRelationId(
                 func.return_type_relation_id,
                 func.return_type_id,
               ))))
       ) {
-        introspectionBySchema[func.schema].functions.push({ fn: func, inArgs });
+        schemaIntrospection.functions.push({ fn: func, inArgs });
       }
     }
   }
@@ -332,20 +353,18 @@ export const generateTypescript = async (
   // 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) =>
+  for (const schemaIntrospection of Object.values(introspectionBySchema)) {
+    schemaIntrospection.tables.sort((a, b) =>
       compareStrings(a.table.name, b.table.name),
     );
-    introspectionBySchema[schema].views.sort((a, b) =>
+    schemaIntrospection.views.sort((a, b) =>
       compareStrings(a.view.name, b.view.name),
     );
-    introspectionBySchema[schema].functions.sort((a, b) =>
+    schemaIntrospection.functions.sort((a, b) =>
       compareStrings(a.fn.name, b.fn.name),
     );
-    introspectionBySchema[schema].enums.sort((a, b) =>
-      compareStrings(a.name, b.name),
-    );
-    introspectionBySchema[schema].compositeTypes.sort((a, b) =>
+    schemaIntrospection.enums.sort((a, b) => compareStrings(a.name, b.name));
+    schemaIntrospection.compositeTypes.sort((a, b) =>
       compareStrings(a.name, b.name),
     );
   }
@@ -376,8 +395,9 @@ export const generateTypescript = async (
     }
     // 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);
+    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
@@ -445,7 +465,7 @@ export const generateTypescript = async (
       )?.view;
     if (relation) {
       return `{
-              ${columnsByTableId[relation.id]
+              ${getColumns(relation.id)
                 .map((column) =>
                   generateColumnTsDefinition(
                     schema,
@@ -476,10 +496,11 @@ export const generateTypescript = async (
     fn: PostgresFunction,
     inArgs: PostgresFunction["args"],
   ) => {
+    const soleInArg = inArgs.length === 1 ? inArgs[0] : undefined;
     if (
-      inArgs.length === 1 &&
-      inArgs[0].name === "" &&
-      relationTypeByIds.get(inArgs[0].type_id) &&
+      soleInArg &&
+      soleInArg.name === "" &&
+      relationTypeByIds.get(soleInArg.type_id) &&
       !getTableNameFromRelationId(fn.return_type_relation_id, fn.return_type_id)
     ) {
       return true;
@@ -496,6 +517,7 @@ export const generateTypescript = async (
   ) => {
     // 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
@@ -503,16 +525,18 @@ export const generateTypescript = async (
       const conflictingFns = fns.filter(
         ({ fn: otherFn, inArgs: otherInArgs }) => {
           if (otherFn === fn) return false;
+          const otherSoleInArg =
+            otherInArgs.length === 1 ? otherInArgs[0] : undefined;
           return (
-            otherInArgs.length === 1 &&
-            otherInArgs[0].name === "" &&
-            otherInArgs[0].has_default
+            otherSoleInArg &&
+            otherSoleInArg.name === "" &&
+            otherSoleInArg.has_default
           );
         },
       );
 
-      if (conflictingFns.length > 0) {
-        const conflictingFn = conflictingFns[0];
+      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`;
@@ -520,14 +544,16 @@ export const generateTypescript = async (
     }
 
     // Pattern 2: Same parameter name but different types (unresolvable overloads)
-    if (inArgs.length === 1 && inArgs[0].name !== "") {
+    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 (
-            otherInArgs.length === 1 &&
-            otherInArgs[0].name === inArgs[0].name &&
-            otherInArgs[0].type_id !== inArgs[0].type_id
+            otherSoleInArg &&
+            otherSoleInArg.name === soleInArg.name &&
+            otherSoleInArg.type_id !== soleInArg.type_id
           );
         },
       );
@@ -711,11 +737,12 @@ export const generateTypescript = async (
     inArgs: PostgresFunction["args"],
     relation: { id: number; name: string },
   ) => {
-    if (inArgs.length === 1) {
+    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(inArgs[0]!.type_id);
+      const argType = relationTypeByIds.get(soleInArg.type_id);
       if (argType) {
         return argType.type_relation_id === relation.id;
       }
@@ -738,7 +765,7 @@ export type Database = {
       functions: schemaFunctions,
       enums: schemaEnums,
       compositeTypes: schemaCompositeTypes,
-    } = introspectionBySchema[schema.name];
+    } = getSchemaIntrospection(schema.name);
     return `${JSON.stringify(schema.name)}: {
           Tables: {
             ${
@@ -751,7 +778,7 @@ export type Database = {
                     }) => `${JSON.stringify(table.name)}: {
                   Row: {
                     ${[
-                      ...columnsByTableId[table.id].map((column) =>
+                      ...getColumns(table.id).map((column) =>
                         generateColumnTsDefinition(
                           schema,
                           {
@@ -777,7 +804,7 @@ export type Database = {
                     ]}
                   }
                   Insert: {
-                    ${columnsByTableId[table.id].map((column) => {
+                    ${getColumns(table.id).map((column) => {
                       if (
                         column.identity_generation === "ALWAYS" ||
                         column.is_generated
@@ -801,7 +828,7 @@ export type Database = {
                     })}
                   }
                   Update: {
-                    ${columnsByTableId[table.id].map((column) => {
+                    ${getColumns(table.id).map((column) => {
                       if (
                         column.identity_generation === "ALWAYS" ||
                         column.is_generated
@@ -840,7 +867,7 @@ export type Database = {
                     }) => `${JSON.stringify(view.name)}: {
                   Row: {
                     ${[
-                      ...columnsByTableId[view.id].map((column) =>
+                      ...getColumns(view.id).map((column) =>
                         generateColumnTsDefinition(
                           schema,
                           {
@@ -871,7 +898,7 @@ export type Database = {
                     // version 1 documents) falls back to the old gate.
                     (view.is_insert_enabled ?? view.is_updatable)
                       ? `Insert: {
-                           ${columnsByTableId[view.id].map((column) => {
+                           ${getColumns(view.id).map((column) => {
                              if (!column.is_updatable) {
                                return `${JSON.stringify(column.name)}?: never`;
                              }
@@ -893,7 +920,7 @@ export type Database = {
                   }${
                     (view.is_update_enabled ?? view.is_updatable)
                       ? `Update: {
-                           ${columnsByTableId[view.id].map((column) => {
+                           ${getColumns(view.id).map((column) => {
                              if (!column.is_updatable) {
                                return `${JSON.stringify(column.name)}?: never`;
                              }
@@ -926,14 +953,13 @@ export type Database = {
               }
               const schemaFunctionsGroupedByName = schemaFunctions.reduce(
                 (acc, curr) => {
-                  acc[curr.fn.name] ??= [];
-                  acc[curr.fn.name].push(curr);
+                  (acc[curr.fn.name] ??= []).push(curr);
                   return acc;
                 },
                 {} as Record<string, typeof schemaFunctions>,
               );
-              for (const fnName in schemaFunctionsGroupedByName) {
-                schemaFunctionsGroupedByName[fnName].sort(
+              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),
@@ -1100,7 +1126,7 @@ export type CompositeTypes<
 
 export const Constants = {
   ${schemas.map((schema) => {
-    const schemaEnums = introspectionBySchema[schema.name].enums;
+    const schemaEnums = getSchemaIntrospection(schema.name).enums;
     return `${JSON.stringify(schema.name)}: {
           Enums: {
             ${schemaEnums.map(
@@ -1176,10 +1202,9 @@ export const pgTypeToTsType = (
     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];
+    const enumType =
+      enumTypes.find((type) => type.schema === preferredSchema) ?? enumTypes[0];
+    if (enumType) {
       if (schemas.some(({ name }) => name === enumType.schema)) {
         return `Database[${JSON.stringify(enumType.schema)}]['Enums'][${JSON.stringify(
           enumType.name,
@@ -1191,10 +1216,10 @@ export const pgTypeToTsType = (
     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];
+    const compositeType =
+      compositeTypes.find((type) => type.schema === preferredSchema) ??
+      compositeTypes[0];
+    if (compositeType) {
       if (schemas.some(({ name }) => name === compositeType.schema)) {
         return `Database[${JSON.stringify(
           compositeType.schema,