cloudbroker-sdk 0.5.0 → 0.6.0

package/.github/workflows/publish.yml

@@ -4,7 +4,16 @@ on:
   push:
     branches: [main]
     paths:
+      # Sem barra inicial: filtros de path do GitHub Actions são relativos à
+      # raiz do repo e '/package.json' não casa com nada — o workflow deixou de
+      # disparar por completo (o 0.6.0 foi mergeado e nunca publicado).
+      # 'package.json' já cobre só a raiz: sem '**', o glob não atravessa
+      # diretórios, que era a intenção original de ancorar.
       - 'package.json'
+  # Escape hatch: quando o filtro acima não dispara (foi o caso do 0.6.0, que
+  # entrou no main sem publicar), dá pra publicar a versão que está no main sem
+  # precisar de um bump artificial só pra acionar o gatilho.
+  workflow_dispatch:
 
 jobs:
   publish:
@@ -22,6 +31,15 @@ jobs:
           node-version: 20
           registry-url: 'https://registry.npmjs.org'
 
+      # Gate de teste antes do publish — este pacote roda DENTRO da aplicação
+      # de produção do cliente; publicar sem rodar a suíte já era um risco
+      # aberto (nenhum CI de teste existia neste repo).
+      - name: Instalar dependências de teste
+        run: npm ci || npm install
+
+      - name: Rodar testes
+        run: npm test
+
       - name: Publish to npm
         run: npm publish
         env:

package/README.md

@@ -106,14 +106,17 @@ CloudBrokerAI.trackDeploy("cb-key-xxxx", {
 });
 ```
 
-## Custo de nuvem a nível de código (MVP)
+## Cost per Feature — Rastreie Custo por Feature
 
-Atribua custo de **AWS** a um trecho de código / produto. O SDK envolve um client
-do AWS SDK v3 e, a cada `.send()`, estima o custo (requests + transferência) e
+Atribua custo de **AWS** e **Azure** a cada feature/módulo sua. O SDK envolve um
+client do provedor e, a cada chamada, estima o custo (requests + transferência) e
 registra um evento — mesmo padrão fire-and-forget do wrapper de IA.
 
-> MVP: AWS apenas, serviços **S3** e **DynamoDB**, região `us-east-2`. Armazenamento
-> GB-mês, Azure e atribuição automática (stack-trace) estão fora do MVP.
+**👉 [Guia Completo](./docs/COST_PER_FEATURE.md)** — Setup (5 min), exemplos, FAQ.
+
+> Escopo atual — AWS: **S3** e **DynamoDB** (`us-east-2`); Azure: **Blob Storage**
+> e **Cosmos DB** (`eastus2`). Armazenamento GB-mês e atribuição automática
+> (stack-trace) estão fora do MVP.
 
 ```js
 import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
@@ -146,6 +149,81 @@ Cada chamada gera um evento `POST /api/cloud/events` com `service`, `operation`,
 `product`, `team`, `label`, `requests`, `bytesIn`/`bytesOut`, `costUSD` estimado e
 `latencyMs`. O `cbLabel` nunca é repassado ao AWS SDK.
 
