@rebasepro/server-postgres 0.0.1-canary.4829d6e

package/src/schema/dynamic-tables.test.ts

@@ -0,0 +1,302 @@
+import { describe, expect, it } from "@jest/globals";
+import { getTableName, sql } from "drizzle-orm";
+import { getTableConfig } from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/node-postgres";
+
+import { buildDrizzleTablesFromSchema, buildDrizzleRelationsFromSchema } from "./dynamic-tables";
+import { buildTablesMap, TableColumn, PrimaryKeyRow, ForeignKeyRow } from "./introspect-db-logic";
+
+function column(overrides: Partial<TableColumn> & { table_name: string; column_name: string }): TableColumn {
+    return {
+        data_type: "text",
+        udt_name: "text",
+        is_nullable: "YES",
+        column_default: null,
+        atttypmod: null,
+        ...overrides
+    };
+}
+
+function tablesMapOf(columns: TableColumn[], pks: PrimaryKeyRow[], fks: ForeignKeyRow[] = []) {
+    const tableNames = [...new Set(columns.map((c) => c.table_name))].map((table_name) => ({ table_name }));
+    return buildTablesMap(tableNames, columns, pks, fks);
+}
+
+describe("buildDrizzleTablesFromSchema", () => {
+    it("builds a table per introspected table, named after the pg table", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [column({ table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" })],
+                [{ table_name: "posts", column_name: "id" }]
+            )
+        );
+
+        expect(Object.keys(tables)).toEqual(["posts"]);
+        expect(getTableName(tables.posts)).toBe("posts");
+    });
+
+    it("maps pg types onto the matching drizzle column types", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "count", data_type: "integer", udt_name: "int4" }),
+                    column({ table_name: "t", column_name: "big", data_type: "bigint", udt_name: "int8" }),
+                    column({ table_name: "t", column_name: "price", data_type: "numeric", udt_name: "numeric" }),
+                    column({ table_name: "t", column_name: "active", data_type: "boolean", udt_name: "bool" }),
+                    column({ table_name: "t", column_name: "meta", data_type: "jsonb", udt_name: "jsonb" }),
+                    column({ table_name: "t", column_name: "created_at", data_type: "timestamp with time zone", udt_name: "timestamptz" }),
+                    column({ table_name: "t", column_name: "born_on", data_type: "date", udt_name: "date" })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const byName = Object.fromEntries(
+            getTableConfig(tables.t).columns.map((c) => [c.name, c.getSQLType()])
+        );
+
+        expect(byName.id).toBe("uuid");
+        expect(byName.count).toBe("integer");
+        expect(byName.big).toBe("bigint");
+        expect(byName.price).toBe("numeric");
+        expect(byName.active).toBe("boolean");
+        expect(byName.meta).toBe("jsonb");
+        expect(byName.created_at).toBe("timestamp with time zone");
+        expect(byName.born_on).toBe("date");
+    });
+
+    it("carries NOT NULL and single-column primary keys onto the columns", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "title", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "subtitle", is_nullable: "YES" })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const columns = getTableConfig(tables.t).columns;
+        const id = columns.find((c) => c.name === "id")!;
+        const title = columns.find((c) => c.name === "title")!;
+        const subtitle = columns.find((c) => c.name === "subtitle")!;
+
+        expect(id.primary).toBe(true);
+        expect(title.notNull).toBe(true);
+        expect(title.primary).toBe(false);
+        expect(subtitle.notNull).toBe(false);
+    });
+
+    it("declares composite primary keys as a table constraint", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "posts_tags", column_name: "post_id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "posts_tags", column_name: "tag_id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" })
+                ],
+                [
+                    { table_name: "posts_tags", column_name: "post_id" },
+                    { table_name: "posts_tags", column_name: "tag_id" }
+                ]
+            )
+        );
+
+        const config = getTableConfig(tables.posts_tags);
+        expect(config.primaryKeys).toHaveLength(1);
+        expect(config.primaryKeys[0].columns.map((c) => c.name).sort()).toEqual(["post_id", "tag_id"]);
+        // No column should claim the primary key on its own.
+        expect(config.columns.every((c) => !c.primary)).toBe(true);
+    });
+
+    it("binds tables to a non-public schema", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [column({ table_name: "users", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" })],
+                [{ table_name: "users", column_name: "id" }]
+            ),
+            "rebase"
+        );
+
+        expect(getTableConfig(tables.users).schema).toBe("rebase");
+    });
+
+    it("falls back to text for unknown types rather than dropping the column", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "location", data_type: "USER-DEFINED", udt_name: "geography" }),
+                    column({ table_name: "t", column_name: "weird", data_type: "USER-DEFINED", udt_name: "some_future_type" })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const byName = Object.fromEntries(getTableConfig(tables.t).columns.map((c) => [c.name, c.getSQLType()]));
+        expect(byName.location).toBe("text");
+        expect(byName.weird).toBe("text");
+    });
+
+    it("maps the types a plain type switch tends to miss", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "blob", data_type: "bytea", udt_name: "bytea" }),
+                    column({ table_name: "t", column_name: "span", data_type: "interval", udt_name: "interval" }),
+                    column({ table_name: "t", column_name: "ip", data_type: "inet", udt_name: "inet" }),
+                    column({ table_name: "t", column_name: "mac", data_type: "macaddr", udt_name: "macaddr" }),
+                    column({ table_name: "t", column_name: "code", data_type: "character", udt_name: "bpchar", atttypmod: 14 }),
+                    column({ table_name: "t", column_name: "name", data_type: "character varying", udt_name: "varchar", atttypmod: 104 }),
+                    column({ table_name: "t", column_name: "clock", data_type: "time with time zone", udt_name: "timetz" }),
+                    column({ table_name: "t", column_name: "embedding", data_type: "USER-DEFINED", udt_name: "vector", atttypmod: 3 })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const byName = Object.fromEntries(getTableConfig(tables.t).columns.map((c) => [c.name, c.getSQLType()]));
+
+        // bytea has no drizzle builder — a text fallback would corrupt binary.
+        expect(byName.blob).toBe("bytea");
+        expect(byName.span).toBe("interval");
+        expect(byName.ip).toBe("inet");
+        expect(byName.mac).toBe("macaddr");
+        expect(byName.code).toBe("char(10)");
+        expect(byName.name).toBe("varchar(100)");
+        expect(byName.clock).toBe("time with time zone");
+        expect(byName.embedding).toBe("vector(3)");
+    });
+
+    it("types arrays by their element rather than flattening them to text[]", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "tags", data_type: "ARRAY", udt_name: "_text" }),
+                    column({ table_name: "t", column_name: "scores", data_type: "ARRAY", udt_name: "_int4" }),
+                    column({ table_name: "t", column_name: "ids", data_type: "ARRAY", udt_name: "_uuid" })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const byName = Object.fromEntries(getTableConfig(tables.t).columns.map((c) => [c.name, c.getSQLType()]));
+
+        expect(byName.tags).toBe("text[]");
+        expect(byName.scores).toBe("integer[]");
+        expect(byName.ids).toBe("uuid[]");
+    });
+
+    it("falls back to text for a vector of undeclared width", () => {
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "t", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "t", column_name: "embedding", data_type: "USER-DEFINED", udt_name: "vector", atttypmod: -1 })
+                ],
+                [{ table_name: "t", column_name: "id" }]
+            )
+        );
+
+        const byName = Object.fromEntries(getTableConfig(tables.t).columns.map((c) => [c.name, c.getSQLType()]));
+        expect(byName.embedding).toBe("text");
+    });
+
+    it("produces tables drizzle can compile into SQL", () => {
+        // The real proof: a table object is only useful if the query builder
+        // accepts it. Compiling a select exercises the whole construction.
+        const tables = buildDrizzleTablesFromSchema(
+            tablesMapOf(
+                [
+                    column({ table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                    column({ table_name: "posts", column_name: "title", is_nullable: "NO" })
+                ],
+                [{ table_name: "posts", column_name: "id" }]
+            )
+        );
+
+        const db = drizzle({ schema: tables, client: {} as never });
+        const query = db.select().from(tables.posts as never).toSQL();
+
+        expect(query.sql).toContain('from "posts"');
+        expect(query.sql).toContain('"id"');
+        expect(query.sql).toContain('"title"');
+    });
+});
+
+describe("buildDrizzleRelationsFromSchema", () => {
+    const schema = () =>
+        tablesMapOf(
+            [
+                column({ table_name: "authors", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                column({ table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                column({ table_name: "posts", column_name: "author_id", data_type: "uuid", udt_name: "uuid" })
+            ],
+            [
+                { table_name: "authors", column_name: "id" },
+                { table_name: "posts", column_name: "id" }
+            ],
+            [{ table_name: "posts", column_name: "author_id", foreign_table_name: "authors", foreign_column_name: "id" }]
+        );
+
+    it("pairs each owning one() with the inverse many() drizzle requires", () => {
+        // Drizzle's normalizeRelation throws on a named one() with no matching
+        // many(), which silently drops the query to the N+1 fallback path.
+        const map = schema();
+        const tables = buildDrizzleTablesFromSchema(map);
+        const rels = buildDrizzleRelationsFromSchema(map, tables);
+
+        expect(Object.keys(rels).sort()).toEqual(["authorsRelations", "postsRelations"]);
+
+        const db = drizzle({ schema: { ...tables, ...rels }, client: {} as never });
+        const config = (db as unknown as { _: { schema: Record<string, { relations: Record<string, unknown> }> } })._.schema;
+
+        expect(Object.keys(config.posts.relations)).toEqual(["author"]);
+        expect(Object.keys(config.authors.relations)).toEqual(["posts"]);
+    });
+
+    it("compiles a relational query that joins the related table", () => {
+        const map = schema();
+        const tables = buildDrizzleTablesFromSchema(map);
+        const rels = buildDrizzleRelationsFromSchema(map, tables);
+        const db = drizzle({ schema: { ...tables, ...rels }, client: {} as never });
+
+        const query = (db as never as { query: Record<string, { findMany(a: unknown): { toSQL(): { sql: string } } }> })
+            .query.posts.findMany({ with: { author: true } }).toSQL();
+
+        expect(query.sql).toContain('"authors"');
+        expect(query.sql).toContain("author_id");
+    });
+
+    it("skips a relation whose key would shadow a real column", () => {
+        const map = tablesMapOf(
+            [
+                column({ table_name: "authors", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                column({ table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" }),
+                // A literal "author" column alongside the author_id foreign key.
+                column({ table_name: "posts", column_name: "author", data_type: "text", udt_name: "text" }),
+                column({ table_name: "posts", column_name: "author_id", data_type: "uuid", udt_name: "uuid" })
+            ],
+            [
+                { table_name: "authors", column_name: "id" },
+                { table_name: "posts", column_name: "id" }
+            ],
+            [{ table_name: "posts", column_name: "author_id", foreign_table_name: "authors", foreign_column_name: "id" }]
+        );
+        const tables = buildDrizzleTablesFromSchema(map);
+        const rels = buildDrizzleRelationsFromSchema(map, tables);
+
+        expect(rels.postsRelations).toBeUndefined();
+    });
+
+    it("returns nothing for a schema with no foreign keys", () => {
+        const map = tablesMapOf(
+            [column({ table_name: "posts", column_name: "id", data_type: "uuid", udt_name: "uuid", is_nullable: "NO" })],
+            [{ table_name: "posts", column_name: "id" }]
+        );
+        expect(buildDrizzleRelationsFromSchema(map, buildDrizzleTablesFromSchema(map))).toEqual({});
+    });
+});

package/src/schema/dynamic-tables.ts

@@ -0,0 +1,293 @@
+/**
+ * Build drizzle tables at runtime from an introspected schema.
+ *
+ * CMS mode gets its drizzle tables from a generated `schema.generated.ts` that
+ * the developer commits. BaaS mode has no such file — it points at a database
+ * and serves it — so the equivalent table objects are constructed here from
+ * `information_schema` metadata.
+ *
+ * These are handed to drizzle as its schema, which keeps the relational query
+ * path (`db.query.*`) working; without them FetchService would fall back to
+ * plain selects and lose relation loading.
+ */
+import {
+    bigint,
+    boolean,
+    char,
+    cidr,
+    customType,
+    date,
+    doublePrecision,
+    geometry,
+    inet,
+    integer,
+    interval,
+    json,
+    jsonb,
+    line,
+    macaddr,
+    macaddr8,
+    numeric,
+    pgSchema,
+    pgTable,
+    point,
+    primaryKey,
+    real,
+    smallint,
+    text,
+    time,
+    timestamp,
+    uuid,
+    varchar,
+    vector,
+    type PgColumnBuilderBase,
+    type PgTable
+} from "drizzle-orm/pg-core";
+
+import { relations, type Relations } from "drizzle-orm";
+
+import type { TableColumn, TableMeta } from "./introspect-db-logic";
+
+/** drizzle ships no bytea builder; binary must round-trip as a Buffer. */
+const bytea = customType<{ data: Buffer; driverData: Buffer }>({
+    dataType: () => "bytea"
+});
+
+/**
+ * Postgres stores a column's type modifier (varchar length, vector dimensions)
+ * in `atttypmod`. For length-carrying string types it is length + VARHDRSZ(4);
+ * for pgvector it is the dimension count as-is. -1 means unspecified.
+ */
+function varlenLength(col: TableColumn): number | undefined {
+    return col.atttypmod && col.atttypmod > 4 ? col.atttypmod - 4 : undefined;
+}
+
+/**
+ * Map a Postgres type to a drizzle column builder, keyed on `udt_name` — the
+ * concrete underlying type, which is exact where `data_type` reports umbrella
+ * values like "ARRAY" or "USER-DEFINED".
+ *
+ * Unknown types fall back to `text`: the driver still reads and writes them,
+ * with the value passing through as a string, which beats dropping the column.
+ */
+function scalarBuilder(udtName: string, name: string, col: TableColumn): PgColumnBuilderBase {
+    switch (udtName) {
+        case "uuid":
+            return uuid(name);
+        case "bool":
+            return boolean(name);
+        case "int2":
+            return smallint(name);
+        case "int4":
+            return integer(name);
+        case "int8":
+            return bigint(name, { mode: "number" });
+        case "float4":
+            return real(name);
+        case "float8":
+            return doublePrecision(name);
+        case "numeric":
+        case "money":
+            return numeric(name);
+        case "json":
+            return json(name);
+        case "jsonb":
+            return jsonb(name);
+        case "date":
+            return date(name);
+        case "time":
+            return time(name);
+        case "timetz":
+            return time(name, { withTimezone: true });
+        case "timestamp":
+            return timestamp(name);
+        case "timestamptz":
+            return timestamp(name, { withTimezone: true });
+        case "interval":
+            return interval(name);
+        case "bytea":
+            return bytea(name);
+        case "inet":
+            return inet(name);
+        case "cidr":
+            return cidr(name);
+        case "macaddr":
+            return macaddr(name);
+        case "macaddr8":
+            return macaddr8(name);
+        case "point":
+            return point(name);
+        case "line":
+            return line(name);
+        case "geometry":
+            return geometry(name);
+        case "vector": {
+            // drizzle requires the dimension count; without it fall back to text
+            // rather than declaring a vector of unknown width.
+            const dimensions = col.atttypmod && col.atttypmod > 0 ? col.atttypmod : undefined;
+            return dimensions ? vector(name, { dimensions }) : text(name);
+        }
+        case "bpchar": {
+            const length = varlenLength(col);
+            return length ? char(name, { length }) : char(name);
+        }
+        case "varchar": {
+            const length = varlenLength(col);
+            return length ? varchar(name, { length }) : text(name);
+        }
+        default:
+            // Includes text, enums (pg enums are strings on the wire), citext,
+            // geography, and anything else this driver hasn't met yet.
+            return text(name);
+    }
+}
+
+function columnBuilderFor(col: TableColumn): PgColumnBuilderBase {
+    // Array types are named after their element with a leading underscore
+    // (_int4 = int4[]), so the element mapping is reused verbatim.
+    if (col.udt_name.startsWith("_")) {
+        const element = scalarBuilder(col.udt_name.slice(1), col.column_name, col);
+        return (element as unknown as { array(): PgColumnBuilderBase }).array();
+    }
+    return scalarBuilder(col.udt_name, col.column_name, col);
+}
+
+/**
+ * Build one drizzle table per introspected table, keyed by table name.
+ */
+export function buildDrizzleTablesFromSchema(
+    tablesMap: Map<string, TableMeta>,
+    pgSchemaName = "public"
+): Record<string, PgTable> {
+    const schema = pgSchemaName === "public" ? null : pgSchema(pgSchemaName);
+    // The column set is only known at runtime, so drizzle's generic table
+    // signature can't be satisfied statically; call it through a loose type.
+    const createTable = (schema ? schema.table.bind(schema) : pgTable) as unknown as (
+        name: string,
+        columns: Record<string, PgColumnBuilderBase>,
+        extras?: (self: Record<string, unknown>) => unknown[]
+    ) => PgTable;
+
+    const tables: Record<string, PgTable> = {};
+
+    for (const [tableName, meta] of tablesMap) {
+        const columns: Record<string, PgColumnBuilderBase> = {};
+
+        for (const col of meta.columns) {
+            let builder = columnBuilderFor(col);
+
+            if (col.is_nullable === "NO") {
+                builder = (builder as unknown as { notNull(): PgColumnBuilderBase }).notNull();
+            }
+            // Single-column primary keys are marked inline; composite keys are
+            // declared in the table extras below.
+            if (meta.pks.length === 1 && meta.pks[0] === col.column_name) {
+                builder = (builder as unknown as { primaryKey(): PgColumnBuilderBase }).primaryKey();
+            }
+
+            columns[col.column_name] = builder;
+        }
+
+        const isComposite = meta.pks.length > 1;
+        tables[tableName] = createTable(
+            tableName,
+            columns,
+            isComposite
+                ? (t) => [primaryKey({ columns: meta.pks.map((pk) => t[pk]) as never })]
+                : undefined
+        );
+    }
+
+    return tables;
+}
+
+/**
+ * Build drizzle `relations()` for the foreign keys, so the relational query
+ * path can actually load them.
+ *
+ * FetchService asks drizzle for `with: { <key>: true }`, keyed by the relation
+ * property on the collection. Tables alone don't satisfy that — without these,
+ * `?include=author` silently returns the raw `author_id` and no author.
+ *
+ * The keys here must match `buildRelations` in introspect-runtime.ts, which is
+ * what names the collection's relation properties.
+ */
+export function buildDrizzleRelationsFromSchema(
+    tablesMap: Map<string, TableMeta>,
+    tables: Record<string, PgTable>
+): Record<string, Relations> {
+    /** Owning side, per table: the `one()` relations from its foreign keys. */
+    const owning = new Map<string, { key: string; targetTable: string; fkColumn: string; targetColumn: string; relationName: string }[]>();
+    /** Inverse side, per referenced table: the matching `many()` back-references. */
+    const inverse = new Map<string, { key: string; sourceTable: string; relationName: string }[]>();
+
+    for (const [tableName, meta] of tablesMap) {
+        if (!tables[tableName]) continue;
+        const columnNames = new Set(meta.columns.map((c) => c.column_name));
+
+        for (const fk of meta.fks) {
+            if (!tables[fk.foreign_table_name]) continue;
+
+            // Mirrors buildRelations in introspect-runtime: author_id -> author,
+            // falling back to the target table when the column name carries no hint.
+            let key = fk.column_name.replace(/_id$/, "");
+            if (meta.pks.includes(fk.column_name) && key === fk.column_name) {
+                key = fk.foreign_table_name;
+            }
+            // A relation key must not shadow a real column.
+            if (columnNames.has(key)) continue;
+
+            // Pairs the two sides. Drizzle matches a named one() to the many()
+            // carrying the same name, and disambiguates multiple foreign keys
+            // into the same table.
+            const relationName = `${tableName}_${fk.column_name}`;
+
+            owning.set(tableName, [
+                ...(owning.get(tableName) ?? []),
+                { key, targetTable: fk.foreign_table_name, fkColumn: fk.column_name, targetColumn: fk.foreign_column_name, relationName }
+            ]);
+
+            const backKey = tableName;
+            const targetColumns = new Set((tablesMap.get(fk.foreign_table_name)?.columns ?? []).map((c) => c.column_name));
+            if (targetColumns.has(backKey)) continue;
+
+            inverse.set(fk.foreign_table_name, [
+                ...(inverse.get(fk.foreign_table_name) ?? []),
+                { key: backKey, sourceTable: tableName, relationName }
+            ]);
+        }
+    }
+
+    const built: Record<string, Relations> = {};
+
+    for (const tableName of tablesMap.keys()) {
+        const table = tables[tableName];
+        const ones = owning.get(tableName) ?? [];
+        const manys = inverse.get(tableName) ?? [];
+        if (!table || (ones.length === 0 && manys.length === 0)) continue;
+
+        built[`${tableName}Relations`] = relations(table, ({ one, many }) => {
+            const map: Record<string, unknown> = {};
+
+            for (const rel of ones) {
+                map[rel.key] = one(tables[rel.targetTable], {
+                    fields: [(table as unknown as Record<string, never>)[rel.fkColumn]],
+                    references: [(tables[rel.targetTable] as unknown as Record<string, never>)[rel.targetColumn]],
+                    relationName: rel.relationName
+                });
+            }
+
+            // Drizzle needs the inverse of every named one(); without it,
+            // normalizeRelation throws and the relational path is dead.
+            for (const rel of manys) {
+                // An inverse must not collide with an owning key on this table.
+                if (map[rel.key]) continue;
+                map[rel.key] = many(tables[rel.sourceTable], { relationName: rel.relationName });
+            }
+
+            return map as never;
+        });
+    }
+
+    return built;
+}