Declaring relations seperately multiple times for the same table?

[kasbah]

I noticed that calling relations multiple times for the same table breaks Typescript inference. See code below for what I mean. Having manufacturersRelations1 and manufacturersRelations2 split like that causes the relations to disappear from the types altogether. If you combine it into one call it's alright.

full code

import { integer, pgTable, serial } from "drizzle-orm/pg-core";
import { relations } from "drizzle-orm";
import { drizzle } from "drizzle-orm/postgres-js";
import postgres from "postgres";

const products = pgTable("products", {
  id: serial("id").primaryKey(),
  manufacturerId: integer("manufacturerId")
    .notNull()
    .references(() => manufacturers.id),
});

const manufacturers = pgTable("manufacturers", {
  id: serial("id").primaryKey(),
  locationId: integer("locationId")
    .notNull()
    .references(() => locations.id),
});

const locations = pgTable("locations", {
  id: serial("id").primaryKey(),
});

const locationsRelations = relations(locations, ({ many }) => ({
  manufacturers: many(manufacturers),
}));

const manufacturersRelations1 = relations(manufacturers, ({ many }) => ({
  products: many(products),
}));

const manufacturersRelations2 = relations(manufacturers, ({ one }) => ({
  location: one(locations, {
    fields: [manufacturers.locationId],
    references: [locations.id],
  }),
}));

full code

const productsRelations = relations(products, ({ one }) => ({
  manufacturer: one(manufacturers, {
    fields: [products.manufacturerId],
    references: [manufacturers.id],
  }),
}));

const schema = {
  products,
  manufacturers,
  locations,
  locationsRelations,
  manufacturersRelations1,
  manufacturersRelations2,
  productsRelations,
};

const conn = postgres({
  database: "test",
  host: "localhost",
  password: "test",
  user: "test",
});

export const db = drizzle(conn, { schema });

const product = await db.query.products.findFirst({
  with: {
    manufacturer: {
      with: {
        location: true,
      },
    },
  },
});

if (!product) {
  throw Error("No product found");
}

product.manufacturer.location;

// ^^^ Property 'location' does not exist on type '{ id: number; locationId: number; }'. Did you mean 'locationId'?(2551)

Playground Link

The reason I want to do this is that I made some utility functions for relations e.g.

export function oneToMany(
  aOne: TableWithId,
  bMany: PgTable,
  bManyField: PgColumn,
): [ReturnType<typeof relations>, ReturnType<typeof relations>] {
  const aName = getTableName(aOne);
  const bName = getTableName(bMany);
  // just remove the last letter which should be an 's'
  const aSingularName = aName.slice(0, -1);
  const aRelations = relations(aOne, ({ many }) => ({
    [bName]: many(bMany),
  }));
  const bRelations = relations(bMany, ({ one }) => ({
    [aSingularName]: one(aOne, {
      fields: [bManyField],
      references: [aOne.id],
    }),
  }));
  return [aRelations, bRelations];
}

Where the above relations declarations would become:

const [productsRelations, manufacturersRelations1] = oneToMany(manufacturers, products, products.manufacturerId);
const [manufacturersRelations2, locationsRelations] = oneToMany(locations, manufacturers, manufacturers.locationId);

Playground link

Where as you see, the manufacturers relations need to be split. Is this behaviour expected? Is there a way to make this kind of thing work?