@salifbiaye/create-boutique 0.6.0 → 0.7.1

package/templates/backend/src/admin/routes/reviews/page.tsx

@@ -0,0 +1,259 @@
+import { defineRouteConfig } from "@medusajs/admin-sdk"
+import { Check, ChatBubbleLeftRight, StarSolid, Trash, XMark } from "@medusajs/icons"
+import { Badge, Button, Container, Heading, Select, Table, Text, toast, usePrompt } from "@medusajs/ui"
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query"
+import { useState } from "react"
+import { useTranslation } from "react-i18next"
+import { sdk } from "../../lib/client"
+
+type Status = "pending" | "approved" | "rejected"
+type Review = {
+  id: string
+  rating: number
+  title: string | null
+  comment: string
+  author_name: string
+  customer_email: string
+  status: Status
+  created_at: string
+  product: { id: string; title: string; thumbnail: string | null } | null
+  boutique: string | null
+  sales_channel_id: string
+}
+type ListResponse = { reviews: Review[]; count: number; pending: number; limit: number; offset: number }
+type Boutiques = { boutiques: { slug: string; sales_channel_id: string }[] }
+
+const QUERY_KEY = ["product-reviews"]
+const PAGE = 20
+const COLORS: Record<Status, "orange" | "green" | "grey"> = { pending: "orange", approved: "green", rejected: "grey" }
+
+function Stars({ value }: { value: number }) {
+  return (
+    <span className="inline-flex" aria-label={`${value}/5`}>
+      {[1, 2, 3, 4, 5].map((i) => (
+        <StarSolid key={i} className={i <= value ? "text-ui-tag-orange-icon" : "text-ui-fg-disabled"} />
+      ))}
+    </span>
+  )
+}
+
+/**
+ * Page « Avis » : avis des acheteurs (lien de l'e-mail « commande livrée »). Un avis n'apparaît sur les boutiques
+ * qu'une fois validé. Filtre par statut et par boutique (la boutique de la commande).
+ */
+const ReviewsPage = () => {
+  const { t, i18n } = useTranslation()
+  const queryClient = useQueryClient()
+  const prompt = usePrompt()
+  const [status, setStatus] = useState<Status | "all">("pending")
+  const [channel, setChannel] = useState<string>("all")
+  const [offset, setOffset] = useState(0)
+
+  const params = new URLSearchParams({ limit: String(PAGE), offset: String(offset) })
+  if (status !== "all") params.set("status", status)
+  if (channel !== "all") params.set("sales_channel_id", channel)
+
+  const { data, isLoading } = useQuery({
+    queryKey: [...QUERY_KEY, status, channel, offset],
+    queryFn: () => sdk.client.fetch<ListResponse>(`/admin/reviews?${params.toString()}`),
+  })
+  const { data: shops } = useQuery({
+    queryKey: ["boutique-campaigns"],
+    queryFn: () => sdk.client.fetch<Boutiques>("/admin/boutique-campaigns"),
+  })
+
+  const done = () => queryClient.invalidateQueries({ queryKey: QUERY_KEY })
+  const setReviewStatus = useMutation({
+    mutationFn: ({ id, status }: { id: string; status: Status }) => sdk.client.fetch(`/admin/reviews/${id}`, { method: "POST", body: { status } }),
+    onSuccess: (_d, v) => {
+      done()
+      toast.success(t(`reviews.toast.${v.status}`))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const remove = useMutation({
+    mutationFn: (id: string) => sdk.client.fetch(`/admin/reviews/${id}`, { method: "DELETE" }),
+    onSuccess: () => {
+      done()
+      toast.success(t("reviews.toast.deleted"))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+  const askDelete = async (r: Review) => {
+    const ok = await prompt({
+      title: t("reviews.deleteTitle"),
+      description: t("reviews.deleteText", { name: r.author_name }),
+      confirmText: t("reviews.delete"),
+      cancelText: t("reviews.cancel"),
+      variant: "danger",
+    })
+    if (ok) remove.mutate(r.id)
+  }
+
+  const date = (s: string) => new Date(s).toLocaleDateString(i18n.language, { day: "numeric", month: "short", year: "numeric" })
+  const count = data?.count ?? 0
+
+  return (
+    <Container className="divide-y p-0">
+      <div className="flex flex-wrap items-center justify-between gap-4 px-6 py-4">
+        <div>
+          <Heading level="h1">{t("reviews.title")}</Heading>
+          <Text size="small" className="text-ui-fg-subtle">
+            {t("reviews.description")}
+          </Text>
+        </div>
+        <div className="flex flex-wrap items-center gap-2">
+          <Select
+            value={status}
+            onValueChange={(v) => {
+              setStatus(v as Status | "all")
+              setOffset(0)
+            }}
+          >
+            <Select.Trigger className="w-44">
+              <Select.Value />
+            </Select.Trigger>
+            <Select.Content>
+              <Select.Item value="pending">
+                {t("reviews.status.pending")}
+                {data?.pending ? ` (${data.pending})` : ""}
+              </Select.Item>
+              <Select.Item value="approved">{t("reviews.status.approved")}</Select.Item>
+              <Select.Item value="rejected">{t("reviews.status.rejected")}</Select.Item>
+              <Select.Item value="all">{t("reviews.status.all")}</Select.Item>
+            </Select.Content>
+          </Select>
+          <Select
+            value={channel}
+            onValueChange={(v) => {
+              setChannel(v)
+              setOffset(0)
+            }}
+          >
+            <Select.Trigger className="w-52">
+              <Select.Value />
+            </Select.Trigger>
+            <Select.Content>
+              <Select.Item value="all">{t("reviews.allBoutiques")}</Select.Item>
+              {(shops?.boutiques ?? []).map((b) => (
+                <Select.Item key={b.sales_channel_id} value={b.sales_channel_id}>
+                  {b.slug}
+                </Select.Item>
+              ))}
+            </Select.Content>
+          </Select>
+        </div>
+      </div>
+
+      {isLoading ? (
+        <div className="px-6 py-8">
+          <Text className="text-ui-fg-subtle">…</Text>
+        </div>
+      ) : !data?.reviews.length ? (
+        <div className="flex flex-col items-center gap-2 px-6 py-12 text-center">
+          <ChatBubbleLeftRight className="text-ui-fg-muted" />
+          <Text className="text-ui-fg-subtle">{t(status === "pending" ? "reviews.emptyPending" : "reviews.empty")}</Text>
+        </div>
+      ) : (
+        <Table>
+          <Table.Header>
+            <Table.Row>
+              <Table.HeaderCell>{t("reviews.col.product")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.review")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.author")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("reviews.col.status")}</Table.HeaderCell>
+              <Table.HeaderCell className="text-right">{t("reviews.col.actions")}</Table.HeaderCell>
+            </Table.Row>
+          </Table.Header>
+          <Table.Body>
+            {data.reviews.map((r) => (
+              <Table.Row key={r.id} className="align-top">
+                <Table.Cell className="py-3">
+                  <div className="flex items-center gap-3">
+                    {r.product?.thumbnail && <img src={r.product.thumbnail} alt="" className="h-10 w-10 rounded object-cover" />}
+                    <div className="min-w-0">
+                      <Text size="small" weight="plus" className="truncate">
+                        {r.product?.title ?? t("reviews.deletedProduct")}
+                      </Text>
+                      <Text size="xsmall" className="text-ui-fg-subtle">
+                        {r.boutique ?? "—"}
+                      </Text>
+                    </div>
+                  </div>
+                </Table.Cell>
+                <Table.Cell className="max-w-[420px] whitespace-normal py-3">
+                  <Stars value={r.rating} />
+                  {r.title && (
+                    <Text size="small" weight="plus" className="mt-1">
+                      {r.title}
+                    </Text>
+                  )}
+                  <Text size="small" className="text-ui-fg-subtle">
+                    {r.comment}
+                  </Text>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <Text size="small">{r.author_name}</Text>
+                  <Text size="xsmall" className="text-ui-fg-subtle">
+                    {r.customer_email}
+                  </Text>
+                  <Text size="xsmall" className="text-ui-fg-subtle">
+                    {date(r.created_at)}
+                  </Text>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <Badge size="2xsmall" color={COLORS[r.status]}>
+                    {t(`reviews.status.${r.status}`)}
+                  </Badge>
+                </Table.Cell>
+                <Table.Cell className="py-3">
+                  <div className="flex justify-end gap-2">
+                    {r.status !== "approved" && (
+                      <Button size="small" variant="secondary" onClick={() => setReviewStatus.mutate({ id: r.id, status: "approved" })}>
+                        <Check />
+                        {t("reviews.approve")}
+                      </Button>
+                    )}
+                    {r.status !== "rejected" && (
+                      <Button size="small" variant="secondary" onClick={() => setReviewStatus.mutate({ id: r.id, status: "rejected" })}>
+                        <XMark />
+                        {t("reviews.reject")}
+                      </Button>
+                    )}
+                    <Button size="small" variant="transparent" onClick={() => askDelete(r)} aria-label={t("reviews.delete")}>
+                      <Trash />
+                    </Button>
+                  </div>
+                </Table.Cell>
+              </Table.Row>
+            ))}
+          </Table.Body>
+        </Table>
+      )}
+
+      {count > PAGE && (
+        <div className="flex items-center justify-between px-6 py-3">
+          <Text size="small" className="text-ui-fg-subtle">
+            {t("reviews.range", { from: offset + 1, to: Math.min(offset + PAGE, count), count })}
+          </Text>
+          <div className="flex gap-2">
+            <Button size="small" variant="secondary" disabled={offset === 0} onClick={() => setOffset(Math.max(0, offset - PAGE))}>
+              {t("reviews.prev")}
+            </Button>
+            <Button size="small" variant="secondary" disabled={offset + PAGE >= count} onClick={() => setOffset(offset + PAGE)}>
+              {t("reviews.next")}
+            </Button>
+          </div>
+        </div>
+      )}
+    </Container>
+  )
+}
+
+export const config = defineRouteConfig({
+  label: "reviews.nav",
+  translationNs: "translation",
+  icon: StarSolid,
+})
+
+export default ReviewsPage

package/templates/backend/src/api/admin/boutique-campaigns/route.ts

@@ -10,7 +10,7 @@ export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse)
 
   const { data: channels } = await query.graph({
     entity: "sales_channel",
-    fields: ["id", "name", "description", "boutique_campaign.*"],
+    fields: ["id", "name", "description", "metadata", "boutique_campaign.*"],
   })
 
   const { mode } = readProject()
@@ -24,6 +24,8 @@ export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse)
         sales_channel_id: c.id,
         slug: c.name,
         description: c.description,
+        // Mode multi : site ouvert (défaut) ou fermé, choisi ici
+        online: c.metadata?.ub_online !== false,
         campaign: c.boutique_campaign ? toCampaignJson(c.boutique_campaign) : null,
       })),
   })

