Meal Planning - Domain Model

[TheMagnificent11]

From MS Copilot...

Brilliant — since you’ve already got the architecture and you’re using your own DDD framework, we can go straight into the domain model, selection algorithm, and dual‑protein logic in a way that fits cleanly into aggregates, value objects, and domain services.

I’ll keep everything domain‑driven, explicit, and extensible so you can evolve it without painting yourself into a corner.

---

🧱 1. Domain Model

Below is a clean domain model broken into aggregates and value objects. This is designed to support:

• Ingredient inventory
• Dietary profiles
• Recipe search
• Weekly meal planning
• Dual‑protein variations
• Future extensibility (shopping lists, nutrition, expiry logic)

---

🍎 Ingredient Aggregate

Ingredient

Represents a single ingredient in your inventory.

Ingredient
- IngredientId
- Name
- Quantity (Quantity)
- Category (IngredientCategory)
- ExpiryDate (optional)

Value Objects

Quantity
- Amount (decimal)
- Unit (UnitOfMeasure)

UnitOfMeasure
- grams, ml, pieces, tbsp, tsp, etc.

IngredientCategory
- vegetable, protein, spice, pantry, dairy, etc.

---

🥗 Diet Profile Aggregate

DietProfile

Represents a set of dietary rules for a person or group.

DietProfile
- ProfileId
- Name (e.g., "Vegetarian Low-FODMAP", "Omnivore")
- AllowedIngredients (list of IngredientName)
- ExcludedIngredients (list of IngredientName)
- AllowedTags (e.g., vegetarian, low-fodmap)
- ExcludedTags (e.g., garlic, onion)

This lets you express:

• Vegetarian
• Low‑FODMAP
• Omnivore
• Allergies
• Religious restrictions

---

🍽️ Recipe Aggregate

Recipe

Represents a recipe returned from Spoonacular or stored locally.

Recipe
- RecipeId
- Title
- Ingredients (list of RecipeIngredient)
- Instructions (list of InstructionStep)
- Tags (list of RecipeTag)
- Nutrition (optional)

RecipeIngredient

RecipeIngredient
- Name
- Quantity (Quantity)
- IsProtein (bool)

Marking IsProtein is crucial for dual‑protein logic.

---

🍱 MealPlan Aggregate

MealPlan

Represents a weekly plan.

MealPlan
- MealPlanId
- WeekStartDate
- Meals (list of PlannedMeal)

PlannedMeal

PlannedMeal
- DayOfWeek
- BaseRecipe (Recipe)
- Variations (list of MealVariation)

MealVariation

MealVariation
- DietProfileId
- ProteinSubstitution (optional)
- AdjustedIngredients (list of RecipeIngredient)

This structure allows:

• One base recipe
• Multiple variations (vegetarian, omnivore)
• Shared sides
• Different proteins

---

🧠 2. Selection Algorithm (Friday Meal Generation)

This is a domain service, not an aggregate.

MealPlanGeneratorService

Inputs:

• IngredientInventory
• DietProfiles
• RecipeRepository (Spoonacular + cached recipes)
• NumberOfMeals (5)

Output:

• MealPlan

---

Algorithm Overview

Step 1 — Build Candidate Recipe Pool

For each diet profile:

1. Query Spoonacular with:

   • Ingredients you have
   • Dietary tags
   • Meal type = dinner

2. Filter out recipes that:

   • Contain excluded ingredients
   • Require ingredients you don’t have (unless small amounts)
   • Cannot be adapted to dual‑protein (optional rule)

3. Score each recipe (see scoring below)

---

Step 2 — Score Recipes

A simple scoring model:

Score = 
  IngredientMatchWeight * IngredientMatchPercentage
+ PerishableUsageWeight * PerishableUsageScore
+ VarietyWeight * VarietyScore
+ PrepTimeWeight * PrepTimeScore

IngredientMatchPercentage
How many ingredients you already have.

PerishableUsageScore
Higher if it uses ingredients close to expiry.

VarietyScore
Penalise repeating cuisines or proteins.

PrepTimeScore
Optional: prefer < 45 minutes.

---

Step 3 — Select Top Recipes

Pick the top N recipes per diet profile.

Then merge them into a combined pool.

---

Step 4 — Dual‑Protein Adaptation

For each candidate recipe:

1. Identify the primary protein

2. Check if:

   • The base recipe is vegetarian OR
   • The protein is a single ingredient that can be swapped

3. Generate variations:

   • Vegetarian version (tofu, tempeh, eggs)
   • Omnivore version (chicken, salmon, beef, etc.)

4. Ensure both variations share:

   • Sides
   • Seasoning
   • Cooking method (if possible)

---

Step 5 — Build the Weekly Plan

Pick 5 meals that:

• Maximise ingredient usage
• Respect dietary profiles
• Provide variety
• Include at least 2–3 dual‑protein meals

