Profit per customer

await guard.recordRevenue({
  endUserId: 'user_abc123',
  amountUsd: 49.0,                       // negative for refunds
  occurredAt: '2026-10-01T09:30:00Z',    // optional, defaults to now
  externalId: 'in_1PqXyZ',               // optional idempotency key
});

guard.record_revenue(
    end_user_id="user_abc123",
    amount_usd=49.0,                      # negative for refunds
    occurred_at="2026-10-01T09:30:00Z",   # optional, defaults to now
    external_id="in_1PqXyZ",              # optional idempotency key
)

import express from 'express';
import Stripe from 'stripe';
import { NoburnGuard } from '@noburn/sdk';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const guard = new NoburnGuard({
  apiKey: process.env.NOBURN_API_KEY!,
  projectId: process.env.NOBURN_PROJECT_ID!,
});

/** Map a Stripe customer to the id you pass to check()/record(). */
async function endUserIdFor(
  customer: string | Stripe.Customer | Stripe.DeletedCustomer | null,
): Promise<string | undefined> {
  if (!customer) return undefined;
  // Replace with a lookup in your own database if you store the mapping there.
  const c = typeof customer === 'string' ? await stripe.customers.retrieve(customer) : customer;
  return c.deleted ? undefined : c.metadata.app_user_id;
}

const app = express();

// Stripe needs the raw body to verify the signature.
app.post('/webhooks/stripe', express.raw({ type: 'application/json' }), async (req, res) => {
  let event: Stripe.Event;
  try {
    event = stripe.webhooks.constructEvent(
      req.body,
      req.headers['stripe-signature'] as string,
      process.env.STRIPE_WEBHOOK_SECRET!,
    );
  } catch {
    return res.status(400).send('Invalid signature');
  }

  try {
    if (event.type === 'invoice.paid') {
      const invoice = event.data.object;
      // Amounts are in the currency's smallest unit; only USD is cents → dollars.
      if (invoice.currency === 'usd' && invoice.amount_paid > 0) {
        const endUserId = await endUserIdFor(invoice.customer);
        if (endUserId) {
          await guard.recordRevenue({
            endUserId,
            amountUsd: invoice.amount_paid / 100,
            occurredAt: new Date(event.created * 1000).toISOString(),
            externalId: invoice.id, // idempotent across Stripe retries
          });
        }
      }
    }

    if (event.type === 'charge.refunded') {
      // The event carries a Charge. List its refunds and record each one as a
      // negative amount; refund ids make re-deliveries and repeat refunds safe.
      const charge = event.data.object;
      if (charge.currency === 'usd') {
        const endUserId = await endUserIdFor(charge.customer);
        if (endUserId) {
          const refunds = await stripe.refunds.list({ charge: charge.id, limit: 100 });
          for (const refund of refunds.data) {
            if (refund.status !== 'succeeded') continue;
            await guard.recordRevenue({
              endUserId,
              amountUsd: -(refund.amount / 100),
              occurredAt: new Date(refund.created * 1000).toISOString(),
              externalId: refund.id,
            });
          }
        }
      }
    }
  } catch (err) {
    // Only NoburnAuthError (bad SDK key) or a Stripe API error can land here.
    // Answer 500 so Stripe retries after you fix it; external ids prevent double-counting.
    console.error('stripe webhook: failed to record revenue', err);
    return res.status(500).send('Failed to record revenue');
  }

  res.json({ received: true });
});

import asyncio
import os
from datetime import datetime, timezone
from typing import Optional

import stripe
from fastapi import FastAPI, HTTPException, Request
from noburn import NoburnAuthError, NoburnGuard

stripe.api_key = os.environ["STRIPE_SECRET_KEY"]
guard = NoburnGuard(
    api_key=os.environ["NOBURN_API_KEY"],
    project_id=os.environ["NOBURN_PROJECT_ID"],
)

app = FastAPI()


def iso(ts: int) -> str:
    return datetime.fromtimestamp(ts, tz=timezone.utc).isoformat().replace("+00:00", "Z")


def end_user_id_for(customer_id: Optional[str]) -> Optional[str]:
    """Map a Stripe customer to the id you pass to check()/record().

    Blocking network call: run it with asyncio.to_thread from async code.
    Replace with a lookup in your own database if you store the mapping there.
    """
    if not customer_id:
        return None
    customer = stripe.Customer.retrieve(customer_id)
    if getattr(customer, "deleted", False):
        return None
    return getattr(customer.metadata, "app_user_id", None)


@app.post("/webhooks/stripe")
async def stripe_webhook(request: Request):
    payload = await request.body()  # raw body, needed for the signature check
    try:
        event = stripe.Webhook.construct_event(
            payload,
            request.headers.get("stripe-signature"),
            os.environ["STRIPE_WEBHOOK_SECRET"],
        )
    except (ValueError, stripe.SignatureVerificationError):
        raise HTTPException(status_code=400, detail="Invalid signature")

    try:
        if event.type == "invoice.paid":
            invoice = event.data.object
            # Amounts are in the currency's smallest unit; only USD is cents → dollars.
            if invoice.currency == "usd" and invoice.amount_paid > 0:
                end_user_id = await asyncio.to_thread(end_user_id_for, invoice.customer)
                if end_user_id:
                    guard.record_revenue(  # non-blocking: queued for the background worker
                        end_user_id=end_user_id,
                        amount_usd=invoice.amount_paid / 100,
                        occurred_at=iso(event.created),
                        external_id=invoice.id,  # idempotent across Stripe retries
                    )

        elif event.type == "charge.refunded":
            # The event carries a Charge. List its refunds and record each one
            # as a negative amount; refund ids make re-deliveries safe.
            charge = event.data.object
            if charge.currency == "usd":
                end_user_id = await asyncio.to_thread(end_user_id_for, charge.customer)
                if end_user_id:
                    refunds = await asyncio.to_thread(
                        stripe.Refund.list, charge=charge.id, limit=100
                    )
                    for refund in refunds.data:
                        if refund.status != "succeeded":
                            continue
                        guard.record_revenue(
                            end_user_id=end_user_id,
                            amount_usd=-(refund.amount / 100),
                            occurred_at=iso(refund.created),
                            external_id=refund.id,
                        )
    except (NoburnAuthError, stripe.StripeError):
        # Answer 500 so Stripe retries after you fix it; external ids prevent
        # double-counting.
        raise HTTPException(status_code=500, detail="Failed to record revenue")

    return {"received": True}