@salifbiaye/create-boutique 0.5.0 → 0.7.0

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],
+})

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

@@ -0,0 +1,89 @@
+import { MedusaError } from "@medusajs/framework/utils"
+import { type Checkout, type PayStatus, RedirectPaymentProvider, sameHex, sha } from "../../lib/redirect-payment"
+
+type Options = {
+  master_key: string
+  private_key: string
+  token: string
+  /** « test » = sandbox PayDunya, « prod » = paiements réels */
+  env: "test" | "prod"
+  /** Nom affiché sur la page de paiement */
+  store_name?: string
+}
+
+/**
+ * PayDunya (paydunya.com) : Wave, Orange Money, Free Money, carte… sur une facture PayDunya (checkout-invoice).
+ * Doc : https://developers.paydunya.com/doc/FR/http_json — création POST /checkout-invoice/create,
+ * statut GET /checkout-invoice/confirm/{token}, notification (callback_url) en formulaire, champ data[…],
+ * authentifiée par data[hash] = SHA-512 de la clé principale. La session Medusa voyage dans custom_data.
+ * Devise : FCFA (XOF). Remboursement : dans le tableau de bord PayDunya.
+ */
+class PaydunyaProviderService extends RedirectPaymentProvider<Options> {
+  static identifier = "paydunya"
+  protected currencies = ["xof"]
+  protected hookId = "paydunya_paydunya"
+
+  static validateOptions(options: Record<string, unknown>) {
+    if (!options.master_key || !options.private_key || !options.token) {
+      throw new MedusaError(MedusaError.Types.INVALID_DATA, "PayDunya : PAYDUNYA_MASTER_KEY, PAYDUNYA_PRIVATE_KEY et PAYDUNYA_TOKEN requis")
+    }
+  }
+
+  private get api() {
+    return this.options.env === "prod" ? "https://app.paydunya.com/api/v1" : "https://app.paydunya.com/sandbox-api/v1"
+  }
+
+  private get headers() {
+    return {
+      "PAYDUNYA-MASTER-KEY": this.options.master_key,
+      "PAYDUNYA-PRIVATE-KEY": this.options.private_key,
+      "PAYDUNYA-TOKEN": this.options.token,
+    }
+  }
+
+  protected async createCheckout(c: Checkout) {
+    const name = [c.customer.first_name, c.customer.last_name].filter(Boolean).join(" ")
+    const res = await this.http<{ response_code?: string; response_text?: string; token?: string; description?: string }>(
+      `${this.api}/checkout-invoice/create`,
+      {
+        method: "POST",
+        headers: this.headers,
+        json: {
+          invoice: {
+            total_amount: c.amount,
+            description: c.label,
+            ...(name || c.customer.email || c.customer.phone ? { customer: { name, email: c.customer.email, phone: c.customer.phone } } : {}),
+          },
+          store: { name: this.options.store_name || c.label },
+          custom_data: { session_id: c.sessionId },
+          actions: { return_url: c.returnUrl, cancel_url: c.cancelUrl, ...(c.notifyUrl ? { callback_url: c.notifyUrl } : {}) },
+        },
+      }
+    )
+    if (res.response_code !== "00" || !res.token || !res.response_text) {
+      throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, `PayDunya : facture non créée (${res.description ?? res.response_text ?? "réponse inattendue"})`)
+    }
+    return { ref: res.token, redirect_url: res.response_text }
+  }
+
+  protected async fetchStatus(token: string): Promise<PayStatus> {
+    const res = await this.http<{ status?: string }>(`${this.api}/checkout-invoice/confirm/${encodeURIComponent(token)}`, { headers: this.headers })
+    const s = String(res.status ?? "").toLowerCase()
+    if (s === "completed") return "paid"
+    if (s === "cancelled" || s === "failed") return "failed"
+    return "pending"
+  }
+
+  protected parseWebhook(body: Record<string, unknown>) {
+    const data = (body.data ?? body) as Record<string, any>
+    if (!data?.hash || !sameHex(sha("sha512", this.options.master_key), String(data.hash))) return null
+    const custom = (data.custom_data ?? {}) as Record<string, unknown>
+    return {
+      ref: String(data.invoice?.token ?? ""),
+      sessionId: String(custom.session_id ?? ""),
+      amount: Number(data.invoice?.total_amount) || 0,
+    }
+  }
+}
+
+export default PaydunyaProviderService

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

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

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