---

Step 6 — Produce Shopping List

Subtract used ingredients from inventory.

Add missing ingredients.

---

🔀 3. Dual‑Protein Logic (Domain Service)

ProteinSubstitutionService

Inputs:

• Recipe
• DietProfile
• ProteinMappingRules

Output:

• MealVariation

---

Protein Mapping Rules

Define a mapping table:

ProteinMapping
- BaseProtein: "salmon"
- VegetarianAlternative: "tofu"

ProteinMapping
- BaseProtein: "chicken"
- VegetarianAlternative: "tempeh"

You can also define:

ProteinCategoryMapping
- fish → tofu
- poultry → tempeh
- beef → seitan (if not low-FODMAP)

---

Substitution Algorithm

1. Identify the protein ingredient in the recipe
2. Look up a vegetarian alternative
3. Replace the protein ingredient
4. Adjust cooking instructions:
   • Replace “pan‑fry salmon” with “pan‑fry tofu”
   • Adjust cooking time
5. Keep all sides identical
6. Produce two variations:
   • Vegetarian
   • Omnivore

---

🧩 Putting It All Together

Your DDD structure will look like:

Aggregates

• Ingredient
• DietProfile
• Recipe
• MealPlan

Domain Services

• MealPlanGeneratorService
• RecipeScoringService
• ProteinSubstitutionService
• IngredientMatchingService

Repositories

• IngredientRepository
• RecipeRepository (Spoonacular + cache)
• MealPlanRepository

---

If you want, I can help you next with:

• Concrete C# domain models
• Domain service implementations
• A full example of generating a weekly plan
• A dual‑protein substitution engine in code
• A sample JSON structure for Spoonacular responses mapped to your aggregates

Just tell me where you want to go from here.

[TheMagnificent11]

Prompt

Concrete C# domain entities that inherit from the Lewee aggregate root and entity would be useful, thanks.

MS Copilot Response

Absolutely — let’s turn the domain model we shaped earlier into clean, concrete C## domain entities that inherit from your Lewee AggregateRoot and Entity base classes.

Everything below is designed to fit naturally into a DDD architecture using your framework’s conventions:

• Aggregates inherit from AggregateRoot
• Child entities inherit from Entity
• Value objects are immutable records
• No persistence concerns leak into the domain
• Constructors enforce invariants
• Collections are private with read‑only exposure

I’ll keep the code idiomatic, expressive, and ready to drop into your solution.

---

🧱 Ingredient Aggregate

using Lewee.Domain;

public sealed class Ingredient : AggregateRoot
{
    private readonly List<IngredientQuantity> _quantities = new();

    public Ingredient(Guid id, string name, IngredientCategory category)
        : base(id)
    {
        Name = name;
        Category = category;
    }

    public string Name { get; }
    public IngredientCategory Category { get; }
    public IReadOnlyCollection<IngredientQuantity> Quantities => _quantities.AsReadOnly();

    public void AddQuantity(decimal amount, UnitOfMeasure unit, DateTime? expiry = null)
    {
        _quantities.Add(new IngredientQuantity(Guid.NewGuid(), amount, unit, expiry));
    }
}

public sealed class IngredientQuantity : Entity
{
    public IngredientQuantity(Guid id, decimal amount, UnitOfMeasure unit, DateTime? expiry)
        : base(id)
    {
        Amount = amount;
        Unit = unit;
        Expiry = expiry;
    }

    public decimal Amount { get; }
    public UnitOfMeasure Unit { get; }
    public DateTime? Expiry { get; }
}

public enum IngredientCategory
{
    Vegetable,
    Protein,
    Pantry,
    Spice,
    Dairy,
    Other
}

public enum UnitOfMeasure
{
    Grams,
    Milliliters,
    Pieces,
    Tablespoon,
    Teaspoon
}

---

🥗 Diet Profile Aggregate

using Lewee.Domain;

public sealed class DietProfile : AggregateRoot
{
    private readonly List<string> _allowedIngredients = new();
    private readonly List<string> _excludedIngredients = new();
    private readonly List<string> _allowedTags = new();
    private readonly List<string> _excludedTags = new();

    public DietProfile(Guid id, string name)
        : base(id)
    {
        Name = name;
    }

    public string Name { get; }

    public IReadOnlyCollection<string> AllowedIngredients => _allowedIngredients.AsReadOnly();
    public IReadOnlyCollection<string> ExcludedIngredients => _excludedIngredients.AsReadOnly();
    public IReadOnlyCollection<string> AllowedTags => _allowedTags.AsReadOnly();
    public IReadOnlyCollection<string> ExcludedTags => _excludedTags.AsReadOnly();

    public void AllowIngredient(string ingredient) => _allowedIngredients.Add(ingredient);
    public void ExcludeIngredient(string ingredient) => _excludedIngredients.Add(ingredient);