package/templates/backend/src/api/admin/boutique-online/[salesChannelId]/route.ts

@@ -0,0 +1,22 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { z } from "@medusajs/framework/zod"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { updateSalesChannelsWorkflow } from "@medusajs/medusa/core-flows"
+
+export const BoutiqueOnline = z.object({ online: z.boolean() })
+
+/**
+ * POST /admin/boutique-online/:salesChannelId { online } : ouvre ou ferme le site d'une boutique.
+ * Fermé : le site affiche « Boutique fermée » ; compte, suivi de commande et paniers en cours restent accessibles.
+ * Rien d'automatique : seul ce réglage ouvre ou ferme un site (les dates de campagne ne pilotent que la promo).
+ */
+export async function POST(req: AuthenticatedMedusaRequest<z.infer<typeof BoutiqueOnline>>, res: MedusaResponse) {
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data } = await query.graph({ entity: "sales_channel", fields: ["id", "name", "metadata"], filters: { id: req.params.salesChannelId } })
+  if (!data.length) throw new MedusaError(MedusaError.Types.NOT_FOUND, "Unknown store")
+  const channel = data[0]
+  await updateSalesChannelsWorkflow(req.scope).run({
+    input: { selector: { id: channel.id }, update: { metadata: { ...(channel.metadata ?? {}), ub_online: req.validatedBody.online } } },
+  })
+  res.json({ slug: channel.name, online: req.validatedBody.online })
+}

