cloudbroker-sdk 0.5.0 → 0.6.0

package/example-checkout-app/server.js

@@ -0,0 +1,209 @@
+import 'dotenv/config';
+import express from 'express';
+import { S3Client, PutObjectCommand, GetObjectCommand } from '@aws-sdk/client-s3';
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBDocumentClient, PutCommand, GetCommand } from '@aws-sdk/lib-dynamodb';
+import { CloudBrokerCloud } from 'cloudbroker-sdk';
+
+const app = express();
+app.use(express.json());
+
+// ========== AWS Clients Setup (Wrapped) ==========
+
+const s3 = CloudBrokerCloud.wrapAWS(new S3Client({ region: 'us-east-2' }), {
+  apiKey: process.env.CLOUDBROKER_API_KEY,
+  product: process.env.CLOUDBROKER_PRODUCT || 'checkout-example',
+  team: process.env.CLOUDBROKER_TEAM || 'platform',
+});
+
+const dynamodb = CloudBrokerCloud.wrapAWS(
+  DynamoDBDocumentClient.from(new DynamoDBClient({ region: 'us-east-2' })),
+  {
+    apiKey: process.env.CLOUDBROKER_API_KEY,
+    product: process.env.CLOUDBROKER_PRODUCT || 'checkout-example',
+    team: process.env.CLOUDBROKER_TEAM || 'platform',
+  }
+);
+
+// ========== Routes ==========
+
+/**
+ * Health check (no tracking)
+ */
+app.get('/health', (req, res) => {
+  res.json({ ok: true, status: 'healthy', timestamp: new Date().toISOString() });
+});
+
+/**
+ * POST /orders — Create order
+ * Tracks: order-processing (DynamoDB), invoice-generation (S3)
+ */
+app.post('/orders', async (req, res) => {
+  try {
+    const order = {
+      orderId: `order-${Date.now()}`,
+      customerId: req.body.customerId,
+      items: req.body.items || [],
+      total: req.body.total || 0,
+      status: 'pending',
+      createdAt: new Date().toISOString(),
+    };
+
+    // Feature 1: Persistir pedido no DynamoDB
+    await dynamodb.send(
+      new PutCommand({
+        TableName: 'CheckoutOrders',
+        Item: order,
+      }),
+      {
+        cbLabel: 'order-processing', // CloudBroker rastreia como "order-processing"
+      }
+    );
+
+    // Feature 2: Gerar invoice no S3
+    const invoiceJson = JSON.stringify({
+      orderId: order.orderId,
+      customerId: order.customerId,
+      items: order.items,
+      total: order.total,
+      createdAt: order.createdAt,
+    });
+
+    await s3.send(
+      new PutObjectCommand({
+        Bucket: 'checkout-invoices',
+        Key: `invoices/${order.orderId}.json`,
+        Body: invoiceJson,
+        ContentType: 'application/json',
+      }),
+      {
+        cbLabel: 'invoice-generation', // CloudBroker rastreia como "invoice-generation"
+      }
+    );
+
+    res.json({
+      ok: true,
+      orderId: order.orderId,
+      message: 'Order created successfully! Check CloudBroker dashboard for cost breakdown.',
+    });
+  } catch (error) {
+    console.error('[POST /orders] Error:', error.message);
+    res.status(500).json({ ok: false, error: error.message });
+  }
+});
+
+/**
+ * GET /orders/:id — Retrieve order
+ * Tracks: order-retrieval
+ */
+app.get('/orders/:id', async (req, res) => {
+  try {
+    const result = await dynamodb.send(
+      new GetCommand({
+        TableName: 'CheckoutOrders',
+        Key: { orderId: req.params.id },
+      }),
+      {
+        cbLabel: 'order-retrieval',
+      }
+    );
+
+    res.json({
+      ok: true,
+      order: result.Item || null,
+    });
+  } catch (error) {
+    console.error('[GET /orders/:id] Error:', error.message);
+    res.status(500).json({ ok: false, error: error.message });
+  }
+});
+
+/**
+ * POST /verify-fraud — Fraud detection check
+ * Tracks: fraud-detection
+ */
+app.post('/verify-fraud', async (req, res) => {
+  try {
+    const { orderId, customerId } = req.body;
+
+    // Simular: ler perfil de cliente do DynamoDB pra análise
+    const result = await dynamodb.send(
+      new GetCommand({
+        TableName: 'CustomerProfiles',
+        Key: { customerId },
+      }),
+      {
+        cbLabel: 'fraud-detection',
+      }
+    );
+
+    // Mock fraud score
+    const fraudScore = Math.random() * 0.5; // 0–0.5 = low risk
+    const isBlocked = fraudScore > 0.4;
+
+    res.json({
+      ok: true,
+      orderId,
+      customerId,
+      fraud_score: parseFloat(fraudScore.toFixed(2)),
+      is_blocked: isBlocked,
+      message: isBlocked ? 'Order blocked due to fraud risk' : 'Order cleared',
+    });
+  } catch (error) {
+    console.error('[POST /verify-fraud] Error:', error.message);
+    res.status(500).json({ ok: false, error: error.message });
+  }
+});
+
+/**
+ * POST /analytics — Track user action
+ * Tracks: analytics-tracking
+ */
+app.post('/analytics', async (req, res) => {
+  try {
+    const event = {
+      eventId: `event-${Date.now()}`,
+      userId: req.body.userId,
+      eventType: req.body.eventType,
+      data: req.body.data || {},
+      timestamp: new Date().toISOString(),
+    };
+
+    // Store event in DynamoDB
+    await dynamodb.send(
+      new PutCommand({
+        TableName: 'AnalyticsEvents',
+        Item: event,
+      }),
+      {
+        cbLabel: 'analytics-tracking',
+      }
+    );
+
+    res.json({
+      ok: true,
+      eventId: event.eventId,
+      message: 'Analytics event recorded',
+    });
+  } catch (error) {
+    console.error('[POST /analytics] Error:', error.message);
+    res.status(500).json({ ok: false, error: error.message });
+  }
+});
+
+// ========== Server Start ==========
+
+const PORT = parseInt(process.env.PORT || '3000', 10);
+
+app.listen(PORT, () => {
+  console.log(`\n✅ Checkout Example App running on http://localhost:${PORT}`);
+  console.log(`📊 Check costs at: https://app.cloudbroker.app.br → Custo por Código\n`);
+  console.log('Features being tracked:');
+  console.log('  • order-processing (DynamoDB: create order)');
+  console.log('  • invoice-generation (S3: store invoice)');
+  console.log('  • order-retrieval (DynamoDB: fetch order)');
+  console.log('  • fraud-detection (DynamoDB: check profile)');
+  console.log('  • analytics-tracking (DynamoDB: log events)\n');
+});
+
+export default app;

