@salifbiaye/create-boutique 0.1.1

package/templates/backend/src/admin/routes/boutique-campaigns/page.tsx

@@ -0,0 +1,113 @@
+import { defineRouteConfig } from "@medusajs/admin-sdk"
+import { PencilSquare, Sparkles, Spinner } from "@medusajs/icons"
+import { Badge, Button, Container, Heading, Table, Text } from "@medusajs/ui"
+import { useQuery } from "@tanstack/react-query"
+import { useState } from "react"
+import { useTranslation } from "react-i18next"
+import { sdk } from "../../lib/client"
+import { CampaignDrawer, type Boutique } from "./campaign-drawer"
+
+const QUERY_KEY = ["boutique-campaigns"]
+
+function status(c: Boutique["campaign"]): "upcoming" | "live" | "ended" | null {
+  if (!c) return null
+  const now = Date.now()
+  if (now < Date.parse(c.startsAt)) return "upcoming"
+  if (now > Date.parse(c.endsAt)) return "ended"
+  return "live"
+}
+
+const COLORS = { upcoming: "blue", live: "green", ended: "grey" } as const
+
+/** Page « Campagnes » : une ligne par boutique du projet, édition dans un panneau latéral. */
+const CampaignsPage = () => {
+  const { t, i18n } = useTranslation()
+  const [editing, setEditing] = useState<Boutique | null>(null)
+
+  const { data, isLoading } = useQuery({
+    queryKey: QUERY_KEY,
+    queryFn: () => sdk.client.fetch<{ boutiques: Boutique[] }>("/admin/boutique-campaigns"),
+  })
+
+  const date = (iso: string) => new Date(iso).toLocaleDateString(i18n.language, { dateStyle: "medium" })
+
+  return (
+    <Container className="divide-y p-0">
+      <div className="px-6 py-4">
+        <Heading level="h1">{t("campaigns.title")}</Heading>
+        <Text size="small" className="text-ui-fg-subtle mt-1">
+          {t("campaigns.description")}
+        </Text>
+      </div>
+
+      {isLoading ? (
+        <div className="flex justify-center px-6 py-8">
+          <Spinner className="animate-spin" />
+        </div>
+      ) : (
+        <Table>
+          <Table.Header>
+            <Table.Row>
+              <Table.HeaderCell>{t("campaigns.store")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("campaigns.dates")}</Table.HeaderCell>
+              <Table.HeaderCell>{t("campaigns.status")}</Table.HeaderCell>
+              <Table.HeaderCell />
+            </Table.Row>
+          </Table.Header>
+          <Table.Body>
+            {data?.boutiques.map((b) => {
+              const s = status(b.campaign)
+              return (
+                <Table.Row key={b.sales_channel_id}>
+                  <Table.Cell>
+                    <Text size="small" weight="plus" leading="compact">
+                      {b.slug}
+                    </Text>
+                    {b.description && (
+                      <Text size="small" leading="compact" className="text-ui-fg-subtle">
+                        {b.description}
+                      </Text>
+                    )}
+                  </Table.Cell>
+                  <Table.Cell>
+                    {b.campaign ? `${date(b.campaign.startsAt)} → ${date(b.campaign.endsAt)}` : t("campaigns.noCampaign")}
+                  </Table.Cell>
+                  <Table.Cell>
+                    {s && (
+                      <Badge size="2xsmall" color={COLORS[s]}>
+                        {t(`campaigns.${s}`)}
+                      </Badge>
+                    )}
+                  </Table.Cell>
+                  <Table.Cell className="text-right">
+                    <Button size="small" variant="secondary" onClick={() => setEditing(b)}>
+                      <PencilSquare />
+                      {t("campaigns.edit")}
+                    </Button>
+                  </Table.Cell>
+                </Table.Row>
+              )
+            })}
+          </Table.Body>
+        </Table>
+      )}
+
+      {editing && (
+        <CampaignDrawer
+          boutique={editing}
+          others={(data?.boutiques ?? []).filter((b) => b.sales_channel_id !== editing.sales_channel_id).map((b) => b.slug)}
+          queryKey={QUERY_KEY}
+          onClose={() => setEditing(null)}
+        />
+      )}
+    </Container>
+  )
+}
+
+export const config = defineRouteConfig({
+  label: "campaigns.nav",
+  translationNs: "translation",
+  icon: Sparkles,
+})
+
+export default CampaignsPage

