@salifbiaye/create-boutique 0.5.0 → 0.7.0

package/templates/backend/src/api/store/reviews/order/route.ts

@@ -0,0 +1,36 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../../modules/product-review"
+import ProductReviewModuleService from "../../../../modules/product-review/service"
+import { readReviewToken } from "../../../../lib/review-token"
+
+/**
+ * GET /store/reviews/order?token=… : page « Laisser un avis » (lien de l'e-mail « commande livrée »).
+ * Renvoie les produits de la commande à noter (titre, image) et ceux déjà notés ; rien d'autre de la commande.
+ */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const orderId = readReviewToken(String(req.query.token ?? ""))
+  if (!orderId) throw new MedusaError(MedusaError.Types.NOT_ALLOWED, "Lien d'avis invalide ou expiré")
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data } = await query.graph({
+    entity: "order",
+    fields: ["id", "display_id", "status", "shipping_address.first_name", "items.product_id", "items.product_title", "items.product_handle", "items.thumbnail"],
+    filters: { id: orderId },
+  })
+  const order = data[0]
+  if (!order || order.status === "canceled") throw new MedusaError(MedusaError.Types.NOT_FOUND, "Commande introuvable")
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const done = new Set((await service.listReviews({ order_id: order.id }, { select: ["product_id"] })).map((r) => r.product_id))
+  const products = new Map<string, { product_id: string; title: string; handle?: string; thumbnail?: string; reviewed: boolean }>()
+  for (const i of order.items ?? []) {
+    if (!i?.product_id || products.has(i.product_id)) continue
+    products.set(i.product_id, {
+      product_id: i.product_id,
+      title: i.product_title ?? "",
+      handle: i.product_handle ?? undefined,
+      thumbnail: i.thumbnail ?? undefined,
+      reviewed: done.has(i.product_id),
+    })
+  }
+  res.json({ number: order.display_id, first_name: order.shipping_address?.first_name ?? "", products: [...products.values()] })
+}

package/templates/backend/src/api/store/reviews/route.ts

@@ -0,0 +1,43 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { MedusaError } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../modules/product-review"
+import ProductReviewModuleService from "../../../modules/product-review/service"
+import { ReviewInput } from "../../../modules/product-review/validators"
+import { readReviewToken } from "../../../lib/review-token"
+import { PUBLIC_FIELDS, reviewChannels, summarize } from "../../../lib/reviews"
+import { createReviewWorkflow } from "../../../workflows/reviews"
+
+/**
+ * GET /store/reviews?product_id=…&limit=10&offset=0 : avis validés d'un produit + résumé (moyenne, nombre, répartition).
+ * Portée (toutes les boutiques ou celle-ci) : project.json → defaults.reviews. Jamais l'e-mail du client.
+ */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const productId = String(req.query.product_id ?? "")
+  if (!productId) throw new MedusaError(MedusaError.Types.INVALID_DATA, "product_id requis")
+  const limit = Math.min(Math.max(Number(req.query.limit) || 10, 1), 50)
+  const offset = Math.max(Number(req.query.offset) || 0, 0)
+  const channels = reviewChannels(req)
+  const filters = { product_id: productId, status: "approved" as const, ...(channels ? { sales_channel_id: channels } : {}) }
+
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const [reviews, count] = await service.listAndCountReviews(filters, {
+    select: [...PUBLIC_FIELDS],
+    take: limit,
+    skip: offset,
+    order: { created_at: "DESC" },
+  })
+  const all = await service.listReviews(filters, { select: ["rating"], take: 5000 })
+  res.json({ reviews, count, limit, offset, summary: summarize(all.map((r) => r.rating)) })
+}
+
+/**
+ * POST /store/reviews : avis d'un acheteur. Le jeton (lien de l'e-mail « commande livrée ») prouve la commande ;
+ * l'avis part « en attente » et n'apparaît qu'après validation dans l'admin. Limité en tentatives (middlewares.ts).
+ */
+export async function POST(req: MedusaStoreRequest<ReviewInput>, res: MedusaResponse) {
+  const { token, ...review } = req.validatedBody
+  const orderId = readReviewToken(token)
+  if (!orderId) throw new MedusaError(MedusaError.Types.NOT_ALLOWED, "Lien d'avis invalide ou expiré")
+  const { result } = await createReviewWorkflow(req.scope).run({ input: { ...review, order_id: orderId } })
+  res.status(201).json({ review: { id: result.id, status: result.status } })
+}

package/templates/backend/src/api/store/reviews/summary/route.ts