package/example-checkout-app/test/e2e.js

@@ -0,0 +1,97 @@
+import assert from 'assert';
+import fetch from 'node-fetch';
+
+const BASE_URL = 'http://localhost:3000';
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`✅ ${name}`);
+  } catch (error) {
+    console.error(`❌ ${name}`);
+    console.error(`   ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function runTests() {
+  console.log('🧪 Running E2E tests...\n');
+
+  // Test 1: Health check
+  await test('Health check', async () => {
+    const res = await fetch(`${BASE_URL}/health`);
+    assert(res.ok, 'Health check failed');
+    const data = await res.json();
+    assert(data.ok === true, 'Health check returned ok: false');
+  });
+
+  // Test 2: Create order
+  await test('Create order', async () => {
+    const res = await fetch(`${BASE_URL}/orders`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        customerId: 'test-cust-123',
+        items: [{ name: 'Test Widget', price: 99.99 }],
+        total: 99.99,
+      }),
+    });
+    assert(res.ok, `Create order failed: ${res.status}`);
+    const data = await res.json();
+    assert(data.ok === true, 'Create order returned ok: false');
+    assert(data.orderId, 'No orderId in response');
+    global.testOrderId = data.orderId; // Save for next test
+  });
+
+  // Test 3: Get order
+  await test('Get order', async () => {
+    assert(global.testOrderId, 'No orderId from previous test');
+    const res = await fetch(`${BASE_URL}/orders/${global.testOrderId}`);
+    assert(res.ok, `Get order failed: ${res.status}`);
+    const data = await res.json();
+    assert(data.ok === true, 'Get order returned ok: false');
+    // Order might not exist in DynamoDB (local/test setup), but the endpoint should work
+  });
+
+  // Test 4: Verify fraud
+  await test('Verify fraud', async () => {
+    const res = await fetch(`${BASE_URL}/verify-fraud`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        orderId: 'order-test-123',
+        customerId: 'cust-test-456',
+      }),
+    });
+    assert(res.ok, `Verify fraud failed: ${res.status}`);
+    const data = await res.json();
+    assert(data.ok === true, 'Verify fraud returned ok: false');
+    assert(typeof data.fraud_score === 'number', 'No fraud_score in response');
+    assert(data.fraud_score >= 0 && data.fraud_score <= 1, 'fraud_score out of range');
+  });
+
+  // Test 5: Analytics tracking
+  await test('Analytics tracking', async () => {
+    const res = await fetch(`${BASE_URL}/analytics`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        userId: 'user-test-789',
+        eventType: 'page_view',
+        data: { page: '/checkout' },
+      }),
+    });
+    assert(res.ok, `Analytics tracking failed: ${res.status}`);
+    const data = await res.json();
+    assert(data.ok === true, 'Analytics tracking returned ok: false');
+    assert(data.eventId, 'No eventId in response');
+  });
+
+  console.log('\n🎉 All tests passed!');
+  console.log('📊 Check CloudBroker dashboard in ~5 minutes to see the cost breakdown.');
+}
+
+runTests().catch((error) => {
+  console.error('Fatal error:', error.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudbroker-sdk",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "CloudBroker SDK — Token Intelligence & Operational Financial Intelligence",
   "main": "src/index.js",
   "type": "module",
@@ -8,9 +8,18 @@
     ".": "./src/index.js"
   },
   "scripts": {
-    "test": "node src/test.js"
+    "test": "node src/test.js && node src/test-azure-real.js"
   },
-  "keywords": ["cloudbroker", "finops", "token-intelligence", "openai", "anthropic"],
+  "keywords": [
+    "cloudbroker",
+    "finops",
+    "token-intelligence",
+    "openai",
+    "anthropic"
+  ],
   "license": "MIT",
-  "dependencies": {}
+  "devDependencies": {
+    "@azure/cosmos": "^4.10.0",
+    "@azure/storage-blob": "^12.33.0"
+  }
 }

package/src/client.js

@@ -7,6 +7,17 @@ const DEFAULT_AI_ENDPOINT    = "https://api.cloudbroker.app.br/api/ai/events";
 const DEFAULT_CLOUD_ENDPOINT = "https://api.cloudbroker.app.br/api/cloud/events";
 const DEFAULT_API_BASE       = "https://api.cloudbroker.app.br/api";
 const RETRY_DELAY_MS         = 30_000; // 30s entre retries
+
+/**
+ * Retry que NÃO segura o event loop. Sem `.unref()`, um flush que falha deixa
+ * um timer de 30s pendurado que se reagenda — qualquer processo Node curto
+ * (Lambda, cron, CLI, suíte de teste) que use o SDK nunca encerra sozinho.
+ */
+function scheduleRetry(fn) {
+  const t = setTimeout(fn, RETRY_DELAY_MS);
+  if (typeof t?.unref === "function") t.unref();
+  return t;
+}
 const MAX_QUEUE_SIZE         = 500;    // máximo de eventos em memória
 
 export class CloudBrokerClient {
@@ -37,7 +48,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.5.0",
+        sdkVersion: "0.6.0",
         sentAt: new Date().toISOString(),
       };
       if (this.#cloudQueue.length < MAX_QUEUE_SIZE) {
@@ -69,7 +80,7 @@ export class CloudBrokerClient {
       if (!res.ok) {
         if (this.#debug) console.warn("[CloudBroker] cloud flush failed:", res.status);
         this.#cloudQueue.unshift(...batch);
-        setTimeout(() => { this.#cloudFlushing = false; this.#flushCloud(); }, RETRY_DELAY_MS);
+        scheduleRetry(() => { this.#cloudFlushing = false; this.#flushCloud(); });
         return;
       }
 
@@ -77,7 +88,7 @@ export class CloudBrokerClient {
     } catch (err) {
       this.#cloudQueue.unshift(...batch);
       if (this.#debug) console.warn("[CloudBroker] cloud flush error:", err.message);
-      setTimeout(() => { this.#cloudFlushing = false; this.#flushCloud(); }, RETRY_DELAY_MS);
+      scheduleRetry(() => { this.#cloudFlushing = false; this.#flushCloud(); });
       return;
     }
 
@@ -93,7 +104,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.5.0",
+        sdkVersion: "0.6.0",
         sentAt: new Date().toISOString(),
       };
 
@@ -184,7 +195,7 @@ export class CloudBrokerClient {
         // Recoloca na fila e agenda retry com backoff — nunca recursa na hora,
         // senão um erro persistente (ex: 401) martela o endpoint em loop apertado.
         this.#queue.unshift(...batch);
-        setTimeout(() => { this.#flushing = false; this.#flush(); }, RETRY_DELAY_MS);
+        scheduleRetry(() => { this.#flushing = false; this.#flush(); });
         return;
       }
 
@@ -195,7 +206,7 @@ export class CloudBrokerClient {
       if (this.#debug) console.warn("[CloudBroker] flush error:", err.message);
 
       // Retry em 30s
-      setTimeout(() => { this.#flushing = false; this.#flush(); }, RETRY_DELAY_MS);
+      scheduleRetry(() => { this.#flushing = false; this.#flush(); });
       return;
     }