fix(recipes): concatène les ingrédients dupliqués à l'import

Suite au retour utilisateur sur #53 (follow-up) : au lieu de bloquer
l'import et de demander à l'utilisateur de retirer une ligne en double
à la main, deux lignes source qui résolvent vers le même ingrédient
catalogue sont désormais fusionnées automatiquement, quantité
concaténée (sommée), avant même que l'écran de revue ne s'affiche.

- mergeDuplicateIngredients (recipe-translation.ts) : même unité des
  deux côtés -> somme directe. Unité différente mais même UnitType
  (MASS/VOLUME) -> conversion via toBaseFactor avant de sommer, exprimée
  dans l'unité de la première ligne. UnitType différent, ou COUNT des
  deux côtés (une "pincée" n'est pas une fraction fixe d'une "gousse",
  cf. le commentaire de UnitView) -> jamais fusionnées, laissées en
  double (createRecipeSchema/RecipeImportForm continuent de les
  signaler, filet de sécurité déjà en place). Les lignes non résolues
  (ingredientId: null) ne sont jamais fusionnées entre elles.
- rawText concaténé ("100g Sugar + 45g Sugar") pour la traçabilité.
- Branché dans previewSourceItem (sources.service.ts), juste après
  translateRecipeIngredients — c'est le seul endroit où des doublons
  peuvent apparaître (la création manuelle ne peut pas en produire,
  IngredientPicker exclut déjà les ingrédients déjà sélectionnés).

Vérifié via l'API en local (import réel de "Flan" depuis TheMealDB) :
"100g Sugar"/"45g Sugar" -> une seule ligne Sucre, 145g.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

apps/api/src/lib/recipe-translation.ts

@@ -1,3 +1,4 @@
+import type { UnitType } from "@batch-cooking/shared";
 import {
   type IngredientMatchEntry,
   type UnitMatchEntry,
@@ -138,6 +139,111 @@ export function translateRecipeIngredients(
   });
 }
 
