@unbox-plus/cli 0.20.4

package/template/app/api/account/addresses/route.ts

@@ -0,0 +1,39 @@
+// CRUD de endereços do cliente (address book). Token do cliente do cookie.
+import { requireCustomerClient } from "@/lib/customer-session";
+import { addressSchema } from "@/lib/schemas";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+// POST → upsert (com _id atualiza; sem _id cria)
+export async function POST(req: Request) {
+  try {
+    const me = await requireCustomerClient();
+    const body = await req.json();
+    const parsed = addressSchema.safeParse(body.address);
+    if (!parsed.success) return fail("Endereço inválido.", 422, { issues: parsed.error.flatten() });
+    const r = await me.upsertAddress({
+      ...(parsed.data as any),
+      _id: body.address?._id,
+      alias: body.address?.alias,
+      isShippingDefault: body.address?.isShippingDefault,
+      isBillingDefault: body.address?.isBillingDefault,
+    });
+    return ok({ address: r });
+  } catch (e) {
+    return failFrom(e);
+  }
+}
+
+// DELETE { ids: string[] }
+export async function DELETE(req: Request) {
+  try {
+    const me = await requireCustomerClient();
+    const { ids } = await req.json();
+    if (!Array.isArray(ids) || !ids.length) return fail("Nenhum endereço informado.");
+    await me.deleteAddresses(ids);
+    return ok({ ok: true });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/account/exists/route.ts

@@ -0,0 +1,21 @@
+// Verifica se há conta para o e-mail nesta loja (login vs. primeiro acesso). Rate-limit anti-enumeração.
+import { withStoreClient } from "@/lib/unbox/store";
+import { rateLimit, clientIp, LIMITS } from "@/lib/ratelimit";
+import { emailSchema } from "@/lib/schemas";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: Request) {
+  const rl = rateLimit(`exists:${clientIp(req)}`, LIMITS.exists.limit, LIMITS.exists.windowMs);
+  if (!rl.ok) return fail("Muitas tentativas. Aguarde.", 429);
+  try {
+    const { email } = await req.json();
+    const parsed = emailSchema.safeParse(email);
+    if (!parsed.success) return fail("E-mail inválido.", 422);
+    const exists = await withStoreClient((c) => c.customerAccountExists(parsed.data));
+    return ok({ exists });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/account/me/route.ts

@@ -0,0 +1,25 @@
+import { NextResponse } from "next/server";
+import { getCustomerClient } from "@/lib/customer-session";
+
+export const dynamic = "force-dynamic";
+
+const cap = (s: string) => (s ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : s);
+
+/** Primeiro nome do cliente: do endereço salvo, senão da parte local do e-mail. */
+function firstNameFrom(account: any): string | null {
+  const full: string =
+    account?.addressBooks?.find((a: any) => a.isShippingDefault)?.fullName ||
+    account?.addressBooks?.[0]?.fullName ||
+    "";
+  const fromName = full.trim().split(/\s+/)[0];
+  if (fromName) return cap(fromName);
+  const local = String(account?.email ?? "").split("@")[0]?.split(/[._-]/)[0];
+  return local ? cap(local) : null;
+}
+
+export async function GET() {
+  const customer = await getCustomerClient();
+  if (!customer) return NextResponse.json({ firstName: null });
+  const account = await customer.me().catch(() => null);
+  return NextResponse.json({ firstName: account ? firstNameFrom(account) : null });
+}

package/template/app/api/account/otp/route.ts

@@ -0,0 +1,26 @@
+// Pede o código OTP por e-mail. ⚠️ EFEITO REAL: dispara e-mail de verdade (customerOTPRequest).
+// Exige x-captcha-verification (o SDK cuida). Rate-limit anti-spam. NÃO retentar automaticamente.
+import { withStoreClient } from "@/lib/unbox/store";
+import { rateLimit, clientIp, LIMITS } from "@/lib/ratelimit";
+import { emailSchema } from "@/lib/schemas";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: Request) {
+  try {
+    const { email } = await req.json();
+    const parsed = emailSchema.safeParse(email);
+    if (!parsed.success) return fail("E-mail inválido.", 422);
+
+    // limita por IP e por e-mail
+    const ip = rateLimit(`otp:ip:${clientIp(req)}`, LIMITS.otp.limit, LIMITS.otp.windowMs);
+    const byEmail = rateLimit(`otp:email:${parsed.data}`, LIMITS.otp.limit, LIMITS.otp.windowMs);
+    if (!ip.ok || !byEmail.ok) return fail("Muitas solicitações de código. Aguarde alguns minutos.", 429);
+
+    await withStoreClient((c) => c.requestCustomerOtp(parsed.data));
+    return ok({ ok: true });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/account/preferences/route.ts

@@ -0,0 +1,19 @@
+// Atualiza preferências da conta (token do cliente do cookie).
+import { requireCustomerClient } from "@/lib/customer-session";
+import { ok, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function PATCH(req: Request) {
+  try {
+    const me = await requireCustomerClient();
+    const body = await req.json();
+    const input: { receiveNewOrderEmail?: boolean; reuseDataBetweenShops?: boolean } = {};
+    if (typeof body.receiveNewOrderEmail === "boolean") input.receiveNewOrderEmail = body.receiveNewOrderEmail;
+    if (typeof body.reuseDataBetweenShops === "boolean") input.reuseDataBetweenShops = body.reuseDataBetweenShops;
+    const r = await me.updateAccount(input);
+    return ok({ account: r });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/account/signin/route.ts

@@ -0,0 +1,27 @@
+// Troca o OTP pelo token DO CLIENTE e grava em cookie httpOnly. Rate-limit.
+import { withStoreClient } from "@/lib/unbox/store";
+import { setCustomerToken } from "@/lib/session";
+import { rateLimit, clientIp, LIMITS } from "@/lib/ratelimit";
+import { otpSchema } from "@/lib/schemas";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: Request) {
+  const rl = rateLimit(`signin:${clientIp(req)}`, LIMITS.signin.limit, LIMITS.signin.windowMs);
+  if (!rl.ok) return fail("Muitas tentativas. Aguarde.", 429);
+  try {
+    const body = await req.json();
+    const parsed = otpSchema.safeParse(body);
+    if (!parsed.success) return fail("Código inválido.", 422);
+
+    const { accessToken, firstAccess } = await withStoreClient((c) =>
+      c.customerSignIn(parsed.data.email, parsed.data.otp),
+    );
+    if (!accessToken) return fail("Código ou credenciais inválidos.", 401);
+    await setCustomerToken(accessToken);
+    return ok({ ok: true, firstAccess });
+  } catch (e) {
+    return failFrom(e, 401);
+  }
+}

package/template/app/api/account/signout/route.ts

@@ -0,0 +1,9 @@
+import { clearCustomerToken } from "@/lib/session";
+import { ok } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function POST() {
+  await clearCustomerToken();
+  return ok({ ok: true });
+}

package/template/app/api/acesso/route.ts

@@ -0,0 +1,171 @@
+// Registra o lead da porta de preview e assina o cookie que libera a loja.
+// Fica FORA da porta (o middleware deixa /api/acesso passar), senão não haveria como entrar.
+//
+// Os logs da Vercel têm retenção de HORAS — quem PERSISTE o lead é o Pipedrive
+// (e o webhook opcional). Os logs servem pra conferir e contar.
+import { NextResponse } from "next/server";
+import { COOKIE, senhaDoPreview, tokenDaSenha } from "@/middleware";
+
+const LOJA = "minhaloja"; // o CLI troca pelo slug — vira o título do negócio: "minhaloja - Nome"
+
+export const dynamic = "force-dynamic";
+
+/** Cookie que marca "esta pessoa já apareceu antes" — separa gente de recarga. */
+const VISITANTE = `${LOJA}_visitante`;
+
+/** "(11) 93619-8174" → "+5511936198174". Null quando não é BR plausível. */
+function toE164(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  let digits = raw.replace(/\D/g, "");
+  if (digits.startsWith("55") && digits.length >= 12) digits = digits.slice(2);
+  if (digits.length !== 10 && digits.length !== 11) return null;
+  const ddd = Number(digits.slice(0, 2));
+  if (ddd < 11 || ddd > 99) return null;
+  return `+55${digits}`;
+}
+
+/** x-vercel-ip-city vem percent-encoded ("S%C3%A3o%20Paulo") — decodifica antes de
+ *  qualquer uso humano (log, CRM, webhook), senão o time comercial lê lixo. */
+function cidadeDe(req: Request): string | null {
+  const raw = req.headers.get("x-vercel-ip-city");
+  if (!raw) return null;
+  try { return decodeURIComponent(raw); } catch { return raw; }
+}
+
+/**
+ * Uma linha estruturada por tentativa. No painel de Logs da Vercel, filtrar por
+ * `[preview-acesso]` e `"evento":"entrou"` dá a contagem de quem entrou.
+ *
+ * ⚠️ NÃO grava o IP: é dado pessoal sob a LGPD, e cidade/país já respondem "quem entrou".
+ */
+function registrar(req: Request, evento: "entrou" | "invalido", visitante: string, novo: boolean) {
+  const h = req.headers;
+  console.log(
+    JSON.stringify({
+      tag: "[preview-acesso]",
+      evento,
+      visitante, // id aleatório do cookie: conta PESSOAS, não recargas
+      primeiraVez: novo,
+      quando: new Date().toISOString(),
+      cidade: cidadeDe(req),
+      pais: h.get("x-vercel-ip-country") ?? null,
+      dispositivo: /mobile|iphone|android/i.test(h.get("user-agent") ?? "") ? "mobile" : "desktop",
+      veioDe: h.get("referer") ?? null,
+    }),
+  );
+}
+
+export async function POST(req: Request) {
+  // Nome e e-mail obrigatórios; marca e WhatsApp opcionais — barreira alta demais
+  // mata a visualização.
+  const corpo = (await req.json().catch(() => ({}))) as {
+    nome?: string; marca?: string; whatsapp?: string; email?: string;
+  };
+  const nome = (corpo.nome ?? "").trim();
+  const marca = (corpo.marca ?? "").trim();
+  const whatsapp = (corpo.whatsapp ?? "").trim();
+  const email = (corpo.email ?? "").trim();
+
+  // Identifica a pessoa entre tentativas, sem saber quem ela é.
+  const cookies = req.headers.get("cookie") ?? "";
+  const jaTinha = cookies.match(new RegExp(`${VISITANTE}=([^;]+)`))?.[1];
+  const visitante = jaTinha ?? crypto.randomUUID().slice(0, 8);
+  const marcaVisitante = { sameSite: "lax" as const, path: "/", maxAge: 60 * 60 * 24 * 180 };
+
+  // Pausa fixa: torna envio em massa chato o bastante pra um link que circula entre
+  // poucos, e disfarça a latência do Pipedrive.
+  await new Promise((r) => setTimeout(r, 400));
+
+  if (!nome || nome.length < 2 || !/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email)) {
+    registrar(req, "invalido", visitante, !jaTinha);
+    const res = NextResponse.json({ ok: false }, { status: 400 });
+    if (!jaTinha) res.cookies.set(VISITANTE, visitante, marcaVisitante);
+    return res;
+  }
+
+  registrar(req, "entrou", visitante, !jaTinha);
+  console.log(
+    JSON.stringify({
+      tag: "[preview-lead]",
+      nome, marca: marca || null, whatsapp: whatsapp || null, email,
+      visitante, quando: new Date().toISOString(),
+    }),
+  );
+
+  // ── PIPEDRIVE ─────────────────────────────────────────────────────────────
+  // AGUARDADO antes da resposta, de propósito: o `void fetch` do webhook abaixo
+  // aceita perder a mensagem se a função congelar depois do return; pro CRM não dá.
+  // Falha NUNCA bloqueia a entrada: o lead ainda está no log.
+  const pdToken = process.env.PIPEDRIVE_API_TOKEN;
+  if (pdToken) {
+    try {
+      const pd = (caminho: string, body?: unknown) =>
+        fetch(`https://api.pipedrive.com/v1/${caminho}${caminho.includes("?") ? "&" : "?"}api_token=${pdToken}`, {
+          method: body ? "POST" : "GET",
+          headers: body ? { "Content-Type": "application/json" } : undefined,
+          body: body ? JSON.stringify(body) : undefined,
+        }).then((r) => r.json());
+
+      // Dedup por e-mail: quem se cadastra duas vezes não vira pessoa duplicada.
+      const busca = await pd(`persons/search?term=${encodeURIComponent(email)}&fields=email&exact_match=true&limit=1`);
+      let pessoaId: number | undefined = busca?.data?.items?.[0]?.item?.id;
+      if (!pessoaId) {
+        const fone = toE164(whatsapp) ?? (whatsapp || null);
+        const criada = await pd("persons", {
+          name: nome,
+          email: [{ value: email, primary: true }],
+          ...(fone ? { phone: [{ value: fone, label: "whatsapp" }] } : {}),
+          ...(marca ? { org_name: marca } : {}),
+        });
+        pessoaId = criada?.data?.id;
+      }
+      if (pessoaId) {
+        // NEGÓCIO no funil, não Lead na caixa de entrada — o time olha o funil.
+        // ⚠️ A RESPOSTA é conferida, não presumida: recusa do Pipedrive vem com
+        // success:false e status 200 — logar ok sem olhar seria mentira.
+        const negocio = await pd("deals", { title: `${LOJA} - ${nome}`, person_id: pessoaId });
+        console.log(JSON.stringify({
+          tag: "[preview-lead-pipedrive]",
+          ok: !!negocio?.success,
+          pessoaId,
+          dealId: negocio?.data?.id ?? null,
+          erro: negocio?.success ? null : (negocio?.error ?? "resposta sem success"),
+          email,
+        }));
+      } else {
+        console.log(JSON.stringify({ tag: "[preview-lead-pipedrive]", ok: false, motivo: "pessoa sem id", busca: busca?.success, email }));
+      }
+    } catch (e) {
+      console.log(JSON.stringify({ tag: "[preview-lead-pipedrive]", ok: false, motivo: String(e), email }));
+    }
+  } else {
+    // Pulo VISÍVEL, nunca silencioso: sem esta linha, um deploy sem o token engole
+    // leads sem deixar rastro (20 min caçando fantasma numa estreia real).
+    console.log(JSON.stringify({ tag: "[preview-lead-pipedrive]", ok: false, motivo: "sem PIPEDRIVE_API_TOKEN no ambiente", email }));
+  }
+
+  const res = NextResponse.json({ ok: true });
+  res.cookies.set(COOKIE, await tokenDaSenha(senhaDoPreview()), {
+    httpOnly: true, // fora do alcance de JS na página
+    sameSite: "lax",
+    secure: process.env.NODE_ENV === "production",
+    path: "/",
+    maxAge: 60 * 60 * 24 * 30, // 30 dias
+  });
+  if (!jaTinha) res.cookies.set(VISITANTE, visitante, marcaVisitante);
+
+  // Aviso em tempo real, opcional: aponte PREVIEW_WEBHOOK_URL pra um Slack/Zapier.
+  const destino = process.env.PREVIEW_WEBHOOK_URL;
+  if (destino) {
+    const cidade = cidadeDe(req);
+    void fetch(destino, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        text: `🔓 Lead na prévia (${LOJA}): ${nome}${marca ? ` (${marca})` : ""} · ${email}${whatsapp ? ` · ${whatsapp}` : ""}${cidade ? ` · ${cidade}` : ""}`,
+      }),
+    }).catch(() => {});
+  }
+
+  return res;
+}

package/template/app/api/capi/route.ts

@@ -0,0 +1,34 @@
+// Meta Conversions API (server-side) — recebe o evento do browser (lib/analytics.ts) com o MESMO
+// event_id do Pixel → o Meta deduplica e conta 1 vez. Enriquece com fbp/fbc (cookies), IP e UA.
+// Todos os campos de cliente (em, ph, fn, ln, zp, external_id) chegam JÁ hasheados do browser;
+// esta rota nunca vê PII crua. O envio em si está em lib/capi.ts (compartilhado com o webhook).
+import { NextResponse } from "next/server";
+import { cookies, headers } from "next/headers";
+import { sendCapi, capiConfigured } from "@/lib/capi";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+export async function POST(req: Request) {
+  if (!capiConfigured()) return NextResponse.json({ ok: true, capi: false });
+
+  let body: any;
+  try { body = await req.json(); } catch { return NextResponse.json({ ok: false }, { status: 400 }); }
+  const { eventId, eventName, value, currency, contents, sourceUrl, orderId, em, ph, fn, ln, zp, external_id } = body ?? {};
+  if (!eventName || !eventId) return NextResponse.json({ ok: false }, { status: 400 });
+
+  const ck = await cookies();
+  const hd = await headers();
+  const r = await sendCapi({
+    eventId, eventName, value, currency, contents, sourceUrl, orderId,
+    actionSource: "website",
+    userData: {
+      em, ph, fn, ln, zp, external_id,
+      fbp: ck.get("_fbp")?.value,
+      fbc: ck.get("_fbc")?.value,
+      client_ip_address: (hd.get("x-forwarded-for") || "").split(",")[0].trim() || undefined,
+      client_user_agent: hd.get("user-agent") || undefined,
+    },
+  });
+  return NextResponse.json(r, { status: r.ok ? 200 : 502 });
+}

package/template/app/api/cart/coupon/route.ts

@@ -0,0 +1,49 @@
+// Aplicar (POST) e remover (DELETE) cupom de desconto no carrinho.
+// ⚠️ doc 04/05: aplicar o cupom ANTES de selecionar o frete (cupom depois do frete → total divergente).
+import { withStoreClient } from "@/lib/unbox/store";
+import { getCartRef } from "@/lib/session";
+import { cartResponse } from "@/lib/cart-response";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+// POST /api/cart/coupon { code }
+export async function POST(req: Request) {
+  try {
+    const ref = await getCartRef();
+    if (!ref) return fail("Carrinho não encontrado.", 404);
+    const { code } = await req.json();
+    if (!code) return fail("Informe um cupom.");
+
+    const trimmed = String(code).trim();
+    const { events, discountId } = await withStoreClient(async (c) => {
+      const r = await c.applyDiscount(ref.cartId, ref.cartToken, trimmed);
+      // resolve o id do desconto p/ permitir remoção (o Cart lido não traz os ids aplicados)
+      const id = await c.findDiscountIdByCode(trimmed).catch(() => null);
+      return { events: r?.cartEvents ?? [], discountId: id };
+    });
+    const full = await withStoreClient((c) => c.getCart(ref.cartId, ref.cartToken));
+    return ok({ cart: await cartResponse(full, events), coupon: { code: trimmed, discountId } });
+  } catch (e) {
+    return failFrom(e);
+  }
+}
+
+// DELETE /api/cart/coupon { discountId }
+export async function DELETE(req: Request) {
+  try {
+    const ref = await getCartRef();
+    if (!ref) return fail("Carrinho não encontrado.", 404);
+    const { discountId } = await req.json();
+    if (!discountId) return fail("Cupom inválido.");
+
+    const events = await withStoreClient(async (c) => {
+      const r = await c.removeDiscount(ref.cartId, ref.cartToken, discountId);
+      return r?.cartEvents ?? [];
+    });
+    const full = await withStoreClient((c) => c.getCart(ref.cartId, ref.cartToken));
+    return ok({ cart: await cartResponse(full, events) });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/cart/items/route.ts

@@ -0,0 +1,45 @@
+// Alterar quantidade (PATCH) e remover itens (DELETE) do carrinho.
+import { withStoreClient } from "@/lib/unbox/store";
+import { getCartRef } from "@/lib/session";
+import { cartResponse } from "@/lib/cart-response";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+// PATCH /api/cart/items { cartItemId, quantity }
+export async function PATCH(req: Request) {
+  try {
+    const ref = await getCartRef();
+    if (!ref) return fail("Carrinho não encontrado.", 404);
+    const { cartItemId, quantity } = await req.json();
+    if (!cartItemId || typeof quantity !== "number") return fail("Parâmetros inválidos.");
+
+    const events = await withStoreClient(async (c) => {
+      const r = await c.updateItemQuantity(ref.cartId, ref.cartToken, cartItemId, quantity);
+      return r?.cartEvents ?? [];
+    });
+    const full = await withStoreClient((c) => c.getCart(ref.cartId, ref.cartToken));
+    return ok({ cart: await cartResponse(full, events) });
+  } catch (e) {
+    return failFrom(e);
+  }
+}
+
+// DELETE /api/cart/items { cartItemIds: string[] }
+export async function DELETE(req: Request) {
+  try {
+    const ref = await getCartRef();
+    if (!ref) return fail("Carrinho não encontrado.", 404);
+    const { cartItemIds } = await req.json();
+    if (!Array.isArray(cartItemIds) || !cartItemIds.length) return fail("Nenhum item informado.");
+
+    const events = await withStoreClient(async (c) => {
+      const r = await c.removeCartItems(ref.cartId, ref.cartToken, cartItemIds);
+      return r?.cartEvents ?? [];
+    });
+    const full = await withStoreClient((c) => c.getCart(ref.cartId, ref.cartToken));
+    return ok({ cart: await cartResponse(full, events) });
+  } catch (e) {
+    return failFrom(e);
+  }
+}

package/template/app/api/cart/link/route.ts

@@ -0,0 +1,69 @@
+// Link de carrinho: dois modos, pelo mesmo endpoint (URL compartilhável, chamado pelo
+// CartProvider quando os parâmetros aparecem em QUALQUER rota, inclusive /checkout):
+//
+// 1) ?id=<cartId>&token=<cartToken> — RESTAURA um carrinho existente (recuperação de carrinho
+//    abandonado / "continuar em outro aparelho"). Valida o par na Unbox antes de gravar o
+//    cookie — um link velho/inválido nunca derruba o carrinho atual do visitante.
+// 2) ?produtos=SKU:qtd,...&cupom=CODE — monta um carrinho NOVO a partir de SKUs (products.json).
+//
+// Não redireciona; devolve JSON.
+import { withStoreClient } from "@/lib/unbox/store";
+import { getCatalog } from "@/lib/queries";
+import { getCartRef, setCartRef, setRecurFreq } from "@/lib/session";
+import { parseProdutosParam, resolveSkusToItems } from "@/lib/cart-link";
+import { cartResponse } from "@/lib/cart-response";
+import { ok, fail, failFrom } from "@/lib/api";
+
+export const dynamic = "force-dynamic";
+
+export async function POST(req: Request) {
+  const url = new URL(req.url);
+  const id = url.searchParams.get("id");
+  const token = url.searchParams.get("token");
+  const freq = url.searchParams.get("freq");
+  const produtos = url.searchParams.get("produtos");
+  const cupom = url.searchParams.get("cupom");
+
+  // Modo 1: restaurar carrinho existente por id+token — nunca combina com produtos/cupom.
+  if (id && token) {
+    try {
+      const cart = await withStoreClient((c) => c.getCart(id, token));
+      if (!cart) return fail("Carrinho expirado ou link inválido.", 404);
+      await setCartRef({ cartId: id, cartToken: token });
+      // A frequência de assinatura é um campo do pedido (placeOrder), não do carrinho: por
+      // isso ela viaja em cookie — sem isso, um carrinho de assinatura restaurado em outra
+      // sessão mostra "Assinatura" sem frequência e falha no checkout ("Selecione a frequência").
+      if (freq) await setRecurFreq(freq);
+      return ok({ ok: true, cart: await cartResponse(cart) });
+    } catch {
+      // Par inválido/expirado — NÃO grava o cookie, não derruba o carrinho atual do visitante.
+      return fail("Carrinho expirado ou link inválido.", 404);
+    }
+  }
+
+  try {
+    let count = 0;
+    // 1) monta um carrinho novo a partir dos SKUs (se houver)
+    if (produtos) {
+      const skuQtys = parseProdutosParam(produtos);
+      const catalog = await getCatalog({ first: 200 }).catch(() => ({ nodes: [] as any[] }));
+      const nodes = (catalog.nodes ?? []).map((n: any) => n.product ?? n);
+      const items = resolveSkusToItems(skuQtys, nodes);
+      if (items.length) {
+        const cart = await withStoreClient((c) => c.createCart(items));
+        await setCartRef({ cartId: cart.cartId, cartToken: cart.cartToken });
+        count = items.reduce((s, i) => s + i.quantity, 0);
+      }
+    }
+
+    // 2) aplica o cupom no carrinho atual (recém-criado ou o do cookie)
+    if (cupom) {
+      const ref = await getCartRef();
+      if (ref) await withStoreClient((c) => c.applyDiscount(ref.cartId, ref.cartToken, cupom.trim())).catch(() => {});
+    }
+
+    return ok({ ok: true, count });
+  } catch (e) {
+    return failFrom(e, 502);
+  }
+}

package/template/app/api/cart/route.ts

@@ -0,0 +1,113 @@
+// BFF do carrinho. O browser NUNCA fala com a Unbox direto — só com estas rotas same-origin.
+import { withStoreClient } from "@/lib/unbox/store";
+import { UnboxError } from "@/lib/unbox/client";
+import { getCartRef, setCartRef, clearCartRef, setRecurFreq } from "@/lib/session";
+import { cartResponse } from "@/lib/cart-response";
+import { getShopData } from "@/lib/queries";
+import { ok, fail, failFrom } from "@/lib/api";
+import type { CartItemInput } from "@/lib/unbox/types";
+
+export const dynamic = "force-dynamic";
+
+// GET /api/cart → reidrata o carrinho do cookie ({cartId, cartToken})
+export async function GET() {
+  try {
+    const ref = await getCartRef();
+    if (!ref) return ok({ cart: null });
+    const cart = await withStoreClient((c) => c.getCart(ref.cartId, ref.cartToken));
+    if (!cart) {
+      // A query respondeu OK mas sem carrinho → o cartId/cartToken realmente não existe mais.
+      await clearCartRef();
+      return ok({ cart: null });
+    }
+    return ok({ cart: await cartResponse(cart) });
+  } catch (e) {
+    // Só limpa o cookie quando o erro CONFIRMA que o carrinho/token é inválido — nunca em
+    // falha transitória (timeout, rede, 5xx da Unbox). Limpar nesses casos apagava carrinhos
+    // válidos por uma simples intermitência de rede, forçando o cliente a montar tudo de novo.
+    if (isCartGone(e)) await clearCartRef();
+    return ok({ cart: null });
+  }
+}
+
+// Só considera o carrinho "morto" (cookie deve ser limpo) quando o erro da Unbox indica
+// explicitamente que o cartId/cartToken não é mais válido. Qualquer outra falha (timeout,
+// rede, 5xx, GraphQL genérico) é tratada como transitória — mantém o cookie pra tentar de novo.
+function isCartGone(e: unknown): boolean {
+  if (e instanceof UnboxError) {
+    const msg = (e.errors?.[0]?.message ?? e.message ?? "").toUpperCase();
+    // SÓ códigos do CARRINHO. UNAUTHENTICATED/ACCESS_DENIED são o token da LOJA expirado ou a
+    // Unbox Auth instável — transitório. Tratá-los como "carrinho morto" apagava o cookie de
+    // TODOS os visitantes numa rotação de senha ou numa oscilação da API.
+    return /NOT_FOUND|INVALID_TOKEN|INVALID_CART|CART_EXPIRED/.test(msg);
+  }
+  return false;
+}
+
+// POST /api/cart → adiciona itens (cria o carrinho se ainda não existir)
+//
+// ═══ ASSINATURA (item recorrente) — leia antes de montar o payload ═══
+// `isRecurring: true` no item SOZINHO não assina nada: sem `recurringItemsFrequencyId` o
+// pedido é aceito e registrado como compra avulsa, sem erro. Os dois sempre juntos:
+//   1. item com `isRecurring: true`  +  2. `recurringItemsFrequencyId` (id vindo de
+//   shop.recurringOrdersPolicy.allowedFrequencies) no body.
+// O desconto de assinante REAL é shop.recurringOrdersPolicy.pricingPolicy
+// ({ type: "PERCENTAGE_OFF", value: N }) — nunca invente o percentual no front.
+// Implementação de referência: components/landing/product-picker.tsx (monta os dois campos).
+export async function POST(req: Request) {
+  try {
+    const body = await req.json();
+    let items: CartItemInput[] = body.items ?? [];
+    if (!items.length) return fail("Nenhum item informado.");
+    // A Unbox valida `thumbnail` como URI absoluta — path relativo ("/produto.png") derruba o
+    // addCartItems inteiro com `"[0].thumbnail" must be a valid uri`. Melhor sem thumbnail
+    // (o carrinho renderiza placeholder) do que carrinho quebrado.
+    items = items.map(({ thumbnail, ...it }) => /^https?:\/\//.test(thumbnail ?? "") ? { ...it, thumbnail } : it);
+    // A frequência NÃO entra no carrinho (input não aceita); guardamos em cookie p/ o placeOrder.
+    const recurringItemsFrequencyId: string | undefined = body.recurringItemsFrequencyId;
+
+    let ref = await getCartRef();
+    const result = await withStoreClient(async (c) => {
+      if (!ref) {
+        const created = await c.createCart(items);
+        ref = { cartId: created.cartId, cartToken: created.cartToken };
+        return { quantityFailures: failuresOf(created) };
+      }
+      const added = await c.addCartItems(ref.cartId, ref.cartToken, items);
+      return { quantityFailures: failuresOf(added) };
+    });
+
+    if (ref) await setCartRef(ref);
+    // Item recorrente SEM frequência vira "Frequência: Não selecionada" no checkout, em vermelho,
+    // com o preço já descontado (caso real em produção). As telas que adicionam ao carrinho
+    // decidem `isRecurring` e a frequência em expressões separadas, então basta a fonte da
+    // frequência estar vazia num instante para sair uma sem a outra, e o sintoma só aparece no
+    // fim. Quando dois campos só fazem sentido juntos, quem garante o par é o servidor: ele
+    // sempre sabe a política da loja.
+    if (items.some((it) => it.isRecurring)) {
+      let freq = recurringItemsFrequencyId;
+      if (!freq) {
+        const shop = await getShopData().catch(() => null);
+        freq = shop?.recurringOrdersPolicy?.allowedFrequencies?.[0]?._id;
+      }
+      if (freq) await setRecurFreq(freq);
+    }
+    const full = await withStoreClient((c) => c.getCart(ref!.cartId, ref!.cartToken));
+    return ok({ cart: await cartResponse(full), warnings: result.quantityFailures });
+  } catch (e) {
+    return failFrom(e);
+  }
+}
+
+// DELETE /api/cart → esvazia o carrinho (limpa o cookie)
+export async function DELETE() {
+  await clearCartRef();
+  return ok({ cart: null });
+}
+
+function failuresOf(r: any): string[] {
+  const out: string[] = [];
+  for (const f of r?.minOrderQuantityFailures ?? []) out.push(`Quantidade mínima: ${f.minOrderQuantity}.`);
+  for (const f of r?.maxOrderQuantityFailures ?? []) out.push(`Quantidade máxima: ${f.maxOrderQuantity}.`);
+  return out;
+}