package/templates/backend/src/admin/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["."]
+}

package/templates/backend/src/admin/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/templates/backend/src/admin/widgets/category-image.tsx

@@ -0,0 +1,56 @@
+import { defineWidgetConfig } from "@medusajs/admin-sdk"
+import { DetailWidgetProps, HttpTypes } from "@medusajs/framework/types"
+import { Button, Container, Heading, Text, toast } from "@medusajs/ui"
+import { useMutation, useQueryClient } from "@tanstack/react-query"
+import { useState } from "react"
+import { useTranslation } from "react-i18next"
+import { ImageField } from "../components/image-field"
+import { sdk } from "../lib/client"
+
+/**
+ * Image d'une catégorie (tuiles « Shop by category » des boutiques).
+ * Medusa n'a pas de champ image pour les catégories : on la range dans metadata.image.
+ */
+const CategoryImageWidget = ({ data: category }: DetailWidgetProps<HttpTypes.AdminProductCategory>) => {
+  const { t } = useTranslation()
+  const queryClient = useQueryClient()
+  const saved = typeof category.metadata?.image === "string" ? category.metadata.image : ""
+  const [image, setImage] = useState(saved)
+
+  const save = useMutation({
+    mutationFn: () =>
+      sdk.admin.productCategory.update(category.id, {
+        metadata: { ...(category.metadata ?? {}), image: image || null },
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["product_categories"] })
+      toast.success(t("campaigns.category.saved"))
+    },
+    onError: (e: Error) => toast.error(e.message),
+  })
+
+  return (
+    <Container className="divide-y p-0">
+      <div className="px-6 py-4">
+        <Heading level="h2">{t("campaigns.category.title")}</Heading>
+        <Text size="small" leading="compact" className="text-ui-fg-subtle mt-1">
+          {t("campaigns.category.hint")}
+        </Text>
+      </div>
+      <div className="flex flex-col gap-y-3 px-6 py-4">
+        <ImageField label={t("campaigns.category.title")} value={image} onChange={setImage} />
+        <div className="flex justify-end">
+          <Button size="small" onClick={() => save.mutate()} isLoading={save.isPending} disabled={save.isPending || image === saved}>
+            {t("campaigns.category.save")}
+          </Button>
+        </div>
+      </div>
+    </Container>
+  )
+}
+
+export const config = defineWidgetConfig({
+  zone: "product_category.details.side",
+})
+
+export default CategoryImageWidget

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

