@salifbiaye/create-boutique 0.1.1

package/templates/backend/src/emails/fr.json

@@ -0,0 +1,64 @@
+{
+  "order_placed": {
+    "subject": "Commande n° {number} confirmée",
+    "title": "Merci pour votre commande !",
+    "intro": "Bonjour {name}, nous avons bien reçu votre commande n° {number}. En voici le récapitulatif."
+  },
+  "order_shipped": {
+    "subject": "Votre commande n° {number} est en route",
+    "title": "Votre colis est en route",
+    "intro": "Bonne nouvelle {name} : votre commande n° {number} a été expédiée.",
+    "tracking": "Numéro de suivi : {code}",
+    "track": "Suivre mon colis"
+  },
+  "order_delivered": {
+    "subject": "Votre commande n° {number} est livrée",
+    "title": "Votre commande est livrée",
+    "intro": "Bonjour {name}, votre commande n° {number} a été livrée. Nous espérons qu'elle vous plaira !"
+  },
+  "order_canceled": {
+    "subject": "Votre commande n° {number} est annulée",
+    "title": "Commande annulée",
+    "intro": "Bonjour {name}, votre commande n° {number} a été annulée. Si vous avez été débité, vous serez remboursé."
+  },
+  "refund": {
+    "subject": "Remboursement de votre commande n° {number}",
+    "title": "Remboursement effectué",
+    "intro": "Bonjour {name}, nous vous avons remboursé {amount} pour la commande n° {number}. Le montant peut mettre quelques jours à apparaître sur votre compte."
+  },
+  "return_requested": {
+    "subject": "Retour demandé pour la commande n° {number}",
+    "title": "Votre demande de retour",
+    "intro": "Bonjour {name}, nous avons enregistré un retour pour votre commande n° {number}. Merci de renvoyer les articles dans leur emballage d'origine."
+  },
+  "return_received": {
+    "subject": "Retour reçu pour la commande n° {number}",
+    "title": "Retour reçu",
+    "intro": "Bonjour {name}, nous avons reçu les articles retournés de la commande n° {number}. Votre remboursement est en cours."
+  },
+  "merchant_new_order": {
+    "subject": "Nouvelle commande n° {number} — {total}",
+    "title": "Nouvelle commande sur {store}",
+    "intro": "Commande n° {number} de {email}, total {total}."
+  },
+  "common": {
+    "item": "Article",
+    "qty": "Qté",
+    "total": "Total",
+    "shippingTo": "Livraison à",
+    "questions": "Une question ? Répondez simplement à cet e-mail.",
+    "customer": "client"
+  },
+  "password_reset": {
+    "subject": "Réinitialiser votre mot de passe {store}",
+    "title": "Réinitialiser votre mot de passe",
+    "intro": "Nous avons reçu une demande de réinitialisation du mot de passe de votre compte admin {store}. Le lien est valable pendant une durée limitée. Si vous n'êtes pas à l'origine de cette demande, ignorez cet e-mail.",
+    "button": "Choisir un nouveau mot de passe"
+  },
+  "team_invite": {
+    "subject": "Invitation à l'admin {store}",
+    "title": "Rejoindre l'équipe {store}",
+    "intro": "Vous êtes invité à gérer les boutiques {store}. Cliquez sur le bouton pour créer votre compte.",
+    "button": "Accepter l'invitation"
+  }
+}

package/templates/backend/src/jobs/README.md