+/** What {@link mergeDuplicateIngredients} needs to know about a `Unit` to combine two of them — the `type`/`toBaseFactor` slice of `UnitView` (`packages/shared`). */
+export interface UnitConversionEntry {
+  id: number;
+  type: UnitType;
+  toBaseFactor: number;
+}
+
+/**
+ * Combines `a`/`b` — two lines already confirmed to resolve to the same
+ * ingredient — into one, summing their quantities, or returns `null` when
+ * that can't be done safely. `null` (quantity or unit missing on either
+ * side, unit not found in `unitById`, mismatched `UnitType`, or either side
+ * a `COUNT` unit) means "don't merge", not "error" — see
+ * {@link mergeDuplicateIngredients}.
+ *
+ * Same unit on both sides sums directly. Different units of the same
+ * measurable *type* (`MASS`/`VOLUME`) convert `b`'s quantity into `a`'s
+ * unit via `toBaseFactor` first — the groundwork that field's own doc
+ * comment (`UnitView`, `packages/shared`) already anticipated ("a future
+ * conversion feature ... summing '500g' + '0.5kg'"). `COUNT` units are
+ * never converted against each other even when `toBaseFactor` matches — a
+ * "pincée" isn't a fixed fraction of a "gousse" (same doc comment) — so two
+ * different `COUNT` units for the same ingredient are left unmerged.
+ * Rounded to 2 decimal places (`RecipeIngredient.quantity` is
+ * `Decimal(10, 2)`, schema.prisma) to avoid floating-point noise from the
+ * conversion.
+ */
+function combineIngredientLines(
+  a: TranslatedRecipeIngredient,
+  b: TranslatedRecipeIngredient,
+  unitById: Map<number, UnitConversionEntry>,
+): TranslatedRecipeIngredient | null {
+  if (a.quantity === null || b.quantity === null || a.unitId === null || b.unitId === null) {
+    return null;
+  }
+  if (a.unitId === b.unitId) {
+    return { ...a, quantity: a.quantity + b.quantity, rawText: `${a.rawText} + ${b.rawText}` };
+  }
+
+  const unitA = unitById.get(a.unitId);
+  const unitB = unitById.get(b.unitId);
+  if (!unitA || !unitB) return null;
+  if (unitA.type !== unitB.type || unitA.type === "COUNT") return null;
+
+  const combinedInBaseUnit = a.quantity * unitA.toBaseFactor + b.quantity * unitB.toBaseFactor;
+  const quantity = Math.round((combinedInBaseUnit / unitA.toBaseFactor) * 100) / 100;
+  return { ...a, quantity, rawText: `${a.rawText} + ${b.rawText}` };
+}
+
+/**
+ * Folds `ingredients` down to one line per resolved `ingredientId`,
+ * concatenating (summing the quantity of) every duplicate into the first
+ * line it matches — see issue #53's follow-up: two raw source lines (e.g.
+ * TheMealDB's "Egg Yolks"/"Eggs", or "100g Sugar" used in two different
+ * steps) can independently resolve to the same catalog `Ingredient`, and
+ * `RecipeIngredient`'s primary key (`recipeId`, `ingredientId`) only
+ * allows one row per ingredient per recipe — the review form used to
+ * either crash on submit (before `createRecipeSchema` rejected it) or
+ * require the person to manually delete every extra line by hand.
+ *
+ * Unresolved lines (`ingredientId: null`) are never merged with one
+ * another or with anything else — nothing reliable to key them on. Two
+ * lines that resolve to the same ingredient but can't be combined safely
+ * (see {@link combineIngredientLines} — mismatched quantity/unit, or
+ * genuinely incompatible units) are left as separate, still-duplicate
+ * lines: `createRecipeSchema` still rejects the result, and
+ * `RecipeImportForm` still highlights them, same safety net as before this
+ * merge step existed — merging never *invents* a number it isn't confident
+ * in.
+ *
+ * Pure — testable with a hand-built `unitCatalog`, no database involved.
+ * Order-preserving: a merged line keeps its first occurrence's position.
+ */
+export function mergeDuplicateIngredients(
+  ingredients: TranslatedRecipeIngredient[],
+  unitCatalog: UnitConversionEntry[],
+): TranslatedRecipeIngredient[] {
+  const unitById = new Map(unitCatalog.map((unit) => [unit.id, unit]));
+  const merged: TranslatedRecipeIngredient[] = [];
+  const mergedIndexByIngredientId = new Map<number, number>();
+
+  for (const line of ingredients) {
+    const existingIndex =
+      line.ingredientId !== null ? mergedIndexByIngredientId.get(line.ingredientId) : undefined;
+
+    const existingLine = existingIndex !== undefined ? merged[existingIndex] : undefined;
+    if (existingIndex === undefined || existingLine === undefined) {
+      if (line.ingredientId !== null) {
+        mergedIndexByIngredientId.set(line.ingredientId, merged.length);
+      }
+      merged.push(line);
+      continue;
+    }
+
+    const combined = combineIngredientLines(existingLine, line, unitById);
+    if (combined === null) {
+      merged.push(line);
+    } else {
+      merged[existingIndex] = combined;
+    }
+  }
+
+  return merged;
+}
+
 /**
  * Convenience wrapper around {@link translateRecipeSteps}/
  * {@link translateRecipeIngredients} that loads every catalog itself —

apps/api/src/modules/sources/sources.service.ts

@@ -19,7 +19,10 @@ import {
 import { type RecipeSourceAdapter, markAlreadyImported } from "../../lib/recipe-source-adapter.js";
 import { RecipeSourceError } from "../../lib/recipe-source-errors.js";
 import { getRecipeSource } from "../../lib/recipe-source-registry.js";
-import { translateRecipeIngredients } from "../../lib/recipe-translation.js";
+import {
+  mergeDuplicateIngredients,
+  translateRecipeIngredients,
+} from "../../lib/recipe-translation.js";
 import { loadTechStepMappingRules, matchTechStepSpans } from "../../lib/tech-step-matcher.js";
 import { getHouseSourceIds } from "../house/house.service.js";
 import { createImportedRecipe } from "../recipe/recipe.service.js";
@@ -162,7 +165,15 @@ export async function previewSourceItem(
   const ingredientById = new Map(ingredientViews.map((view) => [view.id, view]));
   const unitById = new Map(unitViews.map((view) => [view.id, view]));
 
-  const ingredients: DraftRecipeIngredientView[] = translatedIngredients.map((ingredient) => ({
+  // A source's raw ingredient lines aren't deduplicated by the matcher —
+  // two different lines (e.g. "Egg Yolks"/"Eggs") can resolve to the same
+  // catalog ingredient. Folded into one line per ingredient (quantities
+  // summed where that's safe) before the draft ever reaches the review
+  // screen, rather than surfacing the recipe with two rows for "Œuf" and
+  // making the person sort it out — see issue #53's follow-up.
+  const mergedIngredients = mergeDuplicateIngredients(translatedIngredients, unitViews);
+
+  const ingredients: DraftRecipeIngredientView[] = mergedIngredients.map((ingredient) => ({
     rawText: ingredient.rawText,
     quantity: ingredient.quantity,
     ingredient:

apps/api/test/recipe-translation.test.ts

@@ -3,6 +3,9 @@ import { prisma } from "../src/db/prisma.js";
 import type { IngredientMatchEntry, UnitMatchEntry } from "../src/lib/ingredient-matcher.js";
 import type { ParsedRecipe, ParsedRecipeIngredient } from "../src/lib/recipe-source-adapter.js";
 import {
+  type TranslatedRecipeIngredient,
+  type UnitConversionEntry,
+  mergeDuplicateIngredients,
   translateRecipe,
   translateRecipeIngredients,
   translateRecipeSteps,
@@ -243,6 +246,111 @@ describe("recipe-translation", () => {
     });
   });
 
+  describe("mergeDuplicateIngredients", () => {
+    const gram: UnitConversionEntry = { id: 1, type: "MASS", toBaseFactor: 1 };
+    const kilogram: UnitConversionEntry = { id: 2, type: "MASS", toBaseFactor: 1000 };
+    const milliliter: UnitConversionEntry = { id: 3, type: "VOLUME", toBaseFactor: 1 };
+    const piece: UnitConversionEntry = { id: 4, type: "COUNT", toBaseFactor: 1 };
+    const slice: UnitConversionEntry = { id: 5, type: "COUNT", toBaseFactor: 1 };
+
+    function buildLine(
+      overrides: Partial<TranslatedRecipeIngredient> & { rawText: string },
+    ): TranslatedRecipeIngredient {
+      return {
+        name: overrides.rawText,
+        quantity: null,
+        unit: null,
+        ingredientId: null,
+        unitId: null,
+        ...overrides,
+      };
+    }
+
+    it("sums the quantity of two lines resolving to the same ingredient, same unit (issue #53 follow-up)", () => {
+      const merged = mergeDuplicateIngredients(
+        [
+          buildLine({ rawText: "100g Sugar", ingredientId: 1, quantity: 100, unitId: gram.id }),
+          buildLine({ rawText: "45g Sugar", ingredientId: 1, quantity: 45, unitId: gram.id }),
+        ],
+        [gram, kilogram, milliliter, piece, slice],
+      );
+
+      expect(merged).to.have.length(1);
+      expect(merged[0].quantity).to.equal(145);
+      expect(merged[0].unitId).to.equal(gram.id);
+      expect(merged[0].rawText).to.equal("100g Sugar + 45g Sugar");
+    });
+
+    it("converts through toBaseFactor when the duplicate uses a different unit of the same type", () => {
+      const merged = mergeDuplicateIngredients(
+        [
+          buildLine({ rawText: "500g Flour", ingredientId: 1, quantity: 500, unitId: gram.id }),
+          buildLine({
+            rawText: "0.5kg Flour",
+            ingredientId: 1,
+            quantity: 0.5,
+            unitId: kilogram.id,
+          }),
+        ],
+        [gram, kilogram, milliliter, piece, slice],
+      );
+
+      expect(merged).to.have.length(1);
+      expect(merged[0].quantity).to.equal(1000);
+      expect(merged[0].unitId).to.equal(gram.id);
+    });
+
+    it("keeps duplicate COUNT-unit lines separate rather than guessing — a slice isn't a piece", () => {
+      const merged = mergeDuplicateIngredients(
+        [
+          buildLine({ rawText: "2 piece Bread", ingredientId: 1, quantity: 2, unitId: piece.id }),
+          buildLine({ rawText: "3 slice Bread", ingredientId: 1, quantity: 3, unitId: slice.id }),
+        ],
+        [gram, kilogram, milliliter, piece, slice],
+      );
+
+      expect(merged).to.have.length(2);
+    });
+
+    it("keeps duplicate lines with incompatible unit types separate (MASS vs VOLUME)", () => {
+      const merged = mergeDuplicateIngredients(
+        [
+          buildLine({ rawText: "200g Milk", ingredientId: 1, quantity: 200, unitId: gram.id }),
+          buildLine({
+            rawText: "200ml Milk",
+            ingredientId: 1,
+            quantity: 200,
+            unitId: milliliter.id,
+          }),
+        ],
+        [gram, kilogram, milliliter, piece, slice],
+      );
+
+      expect(merged).to.have.length(2);
+    });
+
+    it("never merges two unresolved lines (ingredientId: null) together", () => {
+      const merged = mergeDuplicateIngredients(
+        [
+          buildLine({ rawText: "1 vanilla pod", quantity: 1 }),
+          buildLine({ rawText: "1 vanilla pod", quantity: 1 }),
+        ],
+        [gram, kilogram, milliliter, piece, slice],
+      );
+
+      expect(merged).to.have.length(2);
+    });
+
+    it("leaves non-duplicate lines untouched and preserves order", () => {
+      const sugar = buildLine({ rawText: "Sugar", ingredientId: 1, quantity: 1, unitId: gram.id });
+      const salt = buildLine({ rawText: "Salt", ingredientId: 2, quantity: 1, unitId: gram.id });
+
+      const merged = mergeDuplicateIngredients([sugar, salt], [gram, kilogram, milliliter]);
+
+      expect(merged).to.deep.equal([sugar, salt]);
+    });
+  });
+
   describe("translateRecipe", () => {
     beforeEach(async () => {
       await resetDatabase();

apps/api/test/sources.test.ts

@@ -78,6 +78,45 @@ function buildFakeAdapter(key = "fakeSource"): RecipeSourceAdapter<{ externalId:
   };
 }
 
+/**
+ * A fake adapter whose two ingredient lines both resolve to the same real
+ * seeded ingredient ("onion"), in the same unit (grams) — exercises
+ * `previewSourceItem`'s duplicate-merging (`mergeDuplicateIngredients`,
+ * see issue #53's follow-up) through the real HTTP endpoint/catalog,
+ * rather than only as a pure unit test of the merge function itself.
+ */
+function buildDuplicateIngredientAdapter(key = "duplicateFakeSource"): RecipeSourceAdapter<{
+  externalId: string;
+}> {
+  return {
+    key,
+    name: "Fake Source With Duplicates",
+    official: true,
+    iconUrl: null,
+    locale: "en",
+    async list(): Promise<RecipeSourceListResult> {
+      return { items: [], nextCursor: null };
+    },
+    async fetchDetail(externalId: string): Promise<{ externalId: string }> {
+      return { externalId };
+    },
+    parse(raw: { externalId: string }): ParsedRecipe {
+      return {
+        name: `Fake recipe ${raw.externalId}`,
+        description: null,
+        picture: null,
+        portions: 4,
+        sourceUrl: `https://fake.test/${raw.externalId}`,
+        ingredients: [
+          { rawText: "100g Onion", quantity: null, unit: null, name: "onion" },
+          { rawText: "50g Onion", quantity: null, unit: null, name: "onion" },
+        ],
+        steps: [{ description: "Chop the onions finely", picture: null }],
+      };
+    },
+  };
+}
+
 /** Resolves a reference ingredient's id by its `reference-seed-data.ts` uid (also its DB `key`) — same reasoning as `recipe.test.ts`'s own helper. */
 async function ingredientId(key: string): Promise<number> {
   const ingredient = await prisma.ingredient.findFirstOrThrow({ where: { key } });
@@ -262,6 +301,28 @@ describe("Sources", () => {
       expect(res.status).to.equal(404);
       expect(res.body.code).to.equal(ErrorCode.RECIPE_NOT_FOUND);
     });
+
+    it("merges two lines that resolve to the same ingredient, summing their quantity (issue #53 follow-up)", async () => {
+      const { agent } = await signupWithHouse();
+      registerRecipeSource(buildDuplicateIngredientAdapter());
+      await syncRecipeSources(prisma);
+      const source = await prisma.source.findUniqueOrThrow({
+        where: { key: "duplicateFakeSource" },
+      });
+      await agent.patch("/house/current/sources").send({ sourceIds: [source.id] });
+      const onion = await prisma.ingredient.findFirstOrThrow({ where: { key: "onion" } });
+      const gram = await prisma.unit.findFirstOrThrow({ where: { key: "gram" } });
+
+      const res = await agent.get("/sources/duplicateFakeSource/preview/1");
+
+      expect(res.status).to.equal(200);
+      expect(res.body.ingredients).to.have.length(1);
+      const [merged] = res.body.ingredients;
+      expect(merged.ingredient).to.deep.include({ id: onion.id, key: "onion" });
+      expect(merged.unit).to.deep.include({ id: gram.id, key: "gram" });
+      expect(merged.quantity).to.equal(150);
+      expect(merged.rawText).to.equal("100g Onion + 50g Onion");
+    });
   });
 
   describe("POST /sources/:sourceKey/import/:externalId", () => {