cloudbroker-sdk 0.3.0 → 0.4.0

package/README.md

@@ -152,26 +152,28 @@ Em vez de passar `cbLabel` em cada `.send()`, use o middleware: todas as chamada
 de nuvem feitas durante a requisição herdam um label de negócio automaticamente
 (via `AsyncLocalStorage`). Ótimo pra agrupar custo por **módulo** ou **rota**.
 
+Cada campo (`label`, `product`, `team`) pode ser fixo (string) ou uma função
+`(req) => string`. Isso permite a hierarquia **Grupo (team) → App (product) →
+Trecho (label) → Serviço** na visão de custo.
+
 ```js
 import express from "express";
 import { CloudBrokerCloud } from "cloudbroker-sdk";
 
 const app = express();
 
-// label fixo, "MÉTODO /caminho" (default), ou uma função req → label:
 app.use(CloudBrokerCloud.expressMiddleware({
-  label: (req) => {
-    if (req.path.startsWith("/api/auth"))    return "Autenticação";
-    if (req.path.startsWith("/api/billing")) return "Billing";
-    return "Outros";
-  },
+  team:    (req) => (req.path.startsWith("/api/admin") ? "Plataforma" : "Produto"), // Grupo
+  product: (req) => req.path.split("/")[2] || "core",                              // App
+  label:   (req) => `${req.method} ${req.path}`,                                   // Trecho
 }));
 
 // daqui pra frente, qualquer s3.send(...)/ddb.send(...) dentro da request
-// é atribuído ao módulo retornado — sem cbLabel manual.
+// é atribuído ao grupo/app/trecho — sem cbLabel manual.
 ```
 
-Prioridade do label: `cbLabel` explícito no `.send()` > contexto do middleware > `null`.
+Prioridade de cada campo: explícito no `.send()` (`cbLabel`/`cbProduct`/`cbTeam`) >
+contexto do middleware > valor estático do `wrapAWS` > `null`.
 
 ## Garantias
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudbroker-sdk",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "CloudBroker SDK — Token Intelligence & Operational Financial Intelligence",
   "main": "src/index.js",
   "type": "module",

package/src/client.js

