@neetru/cli 2.25.0 → 2.26.0

package/templates/billing/checkout.ts

@@ -1,22 +1,38 @@
 /**
- * Template — `src/lib/neetru/billing/checkout.ts` (gerado por `neetru add billing`).
+ * Template — `src/app/api/billing/checkout/route.ts` (gerado por `neetru add billing`).
  *
- * Inicia checkout Stripe via Core. Server route handler.
+ * Inicia checkout Stripe via SDK server-side. O cliente chama este endpoint
+ * com { planId, productId } e recebe a URL de redirecionamento pro Stripe.
+ *
+ * Pré-requisito: NEETRU_API_KEY e NEETRU_PRODUCT_ID no .env.local.
  */
 import { NextRequest, NextResponse } from 'next/server';
+import { createNeetruClient } from '@neetru/sdk';
 
 export const runtime = 'nodejs';
 
 export async function POST(request: NextRequest) {
   const body = await request.json();
-  const slug = body?.slug as string | undefined;
-  if (!slug) {
-    return NextResponse.json({ error: 'slug required' }, { status: 400 });
+  const { planId, productId } = body ?? {};
+  const pid = productId || process.env.NEETRU_PRODUCT_ID;
+
+  if (!planId || !pid) {
+    return NextResponse.json(
+      { error: 'planId e productId obrigatórios' },
+      { status: 400 },
+    );
   }
 
-  // Hit Core REST: POST /api/v1/billing/checkout
-  // (Sprint 9 expõe via SDK direto)
-  return NextResponse.json({
-    redirectUrl: `https://minhaconta.neetru.com/checkout?slug=${slug}`,
+  const client = createNeetruClient({
+    apiKey: process.env.NEETRU_API_KEY!,
+    productId: pid,
   });
+
+  const result = await client.checkout.start({
+    productId: pid,
+    planId,
+    callbackUrl: `${process.env.NEXT_PUBLIC_APP_URL ?? 'http://localhost:3000'}/billing/success`,
+  });
+
+  return NextResponse.json({ redirectUrl: result.redirectUrl });
 }

package/templates/billing/page.tsx

@@ -1,40 +1,81 @@
 /**
- * Template — `src/lib/neetru/billing/page.tsx` (gerado por `neetru add billing`).
+ * Template — `src/app/(marketing)/billing/page.tsx` (gerado por `neetru add billing`).
  *
- * Página simples: lista planos + botão checkout via SDK.
+ * Página de planos: lista os planos do produto e usa <CheckoutLink> do SDK
+ * pra redirecionar ao Stripe. O <CheckoutLink> usa OIDC — o usuário precisa
+ * estar logado (veja `neetru add auth`).
+ *
+ * Pré-requisito: NEXT_PUBLIC_NEETRU_API_KEY e NEXT_PUBLIC_NEETRU_PRODUCT_ID
+ * no .env.local.
  */
 'use client';
 
+import { createNeetruClient } from '@neetru/sdk';
+import { CheckoutLink } from '@neetru/sdk/react';
 import { useEffect, useState } from 'react';
-import { createNeetruClient, type Product } from '@neetru/sdk';
 
 const client = createNeetruClient({
-  apiKey: process.env.NEXT_PUBLIC_NEETRU_API_KEY,
+  apiKey: process.env.NEXT_PUBLIC_NEETRU_API_KEY!,
+  productId: process.env.NEXT_PUBLIC_NEETRU_PRODUCT_ID!,
 });
 
+interface Plan {
+  id: string;
+  name: string;
+  description: string;
+  price: string;
+  slug: string;
+}
+
 export default function BillingPage() {
-  const [products, setProducts] = useState<Product[]>([]);
+  const [plans, setPlans] = useState<Plan[]>([]);
+  const [loading, setLoading] = useState(true);
+
   useEffect(() => {
     client.catalog
       .list()
-      .then(({ products }) => setProducts(products))
-      .catch((err) => console.error(err));
+      .then(({ products }) => {
+        const product = products.find(
+          (p) => p.id === process.env.NEXT_PUBLIC_NEETRU_PRODUCT_ID,
+        );
+        setPlans(
+          product?.plans?.map((plan: { id: string; name: string; description?: string; amount?: number; interval?: string; slug?: string }) => ({
+            id: plan.id,
+            name: plan.name,
+            description: plan.description ?? '',
+            price: plan.amount ? `R$ ${(plan.amount / 100).toFixed(2)}/${plan.interval ?? 'mês'}` : 'Sob consulta',
+            slug: plan.slug ?? plan.id,
+          })) ?? [],
+        );
+      })
+      .catch(console.error)
+      .finally(() => setLoading(false));
   }, []);
 
+  if (loading) return <main className="p-8"><p>Carregando planos...</p></main>;
+
   return (
     <main className="p-8">
       <h1 className="text-3xl font-bold mb-6">Planos</h1>
       <div className="grid gap-4 md:grid-cols-3">
-        {products.map((p) => (
-          <article key={p.slug} className="border p-6">
-            <h2 className="text-xl font-semibold">{p.name}</h2>
-            <p className="text-sm text-zinc-600 mt-1">{p.tagline}</p>
-            <a
-              href={`/checkout?slug=${p.slug}`}
-              className="inline-block mt-4 px-4 py-2 bg-zinc-900 text-white"
+        {plans.map((plan) => (
+          <article key={plan.id} className="border p-6 flex flex-col gap-4">
+            <div>
+              <h2 className="text-xl font-semibold">{plan.name}</h2>
+              <p className="text-2xl font-bold mt-2">{plan.price}</p>
+              {plan.description && (
+                <p className="text-sm text-zinc-600 mt-1">{plan.description}</p>
+              )}
+            </div>
+            <CheckoutLink
+              client={client}
+              productId={process.env.NEXT_PUBLIC_NEETRU_PRODUCT_ID!}
+              planId={plan.id}
+              callbackUrl={`${typeof window !== 'undefined' ? window.location.origin : ''}/billing/success`}
+              className="inline-block mt-auto px-4 py-2 bg-zinc-900 text-white text-center"
             >
               Assinar
-            </a>
+            </CheckoutLink>
           </article>
         ))}
       </div>

package/templates/billing/webhooks.ts

@@ -0,0 +1,83 @@
+/**
+ * Template — `src/app/api/webhooks/neetru/route.ts` (gerado por `neetru add billing`).
+ *
+ * Recebe webhooks do Neetru Core: subscription.activated, .cancelled,
+ * .payment_failed, .trial_ending e outros.
+ *
+ * O secret HMAC deve bater com o registrado via `neetru webhooks register`
+ * ou com NEETRU_WEBHOOK_SECRET no .env.local (dev).
+ *
+ * Pré-requisito: registrar o endpoint via:
+ *   neetru webhooks register --product-id <id> --url <URL> --events subscription.activated,subscription.cancelled,subscription.payment_failed
+ */
+import { NextRequest, NextResponse } from 'next/server';
+import { verifyWebhookRequest } from '@neetru/sdk/webhooks';
+
+export const runtime = 'nodejs';
+
+const WEBHOOK_SECRET = process.env.NEETRU_WEBHOOK_SECRET;
+
+interface WebhookPayload {
+  type: string;
+  data: Record<string, unknown>;
+  timestamp?: string;
+}
+
+async function handleSubscriptionActivated(data: Record<string, unknown>) {
+  const { subscriptionId, productId, tenantId } = data as Record<string, string>;
+  console.log('Assinatura ativada:', { subscriptionId, productId, tenantId });
+}
+
+async function handleSubscriptionCancelled(data: Record<string, unknown>) {
+  const { subscriptionId, productId, tenantId } = data as Record<string, string>;
+  console.log('Assinatura cancelada:', { subscriptionId, productId, tenantId });
+}
+
+async function handleSubscriptionPaymentFailed(data: Record<string, unknown>) {
+  const { subscriptionId, productId, tenantId } = data as Record<string, string>;
+  console.log('Pagamento falhou:', { subscriptionId, productId, tenantId });
+}
+
+async function handleTrialEnding(data: Record<string, unknown>) {
+  const { subscriptionId, productId, tenantId } = data as Record<string, string>;
+  console.log('Trial terminando:', { subscriptionId, productId, tenantId });
+}
+
+const HANDLERS: Record<string, (data: Record<string, unknown>) => Promise<void>> = {
+  'subscription.activated': handleSubscriptionActivated,
+  'subscription.cancelled': handleSubscriptionCancelled,
+  'subscription.payment_failed': handleSubscriptionPaymentFailed,
+  'subscription.trial_ending': handleTrialEnding,
+};
+
+export async function POST(request: NextRequest) {
+  if (!WEBHOOK_SECRET) {
+    return NextResponse.json(
+      { error: 'NEETRU_WEBHOOK_SECRET não configurado' },
+      { status: 500 },
+    );
+  }
+
+  const rawBody = await request.text();
+  const signature = request.headers.get('x-neetru-signature') ?? '';
+  const timestamp = request.headers.get('x-neetru-timestamp') ?? '';
+
+  const isValid = verifyWebhookRequest(rawBody, signature, WEBHOOK_SECRET, { timestamp });
+  if (!isValid) {
+    return NextResponse.json({ error: 'invalid_signature' }, { status: 401 });
+  }
+
+  let payload: WebhookPayload;
+  try {
+    payload = JSON.parse(rawBody);
+  } catch {
+    return NextResponse.json({ error: 'invalid_json' }, { status: 400 });
+  }
+
+  const handler = HANDLERS[payload.type];
+  if (handler) {
+    await handler(payload.data);
+  }
+
+  return NextResponse.json({ ok: true });
+}