feat: core schema redesign — dishes, structured recipes, cuisines, tags (iteration 7)

Replaces the flat JSONB-based recipe schema with a normalized relational model:

Schema (migrations consolidated to 001_initial_schema + 002_seed_data):
- New: dishes, dish_translations, dish_tags — canonical dish catalog
- New: cuisines, tags, dish_categories with _translations tables + full seed data
- New: recipe_ingredients, recipe_steps with _translations (replaces JSONB blobs)
- New: user_saved_recipes thin bookmark (drops saved_recipes + saved_recipe_translations)
- New: product_ingredients M2M table
- recipes: now a cooking variant of a dish (dish_id FK, no title/JSONB columns)
- recipe_translations: repurposed to per-language notes only
- products: mapping_id → primary_ingredient_id
- menu_items: recipe_id FK → recipes; adds dish_id
- meal_diary: adds dish_id, recipe_id → recipes, portion_g

Backend (Go):
- New packages: internal/cuisine, internal/tag, internal/dish (registry + handler + repo)
- New GET /cuisines, GET /tags (public), GET /dishes, GET /dishes/{id}, GET /recipes/{id}
- recipe, savedrecipe, menu, diary, product, ingredient packages updated for new schema

Flutter:
- New models: Cuisine, Tag; new providers: cuisineNamesProvider, tagNamesProvider
- recipe.dart: RecipeIngredient gains unit_code + effectiveUnit getter
- saved_recipe.dart: thin model, manual fromJson, computed nutrition getter
- diary_entry.dart: adds dishId, recipeId, portionG
- recipe_detail_screen.dart: localized cuisine/tag names via providers

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

backend/internal/recipe/repository.go