+### Azure — Blob Storage e Cosmos DB
+
+O Azure SDK não tem um `.send()` único como o AWS SDK v3: cada sub-client tem
+métodos próprios. Por isso o `wrapAzure` intercepta a **cadeia de sub-clients** —
+as fábricas (`getContainerClient`, `database`/`container`) devolvem sub-clients já
+embrulhados, e só os métodos de data-plane conhecidos são rastreados. Qualquer
+método fora dessa lista passa intocado.
+
+```js
+import { BlobServiceClient } from "@azure/storage-blob";
+import { CloudBrokerCloud } from "cloudbroker-sdk";
+
+const blobSvc = CloudBrokerCloud.wrapAzure(
+  BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION),
+  { apiKey: "cb-key-xxxx", product: "checkout", team: "mobile" },
+);
+
+// label opcional dentro do objeto de options nativo do método
+await blobSvc
+  .getContainerClient("docs")
+  .getBlockBlobClient("nf.pdf")
+  .uploadData(buf, { cbLabel: "upload-nota-fiscal" });
+```
+
+Cosmos DB usa o **`requestCharge` (RUs) real** que o servidor devolve em cada
+resposta — custo por unidade cobrada de verdade, não aproximação por request:
+
+```js
+import { CosmosClient } from "@azure/cosmos";
+
+const cosmos = CloudBrokerCloud.wrapAzure(new CosmosClient(conn), {
+  apiKey: "cb-key-xxxx", product: "checkout",
+});
+const orders = cosmos.database("loja").container("pedidos");
+
+await orders.items.create({ id: "123" }, { cbLabel: "criar-pedido" });
+await orders.items.query("SELECT * FROM c").fetchAll(); // RUs do query também contam
+```
+
+O `expressMiddleware` (abaixo) funciona igual pros dois provedores — mesma
+prioridade de `label`/`product`/`team`, sem precisar de `cbLabel` manual.
+
+> **Precisão e premissas — leia antes de tratar o número como fechado:**
+>
+> - **Cosmos:** as RUs são as **reais** devolvidas pelo servidor em cada resposta
+>   (`requestCharge`). O **preço por RU** assume o modelo **serverless**. Em
+>   *throughput provisionado* (manual ou autoscale) a Azure cobra RU/s reservada
+>   por hora, independentemente do consumo — esse modelo ainda não é representado,
+>   então o custo calculado não corresponde à fatura nesse caso.
+> - **Blob:** estimado por classe de operação (write/read/list), assumindo tier
+>   **Hot** e redundância **LRS**. Cool/Archive e GRS/ZRS têm outro preço.
+> - **Transferência de saída:** cobrada sobre todo `bytesOut`. A Azure não cobra
+>   saída intra-região e concede franquia mensal — para um app rodando na mesma
+>   região do Storage, este termo **superestima**.
+> - **Região:** só `eastus2` tem tabela de preço. Em outra região o evento é
+>   registrado com `costUSD: null` e `billingUnit: "*-region-unpriced"` — a
+>   operação aparece no relatório, mas sem custo inventado.
+> - **Reconciliação:** a tela compara o estimado contra o custo real do Cost
+>   Management e mostra o **desvio**; o ajuste da tabela é manual (não há
+>   recalibração automática).
+> - **Listagem:** `listBlobsFlat`/`listContainers` devolvem iterator preguiçoso —
+>   o evento só é emitido quando uma página é de fato buscada. Percorrendo com
+>   `for await`, contamos **1 operação** mesmo que o SDK pagine internamente;
+>   use `.byPage()` para contagem por página.
+> - **Cosmos `for await` direto** (`getAsyncIterator`) não é instrumentado —
+>   use `fetchAll()`/`fetchNext()`.
+> - **Delete** no tier Hot é grátis: sai com custo `0` e
+>   `billingUnit: "blob-free"`, sem sumir do relatório.
+>
+> ⚠️ **Ainda não calibrado contra uma fatura Azure real.** A estrutura é
+> exercitada contra os SDKs oficiais (`@azure/storage-blob`, `@azure/cosmos`) na
+> suíte de testes, mas os valores da tabela de preço Azure não foram conferidos
+> contra a página oficial nem contra uma fatura. Trate o custo Azure como ordem
+> de grandeza até rodar a reconciliação na sua conta.
+
 ### Atribuição automática por requisição (Express)
 
 Em vez de passar `cbLabel` em cada `.send()`, use o middleware: todas as chamadas

package/docs/COST_PER_FEATURE.md