@@ -0,0 +1,38 @@
+# Custom scheduled jobs
+
+A scheduled job is a function executed at a specified interval of time in the background of your Medusa application.
+
+> Learn more about scheduled jobs in [this documentation](https://docs.medusajs.com/learn/fundamentals/scheduled-jobs).
+
+A scheduled job is created in a TypeScript or JavaScript file under the `src/jobs` directory.
+
+For example, create the file `src/jobs/hello-world.ts` with the following content:
+
+```ts
+import {
+  MedusaContainer
+} from "@medusajs/framework/types";
+
+export default async function myCustomJob(container: MedusaContainer) {
+  const productService = container.resolve("product")
+
+  const products = await productService.listAndCountProducts();
+
+  // Do something with the products
+}
+
+export const config = {
+  name: "daily-product-report",
+  schedule: "0 0 * * *", // Every day at midnight
+};
+```
+
+A scheduled job file must export:
+
+- The function to be executed whenever it’s time to run the scheduled job.
+- A configuration object defining the job. It has three properties:
+  - `name`: a unique name for the job.
+  - `schedule`: a [cron expression](https://crontab.guru/).
+  - `numberOfExecutions`: an optional integer, specifying how many times the job will execute before being removed
+
+The `handler` is a function that accepts one parameter, `container`, which is a `MedusaContainer` instance used to resolve services.

package/templates/backend/src/lib/emails.ts

@@ -0,0 +1,94 @@
+import en from "../emails/en.json"
+import fr from "../emails/fr.json"
+
+/**
+ * Rendu des e-mails : un texte par type et par langue (src/emails/<lang>.json),
+ * aux couleurs du thème de la boutique d'où vient la commande.
+ * Toute valeur insérée est échappée : jamais de HTML venant d'une saisie.
+ */
+export type EmailType =
+  | "order_placed"
+  | "order_shipped"
+  | "order_delivered"
+  | "order_canceled"
+  | "refund"
+  | "return_requested"
+  | "return_received"
+  | "merchant_new_order"
+  | "password_reset"
+  | "team_invite"
+
+const DICTS: Record<string, typeof en> = { en, fr }
+
+// Couleurs principales des thèmes (design/tokens.css). Fond clair pour tous : lisible dans toutes les messageries.
+const THEMES: Record<string, { primary: string; onPrimary: string }> = {
+  halloween: { primary: "#ff7a1a", onPrimary: "#0e0c14" },
+  thanksgiving: { primary: "#c2410c", onPrimary: "#ffffff" },
+  "black-friday": { primary: "#f97316", onPrimary: "#09090b" },
+  "cyber-monday": { primary: "#4a2bd6", onPrimary: "#ffffff" },
+  noel: { primary: "#b91c1c", onPrimary: "#ffffff" },
+  "nouvel-an": { primary: "#d9b54a", onPrimary: "#111018" },
+}
+
+export const escapeHtml = (s: unknown) =>
+  String(s ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!)
+
+const fill = (text: string, vars: Record<string, string | number | undefined>) =>
+  text.replace(/\{(\w+)\}/g, (_, k: string) => String(vars[k] ?? ""))
+
+export type EmailData = {
+  storeName: string
+  theme: string
+  language: string
+  vars: Record<string, string | number | undefined>
+  items?: { title: string; quantity: number; total: string }[]
+  total?: string
+  address?: string
+  button?: { label: string; url: string }
+  extra?: string
+}
+
+export function renderEmail(type: EmailType, d: EmailData) {
+  const dict = DICTS[d.language] ?? en
+  const t = dict[type] as Record<string, string>
+  const c = dict.common
+  const color = THEMES[d.theme] ?? THEMES["black-friday"]
+  const vars = { ...d.vars, store: d.storeName }
+
+  const subject = fill(t.subject, vars)
+  const title = fill(t.title, vars)
+  const intro = fill(t.intro, vars)
+
+  const rows = (d.items ?? [])
+    .map(
+      (i) =>
+        `<tr><td style="padding:8px 0;border-bottom:1px solid #eee">${escapeHtml(i.title)}</td>` +
+        `<td style="padding:8px 0;border-bottom:1px solid #eee;text-align:center">${escapeHtml(i.quantity)}</td>` +
+        `<td style="padding:8px 0;border-bottom:1px solid #eee;text-align:right">${escapeHtml(i.total)}</td></tr>`
+    )
+    .join("")
+
+  const html = `<!doctype html><html lang="${escapeHtml(d.language)}"><body style="margin:0;background:#f4f4f5;font-family:Arial,Helvetica,sans-serif;color:#18181b">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="padding:24px 12px"><tr><td align="center">
+<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="max-width:560px;background:#ffffff;border-radius:12px;overflow:hidden">
+<tr><td style="background:${color.primary};color:${color.onPrimary};padding:20px 28px;font-size:18px;font-weight:bold">${escapeHtml(d.storeName)}</td></tr>
+<tr><td style="padding:28px">
+<h1 style="margin:0 0 12px;font-size:22px">${escapeHtml(title)}</h1>
+<p style="margin:0 0 20px;line-height:1.5">${escapeHtml(intro)}</p>
+${d.extra ? `<p style="margin:0 0 20px;line-height:1.5">${escapeHtml(d.extra)}</p>` : ""}
+${rows ? `<table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="font-size:14px;margin-bottom:16px"><tr style="color:#71717a"><td>${escapeHtml(c.item)}</td><td style="text-align:center">${escapeHtml(c.qty)}</td><td style="text-align:right">${escapeHtml(c.total)}</td></tr>${rows}</table>` : ""}
+${d.total ? `<p style="margin:0 0 20px;font-size:16px;text-align:right"><strong>${escapeHtml(c.total)} : ${escapeHtml(d.total)}</strong></p>` : ""}
+${d.address ? `<p style="margin:0 0 20px;font-size:14px;color:#52525b">${escapeHtml(c.shippingTo)} : ${escapeHtml(d.address)}</p>` : ""}
+${d.button ? `<p style="margin:0 0 20px"><a href="${escapeHtml(d.button.url)}" style="display:inline-block;background:${color.primary};color:${color.onPrimary};padding:12px 20px;border-radius:999px;text-decoration:none;font-weight:bold">${escapeHtml(d.button.label)}</a></p>` : ""}
+<p style="margin:24px 0 0;font-size:13px;color:#71717a">${escapeHtml(c.questions)}</p>
+</td></tr></table></td></tr></table></body></html>`
+
+  const text = [title, intro, d.extra, ...(d.items ?? []).map((i) => `- ${i.title} x${i.quantity} : ${i.total}`), d.total && `${c.total} : ${d.total}`, d.address && `${c.shippingTo} : ${d.address}`, d.button && `${d.button.label} : ${d.button.url}`, c.questions]
+    .filter(Boolean)
+    .join("\n")
+
+  return { subject, html, text, button: t.track }
+}
+
+export const emailLabel = (language: string, type: EmailType, key: string) =>
+  ((DICTS[language] ?? en)[type] as Record<string, string>)[key] ?? ""

package/templates/backend/src/lib/notify.ts

@@ -0,0 +1,148 @@
+import { MedusaContainer } from "@medusajs/framework/types"
+import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
+import { type EmailType, renderEmail, emailLabel } from "./emails"
+import { readProject } from "./project"
+
+type Options = {
+  /** Texte en plus sous l'introduction (ex. numéro de suivi) */
+  extra?: string
+  /** Bouton (ex. lien de suivi du colis) */
+  button?: { label: string; url: string }
+  /** Variables en plus (ex. montant remboursé) */
+  vars?: Record<string, string>
+  /** Envoyer le récapitulatif des articles */
+  withItems?: boolean
+}
+
+let warned = false
+
+/**
+ * E-mail au client d'une commande (et au marchand pour une nouvelle commande).
+ * Langue, nom et couleurs : ceux de la boutique d'où vient la commande (sales channel → project.json).
+ * Sans RESEND_API_KEY : rien n'est envoyé (la boutique fonctionne quand même, `check` le signale).
+ * Une erreur d'envoi est journalisée mais ne bloque jamais la commande.
+ */
+export async function sendOrderEmail(container: MedusaContainer, orderId: string, type: EmailType, opts: Options = {}) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER)
+  if (!process.env.RESEND_API_KEY) {
+    if (!warned) logger.warn("[emails] RESEND_API_KEY absente : aucun e-mail n'est envoyé")
+    warned = true
+    return
+  }
+
+  try {
+    const query = container.resolve(ContainerRegistrationKeys.QUERY)
+    const { data: orders } = await query.graph({
+      entity: "order",
+      fields: [
+        "id",
+        "display_id",
+        "email",
+        "currency_code",
+        "total",
+        "sales_channel_id",
+        "items.product_title",
+        "items.variant_title",
+        "items.quantity",
+        "items.total",
+        "shipping_address.*",
+      ],
+      filters: { id: orderId },
+    })
+    const order = orders[0]
+    if (!order?.email) return
+
+    const { data: channels } = await query.graph({ entity: "sales_channel", fields: ["name"], filters: { id: order.sales_channel_id! } })
+    const project = readProject()
+    const boutique = project.boutiques.find((b) => b.slug === channels[0]?.name) ?? project.boutiques[0]
+    const locale = `${project.language}-${boutique.country.toUpperCase()}`
+    const money = (n: unknown) => new Intl.NumberFormat(locale, { style: "currency", currency: order.currency_code }).format(Number(n ?? 0))
+
+    const a = order.shipping_address
+    const address = a ? [a.address_1, a.postal_code, a.city, a.country_code?.toUpperCase()].filter(Boolean).join(", ") : undefined
+    const vars = {
+      number: order.display_id ?? "",
+      name: a?.first_name || emailLabel(project.language, "order_placed", "customer") || "",
+      total: money(order.total),
+      email: order.email,
+      ...opts.vars,
+    }
+    const items = (order.items ?? []).filter(Boolean).map((i) => ({
+      title: [i!.product_title, i!.variant_title].filter(Boolean).join(" — "),
+      quantity: Number(i!.quantity),
+      total: money(i!.total),
+    }))
+
+    const base = { storeName: boutique.storeName, theme: boutique.theme, language: project.language, vars }
+    const customer = renderEmail(type, {
+      ...base,
+      items: opts.withItems ? items : undefined,
+      total: opts.withItems ? money(order.total) : undefined,
+      address: opts.withItems ? address : undefined,
+      extra: opts.extra,
+      button: opts.button,
+    })
+
+    const notifications = container.resolve(Modules.NOTIFICATION)
+    const common = { channel: "email", resource_id: order.id, resource_type: "order", trigger_type: type }
+    const data = { fromName: boutique.storeName, replyTo: project.merchantEmail }
+
+    await notifications.createNotifications({
+      ...common,
+      to: order.email,
+      template: type,
+      content: { subject: customer.subject, html: customer.html, text: customer.text },
+      data,
+    })
+
+    if (type === "order_placed" && project.merchantEmail) {
+      const merchant = renderEmail("merchant_new_order", { ...base, items, total: money(order.total), address })
+      await notifications.createNotifications({
+        ...common,
+        to: project.merchantEmail,
+        template: "merchant_new_order",
+        content: { subject: merchant.subject, html: merchant.html, text: merchant.text },
+        data: { fromName: boutique.storeName, replyTo: order.email },
+      })
+    }
+  } catch (e) {
+    logger.error(`[emails] ${type} pour la commande ${orderId} : ${(e as Error).message}`)
+  }
+}
+
+/** Adresse publique de l'admin (liens des e-mails) : ADMIN_URL, sinon la 1re origine d'ADMIN_CORS. */
+export const adminUrl = () => (process.env.ADMIN_URL || process.env.ADMIN_CORS?.split(",")[0] || "http://localhost:9000").replace(/\/$/, "")
+
+/**
+ * E-mails de compte admin (mot de passe oublié, invitation d'équipe) : un bouton vers l'admin.
+ * Sans RESEND_API_KEY : rien n'est envoyé (le lien reste visible dans les logs du backend en dev).
+ */
+export async function sendAccountEmail(container: MedusaContainer, to: string, type: "password_reset" | "team_invite", url: string) {
+  const logger = container.resolve(ContainerRegistrationKeys.LOGGER)
+  if (!process.env.RESEND_API_KEY) {
+    logger.warn(`[emails] RESEND_API_KEY absente : e-mail « ${type} » non envoyé à ${to}`)
+    return
+  }
+  try {
+    const project = readProject()
+    const first = project.boutiques[0]
+    const storeName = first.storeName
+    const email = renderEmail(type, {
+      storeName,
+      theme: first.theme,
+      language: project.language,
+      vars: {},
+      button: { label: emailLabel(project.language, type, "button"), url },
+    })
+    await container.resolve(Modules.NOTIFICATION).createNotifications({
+      to,
+      channel: "email",
+      template: type,
+      trigger_type: type,
+      content: { subject: email.subject, html: email.html, text: email.text },
+      data: { fromName: storeName, replyTo: project.merchantEmail },
+    })
+  } catch (e) {
+    logger.error(`[emails] ${type} pour ${to} : ${(e as Error).message}`)
+  }
+}