@@ -2,7 +2,6 @@ package recipe
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 
@@ -11,7 +10,7 @@ import (
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
-// Repository handles persistence for recipes and their translations.
+// Repository handles persistence for recipes and their relational sub-tables.
 type Repository struct {
 	pool *pgxpool.Pool
 }
@@ -21,77 +20,39 @@ func NewRepository(pool *pgxpool.Pool) *Repository {
 	return &Repository{pool: pool}
 }
 
-// Upsert inserts or updates a recipe (English canonical content only).
-// Conflict is resolved on spoonacular_id.
-func (r *Repository) Upsert(ctx context.Context, recipe *Recipe) (*Recipe, error) {
-	query := `
-		INSERT INTO recipes (
-			source, spoonacular_id,
-			title, description,
-			cuisine, difficulty, prep_time_min, cook_time_min, servings, image_url,
-			calories_per_serving, protein_per_serving, fat_per_serving, carbs_per_serving, fiber_per_serving,
-			ingredients, steps, tags
-		) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)
-		ON CONFLICT (spoonacular_id) DO UPDATE SET
-			title                = EXCLUDED.title,
-			description          = EXCLUDED.description,
-			cuisine              = EXCLUDED.cuisine,
-			difficulty           = EXCLUDED.difficulty,
-			prep_time_min        = EXCLUDED.prep_time_min,
-			cook_time_min        = EXCLUDED.cook_time_min,
-			servings             = EXCLUDED.servings,
-			image_url            = EXCLUDED.image_url,
-			calories_per_serving = EXCLUDED.calories_per_serving,
-			protein_per_serving  = EXCLUDED.protein_per_serving,
-			fat_per_serving      = EXCLUDED.fat_per_serving,
-			carbs_per_serving    = EXCLUDED.carbs_per_serving,
-			fiber_per_serving    = EXCLUDED.fiber_per_serving,
-			ingredients          = EXCLUDED.ingredients,
-			steps                = EXCLUDED.steps,
-			tags                 = EXCLUDED.tags,
-			updated_at           = now()
-		RETURNING id, source, spoonacular_id,
-			title, description,
-			cuisine, difficulty, prep_time_min, cook_time_min, servings, image_url,
-			calories_per_serving, protein_per_serving, fat_per_serving, carbs_per_serving, fiber_per_serving,
-			ingredients, steps, tags,
-			avg_rating, review_count, created_by, created_at, updated_at`
-
-	row := r.pool.QueryRow(ctx, query,
-		recipe.Source, recipe.SpoonacularID,
-		recipe.Title, recipe.Description,
-		recipe.Cuisine, recipe.Difficulty, recipe.PrepTimeMin, recipe.CookTimeMin, recipe.Servings, recipe.ImageURL,
-		recipe.CaloriesPerServing, recipe.ProteinPerServing, recipe.FatPerServing, recipe.CarbsPerServing, recipe.FiberPerServing,
-		recipe.Ingredients, recipe.Steps, recipe.Tags,
-	)
-	return scanRecipe(row)
-}
-
-// GetByID returns a recipe by UUID, with content resolved for the language
-// stored in ctx (falls back to English when no translation exists).
+// GetByID returns a recipe with its ingredients and steps.
+// Text is resolved for the language stored in ctx (English fallback).
 // Returns nil, nil if not found.
 func (r *Repository) GetByID(ctx context.Context, id string) (*Recipe, error) {
 	lang := locale.FromContext(ctx)
-	query := `
-		SELECT r.id, r.source, r.spoonacular_id,
-			COALESCE(rt.title,       r.title)       AS title,
-			COALESCE(rt.description, r.description) AS description,
-			r.cuisine, r.difficulty, r.prep_time_min, r.cook_time_min, r.servings, r.image_url,
-			r.calories_per_serving, r.protein_per_serving, r.fat_per_serving, r.carbs_per_serving, r.fiber_per_serving,
-			COALESCE(rt.ingredients, r.ingredients) AS ingredients,
-			COALESCE(rt.steps,       r.steps)       AS steps,
-			r.tags,
-			r.avg_rating, r.review_count, r.created_by, r.created_at, r.updated_at
+
+	const q = `
+		SELECT r.id, r.dish_id, r.source, r.difficulty,
+			r.prep_time_min, r.cook_time_min, r.servings,
+			r.calories_per_serving, r.protein_per_serving, r.fat_per_serving,
+			r.carbs_per_serving, r.fiber_per_serving,
+			rt.notes,
+			r.created_at, r.updated_at
 		FROM recipes r
 		LEFT JOIN recipe_translations rt ON rt.recipe_id = r.id AND rt.lang = $2
 		WHERE r.id = $1`
 
-	row := r.pool.QueryRow(ctx, query, id, lang)
+	row := r.pool.QueryRow(ctx, q, id, lang)
 	rec, err := scanRecipe(row)
 	if errors.Is(err, pgx.ErrNoRows) {
 		return nil, nil
 	}
-	return rec, err
+	if err != nil {
+		return nil, fmt.Errorf("get recipe %s: %w", id, err)
+	}
+
+	if err := r.loadIngredients(ctx, rec, lang); err != nil {
+		return nil, err
+	}
+	if err := r.loadSteps(ctx, rec, lang); err != nil {
+		return nil, err
+	}
+	return rec, nil
 }
 
 // Count returns the total number of recipes.
@@ -103,97 +64,79 @@ func (r *Repository) Count(ctx context.Context) (int, error) {
 	return n, nil
 }
 
-// ListMissingTranslation returns Spoonacular recipes that have no translation
-// for the given language, ordered by review_count DESC.
-func (r *Repository) ListMissingTranslation(ctx context.Context, lang string, limit, offset int) ([]*Recipe, error) {
-	query := `
-		SELECT id, source, spoonacular_id,
-			title, description,
-			cuisine, difficulty, prep_time_min, cook_time_min, servings, image_url,
-			calories_per_serving, protein_per_serving, fat_per_serving, carbs_per_serving, fiber_per_serving,
-			ingredients, steps, tags,
-			avg_rating, review_count, created_by, created_at, updated_at
-		FROM recipes
-		WHERE source = 'spoonacular'
-		  AND NOT EXISTS (
-		      SELECT 1 FROM recipe_translations rt
-		      WHERE rt.recipe_id = recipes.id AND rt.lang = $3
-		  )
-		ORDER BY review_count DESC
-		LIMIT $1 OFFSET $2`
-
-	rows, err := r.pool.Query(ctx, query, limit, offset, lang)
+// loadIngredients fills rec.Ingredients from recipe_ingredients.
+func (r *Repository) loadIngredients(ctx context.Context, rec *Recipe, lang string) error {
+	rows, err := r.pool.Query(ctx, `
+		SELECT ri.id, ri.ingredient_id,
+			COALESCE(rit.name, ri.name) AS name,
+			ri.amount, ri.unit_code, ri.is_optional, ri.sort_order
+		FROM recipe_ingredients ri
+		LEFT JOIN recipe_ingredient_translations rit
+			ON rit.ri_id = ri.id AND rit.lang = $2
+		WHERE ri.recipe_id = $1
+		ORDER BY ri.sort_order`, rec.ID, lang)
 	if err != nil {
-		return nil, fmt.Errorf("list missing translation (%s): %w", lang, err)
+		return fmt.Errorf("load ingredients for recipe %s: %w", rec.ID, err)
 	}
 	defer rows.Close()
-	return collectRecipes(rows)
-}
 
-// UpsertTranslation inserts or replaces a recipe translation for a specific language.
-func (r *Repository) UpsertTranslation(
-	ctx context.Context,
-	id, lang string,
-	title, description *string,
-	ingredients, steps json.RawMessage,
-) error {
-	query := `
-		INSERT INTO recipe_translations (recipe_id, lang, title, description, ingredients, steps)
-		VALUES ($1, $2, $3, $4, $5, $6)
-		ON CONFLICT (recipe_id, lang) DO UPDATE SET
-			title       = EXCLUDED.title,
-			description = EXCLUDED.description,
-			ingredients = EXCLUDED.ingredients,
-			steps       = EXCLUDED.steps`
-
-	if _, err := r.pool.Exec(ctx, query, id, lang, title, description, ingredients, steps); err != nil {
-		return fmt.Errorf("upsert recipe translation %s/%s: %w", id, lang, err)
+	for rows.Next() {
+		var ing RecipeIngredient
+		if err := rows.Scan(
+			&ing.ID, &ing.IngredientID, &ing.Name,
+			&ing.Amount, &ing.UnitCode, &ing.IsOptional, &ing.SortOrder,
+		); err != nil {
+			return fmt.Errorf("scan ingredient: %w", err)
+		}
+		rec.Ingredients = append(rec.Ingredients, ing)
 	}
-	return nil
+	return rows.Err()
 }
 
-// --- helpers ---
+// loadSteps fills rec.Steps from recipe_steps.
+func (r *Repository) loadSteps(ctx context.Context, rec *Recipe, lang string) error {
+	rows, err := r.pool.Query(ctx, `
+		SELECT rs.id, rs.step_number,
+			COALESCE(rst.description, rs.description) AS description,
+			rs.timer_seconds, rs.image_url
+		FROM recipe_steps rs
+		LEFT JOIN recipe_step_translations rst
+			ON rst.step_id = rs.id AND rst.lang = $2
+		WHERE rs.recipe_id = $1
+		ORDER BY rs.step_number`, rec.ID, lang)
+	if err != nil {
+		return fmt.Errorf("load steps for recipe %s: %w", rec.ID, err)
+	}
+	defer rows.Close()
+
+	for rows.Next() {
+		var s RecipeStep
+		if err := rows.Scan(
+			&s.ID, &s.StepNumber, &s.Description, &s.TimerSeconds, &s.ImageURL,
+		); err != nil {
+			return fmt.Errorf("scan step: %w", err)
+		}
+		rec.Steps = append(rec.Steps, s)
+	}
+	return rows.Err()
+}
+
+// --- scan helpers ---
 
 func scanRecipe(row pgx.Row) (*Recipe, error) {
 	var rec Recipe
-	var ingredients, steps, tags []byte
-
 	err := row.Scan(
-		&rec.ID, &rec.Source, &rec.SpoonacularID,
-		&rec.Title, &rec.Description,
-		&rec.Cuisine, &rec.Difficulty, &rec.PrepTimeMin, &rec.CookTimeMin, &rec.Servings, &rec.ImageURL,
-		&rec.CaloriesPerServing, &rec.ProteinPerServing, &rec.FatPerServing, &rec.CarbsPerServing, &rec.FiberPerServing,
-		&ingredients, &steps, &tags,
-		&rec.AvgRating, &rec.ReviewCount, &rec.CreatedBy, &rec.CreatedAt, &rec.UpdatedAt,
+		&rec.ID, &rec.DishID, &rec.Source, &rec.Difficulty,
+		&rec.PrepTimeMin, &rec.CookTimeMin, &rec.Servings,
+		&rec.CaloriesPerServing, &rec.ProteinPerServing, &rec.FatPerServing,
+		&rec.CarbsPerServing, &rec.FiberPerServing,
+		&rec.Notes,
+		&rec.CreatedAt, &rec.UpdatedAt,
 	)
 	if err != nil {
 		return nil, err
 	}
-	rec.Ingredients = json.RawMessage(ingredients)
-	rec.Steps = json.RawMessage(steps)
-	rec.Tags = json.RawMessage(tags)
+	rec.Ingredients = []RecipeIngredient{}
+	rec.Steps = []RecipeStep{}
 	return &rec, nil
 }
-
-func collectRecipes(rows pgx.Rows) ([]*Recipe, error) {
-	var result []*Recipe
-	for rows.Next() {
-		var rec Recipe
-		var ingredients, steps, tags []byte
-		if err := rows.Scan(
-			&rec.ID, &rec.Source, &rec.SpoonacularID,
-			&rec.Title, &rec.Description,
-			&rec.Cuisine, &rec.Difficulty, &rec.PrepTimeMin, &rec.CookTimeMin, &rec.Servings, &rec.ImageURL,
-			&rec.CaloriesPerServing, &rec.ProteinPerServing, &rec.FatPerServing, &rec.CarbsPerServing, &rec.FiberPerServing,
-			&ingredients, &steps, &tags,
-			&rec.AvgRating, &rec.ReviewCount, &rec.CreatedBy, &rec.CreatedAt, &rec.UpdatedAt,
-		); err != nil {
-			return nil, fmt.Errorf("scan recipe: %w", err)
-		}
-		rec.Ingredients = json.RawMessage(ingredients)
-		rec.Steps = json.RawMessage(steps)
-		rec.Tags = json.RawMessage(tags)
-		result = append(result, &rec)
-	}
-	return result, rows.Err()
-}