    public void AllowTag(string tag) => _allowedTags.Add(tag);
    public void ExcludeTag(string tag) => _excludedTags.Add(tag);
}

---

🍽️ Recipe Aggregate

using Lewee.Domain;

public sealed class Recipe : AggregateRoot
{
    private readonly List<RecipeIngredient> _ingredients = new();
    private readonly List<InstructionStep> _instructions = new();
    private readonly List<string> _tags = new();

    public Recipe(Guid id, string title)
        : base(id)
    {
        Title = title;
    }

    public string Title { get; }

    public IReadOnlyCollection<RecipeIngredient> Ingredients => _ingredients.AsReadOnly();
    public IReadOnlyCollection<InstructionStep> Instructions => _instructions.AsReadOnly();
    public IReadOnlyCollection<string> Tags => _tags.AsReadOnly();

    public void AddIngredient(string name, decimal amount, UnitOfMeasure unit, bool isProtein = false)
    {
        _ingredients.Add(new RecipeIngredient(Guid.NewGuid(), name, amount, unit, isProtein));
    }

    public void AddInstruction(int order, string text)
    {
        _instructions.Add(new InstructionStep(Guid.NewGuid(), order, text));
    }

    public void AddTag(string tag) => _tags.Add(tag);
}

public sealed class RecipeIngredient : Entity
{
    public RecipeIngredient(Guid id, string name, decimal amount, UnitOfMeasure unit, bool isProtein)
        : base(id)
    {
        Name = name;
        Amount = amount;
        Unit = unit;
        IsProtein = isProtein;
    }

    public string Name { get; }
    public decimal Amount { get; }
    public UnitOfMeasure Unit { get; }
    public bool IsProtein { get; }
}

public sealed class InstructionStep : Entity
{
    public InstructionStep(Guid id, int order, string text)
        : base(id)
    {
        Order = order;
        Text = text;
    }

    public int Order { get; }
    public string Text { get; }
}

---

🍱 Meal Plan Aggregate

using Lewee.Domain;

public sealed class MealPlan : AggregateRoot
{
    private readonly List<PlannedMeal> _meals = new();

    public MealPlan(Guid id, DateTime weekStartDate)
        : base(id)
    {
        WeekStartDate = weekStartDate;
    }

    public DateTime WeekStartDate { get; }
    public IReadOnlyCollection<PlannedMeal> Meals => _meals.AsReadOnly();

    public void AddMeal(DayOfWeek day, Recipe baseRecipe)
    {
        _meals.Add(new PlannedMeal(Guid.NewGuid(), day, baseRecipe));
    }
}

public sealed class PlannedMeal : Entity
{
    private readonly List<MealVariation> _variations = new();

    public PlannedMeal(Guid id, DayOfWeek day, Recipe baseRecipe)
        : base(id)
    {
        Day = day;
        BaseRecipe = baseRecipe;
    }

    public DayOfWeek Day { get; }
    public Recipe BaseRecipe { get; }
    public IReadOnlyCollection<MealVariation> Variations => _variations.AsReadOnly();

    public void AddVariation(Guid dietProfileId, ProteinSubstitution? substitution, IEnumerable<RecipeIngredient> adjustedIngredients)
    {
        _variations.Add(new MealVariation(Guid.NewGuid(), dietProfileId, substitution, adjustedIngredients));
    }
}

public sealed class MealVariation : Entity
{
    public MealVariation(Guid id, Guid dietProfileId, ProteinSubstitution? substitution, IEnumerable<RecipeIngredient> adjustedIngredients)
        : base(id)
    {
        DietProfileId = dietProfileId;
        Substitution = substitution;
        AdjustedIngredients = adjustedIngredients.ToList().AsReadOnly();
    }

    public Guid DietProfileId { get; }
    public ProteinSubstitution? Substitution { get; }
    public IReadOnlyCollection<RecipeIngredient> AdjustedIngredients { get; }
}

public sealed class ProteinSubstitution
{
    public ProteinSubstitution(string from, string to)
    {
        From = from;
        To = to;
    }

    public string From { get; }
    public string To { get; }
}

---

🧠 What This Gives You

You now have:

✔ Fully DDD‑aligned aggregates

✔ Entities that inherit from your Lewee base classes

✔ Immutable value objects

✔ Clean separation of concerns

✔ A structure that supports:

• Ingredient inventory
• Dietary profiles
• Recipe ingestion
• Weekly meal planning
• Dual‑protein variations
• Future shopping list generation

This is a solid foundation for the domain layer of your meal‑planning app.

---

If you want, I can also generate:

• Domain services (MealPlanGeneratorService, ProteinSubstitutionService)
• Repository interfaces
• Integration layer models for Spoonacular
• Mapping profiles
• Example unit tests for the aggregates

Just tell me what you want to tackle next.