@salifbiaye/create-boutique 0.6.0 → 0.7.0

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

@@ -2,6 +2,8 @@ import { MedusaContainer } from "@medusajs/framework/types"
 import { ContainerRegistrationKeys, Modules } from "@medusajs/framework/utils"
 import { type EmailType, renderEmail, emailLabel } from "./emails"
 import { readProject } from "./project"
+import { emailMode } from "./email-config"
+import { reviewToken } from "./review-token"
 
 type Options = {
   /** Texte en plus sous l'introduction (ex. numéro de suivi) */
@@ -12,6 +14,8 @@ type Options = {
   vars?: Record<string, string>
   /** Envoyer le récapitulatif des articles */
   withItems?: boolean
+  /** Bouton « Laisser un avis » vers la boutique de la commande (lien signé, e-mail « commande livrée ») */
+  reviewLink?: boolean
 }
 
 let warned = false
@@ -19,13 +23,13 @@ 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).
+ * Sans envoi configuré (ni Resend ni SMTP, voir email-config.ts) : rien n'est envoyé (la boutique fonctionne quand même).
  * 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é")
+  if (!emailMode()) {
+    if (!warned) logger.warn("[emails] ni RESEND_API_KEY ni SMTP configuré : aucun e-mail n'est envoyé")
     warned = true
     return
   }
@@ -79,8 +83,10 @@ export async function sendOrderEmail(container: MedusaContainer, orderId: string
       items: opts.withItems ? items : undefined,
       total: opts.withItems ? money(order.total) : undefined,
       address: opts.withItems ? address : undefined,
-      extra: opts.extra,
-      button: opts.button,
+      extra: opts.reviewLink ? emailLabel(project.language, type, "reviewText") : opts.extra,
+      button: opts.reviewLink
+        ? { label: emailLabel(project.language, type, "review"), url: `${boutique.url}/review?token=${encodeURIComponent(reviewToken(order.id))}` }
+        : opts.button,
     })
 
     const notifications = container.resolve(Modules.NOTIFICATION)
