Virtual en action !

🌱Idée sous-jacente

Pour Mongoose : les virtuals sont utilisés pour simuler des relations entre entités, notamment avec populate et les mécanismes de lookup côté MongoDB.


  • Virtual = champ calculé, non stocké en base

  • Virtual populate = relation déclarative

🎯But

Le but est de séparer logique et persistance

- Le modèle MongoDB reste simple (sans duplication ou clé étrangère obligatoire).

-  Les entités sont reliées au niveau applicatif, via Mongoose, ce qui rend le code plus expressif et maintenable.


🆘Explication

 lecture  : → virtual


Virtual est au coeur de mongoose ! 

Autres exemples.


🆘Le coût d'une pizza : champ calculé non stocké.
  1. import mongoose from "mongoose";

  3. const pizzaSchema = new mongoose.Schema({
  4.   name: { type: String, required: true },
  5.   // `description` stores a simple recipe/notes string (renamed from `recept`)
  6.   description: { type: String, default: "" },
  7. }); 

  9. // Include virtuals when converting documents to objects/JSON
  10. pizzaSchema.set("toObject", { virtuals: true });
  11. pizzaSchema.set("toJSON", { virtuals: true });

  13. // Virtual populate: connect Pizza -> Topping via Topping.pizzas (inverse relation)
  14. pizzaSchema.virtual("toppings", {
  15.   ref: "Topping",
  16.   localField: "_id",
  17.   foreignField: "pizzas",
  18.   justOne: false,
  19. });

  21. // Virtual total price (cents) includes toppings when `toppings` is populated
  22. pizzaSchema.virtual("totalPriceCents").get(function () {
  23.   // Compute total price from populated `toppings` only (no base pizza price)
  24.   if (
  25.     !this.toppings ||
  26.     !Array.isArray(this.toppings) ||
  27.     this.toppings.length === 0
  28.   )
  29.     return 0;
  30.   return this.toppings.reduce((acc, t) => acc + (t.priceCents || 0), 0);
  31. });

  33. pizzaSchema.virtual("totalPriceEur").get(function () {
  34.   return (this.totalPriceCents || 0) / 100;
  35. });

  37. export const Pizza = mongoose.model("Pizza", pizzaSchema);
🆘relation inverse ! 

Soit un schéma topping : 

const toppingSchema = new mongoose.Schema({
  title: { },
  pizzas: [{ type: mongoose.Schema.Types.ObjectId, ref: "Pizza" }],
});

pizzas = ensemble des pizzas qui a cet ingrédients.

🛟Comment trouver les pizzas qui ont un ingredient ?

→ Dans le schéma pizza on ecrit un virtual !

🥷pizzaSchema.virtual("toppings", { ref: "Topping", localField: "_id", foreignField: "pizzas", justOne: false, });

Ici on crée une relation inverse :

  • ref: "Topping" → référence le modèle Topping.
  • localField: "_id" → utilise l’ID de la pizza.
  • foreignField: "pizzas" → cherche dans le champ pizzas des documents Topping (qui doit être un tableau d’IDs de pizzas).
  • justOne: false → une pizza peut avoir plusieurs toppings.

👉 En clair : ce virtual permet de récupérer tous les Topping qui contiennent l’ID de cette pizza dans leur champ pizzas.