package/templates/backend/src/api/admin/reviews/[id]/route.ts

@@ -0,0 +1,15 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import type { ReviewStatusInput } from "../../../../modules/product-review/validators"
+import { deleteReviewWorkflow, updateReviewStatusWorkflow } from "../../../../workflows/reviews"
+
+/** POST /admin/reviews/:id { status } : valider, refuser, remettre en attente. */
+export async function POST(req: AuthenticatedMedusaRequest<ReviewStatusInput>, res: MedusaResponse) {
+  const { result } = await updateReviewStatusWorkflow(req.scope).run({ input: { id: req.params.id, status: req.validatedBody.status } })
+  res.json({ review: result })
+}
+
+/** DELETE /admin/reviews/:id : supprimer un avis. */
+export async function DELETE(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  await deleteReviewWorkflow(req.scope).run({ input: { id: req.params.id } })
+  res.json({ id: req.params.id, deleted: true })
+}

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

@@ -0,0 +1,47 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../modules/product-review"
+import ProductReviewModuleService from "../../../modules/product-review/service"
+
+/**
+ * GET /admin/reviews?status=pending&sales_channel_id=…&limit=20&offset=0 : avis pour la page Avis de l'admin,
+ * avec le produit et la boutique (sales channel) de chacun. Compte des avis en attente (badge).
+ */
+export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  const status = ["pending", "approved", "rejected"].includes(String(req.query.status)) ? String(req.query.status) : undefined
+  const channel = typeof req.query.sales_channel_id === "string" && req.query.sales_channel_id ? req.query.sales_channel_id : undefined
+  const limit = Math.min(Math.max(Number(req.query.limit) || 20, 1), 100)
+  const offset = Math.max(Number(req.query.offset) || 0, 0)
+
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const filters = { ...(status ? { status: status as "pending" | "approved" | "rejected" } : {}), ...(channel ? { sales_channel_id: channel } : {}) }
+  const [reviews, count] = await service.listAndCountReviews(filters, { take: limit, skip: offset, order: { created_at: "DESC" } })
+  const [, pending] = await service.listAndCountReviews({ status: "pending" }, { take: 1 })
+
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const productIds = [...new Set(reviews.map((r) => r.product_id))]
+  const channelIds = [...new Set(reviews.map((r) => r.sales_channel_id))]
+  // Types explicites : query.graph n'est typé finement qu'avec les types générés par Medusa (absents en CI)
+  type P = { id: string; title: string; thumbnail: string | null }
+  type C = { id: string; name: string }
+  const products: P[] = productIds.length
+    ? ((await query.graph({ entity: "product", fields: ["id", "title", "thumbnail"], filters: { id: productIds } })).data as P[])
+    : []
+  const channels: C[] = channelIds.length
+    ? ((await query.graph({ entity: "sales_channel", fields: ["id", "name"], filters: { id: channelIds } })).data as C[])
+    : []
+  const productOf = new Map<string, P>(products.map((p) => [p.id, p]))
+  const channelOf = new Map<string, string>(channels.map((c) => [c.id, c.name]))
+
+  res.json({
+    reviews: reviews.map((r) => ({
+      ...r,
+      product: productOf.get(r.product_id) ?? null,
+      boutique: channelOf.get(r.sales_channel_id) ?? null,
+    })),
+    count,
+    pending,
+    limit,
+    offset,
+  })
+}