@@ -37,7 +37,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.3.0",
+        sdkVersion: "0.4.0",
         sentAt: new Date().toISOString(),
       };
       if (this.#cloudQueue.length < MAX_QUEUE_SIZE) {
@@ -93,7 +93,7 @@ export class CloudBrokerClient {
     try {
       const payload = {
         ...event,
-        sdkVersion: "0.3.0",
+        sdkVersion: "0.4.0",
         sentAt: new Date().toISOString(),
       };
 

package/src/cloud-wrapper.js

@@ -24,7 +24,7 @@
 
 import { CloudBrokerClient } from "./client.js";
 import { estimateCloudCost } from "./pricing-cloud.js";
-import { cbStore, currentLabel } from "./context.js";
+import { cbStore } from "./context.js";
 
 export class CloudBrokerCloud {
   /**
@@ -54,13 +54,16 @@ export class CloudBrokerCloud {
     client.send = async (command, sendOptions) => {
       const start = Date.now();
       const operation = (command?.constructor?.name || "").replace(/Command$/, "");
-      // Label: explícito no .send() tem prioridade; senão usa o do contexto da
-      // requisição (expressMiddleware), senão null.
-      const cbLabel = sendOptions?.cbLabel || currentLabel() || null;
+      // Prioridade: explícito no .send() > contexto da requisição (expressMiddleware)
+      // > valor estático do wrapAWS. Permite Grupo/App/Trecho por requisição.
+      const ctx = cbStore.getStore() || {};
+      const cbLabel   = sendOptions?.cbLabel   || ctx.label   || null;
+      const evProduct = sendOptions?.cbProduct || ctx.product || product || null;
+      const evTeam    = sendOptions?.cbTeam    || ctx.team    || team    || null;
       const bytesIn = CloudBrokerCloud.#inputBytes(command?.input);
 
-      // Passa adiante apenas as options nativas — nunca vaza cbLabel pro AWS SDK.
-      const { cbLabel: _omit, ...awsOptions } = sendOptions || {};
+      // Passa adiante apenas as options nativas — nunca vaza campos cb* pro AWS SDK.
+      const { cbLabel: _l, cbProduct: _p, cbTeam: _t, ...awsOptions } = sendOptions || {};
       const result = await originalSend(command, Object.keys(awsOptions).length ? awsOptions : undefined);
 
       try {
@@ -73,8 +76,8 @@ export class CloudBrokerCloud {
           provider:  "aws",
           service,
           operation,
-          product:   product || null,
-          team:      team    || null,
+          product:   evProduct,
+          team:      evTeam,
           label:     cbLabel,
           requests:  1,
           bytesIn,
@@ -95,26 +98,29 @@ export class CloudBrokerCloud {
   }
 
   /**
-   * Middleware Express que atribui um label de negócio a todas as chamadas de
-   * nuvem feitas durante a requisição (via AsyncLocalStorage). Assim o custo por
-   * código agrupa por módulo/rota sem precisar de cbLabel manual em cada send.
+   * Middleware Express que atribui contexto de negócio a todas as chamadas de
+   * nuvem feitas durante a requisição (via AsyncLocalStorage). Cada campo pode ser
+   * fixo (string) ou uma função (req) => string — ex: mapear rota → módulo/app/grupo.
+   * Sem precisar passar cbLabel/cbProduct/cbTeam manual em cada send.
    *
    * @param {object} [options]
-   * @param {string|((req)=>string)} [options.label] — label fixo, ou função que
-   *   recebe o req e devolve o label (ex: mapear rota → módulo de negócio).
-   *   Default: "MÉTODO /caminho" da requisição.
+   * @param {string|((req)=>string)} [options.label]   — trecho (default: "MÉTODO /caminho")
+   * @param {string|((req)=>string)} [options.product] — App (sobrescreve o product do wrapAWS)
+   * @param {string|((req)=>string)} [options.team]    — Grupo (sobrescreve o team do wrapAWS)
    * @returns {(req,res,next)=>void}
    */
   static expressMiddleware(options = {}) {
-    const resolve =
-      typeof options.label === "function" ? options.label :
-      typeof options.label === "string"   ? () => options.label :
-      (req) => `${req.method || ""} ${req.baseUrl || ""}${req.route?.path || req.path || ""}`.trim();
+    const mk = (opt, fallback) =>
+      typeof opt === "function" ? opt :
+      typeof opt === "string"   ? () => opt :
+      fallback;
+    const resolveLabel   = mk(options.label, (req) => `${req.method || ""} ${req.baseUrl || ""}${req.route?.path || req.path || ""}`.trim());
+    const resolveProduct = mk(options.product, () => undefined);
+    const resolveTeam    = mk(options.team, () => undefined);
 
     return (req, res, next) => {
-      let label = null;
-      try { label = resolve(req); } catch { label = null; }
-      cbStore.run({ label }, () => next());
+      const safe = (fn) => { try { return fn(req); } catch { return undefined; } };
+      cbStore.run({ label: safe(resolveLabel), product: safe(resolveProduct), team: safe(resolveTeam) }, () => next());
     };
   }
 

package/src/test.js

@@ -154,18 +154,24 @@ assert.ok(ev.costUSD > 0, "deve ter custo estimado");
 console.log("✅ wrapAWS: evento capturado, cbLabel não vazou, resultado preservado");
 
 // 3) expressMiddleware — label do contexto (ALS) entra sem cbLabel explícito
-const mw = CloudBrokerCloud.expressMiddleware({ label: (req) => `modulo:${req.path}` });
+const mw = CloudBrokerCloud.expressMiddleware({
+  label:   (req) => `modulo:${req.path}`,
+  product: (req) => (req.path.startsWith("/api/billing") ? "Billing" : "Outros"),
+  team:    "Plataforma",
+});
 const fakeReq = { method: "GET", path: "/api/billing" };
 await new Promise((resolve) => {
   mw(fakeReq, {}, async () => {
-    await s3.send(new PutObjectCommand({ Bucket: "b", Key: "k", Body: "x" })); // sem cbLabel — herda do contexto
+    await s3.send(new PutObjectCommand({ Bucket: "b", Key: "k", Body: "x" })); // sem cb* — herda do contexto
     resolve();
   });
 });
 await new Promise((r) => setTimeout(r, 50));
 const ctxEvent = captured[captured.length - 1].events[0];
-assert.strictEqual(ctxEvent.label, "modulo:/api/billing", `label do contexto esperado, veio ${ctxEvent.label}`);
-console.log("✅ expressMiddleware: label do contexto aplicado sem cbLabel explícito");
+assert.strictEqual(ctxEvent.label,   "modulo:/api/billing", `label do contexto esperado, veio ${ctxEvent.label}`);
+assert.strictEqual(ctxEvent.product, "Billing",     `product do contexto esperado, veio ${ctxEvent.product}`);
+assert.strictEqual(ctxEvent.team,    "Plataforma",  `team do contexto esperado, veio ${ctxEvent.team}`);
+console.log("✅ expressMiddleware: label/product/team do contexto aplicados sem cb* explícito");
 
 globalThis.fetch = realFetch;
 console.log("\n🎉 Todos os testes passaram.");