package/templates/backend/src/lib/project.ts

@@ -0,0 +1,146 @@
+import fs from "node:fs"
+import path from "node:path"
+import { z } from "@medusajs/framework/zod"
+
+/**
+ * Lecture de config/project.json côté backend (même fichier que le storefront).
+ * Seuls les champs utiles au backend sont validés ici ; le storefront valide le reste.
+ */
+export const CONFIG_DIR = process.env.CONFIG_DIR || "/app/config"
+export const SEED_DIR = process.env.SEED_DIR || "/app/seed"
+export const KEYS_DIR = process.env.KEYS_DIR || "/app/keys"
+
+const code2 = z.string().regex(/^[a-z]{2}$/)
+const code3 = z.string().regex(/^[a-z]{3}$/)
+const shipsTo = z.union([z.literal("all"), z.array(code2).min(1)])
+
+const projectSchema = z.object({
+  project: z.string(),
+  defaults: z.looseObject({
+    storeName: z.string(),
+    currency: code3,
+    country: code2,
+    language: z.string().default("en"),
+    shipsTo: shipsTo.default("all"),
+    merchantEmail: z.email().optional(),
+  }),
+  boutiques: z
+    .array(
+      z.looseObject({
+        slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
+        theme: z.string(),
+        port: z.number(),
+        storeName: z.string().optional(),
+        currency: code3.optional(),
+        country: code2.optional(),
+        shipsTo: shipsTo.optional(),
+      })
+    )
+    .min(1),
+})
+
+export type Boutique = {
+  slug: string
+  theme: string
+  storeName: string
+  currency: string
+  country: string
+  shipsTo: "all" | string[]
+}
+
+export type Project = {
+  project: string
+  defaultCurrency: string
+  language: string
+  merchantEmail?: string
+  boutiques: Boutique[]
+}
+
+export function readProject(): Project {
+  const file = path.join(CONFIG_DIR, "project.json")
+  const raw = JSON.parse(fs.readFileSync(file, "utf8"))
+  const res = projectSchema.safeParse(raw)
+  if (!res.success) {
+    throw new Error(`${file} invalide :\n${z.prettifyError(res.error)}`)
+  }
+  const { defaults, boutiques } = res.data
+  return {
+    project: res.data.project,
+    defaultCurrency: defaults.currency,
+    language: defaults.language,
+    merchantEmail: defaults.merchantEmail,
+    boutiques: boutiques.map((b) => ({
+      slug: b.slug,
+      theme: b.theme,
+      storeName: b.storeName ?? defaults.storeName,
+      currency: b.currency ?? defaults.currency,
+      country: b.country ?? defaults.country,
+      shipsTo: b.shipsTo ?? defaults.shipsTo,
+    })),
+  }
+}
+
+/** Pays qui utilisent officiellement une devise : zone d'une boutique en devise secondaire avec shipsTo "all". */
+export const CURRENCY_COUNTRIES: Record<string, string[]> = {
+  eur: ["at", "be", "cy", "de", "ee", "es", "fi", "fr", "gr", "hr", "ie", "it", "lt", "lu", "lv", "mt", "nl", "pt", "si", "sk"],
+  xof: ["bj", "bf", "ci", "gw", "ml", "ne", "sn", "tg"],
+  xaf: ["cm", "cf", "td", "cg", "gq", "ga"],
+  usd: ["us", "ec", "sv", "pa", "pr"],
+  gbp: ["gb"],
+  chf: ["ch", "li"],
+  cad: ["ca"],
+  aud: ["au"],
+  jpy: ["jp"],
+  mad: ["ma"],
+  ngn: ["ng"],
+  ghs: ["gh"],
+  kes: ["ke"],
+  zar: ["za"],
+}
+
+/**
+ * Un pays n'appartient qu'à une région Medusa, donc qu'à une devise.
+ * Règles : listes explicites d'abord (conflit = erreur) ; une devise secondaire en "all"
+ * prend les pays de sa zone monétaire ; la devise principale en "all" prend le reste.
+ */
+export function countriesByCurrency(project: Project, allCountries: string[]): Map<string, Set<string>> {
+  const owner = new Map<string, string>()
+  const result = new Map<string, Set<string>>()
+  const claim = (country: string, currency: string, strict: boolean, why: string) => {
+    const current = owner.get(country)
+    if (current && current !== currency) {
+      if (strict) {
+        throw new Error(`le pays « ${country} » est demandé en ${currency.toUpperCase()} (${why}) mais appartient déjà à ${current.toUpperCase()} : un pays ne peut avoir qu'une devise.`)
+      }
+      return
+    }
+    owner.set(country, currency)
+    if (!result.has(currency)) result.set(currency, new Set())
+    result.get(currency)!.add(country)
+  }
+
+  for (const b of project.boutiques) {
+    if (Array.isArray(b.shipsTo)) for (const c of b.shipsTo) claim(c, b.currency, true, `shipsTo de ${b.slug}`)
+  }
+  for (const b of project.boutiques) claim(b.country, b.currency, true, `pays principal de ${b.slug}`)
+  for (const b of project.boutiques) {
+    if (b.shipsTo === "all" && b.currency !== project.defaultCurrency) {
+      for (const c of CURRENCY_COUNTRIES[b.currency] ?? []) claim(c, b.currency, false, b.slug)
+    }
+  }
+  if (project.boutiques.some((b) => b.shipsTo === "all" && b.currency === project.defaultCurrency)) {
+    for (const c of allCountries) if (!owner.has(c)) claim(c, project.defaultCurrency, false, "reste du monde")
+  }
+  return result
+}
+
+/** Tarifs de livraison par défaut (modifiables ensuite dans l'admin) : [standard, express]. */
+export const SHIPPING_RATES: Record<string, [number, number]> = {
+  usd: [5, 15],
+  eur: [5, 15],
+  gbp: [5, 12],
+  cad: [7, 20],
+  xof: [2000, 5000],
+  xaf: [2000, 5000],
+}
+export const shippingRates = (currency: string): [number, number] => SHIPPING_RATES[currency] ?? [0, 0]