@@ -0,0 +1,28 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { PRODUCT_REVIEW_MODULE } from "../../../../modules/product-review"
+import ProductReviewModuleService from "../../../../modules/product-review/service"
+import { reviewChannels, summarize, type Summary } from "../../../../lib/reviews"
+
+/** GET /store/reviews/summary?product_ids=a,b,c : note moyenne et nombre d'avis validés par produit (cartes produits). */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const ids = String(req.query.product_ids ?? "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean)
+    .slice(0, 100)
+  if (!ids.length) return res.json({ summaries: {} })
+  const channels = reviewChannels(req)
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const reviews = await service.listReviews(
+    { product_id: ids, status: "approved", ...(channels ? { sales_channel_id: channels } : {}) },
+    { select: ["product_id", "rating"], take: 10000 }
+  )
+  const byProduct = new Map<string, number[]>()
+  for (const r of reviews) byProduct.set(r.product_id, [...(byProduct.get(r.product_id) ?? []), r.rating])
+  const summaries: Record<string, Pick<Summary, "average" | "count">> = {}
+  for (const [id, ratings] of byProduct) {
+    const { average, count } = summarize(ratings)
+    summaries[id] = { average, count }
+  }
+  res.json({ summaries })
+}

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

@@ -14,7 +14,9 @@
   "order_delivered": {
     "subject": "Your order #{number} has been delivered",
     "title": "Your order has been delivered",
-    "intro": "Hi {name}, your order #{number} has been delivered. We hope you love it!"
+    "intro": "Hi {name}, your order #{number} has been delivered. We hope you love it!",
+    "review": "Leave a review",
+    "reviewText": "Your review helps other customers: rate your items in a minute."
   },
   "order_canceled": {
     "subject": "Your order #{number} has been canceled",

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

@@ -14,7 +14,9 @@
   "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 !"
+    "intro": "Bonjour {name}, votre commande n° {number} a été livrée. Nous espérons qu'elle vous plaira !",
+    "review": "Laisser un avis",
+    "reviewText": "Votre avis aide les autres clients : notez vos articles en une minute."
   },
   "order_canceled": {
     "subject": "Votre commande n° {number} est annulée",

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

@@ -0,0 +1,41 @@
+import fs from "node:fs"
+import path from "node:path"
+import { MedusaContainer } from "@medusajs/framework/types"
+import { Modules } from "@medusajs/framework/utils"
+import { updateStoresWorkflow } from "@medusajs/medusa/core-flows"
+import { KEYS_DIR, readProject } from "./project"
+
+/**
+ * Mode single : une seule boutique en ligne à la fois.
+ * - Source de vérité : metadata.active_boutique du store Medusa (base de données).
+ * - Copie dans KEYS_DIR/_active : le site la lit à chaque requête (volume partagé, pas d'appel réseau).
+ * Il y a toujours exactement une boutique active : activer une boutique remplace la précédente,
+ * et une valeur absente ou inconnue retombe sur la première boutique du projet.
+ */
+const ACTIVE_FILE = path.join(KEYS_DIR, "_active")
+
+export async function getActive(container: MedusaContainer): Promise<string> {
+  const project = readProject()
+  const slugs = project.boutiques.map((b) => b.slug)
+  const [store] = await container.resolve(Modules.STORE).listStores({}, { select: ["id", "metadata"] })
+  const saved = store?.metadata?.active_boutique
+  return typeof saved === "string" && slugs.includes(saved) ? saved : slugs[0]
+}
+
+export async function setActive(container: MedusaContainer, slug: string): Promise<string> {
+  const project = readProject()
+  if (!project.boutiques.some((b) => b.slug === slug)) throw new Error(`boutique inconnue : ${slug}`)
+  const [store] = await container.resolve(Modules.STORE).listStores({}, { select: ["id", "metadata"] })
+  await updateStoresWorkflow(container).run({
+    input: { selector: { id: store.id }, update: { metadata: { ...(store.metadata ?? {}), active_boutique: slug } } },
+  })
+  writeActiveFile(slug)
+  return slug
+}
+
+export function writeActiveFile(slug: string) {
+  fs.mkdirSync(KEYS_DIR, { recursive: true })
+  // Écriture atomique : le site ne lit jamais un fichier à moitié écrit
+  fs.writeFileSync(`${ACTIVE_FILE}.tmp`, slug)
+  fs.renameSync(`${ACTIVE_FILE}.tmp`, ACTIVE_FILE)
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Choix de l'envoi des e-mails, d'après l'environnement (.env) :
+ * - Resend si RESEND_API_KEY est renseignée (mode plateforme, prioritaire) ;
+ * - sinon SMTP si SMTP_HOST, SMTP_USER et SMTP_PASS le sont (Gmail avec mot de passe d'application, OVH, Brevo…) ;
+ * - sinon aucun e-mail (la boutique fonctionne quand même).
+ * Utilisé par medusa-config.ts (quel provider charger) et src/lib/notify.ts (envoyer ou non).
+ */
+export type EmailMode = "resend" | "smtp" | null
+
+export function emailMode(env: NodeJS.ProcessEnv = process.env): EmailMode {
+  if (env.RESEND_API_KEY) return "resend"
+  if (env.SMTP_HOST && env.SMTP_USER && env.SMTP_PASS) return "smtp"
+  return null
+}

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

@@ -35,6 +35,15 @@ const THEMES: Record<string, { primary: string; onPrimary: string }> = {
   "cyber-monday-2": { primary: "#22d3ee", onPrimary: "#04111a" },
   "noel-2": { primary: "#d4af37", onPrimary: "#0f1d17" },
   "nouvel-an-2": { primary: "#f5b5c8", onPrimary: "#0c0f24" },
+  // Été et fêtes (thèmes ajoutés ensuite)
+  summer: { primary: "#1f3a30", onPrimary: "#f4f1ea" },
+  "summer-2": { primary: "#e8330f", onPrimary: "#ffffff" },
+  sport: { primary: "#d31c24", onPrimary: "#ffffff" },
+  "sport-2": { primary: "#0c0d0f", onPrimary: "#c6ff3d" },
+  jeux: { primary: "#1646d8", onPrimary: "#ffffff" },
+  "jeux-2": { primary: "#1d6ff2", onPrimary: "#ffffff" },
+  mubarak: { primary: "#07122b", onPrimary: "#f3d98a" },
+  "mubarak-2": { primary: "#a8431f", onPrimary: "#fff8ef" },
 }
 
 export const escapeHtml = (s: unknown) =>

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

@@ -16,6 +16,7 @@ const shipsTo = z.union([z.literal("all"), z.array(code2).min(1)])
 
 const projectSchema = z.object({
   project: z.string(),
+  mode: z.enum(["multi", "single"]).default("multi"),
   defaults: z.looseObject({
     storeName: z.string(),
     currency: code3,
@@ -23,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(),
+        port: z.number().optional(),
+        url: z.string().optional(),
         storeName: z.string().optional(),
         currency: code3.optional(),
         country: code2.optional(),
@@ -46,13 +51,18 @@ 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 = {
   project: string
+  /** single : un seul site public, qui affiche la boutique active (lib/active.ts) */
+  mode: "multi" | "single"
   defaultCurrency: string
   language: string
   merchantEmail?: string
+  reviews: "shared" | "boutique"
   boutiques: Boutique[]
 }
 
@@ -66,9 +76,11 @@ export function readProject(): Project {
   const { defaults, boutiques } = res.data
   return {
     project: res.data.project,
+    mode: res.data.mode,
     defaultCurrency: defaults.currency,
     language: defaults.language,
     merchantEmail: defaults.merchantEmail,
+    reviews: defaults.reviews,
     boutiques: boutiques.map((b) => ({
       slug: b.slug,
       theme: b.theme,
@@ -76,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(/\/+$/, ""),
     })),
   }
 }
@@ -144,3 +160,24 @@ export const SHIPPING_RATES: Record<string, [number, number]> = {
   xaf: [2000, 5000],
 }
 export const shippingRates = (currency: string): [number, number] => SHIPPING_RATES[currency] ?? [0, 0]
+
+export const THEMES_DIR = process.env.THEMES_DIR || "/app/themes"
+
+/**
+ * Textes par défaut du thème d'une boutique (themes/<thème>/campaign.<langue>.json, anglais à défaut),
+ * affichés pré-remplis dans l'admin → Campagnes. Variables {discount}, {endDate}, {freeShipping} laissées telles quelles.
+ */
+export function themeTexts(slug: string): Record<string, unknown> | undefined {
+  try {
+    const project = readProject()
+    const theme = project.boutiques.find((b) => b.slug === slug)?.theme
+    if (!theme) return undefined
+    for (const lang of [project.language, "en"]) {
+      const file = path.join(THEMES_DIR, theme, `campaign.${lang}.json`)
+      if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, "utf8"))
+    }
+  } catch {
+    // Thèmes non montés (ancien projet) : l'admin affiche des champs vides, comme avant
+  }
+  return undefined
+}