[BUG]: Error: There is not enough information to infer relation for many-to-many relationship about drizzle-orm

[recoskyler]

It is a bit embarrassing to solve the issue a few hours after I have created it, but here's the thing I did wrong just in case someone else is having the same problem:

I had to change the related tables in the categoryRelations and productRelations from products: many(products)/categories: many(categories) to products: many(productCategory)/categories: many(productCategory) like so:

schema.ts

Omitted unrelated parts of the file*

//* Products

export const products = pgTable(
  "products",
  {
    id: uuid("id").primaryKey().defaultRandom(),
    enabled: boolean("enabled").notNull().default(true),
    createdAt: timestamp("created_at")
      .notNull()
      .default(sql`CURRENT_TIMESTAMP`),
    ean: varchar("ean", { length: 128 }).unique().notNull(),
    measurement: doublePrecision("measurement").notNull().default(1),
    isExactMeasurement: boolean("is_exact_measurement").notNull().default(true),
    uom: unitOfMeasurementEnum("uom").notNull().default("pc"),
    updatedAt: timestamp("updated_at", {
      mode: "date",
      precision: 3,
    }).$onUpdate(() => new Date()),
  },
  (table) => ({
    enabledIdx: index("product_enabled_idx").on(table.enabled),
    eanIdx: index("product_ean_idx").on(table.ean),
    measurementIdx: index("product_measurement_idx").on(table.measurement),
    uomIdx: index("product_uom_idx").on(table.uom),
    isExactMeasurementIdx: index("product_is_exact_measurement_idx").on(
      table.isExactMeasurement,
    ),
  }),
);

export const productRelations = relations(products, ({ many }) => ({
  categories: many(productCategory),  // CHANGED THIS
  subNames: many(productSubNames, {
    relationName: "product-sub-names",
  }),
  prices: many(prices, {
    relationName: "product-prices",
  }),
  media: many(media, {
    relationName: "product-media",
  }),
  names: many(productNames, {
    relationName: "product-names",
  }),
  stores: many(stores, {
    relationName: "store-products",
  }),
}));

//* Product-Category

export const productCategory = pgTable(
  "product_category",
  {
    productId: uuid("product_id")
      .notNull()
      .references(() => products.id),
    categoryId: uuid("category_id")
      .notNull()
      .references(() => categories.id),
  },
  (table) => ({
    pk: primaryKey({ columns: [table.productId, table.categoryId] }),
  }),
);

export const productCategoryRelations = relations(
  productCategory,
  ({ one }) => ({
    product: one(products, {
      fields: [productCategory.productId],
      references: [products.id],
    }),
    category: one(categories, {
      fields: [productCategory.categoryId],
      references: [categories.id],
    }),
  }),
);

//* Categories

export const categories = pgTable(
  "categories",
  {
    id: uuid("id").primaryKey().defaultRandom(),
    enabled: boolean("enabled").notNull().default(true),
    storeId: uuid("store_id")
      .notNull()
      .references(() => stores.id),
    parentCategoryId: uuid("parent_category_id"),
    thumbnailUrl: varchar("thumbnail_url", { length: 256 }),
  },
  (table) => ({
    enabledIdx: index("category_enabled_idx").on(table.enabled),
    storeIdx: index("category_store_idx").on(table.storeId),
  }),
);

export const categoryRelations = relations(categories, ({ one, many }) => ({
  parent: one(categories, {
    fields: [categories.parentCategoryId],
    references: [categories.id],
    relationName: "sub-categories",
  }),
  subCategories: many(categories, {
    relationName: "sub-categories",
  }),
  names: many(categoryNames, {
    relationName: "category-names",
  }),
  products: many(productCategory), // CHANGED THIS
  store: one(stores, {
    fields: [categories.storeId],
    references: [stores.id],
    relationName: "store-categories",
  }),
}));

This would've been easily solved if I read the documentation on many-to-many relationships carefully...