package/templates/backend/src/links/README.md

@@ -0,0 +1,26 @@
+# Module Links
+
+A module link forms an association between two data models of different modules, while maintaining module isolation.
+
+> Learn more about links in [this documentation](https://docs.medusajs.com/learn/fundamentals/module-links)
+
+For example:
+
+```ts
+import BlogModule from "../modules/blog"
+import ProductModule from "@medusajs/medusa/product"
+import { defineLink } from "@medusajs/framework/utils"
+
+export default defineLink(
+  ProductModule.linkable.product,
+  BlogModule.linkable.post
+)
+```
+
+This defines a link between the Product Module's `product` data model and the Blog Module (custom module)'s `post` data model.
+
+Then, in the Medusa application, run the following command to sync the links to the database:
+
+```bash
+npx medusa db:migrate
+```

package/templates/backend/src/links/campaign-sales-channel.ts

@@ -0,0 +1,9 @@
+import { defineLink } from "@medusajs/framework/utils"
+import SalesChannelModule from "@medusajs/medusa/sales-channel"
+import CampaignModule from "../modules/campaign"
+
+// Une campagne par boutique (sales channel). Supprimer la campagne supprime le lien.
+export default defineLink(SalesChannelModule.linkable.salesChannel, {
+  linkable: CampaignModule.linkable.boutiqueCampaign,
+  deleteCascade: true,
+})

package/templates/backend/src/modules/README.md

@@ -0,0 +1,117 @@
+# Custom Module
+
+A module is a package of reusable functionalities. It can be integrated into your Medusa application without affecting the overall system. You can create a module as part of a plugin.
+
+> Learn more about modules in [this documentation](https://docs.medusajs.com/learn/fundamentals/modules).
+
+To create a module:
+
+## 1. Create a Data Model
+
+A data model represents a table in the database. You create a data model in a TypeScript or JavaScript file under the `models` directory of a module.
+
+For example, create the file `src/modules/blog/models/post.ts` with the following content:
+
+```ts
+import { model } from "@medusajs/framework/utils"
+
+const Post = model.define("post", {
+  id: model.id().primaryKey(),
+  title: model.text(),
+})
+
+export default Post
+```
+
+## 2. Create a Service
+
+A module must define a service. A service is a TypeScript or JavaScript class holding methods related to a business logic or commerce functionality.
+
+For example, create the file `src/modules/blog/service.ts` with the following content:
+
+```ts
+import { MedusaService } from "@medusajs/framework/utils"
+import Post from "./models/post"
+
+class BlogModuleService extends MedusaService({
+  Post,
+}){
+}
+
+export default BlogModuleService
+```
+
+## 3. Export Module Definition
+
+A module must have an `index.ts` file in its root directory that exports its definition. The definition specifies the main service of the module.
+
+For example, create the file `src/modules/blog/index.ts` with the following content:
+
+```ts
+import BlogModuleService from "./service"
+import { Module } from "@medusajs/framework/utils"
+
+export const BLOG_MODULE = "blog"
+
+export default Module(BLOG_MODULE, {
+  service: BlogModuleService,
+})
+```
+
+## 4. Add Module to Medusa's Configurations
+
+To start using the module, add it to `medusa-config.ts`:
+
+```ts
+module.exports = defineConfig({
+  projectConfig: {
+    // ...
+  },
+  modules: [
+    {
+      resolve: "./src/modules/blog",
+    },
+  ],
+})
+```
+
+## 5. Generate and Run Migrations
+
+To generate migrations for your module, run the following command:
+
+```bash
+npx medusa db:generate blog
+```
+
+Then, to run migrations, run the following command:
+
+```bash
+npx medusa db:migrate
+```
+
+## Use Module
+
+You can use the module in customizations within the Medusa application, such as workflows and API routes.
+
+For example, to use the module in an API route:
+
+```ts
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework"
+import BlogModuleService from "../../../modules/blog/service"
+import { BLOG_MODULE } from "../../../modules/blog"
+
+export async function GET(
+  req: MedusaRequest,
+  res: MedusaResponse
+): Promise<void> {
+  const blogModuleService: BlogModuleService = req.scope.resolve(
+    BLOG_MODULE
+  )
+
+  const posts = await blogModuleService.listPosts()
+
+  res.json({
+    posts
+  })
+}
+```

package/templates/backend/src/modules/campaign/index.ts

@@ -0,0 +1,9 @@
+import { Module } from "@medusajs/framework/utils"
+import CampaignModuleService from "./service"
+
+// « campaign » est déjà pris par le module Promotion de Medusa.
+export const CAMPAIGN_MODULE = "boutiqueCampaign"
+
+export default Module(CAMPAIGN_MODULE, {
+  service: CampaignModuleService,
+})