@@ -0,0 +1,114 @@
+import { MedusaError } from "@medusajs/framework/utils"
+import { type Checkout, type PayStatus, RedirectPaymentProvider, hmac256, sameHex, sha } from "../../lib/redirect-payment"
+
+type Options = {
+  api_key: string
+  api_secret: string
+  /** « test » (débite 100 à 150 FCFA quel que soit le montant) ou « prod » (compte activé chez PayTech) */
+  env: "test" | "prod"
+}
+
+const API = "https://paytech.sn/api"
+
+/**
+ * PayTech (paytech.sn) : Wave, Orange Money, Free Money, carte bancaire… sur une page de paiement PayTech.
+ * Doc : https://docs.intech.sn/doc_paytech.php — création POST /payment/request-payment, statut GET /payment/get-status,
+ * IPN signée (HMAC-SHA256 « montant|ref_command|api_key » avec api_secret, ou SHA-256 des clés), remboursement.
+ * La référence du paiement Medusa (session) voyage dans custom_field.
+ */
+class PaytechProviderService extends RedirectPaymentProvider<Options> {
+  static identifier = "paytech"
+  protected currencies = ["xof", "eur", "usd", "cad", "gbp", "mad"]
+  protected hookId = "paytech_paytech"
+
+  static validateOptions(options: Record<string, unknown>) {
+    if (!options.api_key || !options.api_secret) {
+      throw new MedusaError(MedusaError.Types.INVALID_DATA, "PayTech : PAYTECH_API_KEY et PAYTECH_API_SECRET requis")
+    }
+  }
+
+  private get headers() {
+    return { API_KEY: this.options.api_key, API_SECRET: this.options.api_secret }
+  }
+
+  protected async createCheckout(c: Checkout) {
+    // Référence unique par tentative (la session peut créer plusieurs paiements si le panier change)
+    const ref = `${c.sessionId}_${Date.now().toString(36)}`
+    const res = await this.http<{ success?: number; token?: string; redirect_url?: string; redirectUrl?: string; message?: string }>(
+      `${API}/payment/request-payment`,
+      {
+        method: "POST",
+        headers: this.headers,
+        json: {
+          item_name: c.label,
+          item_price: c.amount,
+          currency: c.currency.toUpperCase(),
+          ref_command: ref,
+          command_name: c.label,
+          env: this.options.env === "prod" ? "prod" : "test",
+          ...(c.notifyUrl ? { ipn_url: c.notifyUrl } : {}),
+          success_url: c.returnUrl,
+          cancel_url: c.cancelUrl,
+          custom_field: JSON.stringify({ session_id: c.sessionId }),
+        },
+      }
+    )
+    const url = res.redirect_url ?? res.redirectUrl
+    if (res.success !== 1 || !res.token || !url) {
+      throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, `PayTech : paiement non créé (${res.message ?? "réponse inattendue"})`)
+    }
+    // ref = jeton PayTech (sert au statut) ; ref_command gardé pour le remboursement
+    return { ref: res.token, redirect_url: url, extra: { ref_command: ref } }
+  }
+
+  /**
+   * Le format exact de la réponse de get-status n'est pas documenté : lecture tolérante des champs usuels.
+   * L'IPN signée reste la voie sûre de confirmation (voir getWebhookActionAndData).
+   */
+  protected async fetchStatus(token: string): Promise<PayStatus> {
+    const res = await this.http<Record<string, any>>(`${API}/payment/get-status?token_payment=${encodeURIComponent(token)}`, { headers: this.headers })
+    const s = String(res.payment?.state ?? res.payment?.status ?? res.state ?? res.status ?? res.type_event ?? res.transaction?.status ?? "").toLowerCase()
+    if (/complet|success|paid|sale_complete|accepted/.test(s)) return "paid"
+    if (/cancel|fail|refus|expired|sale_canceled/.test(s)) return "failed"
+    return "pending"
+  }
+
+  protected parseWebhook(body: Record<string, unknown>) {
+    const f = (k: string) => (body[k] == null ? "" : String(body[k]))
+    const ref = f("token")
+    const refCommand = f("ref_command")
+    // Authenticité : HMAC (recommandé) sur le montant final ou initial, sinon empreintes SHA-256 des clés
+    const received = f("hmac_compute")
+    const okHmac =
+      !!received &&
+      [f("final_item_price"), f("item_price")].filter(Boolean).some((amount) => sameHex(hmac256(this.options.api_secret, `${amount}|${refCommand}|${this.options.api_key}`), received))
+    const okSha =
+      !!f("api_key_sha256") &&
+      sameHex(sha("sha256", this.options.api_key), f("api_key_sha256")) &&
+      sameHex(sha("sha256", this.options.api_secret), f("api_secret_sha256"))
+    if (!okHmac && !okSha) return null
+
+    let sessionId = ""
+    try {
+      const custom = f("custom_field")
+      const json = custom.trim().startsWith("{") ? custom : Buffer.from(custom, "base64").toString("utf8")
+      sessionId = String(JSON.parse(json).session_id ?? "")
+    } catch {
+      // repli : la référence commence par le numéro de session
+      sessionId = refCommand.slice(0, refCommand.lastIndexOf("_"))
+    }
+    return { ref, sessionId, amount: Number(f("final_item_price") || f("item_price")) || 0 }
+  }
+
+  /** Remboursement de la transaction (POST /payment/refund-payment avec ref_command) */
+  protected async refund(data: Record<string, unknown>) {
+    const res = await this.http<{ success?: number; message?: string }>(`${API}/payment/refund-payment`, {
+      method: "POST",
+      headers: this.headers,
+      json: { ref_command: String(data.ref_command ?? "") },
+    })
+    if (res.success !== 1) throw new MedusaError(MedusaError.Types.UNEXPECTED_STATE, `PayTech : remboursement refusé (${res.message ?? "réponse inattendue"})`)
+  }
+}
+
+export default PaytechProviderService

package/templates/backend/src/modules/product-review/index.ts

@@ -0,0 +1,8 @@
+import { Module } from "@medusajs/framework/utils"
+import ProductReviewModuleService from "./service"
+
+export const PRODUCT_REVIEW_MODULE = "productReview"
+
+export default Module(PRODUCT_REVIEW_MODULE, {
+  service: ProductReviewModuleService,
+})