@rebasepro/server-postgres 0.17.3 → 0.18.0

package/src/schema/drizzle-ddl.ts

@@ -1,33 +0,0 @@
-/**
- * The server's DDL bootstrapper, over a Drizzle handle.
- *
- * `createDdlBootstrapper` in `@rebasepro/server` wants a plain
- * `(sql: string) => Promise<rows>`; the driver's internal stores hold a Drizzle
- * database. This is the adapter between them, and it exists so the retry policy
- * has exactly one definition. A second copy of the SQLSTATE list living in the
- * driver is how the two drift apart, and the drift is invisible: both versions
- * work perfectly on every single-instance deployment.
- */
-import { sql } from "drizzle-orm";
-import type { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { createDdlBootstrapper, type DdlBootstrapper } from "@rebasepro/server";
-
-/**
- * A {@link DdlBootstrapper} that runs its statements through `db.execute`.
- *
- * @param db    the Drizzle handle the calling store already holds
- * @param scope log prefix identifying the caller, e.g. `"channel-presence"`
- */
-export function drizzleDdlBootstrapper(
-    db: NodePgDatabase<Record<string, unknown>>,
-    scope: string
-): DdlBootstrapper {
-    return createDdlBootstrapper(async (statement: string) => {
-        // `sql.raw`, because everything reaching this path is DDL assembled from
-        // identifiers that were validated before they got here — there is no
-        // parameter to bind, and Drizzle's tagged template would treat the whole
-        // statement as one.
-        const result = await db.execute(sql.raw(statement));
-        return (result as unknown as { rows?: Record<string, unknown>[] }).rows ?? [];
-    }, scope);
-}

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

@@ -1,302 +0,0 @@
-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

@@ -1,293 +0,0 @@
-/**
- * Build drizzle tables at runtime from an introspected schema.
- *
- * A project with declared collections 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;
-}