@@ -0,0 +1,135 @@
+# Custom API Routes
+
+An API Route is a REST API endpoint.
+
+An API Route is created in a TypeScript or JavaScript file under the `/src/api` directory of your Medusa application. The file’s name must be `route.ts` or `route.js`.
+
+> Learn more about API Routes in [this documentation](https://docs.medusajs.com/learn/fundamentals/api-routes)
+
+For example, to create a `GET` API Route at `/store/hello-world`, create the file `src/api/store/hello-world/route.ts` with the following content:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  res.json({
+    message: "Hello world!",
+  });
+}
+```
+
+## Supported HTTP methods
+
+The file based routing supports the following HTTP methods:
+
+- GET
+- POST
+- PUT
+- PATCH
+- DELETE
+- OPTIONS
+- HEAD
+
+You can define a handler for each of these methods by exporting a function with the name of the method in the paths `route.ts` file.
+
+For example:
+
+```ts
+import type { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  // Handle GET requests
+}
+
+export async function POST(req: MedusaRequest, res: MedusaResponse) {
+  // Handle POST requests
+}
+
+export async function PUT(req: MedusaRequest, res: MedusaResponse) {
+  // Handle PUT requests
+}
+```
+
+## Parameters
+
+To create an API route that accepts a path parameter, create a directory within the route's path whose name is of the format `[param]`.
+
+For example, if you want to define a route that takes a `productId` parameter, you can do so by creating a file called `/api/products/[productId]/route.ts`:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework/http"
+
+export async function GET(req: MedusaRequest, res: MedusaResponse) {
+  const { productId } = req.params;
+
+  res.json({
+    message: `You're looking for product ${productId}`
+  })
+}
+```
+
+To create an API route that accepts multiple path parameters, create within the file's path multiple directories whose names are of the format `[param]`.
+
+For example, if you want to define a route that takes both a `productId` and a `variantId` parameter, you can do so by creating a file called `/api/products/[productId]/variants/[variantId]/route.ts`.
+
+## Using the container
+
+The Medusa container is available on `req.scope`. Use it to access modules' main services and other registered resources:
+
+```ts
+import type {
+  MedusaRequest,
+  MedusaResponse,
+} from "@medusajs/framework/http"
+
+export const GET = async (
+  req: MedusaRequest,
+  res: MedusaResponse
+) => {
+  const productModuleService = req.scope.resolve("product")
+
+  const [, count] = await productModuleService.listAndCount()
+
+  res.json({
+    count,
+  })
+}
+```
+
+## Middleware
+
+You can apply middleware to your routes by creating a file called `/api/middlewares.ts`. This file must export a configuration object with what middleware you want to apply to which routes.
+
+For example, if you want to apply a custom middleware function to the `/store/custom` route, you can do so by adding the following to your `/api/middlewares.ts` file:
+
+```ts
+import { defineMiddlewares } from "@medusajs/framework/http"
+import type {
+  MedusaRequest,
+  MedusaResponse,
+  MedusaNextFunction,
+} from "@medusajs/framework/http";
+
+async function logger(
+  req: MedusaRequest,
+  res: MedusaResponse,
+  next: MedusaNextFunction
+) {
+  console.log("Request received");
+  next();
+}
+
+export default defineMiddlewares({
+  routes: [
+    {
+      matcher: "/store/custom",
+      middlewares: [logger],
+    },
+  ],
+})
+```
+
+The `matcher` property can be either a string or a regular expression. The `middlewares` property accepts an array of middleware functions.

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

@@ -0,0 +1,30 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { toCampaignJson, type CampaignInput } from "../../../../modules/campaign/validators"
+import { upsertCampaignWorkflow } from "../../../../workflows/upsert-campaign"
+
+async function channelOrThrow(req: AuthenticatedMedusaRequest<unknown>) {
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+  const { data } = await query.graph({
+    entity: "sales_channel",
+    fields: ["id", "name", "boutique_campaign.*"],
+    filters: { id: req.params.salesChannelId },
+  })
+  if (!data.length) throw new MedusaError(MedusaError.Types.NOT_FOUND, "Unknown store")
+  return data[0]
+}
+
+/** GET /admin/boutique-campaigns/:salesChannelId */
+export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  const channel = await channelOrThrow(req)
+  res.json({ slug: channel.name, campaign: channel.boutique_campaign ? toCampaignJson(channel.boutique_campaign) : null })
+}
+
+/** POST /admin/boutique-campaigns/:salesChannelId : enregistre la campagne (corps validé par zod, cf. middlewares). */
+export async function POST(req: AuthenticatedMedusaRequest<CampaignInput>, res: MedusaResponse) {
+  const channel = await channelOrThrow(req)
+  const { result } = await upsertCampaignWorkflow(req.scope).run({
+    input: { sales_channel_id: channel.id, campaign: req.validatedBody },
+  })
+  res.json({ slug: channel.name, campaign: toCampaignJson(result) })
+}

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

@@ -0,0 +1,24 @@
+import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys } from "@medusajs/framework/utils"
+import { toCampaignJson } from "../../../modules/campaign/validators"
+
+/** GET /admin/boutique-campaigns : les boutiques du projet (sales channels) et leur campagne. */
+export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+
+  const { data: channels } = await query.graph({
+    entity: "sales_channel",
+    fields: ["id", "name", "description", "boutique_campaign.*"],
+  })
+
+  res.json({
+    boutiques: channels
+      .filter((c) => c.name !== "Default Sales Channel")
+      .map((c) => ({
+        sales_channel_id: c.id,
+        slug: c.name,
+        description: c.description,
+        campaign: c.boutique_campaign ? toCampaignJson(c.boutique_campaign) : null,
+      })),
+  })
+}

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

@@ -0,0 +1,28 @@
+import { defineMiddlewares, validateAndTransformBody } from "@medusajs/framework/http"
+import { CampaignInput } from "../modules/campaign/validators"
+import { rateLimit } from "./rate-limit"
+import { OrderLookup } from "./store/order-lookup/route"
+
+// 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 })
+
+export default defineMiddlewares({
+  routes: [
+    {
+      // Routes /admin/* : authentification admin Medusa appliquée par défaut.
+      matcher: "/admin/boutique-campaigns/:salesChannelId",
+      method: "POST",
+      middlewares: [validateAndTransformBody(CampaignInput)],
+    },
+    { 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: "/store/order-lookup",
+      method: "POST",
+      middlewares: [lookupLimit, validateAndTransformBody(OrderLookup)],
+    },
+  ],
+})

package/templates/backend/src/api/rate-limit.ts

@@ -0,0 +1,30 @@
+import type { MedusaNextFunction, MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+
+/**
+ * Limite de tentatives par adresse IP (fenêtre glissante, en mémoire : un seul backend par projet).
+ * Utilisée pour la connexion admin, le mot de passe oublié et le suivi de commande (anti force brute).
+ * Derrière un reverse proxy, l'IP réelle vient de X-Forwarded-For.
+ */
+export function rateLimit({ max, windowMs, name }: { max: number; windowMs: number; name: string }) {
+  const hits = new Map<string, number[]>()
+
+  return (req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction) => {
+    const forwarded = req.headers["x-forwarded-for"]
+    const ip = (Array.isArray(forwarded) ? forwarded[0] : forwarded)?.split(",")[0]?.trim() || req.ip || "unknown"
+    const now = Date.now()
+    const recent = (hits.get(ip) ?? []).filter((t) => now - t < windowMs)
+
+    if (recent.length >= max) {
+      const retry = Math.ceil((windowMs - (now - recent[0])) / 1000)
+      res.setHeader("Retry-After", String(retry))
+      res.status(429).json({ type: "too_many_requests", message: `Trop de tentatives (${name}). Réessayez dans ${Math.ceil(retry / 60)} min.` })
+      return
+    }
+
+    recent.push(now)
+    hits.set(ip, recent)
+    // Nettoyage occasionnel pour ne pas garder les IP inactives en mémoire
+    if (hits.size > 10000) for (const [k, v] of hits) if (!v.some((t) => now - t < windowMs)) hits.delete(k)
+    next()
+  }
+}

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

@@ -0,0 +1,6 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http"
+
+/** La racine du backend n'a pas de page : on renvoie vers l'admin (/app). */
+export async function GET(_req: MedusaRequest, res: MedusaResponse) {
+  res.redirect("/app")
+}

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

@@ -0,0 +1,25 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { toCampaignJson } from "../../../modules/campaign/validators"
+
+/**
+ * GET /store/campaign : campagne de LA boutique qui appelle, déterminée par sa publishable key
+ * (sales channel associé). Aucun paramètre ne permet de lire la campagne d'une autre boutique.
+ */
+export async function GET(req: MedusaStoreRequest, res: MedusaResponse) {
+  const salesChannelIds = req.publishable_key_context?.sales_channel_ids ?? []
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+
+  const { data } = await query.graph({
+    entity: "boutique_campaign",
+    fields: ["starts_at", "ends_at", "next_campaign", "texts", "vars", "hero_image", "logo", "promo_image", "show_countdown"],
+    filters: { sales_channel_id: salesChannelIds },
+  })
+
+  if (!data.length) {
+    throw new MedusaError(MedusaError.Types.NOT_FOUND, "No campaign for this store")
+  }
+
+  res.setHeader("Cache-Control", "public, max-age=60")
+  res.json({ campaign: toCampaignJson(data[0]) })
+}

package/templates/backend/src/api/store/order-lookup/route.ts

@@ -0,0 +1,74 @@
+import { MedusaStoreRequest, MedusaResponse } from "@medusajs/framework/http"
+import { ContainerRegistrationKeys, MedusaError } from "@medusajs/framework/utils"
+import { z } from "@medusajs/framework/zod"
+
+export const OrderLookup = z.object({
+  number: z.coerce.number().int().positive().max(1e9),
+  email: z.email().max(200),
+})
+export type OrderLookup = z.infer<typeof OrderLookup>
+
+/**
+ * POST /store/order-lookup : suivi de commande sans compte (n° + e-mail de la commande).
+ * Réponse seulement si l'e-mail correspond ET si la commande vient de la boutique qui interroge
+ * (sales channel de la publishable key). Sinon, même erreur « introuvable » (rien ne fuit).
+ * Données renvoyées limitées au suivi : pas d'adresse ni de téléphone. Limité en tentatives.
+ */
+export async function POST(req: MedusaStoreRequest<OrderLookup>, res: MedusaResponse) {
+  const { number, email } = req.validatedBody
+  const channels = req.publishable_key_context?.sales_channel_ids ?? []
+  const query = req.scope.resolve(ContainerRegistrationKeys.QUERY)
+
+  const { data } = await query.graph({
+    entity: "order",
+    fields: [
+      "display_id",
+      "email",
+      "created_at",
+      "status",
+      "currency_code",
+      "total",
+      "sales_channel_id",
+      "items.product_title",
+      "items.variant_title",
+      "items.quantity",
+      "fulfillments.shipped_at",
+      "fulfillments.delivered_at",
+      "fulfillments.canceled_at",
+      "fulfillments.labels.tracking_number",
+      "fulfillments.labels.tracking_url",
+    ],
+    // display_id est un nombre en base (le type généré le déclare en texte)
+    filters: { display_id: number as unknown as string, sales_channel_id: channels },
+  })
+
+  const order = data.find((o) => o.email?.toLowerCase() === email.toLowerCase())
+  if (!order) throw new MedusaError(MedusaError.Types.NOT_FOUND, "Order not found")
+
+  const shipments = (order.fulfillments ?? []).filter((f) => f && !f.canceled_at)
+  // Étape affichée au client, déduite des expéditions
+  const step =
+    order.status === "canceled"
+      ? "canceled"
+      : shipments.some((f) => f!.delivered_at)
+        ? "delivered"
+        : shipments.some((f) => f!.shipped_at)
+          ? "shipped"
+          : "placed"
+
+  res.json({
+    order: {
+      number: order.display_id,
+      created_at: order.created_at,
+      step,
+      currency_code: order.currency_code,
+      total: order.total,
+      items: (order.items ?? []).filter(Boolean).map((i) => ({ title: i!.product_title, variant: i!.variant_title, quantity: i!.quantity })),
+      shipments: shipments.map((f) => ({
+          shipped_at: f!.shipped_at,
+          delivered_at: f!.delivered_at,
+          tracking: (f!.labels ?? []).filter(Boolean).map((l) => ({ number: l!.tracking_number, url: l!.tracking_url })),
+        })),
+    },
+  })
+}

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

@@ -0,0 +1,64 @@
+{
+  "order_placed": {
+    "subject": "Order #{number} confirmed",
+    "title": "Thank you for your order!",
+    "intro": "Hi {name}, we have received your order #{number}. Here is a summary."
+  },
+  "order_shipped": {
+    "subject": "Your order #{number} is on its way",
+    "title": "Your package is on its way",
+    "intro": "Good news {name}: your order #{number} has shipped.",
+    "tracking": "Tracking number: {code}",
+    "track": "Track my package"
+  },
+  "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!"
+  },
+  "order_canceled": {
+    "subject": "Your order #{number} has been canceled",
+    "title": "Order canceled",
+    "intro": "Hi {name}, your order #{number} has been canceled. If you were charged, you will be refunded."
+  },
+  "refund": {
+    "subject": "Refund for your order #{number}",
+    "title": "Refund issued",
+    "intro": "Hi {name}, we have refunded {amount} for your order #{number}. It can take a few days to appear on your account."
+  },
+  "return_requested": {
+    "subject": "Return requested for order #{number}",
+    "title": "Your return request",
+    "intro": "Hi {name}, we have registered a return for your order #{number}. Please send the items back in their original packaging."
+  },
+  "return_received": {
+    "subject": "We received your return for order #{number}",
+    "title": "Return received",
+    "intro": "Hi {name}, we have received the items you returned for order #{number}. Your refund is being processed."
+  },
+  "merchant_new_order": {
+    "subject": "New order #{number} — {total}",
+    "title": "New order on {store}",
+    "intro": "Order #{number} from {email}, total {total}."
+  },
+  "common": {
+    "item": "Item",
+    "qty": "Qty",
+    "total": "Total",
+    "shippingTo": "Shipping to",
+    "questions": "Questions? Just reply to this email.",
+    "customer": "customer"
+  },
+  "password_reset": {
+    "subject": "Reset your {store} admin password",
+    "title": "Reset your password",
+    "intro": "We received a request to reset the password of your {store} admin account. The link is valid for a limited time. If you did not ask for it, ignore this email.",
+    "button": "Choose a new password"
+  },
+  "team_invite": {
+    "subject": "You are invited to the {store} admin",
+    "title": "Join the {store} team",
+    "intro": "You have been invited to manage the {store} stores. Click the button to create your account.",
+    "button": "Accept the invitation"
+  }
+}