@@ -0,0 +1,296 @@
+# CloudBroker SDK — Rastreie Custo por Feature
+
+## O Que É?
+
+Instrumentar sua aplicação com o CloudBroker SDK permite rastrear **quanto cada feature/módulo seu custa em AWS e Azure**.
+
+```javascript
+// Seu código
+await s3.putObject({ ... }, { cbLabel: 'invoice-generation' });
+// CloudBroker registra: feature 'invoice-generation' custou $0.00042
+```
+
+**Result:** Dashboard mostra "invoice-generation: $X/mês".
+
+---
+
+## Setup Rápido (5 minutos)
+
+### 1. Instalar
+
+```bash
+npm install cloudbroker-sdk
+```
+
+### 2. Gerar API Key
+
+1. Acesse https://app.cloudbroker.app.br
+2. Configurações → API Keys
+3. Criar nova key do tipo **SDK** (só Admin pode criar keys SDK)
+4. Copiar: `cb_live_...` — **o valor é exibido uma única vez**; depois só o
+   prefixo mascarado fica visível. Se perder, gere outra.
+
+### 3. Instrumentar Backend
+
+```javascript
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, PutCommand } from "@aws-sdk/lib-dynamodb";
+import { CloudBrokerCloud } from "cloudbroker-sdk";
+
+// S3
+const s3 = CloudBrokerCloud.wrapAWS(new S3Client({ region: "us-east-2" }), {
+  apiKey: process.env.CLOUDBROKER_API_KEY,
+  product: "checkout-service",  // seu app
+  team: "payments",             // seu squad
+});
+
+// DynamoDB
+const dynamodb = CloudBrokerCloud.wrapAWS(
+  DynamoDBDocumentClient.from(new DynamoDBClient({ region: "us-east-2" })),
+  { apiKey: process.env.CLOUDBROKER_API_KEY, product: "checkout-service", team: "payments" }
+);
+```
+
+### 4. Adicionar Labels
+
+```javascript
+// S3 upload com label
+await s3.send(new PutObjectCommand({
+  Bucket: 'invoices',
+  Key: `${orderId}.pdf`,
+  Body: pdfBuffer,
+}), {
+  cbLabel: 'invoice-generation',  // ← Identifica a feature
+});
+
+// DynamoDB insert com label
+await dynamodb.send(new PutCommand({
+  TableName: 'Orders',
+  Item: { orderId, status: 'pending' },
+}), {
+  cbLabel: 'order-processing',  // ← Identifica a feature
+});
+```
+
+### 5. Ver Custos
+
+Dashboard: **CloudBroker App → Custo por Código**
+
+```
+Feature: order-processing
+  Requests: 3,456
+  Total: $87.50
+  Per Request: $0.0253 ✅
+
+Feature: invoice-generation
+  Requests: 1,234
+  Total: $10.20
+  Per Request: $0.00828 ✅
+```
+
+---
+
+## Azure — Blob Storage e Cosmos DB
+
+O SDK da Azure não tem um `.send()` único como o AWS SDK v3, então o `wrapAzure`
+intercepta a **cadeia de sub-clients**: as fábricas (`getContainerClient`,
+`database`/`container`) devolvem sub-clients já instrumentados.
+
+```javascript
+import { BlobServiceClient } from "@azure/storage-blob";
+import { CloudBrokerCloud } from "cloudbroker-sdk";
+
+const blobSvc = CloudBrokerCloud.wrapAzure(
+  BlobServiceClient.fromConnectionString(process.env.AZURE_STORAGE_CONNECTION),
+  { apiKey: "cb_live_...", product: "checkout", team: "mobile" },
+);
+
+await blobSvc
+  .getContainerClient("docs")
+  .getBlockBlobClient("nf.pdf")
+  .uploadData(buf, { cbLabel: "upload-nota-fiscal" });
+```
+
+Cosmos DB usa o `requestCharge` (RUs) **real** devolvido pelo servidor:
+
+```javascript
+import { CosmosClient } from "@azure/cosmos";
+
+const cosmos = CloudBrokerCloud.wrapAzure(new CosmosClient(conn), {
+  apiKey: "cb_live_...", product: "checkout",
+});
+const pedidos = cosmos.database("loja").container("pedidos");
+
+await pedidos.items.create({ id: "123" }, { cbLabel: "criar-pedido" });
+await pedidos.items.query("SELECT * FROM c").fetchAll();
+```
+
+O `expressMiddleware` funciona igual para AWS e Azure.
+
+**Premissas que mudam o número** (detalhe completo no
+[README](../README.md#cost-per-feature--rastreie-custo-por-feature)):
+
+| Item | Situação |
+|---|---|
+| Cosmos — RUs | Reais (`requestCharge` do servidor) |
+| Cosmos — preço por RU | Assume **serverless**. Throughput provisionado não é modelado |
+| Blob | Estimado por classe de operação; assume tier **Hot** + **LRS** |
+| Egress | Cobrado sobre todo `bytesOut` (a Azure não cobra intra-região) |
+| Região | Só `eastus2` tem preço; outras saem com `costUSD: null` |
+| `for await` no Cosmos | Não instrumentado — use `fetchAll()`/`fetchNext()` |
+| Calibração | ⚠️ **Não conferido contra fatura Azure real ainda** |
+
+---
+
+## Convenção de Labels
+
+Use nomes **descritivos** que refletem features/módulos:
+
+| Feature | Label | Exemplos de Operações |
+|---------|-------|----------------------|
+| Checkout | `order-processing` | Criar pedido, persistir dados |
+| Geração de Invoice | `invoice-generation` | Upload de PDF, armazenamento |
+| Detecção de Fraude | `fraud-detection` | Análise de padrões, lookup histórico |
+| Analytics | `analytics-tracking` | Coleta de eventos, agregação |
+| Admin Panel | `admin-reports` | Geração de relatórios, queries |
+
+**Regras:**
+- ✅ Use labels **finitos** (não criar um label por request)
+- ✅ Labels **descritivos** (não `x1`, `x2`, etc)
+- ✅ Use **kebab-case** (`order-processing`, não `orderProcessing`)
+
+❌ **EVITAR:**
+```javascript
+// Ruim: label infinito (1 por request)
+cbLabel: `order-${order.id}`
+
+// Ruim: não descritivo
+cbLabel: 'x1'
+
+// Bom: finito e descritivo
+cbLabel: 'order-processing'
+```
+
+---
+
+## Exemplo Completo
+
+```javascript
+import express from 'express';
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { DynamoDBDocumentClient, PutCommand } from '@aws-sdk/lib-dynamodb';
+import { CloudBrokerCloud } from 'cloudbroker-sdk';
+
+const app = express();
+
+// Setup
+const s3 = CloudBrokerCloud.wrapAWS(new S3Client(), {
+  apiKey: process.env.CLOUDBROKER_API_KEY,
+  product: 'checkout-service',
+  team: 'payments',
+});
+
+const dynamodb = CloudBrokerCloud.wrapAWS(
+  DynamoDBDocumentClient.from(new DynamoDBClient()),
+  { apiKey: process.env.CLOUDBROKER_API_KEY, product: 'checkout-service', team: 'payments' }
+);
+
+// POST /orders — cria pedido com 2 features diferentes
+app.post('/orders', async (req, res) => {
+  const order = { orderId: `order-${Date.now()}`, ...req.body };
+
+  // Feature 1: Persistir pedido
+  await dynamodb.send(new PutCommand({
+    TableName: 'Orders',
+    Item: order,
+  }), {
+    cbLabel: 'order-processing',
+  });
+
+  // Feature 2: Gerar invoice
+  await s3.send(new PutObjectCommand({
+    Bucket: 'invoices',
+    Key: `${order.orderId}.json`,
+    Body: JSON.stringify(order),
+  }), {
+    cbLabel: 'invoice-generation',
+  });
+
+  res.json({ ok: true, orderId: order.orderId });
+});
+
+app.listen(3000);
+```
+
+**Result no Dashboard:**
+- `order-processing`: $X/mês
+- `invoice-generation`: $Y/mês
+
+---
+
+## FAQ
+
+**P: Quanto tempo leva pra aparecer no dashboard?**
+A: ~5 minutos (batch em DynamoDB).
+
+**P: E se não colocar label?**
+A: Ainda rastreia como `null` (agrupa sem label).
+
+**P: Posso mudar o label depois?**
+A: Não — é histórico. Use um novo label a partir de agora.
+
+**P: Qual é o overhead?**
+A: <1% CPU (fire-and-forget, não bloqueia requests).
+
+**P: Funciona em todas as regiões?**
+A: Hoje há tabela de preço para `us-east-2` (AWS) e `eastus2` (Azure). Em outra
+região a operação é registrada com `costUSD: null` e `billingUnit`
+`*-region-unpriced` — aparece no relatório, mas sem custo estimado (preferimos
+não exibir o preço de outra região como se fosse o seu).
+
+**P: E se der erro no rastreamento?**
+A: Silencioso — seu request continua normal (fail-soft).
+
+---
+
+## Troubleshooting
+
+### Nenhum dado aparecendo no dashboard?
+
+1. ✅ API Key configurada?
+   ```bash
+   echo $CLOUDBROKER_API_KEY
+   ```
+
+2. ✅ CloudBrokerCloud.wrapAWS() chamado?
+   ```javascript
+   const s3 = CloudBrokerCloud.wrapAWS(new S3Client(), { apiKey, product, team });
+   ```
+
+3. ✅ cbLabel adicionado?
+   ```javascript
+   await s3.send(cmd, { cbLabel: 'seu-label' });
+   ```
+
+4. ✅ Esperou 5+ minutos?
+   (CloudBroker faz batch, não é real-time)
+
+### Custo aparecendo como $0?
+
+- Normal no MVP (estimativa simplificada, reconciliação depois)
+- Operações muito baratas podem ficar abaixo do centavo
+
+---
+
+## Próximos Passos
+
+- **Exemplo funcional:** Veja `example-checkout-app` no repo
+- **Mais Serviços:** Lambda, SQS, SNS; Azure Functions, Service Bus (roadmap)
+- **OpenTelemetry:** Rastrear custom operations (futuro)
+
+---
+
+## Suporte
+
+Dúvidas? Abra issue no [GitHub](https://github.com/cloudbroker-app/cloudbroker-sdk).

package/example-checkout-app/.env.example

@@ -0,0 +1,13 @@
+# AWS Configuration
+AWS_REGION=us-east-2
+AWS_ACCESS_KEY_ID=your-access-key
+AWS_SECRET_ACCESS_KEY=your-secret-key
+
+# CloudBroker Configuration
+CLOUDBROKER_API_KEY=sk_1234...
+CLOUDBROKER_PRODUCT=checkout-example
+CLOUDBROKER_TEAM=platform
+
+# App Configuration
+PORT=3000
+NODE_ENV=development

package/example-checkout-app/README.md

@@ -0,0 +1,225 @@
+# CloudBroker SDK Example — Checkout Service
+
+Exemplo funcional de como instrumentar um serviço de checkout com CloudBroker SDK para rastrear custo por feature.
+
+## O Que Faz
+
+Este app de exemplo mostra 5 features sendo rastreadas:
+
+| Feature | Route | Operation | Label |
+|---------|-------|-----------|-------|
+| **Order Processing** | POST /orders | DynamoDB PutItem | `order-processing` |
+| **Invoice Generation** | POST /orders | S3 PutObject | `invoice-generation` |
+| **Order Retrieval** | GET /orders/:id | DynamoDB GetItem | `order-retrieval` |
+| **Fraud Detection** | POST /verify-fraud | DynamoDB GetItem | `fraud-detection` |
+| **Analytics Tracking** | POST /analytics | DynamoDB PutItem | `analytics-tracking` |
+
+Cada feature rastreia seu custo AWS separadamente — depois você pode ver no dashboard CloudBroker quanto cada uma custou.
+
+## Setup (5 minutos)
+
+### 1. Instalar Dependências
+
+```bash
+npm install
+```
+
+### 2. Configurar Credenciais
+
+```bash
+cp .env.example .env
+# Editar .env com suas credenciais AWS + CloudBroker API Key
+```
+
+**Campos obrigatórios:**
+- `AWS_ACCESS_KEY_ID` — sua chave AWS
+- `AWS_SECRET_ACCESS_KEY` — seu secret AWS
+- `CLOUDBROKER_API_KEY` — sua API key CloudBroker (obter em app.cloudbroker.app.br)
+
+### 3. Rodar
+
+```bash
+npm start
+# Saída: ✅ Checkout Example App running on http://localhost:3000
+```
+
+### 4. Testar
+
+```bash
+# Criar pedido (rastreia 2 features)
+curl -X POST http://localhost:3000/orders \
+  -H "Content-Type: application/json" \
+  -d '{
+    "customerId": "cust-123",
+    "items": [{"name": "Widget", "price": 99.99}],
+    "total": 99.99
+  }'
+
+# Resposta:
+# {
+#   "ok": true,
+#   "orderId": "order-1719600600000",
+#   "message": "Order created successfully!..."
+# }
+```
+
+### 5. Ver Custos
+
+1. Acesse https://app.cloudbroker.app.br
+2. Vá a **Custo por Código**
+3. Você verá os labels: `order-processing`, `invoice-generation`, etc
+4. **Nota:** Demora ~5 minutos pro CloudBroker processar os dados
+
+## Exemplos de Uso
+
+### Criar Pedido
+
+```bash
+curl -X POST http://localhost:3000/orders \
+  -H "Content-Type: application/json" \
+  -d '{
+    "customerId": "user-456",
+    "items": [{"name": "Widget A"}, {"name": "Widget B"}],
+    "total": 250.00
+  }'
+```
+
+**O que acontece:**
+1. `order-processing`: DynamoDB registra o pedido
+2. `invoice-generation`: S3 armazena o JSON da invoice
+
+### Recuperar Pedido
+
+```bash
+curl -X GET http://localhost:3000/orders/order-1719600600000
+```
+
+**O que acontece:**
+1. `order-retrieval`: DynamoDB busca o pedido
+2. CloudBroker rastreia o custo dessa operação
+
+### Verificar Fraude
+
+```bash
+curl -X POST http://localhost:3000/verify-fraud \
+  -H "Content-Type: application/json" \
+  -d '{
+    "orderId": "order-123",
+    "customerId": "user-456"
+  }'
+```
+
+**O que acontece:**
+1. `fraud-detection`: DynamoDB consulta perfil do cliente
+2. Retorna score de fraude (0–1)
+
+### Registrar Evento de Analytics
+
+```bash
+curl -X POST http://localhost:3000/analytics \
+  -H "Content-Type: application/json" \
+  -d '{
+    "userId": "user-789",
+    "eventType": "page_view",
+    "data": {"page": "/checkout"}
+  }'
+```
+
+**O que acontece:**
+1. `analytics-tracking`: DynamoDB armazena o evento
+
+## Entendendo os Custos
+
+Depois de ~5 minutos, no dashboard CloudBroker você verá algo assim:
+
+```
+Feature: order-processing
+  Requests: 2
+  Total Cost: $0.000003
+  Cost per Request: $0.0000015
+
+Feature: invoice-generation
+  Requests: 2
+  Total Cost: $0.000002
+  Cost per Request: $0.000001
+
+Feature: order-retrieval
+  Requests: 1
+  Total Cost: $0.00000025
+  Cost per Request: $0.00000025
+
+Feature: fraud-detection
+  Requests: 1
+  Total Cost: $0.00000025
+  Cost per Request: $0.00000025
+
+Feature: analytics-tracking
+  Requests: 2
+  Total Cost: $0.000003
+  Cost per Request: $0.0000015
+```
+
+## Modo Desenvolvimento
+
+Rodar com auto-reload:
+
+```bash
+npm run dev
+```
+
+## Testes E2E
+
+```bash
+npm test
+```
+
+Runs `test/e2e.js` que faz requisições e valida respostas.
+
+## Troubleshooting
+
+### "Nenhum dado aparecendo no dashboard"
+
+1. ✅ API Key configurada?
+   ```bash
+   echo $CLOUDBROKER_API_KEY
+   ```
+
+2. ✅ AWS credenciais válidas? (tente fazer um `aws s3 ls`)
+
+3. ✅ Esperou 5+ minutos? (CloudBroker faz batch)
+
+4. ✅ Fez pelo menos 1 request pro app?
+   ```bash
+   curl http://localhost:3000/health
+   ```
+
+### "Erro 403 na DynamoDB"
+
+- Tabelas `CheckoutOrders`, `CustomerProfiles`, `AnalyticsEvents` não existem na sua conta AWS
+- CloudBroker **não cria tabelas automaticamente** — você precisa criar:
+  ```bash
+  aws dynamodb create-table \
+    --table-name CheckoutOrders \
+    --attribute-definitions AttributeName=orderId,AttributeType=S \
+    --key-schema AttributeName=orderId,KeyType=HASH \
+    --billing-mode PAY_PER_REQUEST
+  ```
+
+### "Erro ao conectar no S3"
+
+- Bucket `checkout-invoices` não existe
+- Crie:
+  ```bash
+  aws s3 mb s3://checkout-invoices-YOUR-UID --region us-east-2
+  ```
+
+## Próximos Passos
+
+- Leia [docs/COST_PER_FEATURE.md](../docs/COST_PER_FEATURE.md) pro guia completo
+- Copie os patterns aqui pro seu próprio backend
+- Cada label representa uma feature — customize conforme suas necessidades
+- Monitore no dashboard CloudBroker qual feature custa mais
+
+## Suporte
+
+Dúvidas? Abra issue em [github.com/rmoura151179/cloudbroker-sdk](https://github.com/rmoura151179/cloudbroker-sdk).

package/example-checkout-app/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "cloudbroker-sdk-example-checkout",
+  "version": "1.0.0",
+  "description": "Exemplo: Rastrear custo por feature com CloudBroker SDK",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "node --watch server.js",
+    "test": "node test/e2e.js"
+  },
+  "keywords": ["cloudbroker", "finops", "cost-tracking"],
+  "author": "CloudBroker",
+  "license": "MIT",
+  "dependencies": {
+    "express": "^4.18.2",
+    "@aws-sdk/client-s3": "^3.400.0",
+    "@aws-sdk/client-dynamodb": "^3.400.0",
+    "@aws-sdk/lib-dynamodb": "^3.400.0",
+    "cloudbroker-sdk": "^0.5.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}