@@ -115,12 +121,12 @@ export const adminUrl = () => (process.env.ADMIN_URL || process.env.ADMIN_CORS?.
 
 /**
  * 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).
+ * Sans envoi configuré (ni Resend ni SMTP) : 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}`)
+  if (!emailMode()) {
+    logger.warn(`[emails] aucun envoi configuré (Resend ou SMTP) : e-mail « ${type} » non envoyé à ${to}`)
     return
   }
   try {

package/templates/backend/src/lib/payment-config.ts

@@ -0,0 +1,66 @@
+/**
+ * Moyens de paiement activés d'après l'environnement (.env). Un moyen sans ses clés n'est pas chargé.
+ * Utilisé par medusa-config.ts (providers à charger) et par le seed (providers de chaque région, selon sa devise).
+ *
+ * - Manuel (pp_system_default) : toujours.
+ * - Stripe (carte, Apple Pay, Google Pay) : STRIPE_API_KEY.
+ * - PayTech (Wave, Orange Money, Free Money, carte) : PAYTECH_API_KEY + PAYTECH_API_SECRET ; PAYTECH_ENV=test|prod.
+ * - PayDunya (Wave, Orange Money, carte) : PAYDUNYA_MASTER_KEY + PAYDUNYA_PRIVATE_KEY + PAYDUNYA_TOKEN ; PAYDUNYA_ENV=test|prod.
+ * - NabooPay (Wave, Orange Money) : NABOOPAY_API_KEY (+ NABOOPAY_WEBHOOK_SECRET) ; NABOOPAY_METHODS=wave,orange_money.
+ */
+type Provider = { resolve: string; id: string; options: Record<string, unknown>; providerId: string; currencies?: string[] }
+
+export function paymentProviders(env: NodeJS.ProcessEnv = process.env): Provider[] {
+  const list: Provider[] = []
+  if (env.STRIPE_API_KEY) {
+    list.push({
+      resolve: "@medusajs/medusa/payment-stripe",
+      id: "stripe",
+      providerId: "pp_stripe_stripe",
+      options: { apiKey: env.STRIPE_API_KEY, webhookSecret: env.STRIPE_WEBHOOK_SECRET || undefined, capture: true, automaticPaymentMethods: true },
+    })
+  }
+  if (env.PAYTECH_API_KEY && env.PAYTECH_API_SECRET) {
+    list.push({
+      resolve: "./src/modules/paytech",
+      id: "paytech",
+      providerId: "pp_paytech_paytech",
+      currencies: ["xof", "eur", "usd", "cad", "gbp", "mad"],
+      options: { api_key: env.PAYTECH_API_KEY, api_secret: env.PAYTECH_API_SECRET, env: env.PAYTECH_ENV === "prod" ? "prod" : "test" },
+    })
+  }
+  if (env.PAYDUNYA_MASTER_KEY && env.PAYDUNYA_PRIVATE_KEY && env.PAYDUNYA_TOKEN) {
+    list.push({
+      resolve: "./src/modules/paydunya",
+      id: "paydunya",
+      providerId: "pp_paydunya_paydunya",
+      currencies: ["xof"],
+      options: {
+        master_key: env.PAYDUNYA_MASTER_KEY,
+        private_key: env.PAYDUNYA_PRIVATE_KEY,
+        token: env.PAYDUNYA_TOKEN,
+        env: env.PAYDUNYA_ENV === "prod" ? "prod" : "test",
+      },
+    })
+  }
+  if (env.NABOOPAY_API_KEY) {
+    list.push({
+      resolve: "./src/modules/naboopay",
+      id: "naboopay",
+      providerId: "pp_naboopay_naboopay",
+      currencies: ["xof"],
+      options: {
+        api_key: env.NABOOPAY_API_KEY,
+        webhook_secret: env.NABOOPAY_WEBHOOK_SECRET || undefined,
+        methods: (env.NABOOPAY_METHODS || "wave,orange_money").split(",").map((m) => m.trim()).filter(Boolean),
+      },
+    })
+  }
+  return list
+}
+
+/** Providers d'une région (devise) : manuel + ceux qui acceptent cette devise */
+export function regionPaymentProviders(currency: string, env: NodeJS.ProcessEnv = process.env): string[] {
+  const c = currency.toLowerCase()
+  return ["pp_system_default", ...paymentProviders(env).filter((p) => !p.currencies || p.currencies.includes(c)).map((p) => p.providerId)]
+}

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

@@ -24,13 +24,17 @@ const projectSchema = z.object({
     language: z.string().default("en"),
     shipsTo: shipsTo.default("all"),
     merchantEmail: z.email().optional(),
+    /** Avis : « shared » = un produit affiche les avis de toutes les boutiques (défaut) ; « boutique » = seulement les siens */
+    reviews: z.enum(["shared", "boutique"]).default("shared"),
   }),
+  site: z.looseObject({ port: z.number().optional(), url: z.string().optional() }).optional(),
   boutiques: z
     .array(
       z.looseObject({
         slug: z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/),
         theme: z.string(),
         port: z.number().optional(),
+        url: z.string().optional(),
         storeName: z.string().optional(),
         currency: code3.optional(),
         country: code2.optional(),
@@ -47,6 +51,8 @@ export type Boutique = {
   currency: string
   country: string
   shipsTo: "all" | string[]
+  /** Adresse publique du site de la boutique (mode single : celle du site unique) */
+  url: string
 }
 
 export type Project = {
@@ -56,6 +62,7 @@ export type Project = {
   defaultCurrency: string
   language: string
   merchantEmail?: string
+  reviews: "shared" | "boutique"
   boutiques: Boutique[]
 }
 
@@ -73,6 +80,7 @@ export function readProject(): Project {
     defaultCurrency: defaults.currency,
     language: defaults.language,
     merchantEmail: defaults.merchantEmail,
+    reviews: defaults.reviews,
     boutiques: boutiques.map((b) => ({
       slug: b.slug,
       theme: b.theme,
@@ -80,6 +88,10 @@ export function readProject(): Project {
       currency: b.currency ?? defaults.currency,
       country: b.country ?? defaults.country,
       shipsTo: b.shipsTo ?? defaults.shipsTo,
+      url: (res.data.mode === "single"
+        ? (res.data.site?.url ?? `http://localhost:${res.data.site?.port ?? 8000}`)
+        : (b.url ?? `http://localhost:${b.port ?? 8000}`)
+      ).replace(/\/+$/, ""),
     })),
   }
 }

package/templates/backend/src/lib/redirect-payment.ts

@@ -0,0 +1,264 @@
+import crypto from "node:crypto"
+import type {
+  AuthorizePaymentInput,
+  AuthorizePaymentOutput,
+  CancelPaymentInput,
+  CancelPaymentOutput,
+  CapturePaymentInput,
+  CapturePaymentOutput,
+  DeletePaymentInput,
+  DeletePaymentOutput,
+  GetPaymentStatusInput,
+  GetPaymentStatusOutput,
+  InitiatePaymentInput,
+  InitiatePaymentOutput,
+  Logger,
+  PaymentSessionStatus,
+  ProviderWebhookPayload,
+  RefundPaymentInput,
+  RefundPaymentOutput,
+  RetrievePaymentInput,
+  RetrievePaymentOutput,
+  UpdatePaymentInput,
+  UpdatePaymentOutput,
+  WebhookActionResult,
+} from "@medusajs/framework/types"
+import { AbstractPaymentProvider, BigNumber, MedusaError } from "@medusajs/framework/utils"
+
+/**
+ * Base commune des agrégateurs à redirection d'Afrique de l'Ouest (PayTech, PayDunya, NabooPay : Wave, Orange Money,
+ * Free Money, carte…). Le déroulé est le même pour les trois :
+ *
+ * 1. initiatePayment : on crée le paiement chez l'agrégateur (montant calculé par Medusa, jamais envoyé par le site)
+ *    et on garde son adresse de paiement (redirect_url) dans les données de la session ;
+ * 2. le site envoie le client sur cette adresse ; il paie (Wave, Orange Money, carte…) puis revient sur le site ;
+ * 3. au retour, le site termine la commande : Medusa appelle authorizePayment, qui DEMANDE le statut à l'agrégateur
+ *    (on ne croit jamais l'URL de retour) → « captured » si payé ;
+ * 4. en parallèle, l'agrégateur notifie le backend (/hooks/payment/<id>_<id>) : notification vérifiée (signature),
+ *    puis statut reconfirmé auprès de l'agrégateur ; Medusa termine alors la commande même si le client n'est pas revenu.
+ *
+ * Le numéro de session Medusa (data.session_id, fourni par Medusa) voyage chez l'agrégateur (champ libre ou URL de
+ * retour) pour relier la notification à la bonne session.
+ */
+
+export type PayStatus = "paid" | "pending" | "failed"
+
+export type Checkout = {
+  amount: number
+  currency: string
+  sessionId: string
+  /** Adresse de retour sur la boutique (vérifiée : une des origines de STORE_CORS) */
+  returnUrl: string
+  cancelUrl: string
+  /** Adresse publique de notification (IPN) ; absente si le backend n'est pas en HTTPS (les agrégateurs l'exigent) */
+  notifyUrl?: string
+  label: string
+  customer: { first_name?: string; last_name?: string; phone?: string; email?: string }
+}
+
+export type WebhookInfo = { ref: string; sessionId: string; amount: number }
+
+type Deps = { logger: Logger }
+
+export abstract class RedirectPaymentProvider<TOptions extends Record<string, unknown>> extends AbstractPaymentProvider<TOptions> {
+  protected logger: Logger
+  protected options: TOptions
+
+  /** Devises acceptées par l'agrégateur (codes Medusa, minuscules) */
+  protected abstract currencies: string[]
+  /** Chemin du webhook après /hooks/payment/ (ex. « paytech_paytech ») */
+  protected abstract hookId: string
+
+  protected abstract createCheckout(c: Checkout): Promise<{ ref: string; redirect_url: string; extra?: Record<string, unknown> }>
+  protected abstract fetchStatus(ref: string): Promise<PayStatus>
+  /** Notification : vérifie l'authenticité (sinon null) et en extrait la référence et la session */
+  protected abstract parseWebhook(body: Record<string, unknown>, raw: string, headers: Record<string, unknown>): WebhookInfo | null
+  /**
+   * Remboursement chez l'agrégateur. Par défaut (agrégateur sans API de remboursement, ex. PayDunya) : le marchand
+   * rembourse dans le tableau de bord de l'agrégateur, puis le bouton Remboursement de l'admin l'ENREGISTRE (commande,
+   * e-mail au client) sans mouvement d'argent ici. Voir le guide client, section 4.3.
+   */
+  protected async refund(_data: Record<string, unknown>, amount: number): Promise<void> {
+    this.logger.warn(`[${this.hookId}] remboursement de ${amount} enregistré : à effectuer dans le tableau de bord de l'agrégateur`)
+  }
+
+  constructor({ logger }: Deps, options: TOptions) {
+    super({ logger }, options)
+    this.logger = logger
+    this.options = options
+  }
+
+  // ---------- Adresses ----------
+
+  private get storeOrigins() {
+    return (process.env.STORE_CORS ?? "").split(",").map((o) => o.trim().replace(/\/+$/, "")).filter(Boolean)
+  }
+
+  private get backendUrl() {
+    return (process.env.ADMIN_URL || process.env.ADMIN_CORS?.split(",")[0] || "http://localhost:9000").replace(/\/+$/, "")
+  }
+
+  /** Adresse de retour fournie par le site : acceptée seulement si elle pointe vers une des boutiques du projet */
+  private safeUrl(url: unknown, fallbackPath: string) {
+    const origins = this.storeOrigins
+    if (typeof url === "string" && origins.some((o) => url === o || url.startsWith(`${o}/`))) return url
+    return `${origins[0] ?? "http://localhost:8000"}${fallbackPath}`
+  }
+
+  // ---------- Cycle de vie de la session ----------
+
+  async initiatePayment({ amount, currency_code, data }: InitiatePaymentInput): Promise<InitiatePaymentOutput> {
+    const currency = currency_code.toLowerCase()
+    if (!this.currencies.includes(currency)) {
+      throw new MedusaError(MedusaError.Types.INVALID_DATA, `${this.constructor.name} : devise ${currency.toUpperCase()} non acceptée (${this.currencies.join(", ").toUpperCase()})`)
+    }
+    const sessionId = String(data?.session_id ?? "")
+    const str = (k: string) => (typeof data?.[k] === "string" ? (data[k] as string).slice(0, 120) : undefined)
+    const checkout = await this.createCheckout({
+      amount: Math.round(Number(amount)),
+      currency,
+      sessionId,
+      returnUrl: this.safeUrl(data?.return_url, "/checkout?step=review&pay_return=1"),
+      cancelUrl: this.safeUrl(data?.cancel_url, "/checkout?step=review&pay_return=cancel"),
+      notifyUrl: this.backendUrl.startsWith("https://") ? `${this.backendUrl}/hooks/payment/${this.hookId}` : undefined,
+      label: str("label") ?? "Commande",
+      customer: { first_name: str("first_name"), last_name: str("last_name"), phone: str("phone"), email: str("email") },
+    })
+    return {
+      id: checkout.ref,
+      status: "pending",
+      data: { ref: checkout.ref, redirect_url: checkout.redirect_url, session_id: sessionId, ...(checkout.extra ?? {}) },
+    }
+  }
+
+  /** Montant ou panier modifié : nouveau paiement chez l'agrégateur (l'ancien n'est jamais payé) */
+  async updatePayment(input: UpdatePaymentInput): Promise<UpdatePaymentOutput> {
+    const out = await this.initiatePayment({ ...input, data: { ...input.data } } as InitiatePaymentInput)
+    return { data: out.data, status: out.status }
+  }
+
+  async authorizePayment({ data }: AuthorizePaymentInput): Promise<AuthorizePaymentOutput> {
+    const status = await this.statusOf(data)
+    return { data, status }
+  }
+
+  async getPaymentStatus({ data }: GetPaymentStatusInput): Promise<GetPaymentStatusOutput> {
+    return { status: await this.statusOf(data), data }
+  }
+
+  async retrievePayment({ data }: RetrievePaymentInput): Promise<RetrievePaymentOutput> {
+    return { data: { ...(data ?? {}), status: await this.statusOf(data) } }
+  }
+
+  /** Le paiement est encaissé dès qu'il est confirmé (pas de pré-autorisation chez ces agrégateurs) */
+  async capturePayment({ data }: CapturePaymentInput): Promise<CapturePaymentOutput> {
+    return { data }
+  }
+
+  async cancelPayment({ data }: CancelPaymentInput): Promise<CancelPaymentOutput> {
+    return { data }
+  }
+
+  async deletePayment({ data }: DeletePaymentInput): Promise<DeletePaymentOutput> {
+    return { data }
+  }
+
+  async refundPayment({ data, amount }: RefundPaymentInput): Promise<RefundPaymentOutput> {
+    await this.refund(data ?? {}, Math.round(Number(amount)))
+    return { data }
+  }
+
+  private async statusOf(data: Record<string, unknown> | undefined): Promise<PaymentSessionStatus> {
+    const ref = typeof data?.ref === "string" ? data.ref : ""
+    if (!ref) return "pending"
+    const s = await this.fetchStatus(ref)
+    return s === "paid" ? "captured" : s === "failed" ? "error" : "pending"
+  }
+
+  // ---------- Notification (webhook) ----------
+
+  async getWebhookActionAndData(payload: ProviderWebhookPayload["payload"]): Promise<WebhookActionResult> {
+    const none = { action: "not_supported" as const, data: { session_id: "", amount: new BigNumber(0) } }
+    const raw = rawText(payload.rawData)
+    const body = bodyOf(payload.data, raw)
+    const info = this.parseWebhook(body, raw, (payload.headers ?? {}) as Record<string, unknown>)
+    if (!info?.sessionId || !info.ref) {
+      this.logger.warn(`[${this.hookId}] notification ignorée (signature invalide ou session inconnue)`)
+      return none
+    }
+    // Défense en profondeur : même signée, la notification est reconfirmée auprès de l'agrégateur
+    const status = await this.fetchStatus(info.ref).catch(() => "pending" as PayStatus)
+    const data = { session_id: info.sessionId, amount: new BigNumber(info.amount) }
+    if (status === "paid") return { action: "captured", data }
+    if (status === "failed") return { action: "failed", data }
+    return none
+  }
+
+  // ---------- Outils pour les agrégateurs ----------
+
+  protected async http<T>(url: string, init: RequestInit & { json?: unknown } = {}): Promise<T> {
+    const { json, ...rest } = init
+    const res = await fetch(url, {
+      ...rest,
+      headers: { Accept: "application/json", ...(json !== undefined ? { "Content-Type": "application/json" } : {}), ...(rest.headers ?? {}) },
+      body: json !== undefined ? JSON.stringify(json) : rest.body,
+      signal: AbortSignal.timeout(20_000),
+    })
+    const text = await res.text()
+    let parsed: unknown
+    try {
+      parsed = text ? JSON.parse(text) : {}
+    } catch {
+      parsed = { raw: text }
+    }
+    if (!res.ok) {
+      this.logger.error(`[${this.hookId}] ${rest.method ?? "GET"} ${url} → ${res.status} ${text.slice(0, 300)}`)
+      throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, `${this.constructor.name} : erreur ${res.status} de l'agrégateur`)
+    }
+    return parsed as T
+  }
+}
+
+/** Corps brut du webhook (Buffer, ou Buffer sérialisé par le bus d'événements Redis) en texte */
+function rawText(raw: unknown): string {
+  if (!raw) return ""
+  if (typeof raw === "string") return raw
+  if (Buffer.isBuffer(raw)) return raw.toString("utf8")
+  const r = raw as { type?: string; data?: number[] }
+  if (r.type === "Buffer" && Array.isArray(r.data)) return Buffer.from(r.data).toString("utf8")
+  return ""
+}
+
+/** Corps du webhook en objet : JSON, ou formulaire (a[b][c]=v, comme PayDunya et PayTech) */
+function bodyOf(parsed: unknown, raw: string): Record<string, unknown> {
+  if (parsed && typeof parsed === "object" && Object.keys(parsed as object).length) return parsed as Record<string, unknown>
+  const t = raw.trim()
+  if (!t) return {}
+  if (t.startsWith("{")) {
+    try {
+      return JSON.parse(t)
+    } catch {
+      return {}
+    }
+  }
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of new URLSearchParams(t)) {
+    const parts = key.replace(/\]/g, "").split("[")
+    let node = out
+    parts.forEach((p, i) => {
+      if (i === parts.length - 1) node[p] = value
+      else node = (node[p] = (node[p] as Record<string, unknown>) ?? {}) as Record<string, unknown>
+    })
+  }
+  return out
+}
+
+/** Comparaison en temps constant de deux chaînes hexadécimales */
+export function sameHex(a: string, b: string) {
+  const x = Buffer.from(a.toLowerCase())
+  const y = Buffer.from(b.toLowerCase())
+  return x.length === y.length && crypto.timingSafeEqual(x, y)
+}
+
+export const sha = (alg: "sha256" | "sha512", s: string) => crypto.createHash(alg).update(s).digest("hex")
+export const hmac256 = (key: string, s: string) => crypto.createHmac("sha256", key).update(s).digest("hex")

package/templates/backend/src/lib/review-token.ts

@@ -0,0 +1,40 @@
+import crypto from "node:crypto"
+
+/**
+ * Lien « Laisser un avis » de l'e-mail « commande livrée » : <boutique>/review?t=<jeton>.
+ * Jeton = commande + date d'expiration, signés (HMAC-SHA256) avec COOKIE_SECRET, le secret du projet :
+ * impossible d'en fabriquer un pour une autre commande. Sans état en base. Valable 180 jours.
+ */
+const DAYS = 180
+
+const secret = () => {
+  const s = process.env.COOKIE_SECRET
+  if (!s) throw new Error("COOKIE_SECRET manquant")
+  return s
+}
+
+const sign = (payload: string) => crypto.createHmac("sha256", secret()).update(`review:${payload}`).digest("base64url")
+
+export function reviewToken(orderId: string, now = Date.now()): string {
+  const exp = Math.floor(now / 1000) + DAYS * 86400
+  const payload = `${orderId}.${exp}`
+  return `${Buffer.from(payload).toString("base64url")}.${sign(payload)}`
+}
+
+/** Numéro de commande si le jeton est authentique et non expiré, sinon null */
+export function readReviewToken(token: string, now = Date.now()): string | null {
+  const [p, sig] = token.split(".")
+  if (!p || !sig) return null
+  let payload: string
+  try {
+    payload = Buffer.from(p, "base64url").toString("utf8")
+  } catch {
+    return null
+  }
+  const expected = Buffer.from(sign(payload))
+  const given = Buffer.from(sig)
+  if (expected.length !== given.length || !crypto.timingSafeEqual(expected, given)) return null
+  const [orderId, exp] = payload.split(".")
+  if (!orderId || !/^\d+$/.test(exp ?? "") || Number(exp) * 1000 < now) return null
+  return orderId
+}

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

@@ -0,0 +1,25 @@
+import type { MedusaStoreRequest } from "@medusajs/framework/http"
+import { readProject } from "./project"
+
+/**
+ * Portée des avis affichés sur un site : réglage project.json → defaults.reviews.
+ * « shared » (défaut) : tous les avis validés du produit, quelle que soit la boutique ;
+ * « boutique » : seulement ceux laissés dans la boutique qui interroge (sales channel de la publishable key).
+ */
+export function reviewChannels(req: MedusaStoreRequest): string[] | undefined {
+  if (readProject().reviews !== "boutique") return undefined
+  return req.publishable_key_context?.sales_channel_ids ?? []
+}
+
+/** Champs d'un avis visibles du public : jamais l'e-mail ni la commande */
+export const PUBLIC_FIELDS = ["id", "product_id", "author_name", "rating", "title", "comment", "created_at"] as const
+
+export type Summary = { average: number; count: number; distribution: [number, number, number, number, number] }
+
+export function summarize(ratings: number[]): Summary {
+  const distribution: Summary["distribution"] = [0, 0, 0, 0, 0]
+  for (const r of ratings) if (r >= 1 && r <= 5) distribution[r - 1]++
+  const count = ratings.length
+  const average = count ? Math.round((ratings.reduce((a, b) => a + b, 0) / count) * 10) / 10 : 0
+  return { average, count, distribution }
+}

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

@@ -0,0 +1,6 @@
+import { ModuleProvider, Modules } from "@medusajs/framework/utils"
+import NaboopayProviderService from "./service"
+
+export default ModuleProvider(Modules.PAYMENT, {
+  services: [NaboopayProviderService],
+})

package/templates/backend/src/modules/naboopay/service.ts

@@ -0,0 +1,92 @@
+import { MedusaError } from "@medusajs/framework/utils"
+import { type Checkout, type PayStatus, RedirectPaymentProvider, hmac256, sameHex } from "../../lib/redirect-payment"
+
+type Options = {
+  api_key: string
+  /** Secret du webhook (tableau de bord NabooPay → Paramètres → Intégration), 16 caractères minimum */
+  webhook_secret?: string
+  /** Moyens proposés sur la page NabooPay */
+  methods: string[]
+}
+
+const API = "https://api.naboopay.com/api/v2"
+
+/**
+ * NabooPay (naboopay.com) : Wave, Orange Money… sur une page de paiement NabooPay.
+ * Doc : https://docs.naboopay.com/api-reference — création POST /transactions (checkout_url, order_id),
+ * statut GET /transactions/{order_id} (pending | paid | paid_and_blocked | refunded | cancelled),
+ * remboursement GET /refund/{order_id} (total, Wave et Orange Money), webhook signé X-Signature =
+ * HMAC-SHA256 du JSON compact avec le secret du webhook. Le webhook ne renvoie pas de champ libre :
+ * la session Medusa voyage dans l'URL de retour (paramètre ps), que le webhook renvoie.
+ * Client obligatoire (prénom, nom, téléphone) : pris de l'adresse de livraison du panier.
+ */
+class NaboopayProviderService extends RedirectPaymentProvider<Options> {
+  static identifier = "naboopay"
+  protected currencies = ["xof"]
+  protected hookId = "naboopay_naboopay"
+
+  static validateOptions(options: Record<string, unknown>) {
+    if (!options.api_key) throw new MedusaError(MedusaError.Types.INVALID_DATA, "NabooPay : NABOOPAY_API_KEY requise")
+  }
+
+  private get headers() {
+    return { Authorization: `Bearer ${this.options.api_key}` }
+  }
+
+  protected async createCheckout(c: Checkout) {
+    const withSession = (url: string) => `${url}${url.includes("?") ? "&" : "?"}ps=${encodeURIComponent(c.sessionId)}`
+    const res = await this.http<{ order_id?: string; checkout_url?: string; message?: string }>(`${API}/transactions`, {
+      method: "POST",
+      headers: this.headers,
+      json: {
+        method_of_payment: this.options.methods?.length ? this.options.methods : ["wave", "orange_money"],
+        products: [{ name: c.label, price: c.amount, quantity: 1, description: c.label }],
+        customer: {
+          first_name: c.customer.first_name || "Client",
+          last_name: c.customer.last_name || "-",
+          phone: c.customer.phone || "",
+        },
+        success_url: withSession(c.returnUrl),
+        error_url: withSession(c.cancelUrl),
+        fees_customer_side: false,
+        is_escrow: false,
+        is_merchant: false,
+      },
+    })
+    if (!res.order_id || !res.checkout_url) {
+      throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, `NabooPay : transaction non créée (${res.message ?? "réponse inattendue"})`)
+    }
+    return { ref: res.order_id, redirect_url: res.checkout_url }
+  }
+
+  protected async fetchStatus(orderId: string): Promise<PayStatus> {
+    const res = await this.http<{ transaction_status?: string }>(`${API}/transactions/${encodeURIComponent(orderId)}`, { headers: this.headers })
+    const s = String(res.transaction_status ?? "").toLowerCase()
+    if (s === "paid" || s === "done" || s === "paid_and_blocked") return "paid"
+    if (s === "cancelled" || s === "refunded") return "failed"
+    return "pending"
+  }
+
+  protected parseWebhook(body: Record<string, unknown>, raw: string, headers: Record<string, unknown>) {
+    const secret = this.options.webhook_secret
+    const signature = String(headers["x-signature"] ?? "")
+    if (!secret || !signature) return null
+    // Signature du JSON compact : on essaie le corps brut tel quel, puis re-sérialisé sans espaces
+    const candidates = [raw, JSON.stringify(body)].filter(Boolean)
+    if (!candidates.some((payload) => sameHex(hmac256(secret, payload), signature))) return null
+    let sessionId = ""
+    try {
+      sessionId = new URL(String(body.success_url ?? "")).searchParams.get("ps") ?? ""
+    } catch {
+      sessionId = ""
+    }
+    return { ref: String(body.order_id ?? ""), sessionId, amount: Number(body.amount) || 0 }
+  }
+
+  /** Remboursement total seulement (Wave et Orange Money) */
+  protected async refund(data: Record<string, unknown>) {
+    await this.http(`${API}/refund/${encodeURIComponent(String(data.ref ?? ""))}`, { headers: this.headers })
+  }
+}
+
+export default NaboopayProviderService

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

@@ -0,0 +1,6 @@
+import { ModuleProvider, Modules } from "@medusajs/framework/utils"
+import PaydunyaProviderService from "./service"
+
+export default ModuleProvider(Modules.PAYMENT, {
+  services: [PaydunyaProviderService],
+})