package/templates/backend/src/api/middlewares.ts

@@ -2,12 +2,15 @@ import { defineMiddlewares, validateAndTransformBody } from "@medusajs/framework
 import { CampaignInput } from "../modules/campaign/validators"
 import { rateLimit } from "./rate-limit"
 import { ActiveBoutique } from "./admin/active-boutique/route"
+import { BoutiqueOnline } from "./admin/boutique-online/[salesChannelId]/route"
 import { OrderLookup } from "./store/order-lookup/route"
+import { ReviewInput, ReviewStatusInput } from "../modules/product-review/validators"
 
 // Anti force brute (par IP) : connexion admin, mot de passe oublié, suivi de commande.
 const loginLimit = rateLimit({ name: "connexion", max: 10, windowMs: 15 * 60 * 1000 })
 const resetLimit = rateLimit({ name: "mot de passe oublié", max: 5, windowMs: 60 * 60 * 1000 })
 const lookupLimit = rateLimit({ name: "suivi de commande", max: 20, windowMs: 10 * 60 * 1000 })
+const reviewLimit = rateLimit({ name: "avis", max: 20, windowMs: 60 * 60 * 1000 })
 
 export default defineMiddlewares({
   routes: [
@@ -18,9 +21,13 @@ export default defineMiddlewares({
       middlewares: [validateAndTransformBody(CampaignInput)],
     },
     { matcher: "/admin/active-boutique", method: "POST", middlewares: [validateAndTransformBody(ActiveBoutique)] },
+    { matcher: "/admin/boutique-online/:salesChannelId", method: "POST", middlewares: [validateAndTransformBody(BoutiqueOnline)] },
     { matcher: "/auth/user/emailpass", method: "POST", middlewares: [loginLimit] },
     { matcher: "/auth/user/emailpass/reset-password", method: "POST", middlewares: [resetLimit] },
     { matcher: "/auth/customer/emailpass", method: "POST", middlewares: [loginLimit] },
+    { matcher: "/admin/reviews/:id", method: "POST", middlewares: [validateAndTransformBody(ReviewStatusInput)] },
+    { matcher: "/store/reviews", method: "POST", middlewares: [reviewLimit, validateAndTransformBody(ReviewInput)] },
+    { matcher: "/store/reviews/order", method: "GET", middlewares: [lookupLimit] },
     {
       matcher: "/store/order-lookup",
       method: "POST",

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

@@ -20,6 +20,10 @@ export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
     throw new MedusaError(MedusaError.Types.NOT_FOUND, "No campaign for this store")
   }
 
+  // Site ouvert / fermé : choisi dans admin → Campagnes (metadata du sales channel), indépendant des dates
+  const { data: channels } = await query.graph({ entity: "sales_channel", fields: ["metadata"], filters: { id: salesChannelIds } })
+  const online = channels[0]?.metadata?.ub_online !== false
+
   res.setHeader("Cache-Control", "public, max-age=60")
-  res.json({ campaign: toCampaignJson(data[0]) })
+  res.json({ campaign: { ...toCampaignJson(data[0]), online } })
 }

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

@@ -0,0 +1,39 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { PRODUCT_REVIEW_MODULE } from "../../../../modules/product-review"
+import ProductReviewModuleService from "../../../../modules/product-review/service"
+import { PUBLIC_FIELDS, reviewChannels } from "../../../../lib/reviews"
+
+/**
+ * GET /store/reviews/latest?limit=6 : derniers avis validés (section « avis » de l'accueil), 4 étoiles et plus,
+ * seulement sur des produits vendus dans la boutique qui interroge ; avec titre, lien et image du produit.
+ */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const limit = Math.min(Math.max(Number(req.query.limit) || 6, 1), 12)
+  const channels = reviewChannels(req)
+  const ownChannels = req.publishable_key_context?.sales_channel_ids ?? []
+  const service: ProductReviewModuleService = req.scope.resolve(PRODUCT_REVIEW_MODULE)
+  const reviews = await service.listReviews(
+    { status: "approved", rating: { $gte: 4 }, ...(channels ? { sales_channel_id: channels } : {}) },
+    { select: [...PUBLIC_FIELDS], take: 60, order: { created_at: "DESC" } }
+  )
+  if (!reviews.length) return res.json({ reviews: [] })
+
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data: products } = await query.graph({
+    entity: "product",
+    fields: ["id", "title", "handle", "thumbnail", "status", "sales_channels.id"],
+    filters: { id: [...new Set(reviews.map((r) => r.product_id))] },
+  })
+  const sold = new Map(
+    products
+      .filter((p) => p.status === "published" && (p.sales_channels ?? []).some((c) => c && ownChannels.includes(c.id)))
+      .map((p) => [p.id, { title: p.title, handle: p.handle, thumbnail: p.thumbnail }])
+  )
+  res.json({
+    reviews: reviews
+      .filter((r) => sold.has(r.product_id))
+      .slice(0, limit)
+      .map((r) => ({ ...r, product: sold.get(r.product_id) })),
+  })
+}

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/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) =>