@baruk/core 0.3.0 → 0.4.2

package/dist/cjs/communication/routing.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Roteamento de webhook de entrada — de quem é este evento?
+ *
+ * **Este módulo existe por causa da topologia do provider, não por gosto de
+ * abstração.** Sob um Meta App único do motor — que é a topologia oficial de
+ * Tech Provider —, a URL de callback e o verify token pertencem ao APP, não à
+ * conta do cliente. A Meta entrega os eventos de TODAS as WABAs assinadas no
+ * mesmo endereço, e não tem como saber o nosso `tenantId`.
+ *
+ * A rota anterior embutia `:tenantId` no path. Isso só funciona quando cada
+ * tenant tem o próprio App e o próprio webhook — uma topologia que a plataforma
+ * suporta, mas que não é a que o motor vai operar, e que não oferece
+ * coexistência com o WhatsApp Business App. Com um App só, o tenant tem de sair
+ * do PAYLOAD.
+ *
+ * O que decide é `metadata.phone_number_id`. O WABA (`entry.id`) é **conferência
+ * de coerência**, nunca segunda chave: um número que resolve para um registro
+ * cujo WABA discorda significa cadastro errado ou payload forjado, e os dois
+ * merecem recusa em vez de palpite. É a mesma conclusão a que o registry do
+ * Paid Media Engine já tinha chegado, e ela é reaproveitada aqui de propósito.
+ *
+ * Nunca decidem: telefone do remetente, nome do contato, texto da mensagem,
+ * nome de campanha. São entrada não autenticada ou ambígua — o mesmo telefone
+ * pode falar com dois tenants.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRoute = resolveRoute;
+exports.sameOrigin = sameOrigin;
+/**
+ * Resolve a origem de um evento para um tenant.
+ *
+ * **Fail-closed por construção.** Não existe neste arquivo nenhum caminho que
+ * devolva uma rota que não tenha sido encontrada pela chave exata do provider:
+ * não há tenant padrão, não há "primeiro tenant", não há fallback por marca. Um
+ * número desconhecido resolve para recusa, e quem chama audita e para.
+ */
+async function resolveRoute(store, origin) {
+    const accountRef = origin.providerAccountRef?.trim();
+    if (!accountRef) {
+        return { ok: false, reason: 'missing_origin', detail: 'evento sem conta de origem' };
+    }
+    const route = await store.findByProviderAccount(origin.provider, accountRef);
+    if (!route) {
+        return {
+            ok: false,
+            reason: 'unknown_account',
+            detail: `conta ${origin.provider} não vinculada a nenhum tenant`,
+        };
+    }
+    // Conferência de coerência — só quando os dois lados declaram o agrupador.
+    // Exigi-lo quando o payload não o traz recusaria evento legítimo; ignorá-lo
+    // quando ambos existem e discordam aceitaria cadastro corrompido.
+    if (origin.providerParentRef &&
+        route.providerParentRef &&
+        origin.providerParentRef !== route.providerParentRef) {
+        return {
+            ok: false,
+            reason: 'parent_mismatch',
+            detail: 'agrupador do evento discorda do vínculo registrado',
+        };
+    }
+    return { ok: true, route };
+}
+/**
+ * Duas origens são a mesma?
+ *
+ * Um POST da Meta pode trazer eventos de mais de uma conta. Agrupar por origem
+ * antes de abrir contexto de tenant é o que impede o evento de um escritório de
+ * ser aplicado dentro da transação de outro.
+ */
+function sameOrigin(a, b) {
+    return (a.provider === b.provider &&
+        a.providerAccountRef === b.providerAccountRef &&
+        (a.providerParentRef ?? '') === (b.providerParentRef ?? ''));
+}
+//# sourceMappingURL=routing.js.map

package/dist/cjs/communication/routing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.js","sourceRoot":"","sources":["../../../src/communication/routing.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;AAqEH,oCAkCC;AASD,gCAMC;AAzDD;;;;;;;GAOG;AACI,KAAK,UAAU,YAAY,CAChC,KAAwB,EACxB,MAAqB;IAErB,MAAM,UAAU,GAAG,MAAM,CAAC,kBAAkB,EAAE,IAAI,EAAE,CAAC;IACrD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,4BAA4B,EAAE,CAAC;IACvF,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,qBAAqB,CAAC,MAAM,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;IAC7E,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,iBAAiB;YACzB,MAAM,EAAE,SAAS,MAAM,CAAC,QAAQ,gCAAgC;SACjE,CAAC;IACJ,CAAC;IAED,2EAA2E;IAC3E,4EAA4E;IAC5E,kEAAkE;IAClE,IACE,MAAM,CAAC,iBAAiB;QACxB,KAAK,CAAC,iBAAiB;QACvB,MAAM,CAAC,iBAAiB,KAAK,KAAK,CAAC,iBAAiB,EACpD,CAAC;QACD,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,iBAAiB;YACzB,MAAM,EAAE,oDAAoD;SAC7D,CAAC;IACJ,CAAC;IAED,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;AAC7B,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,UAAU,CAAC,CAAgB,EAAE,CAAgB;IAC3D,OAAO,CACL,CAAC,CAAC,QAAQ,KAAK,CAAC,CAAC,QAAQ;QACzB,CAAC,CAAC,kBAAkB,KAAK,CAAC,CAAC,kBAAkB;QAC7C,CAAC,CAAC,CAAC,iBAAiB,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAC5D,CAAC;AACJ,CAAC"}

package/dist/cjs/communication/sender-profile.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Perfil de remetente — de quem a mensagem PARECE ser.
+ *
+ * `identity.ts` responde "existe conta deste tenant para este canal?" e não tem
+ * fallback nenhum, de propósito. Este módulo responde a pergunta seguinte, que a
+ * operação real obriga a enfrentar: **e quando o tenant não configurou conta
+ * própria, mas o produto já entrega e-mail hoje?**
+ *
+ * A resposta preguiçosa é `?? contaDaPlataforma`, escrita dentro de um adapter.
+ * Foi assim no Manga Verde, e o custo é conhecido: reputação de domínio
+ * compartilhada em e-mail, e uma WABA respondendo pelo comportamento de outra
+ * marca em WhatsApp — com bloqueio que se propaga para todos os tenants do
+ * número.
+ *
+ * Aqui o fallback existe, mas com quatro amarras que o tornam outra coisa:
+ *
+ *   1. É DECLARADO pelo produto, canal a canal. Não há default implícito.
+ *   2. Nunca vale para canal de telefone. WhatsApp e SMS falham fechado, ponto.
+ *   3. A IDENTIDADE VISÍVEL continua sendo a do tenant que está enviando — o
+ *      nome de exibição vem da marca dele. A SC nunca sai parecendo Manga Verde.
+ *   4. A origem é devolvida junto e vai para a trilha. "Saiu pelo remetente da
+ *      plataforma" tem de ser uma coisa que o escritório consegue VER, não uma
+ *      linha de código que ninguém lê.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSenderProfile = resolveSenderProfile;
+exports.withSenderFallback = withSenderFallback;
+exports.credentialResolverFor = credentialResolverFor;
+/**
+ * Canais que NUNCA aceitam fallback de plataforma.
+ *
+ * Lista fechada no motor, e não configuração do produto, porque a consequência
+ * não é do produto: uma WABA bloqueada por comportamento de um tenant derruba
+ * todos os outros que compartilham o número. Não existe configuração que torne
+ * isso aceitável, então não existe configuração.
+ */
+const FALLBACK_FORBIDDEN = ['whatsapp', 'sms'];
+/**
+ * Resolve o remetente: conta do tenant primeiro, fallback declarado depois.
+ *
+ * A ordem não é preferência, é regra. A conta do tenant, quando existe, é a
+ * única que pode ser usada — mesmo que esteja `paused` ou com erro. Cair para a
+ * plataforma porque a conta PRÓPRIA está com problema seria o pior caso
+ * possível: o escritório que configurou a identidade dele passaria a enviar com
+ * a da plataforma, justamente quando alguém está mexendo na configuração.
+ */
+async function resolveSenderProfile(store, ctx, channel, fallback = {}) {
+    const own = await store.find(ctx, channel);
+    if (own)
+        return { ok: true, profile: { account: own, origin: 'tenant' } };
+    const declared = fallback[channel];
+    if (!declared) {
+        return {
+            ok: false,
+            reason: 'no_account',
+            detail: `sem conta de ${channel} para este tenant/produto e sem fallback declarado`,
+        };
+    }
+    if (FALLBACK_FORBIDDEN.includes(channel)) {
+        // Produto que declarou fallback para telefone cometeu um erro de
+        // configuração perigoso. Recusar em silêncio o esconderia; recusar com
+        // motivo próprio o expõe na trilha.
+        return {
+            ok: false,
+            reason: 'fallback_forbidden_for_channel',
+            detail: `fallback de plataforma é proibido em ${channel}`,
+        };
+    }
+    return {
+        ok: true,
+        profile: {
+            account: {
+                channel,
+                // O contexto pedido, SEMPRE. É o que faz `assertOwnership` continuar
+                // valendo e o que impede a conta de plataforma de carregar a marca de
+                // outro tenant para dentro de um envio deste.
+                tenantId: ctx.tenantId,
+                product: ctx.product,
+                brand: ctx.brand,
+                senderId: declared.senderId,
+                displayName: declared.displayNameFor(ctx),
+                credentialRef: declared.credentialRef,
+                status: 'active',
+            },
+            origin: 'platform_fallback',
+        },
+    };
+}
+/**
+ * Store de contas com o fallback do produto já aplicado.
+ *
+ * Existe porque o fallback tem de valer na RESOLUÇÃO DE IDENTIDADE, e não só na
+ * construção do adapter. Registrar o canal com a conta de fallback e deixar
+ * `deps.accounts` devolvendo `null` produz um motor que pula o canal com
+ * `no_identity` antes de chegar ao adapter — o canal existe, o remetente existe,
+ * e a mensagem não sai. O sintoma é mudo: a trilha diz "sem conta", que é
+ * exatamente o que quem configurou o fallback acredita ter resolvido.
+ *
+ * `identity.ts` continua sem fallback nenhum, e é o ponto: quem decide que a
+ * plataforma pode assinar por um tenant é o PRODUTO, declarando a política, e a
+ * decisão fica visível numa decoração explícita em vez de num `??` dentro do
+ * motor.
+ */
+function withSenderFallback(store, fallback) {
+    return {
+        async find(ctx, channel) {
+            const resolved = await resolveSenderProfile(store, ctx, channel, fallback);
+            return resolved.ok ? resolved.profile.account : null;
+        },
+    };
+}
+/**
+ * Resolvedor de credencial preso a UMA conta.
+ *
+ * Envolve o resolvedor do processo e só deixa passar a referência que a conta
+ * resolvida declarou. Sem isto, o resolvedor injetado é uma função que traduz
+ * qualquer nome em qualquer segredo, e basta um adapter passar a referência
+ * errada — por bug, por conta trocada, por um `??` mal colocado — para um tenant
+ * enviar com a credencial de outro.
+ *
+ * A trava é barata e fecha a classe inteira: nenhuma referência que não seja a
+ * daquela conta resolve, por construção.
+ */
+function credentialResolverFor(account, resolve) {
+    return async (ref) => (ref === account.credentialRef ? resolve(ref) : undefined);
+}
+//# sourceMappingURL=sender-profile.js.map

package/dist/cjs/communication/sender-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sender-profile.js","sourceRoot":"","sources":["../../../src/communication/sender-profile.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;;AA2DH,oDAgDC;AAiBD,gDAUC;AAcD,sDAKC;AAzHD;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAA0B,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;AAUtE;;;;;;;;GAQG;AACI,KAAK,UAAU,oBAAoB,CACxC,KAA0B,EAC1B,GAAyB,EACzB,OAAmB,EACnB,WAAiC,EAAE;IAEnC,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC3C,IAAI,GAAG;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,CAAC;IAE1E,MAAM,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;IACnC,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,gBAAgB,OAAO,oDAAoD;SACpF,CAAC;IACJ,CAAC;IAED,IAAI,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACzC,iEAAiE;QACjE,uEAAuE;QACvE,oCAAoC;QACpC,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,gCAAgC;YACxC,MAAM,EAAE,wCAAwC,OAAO,EAAE;SAC1D,CAAC;IACJ,CAAC;IAED,OAAO;QACL,EAAE,EAAE,IAAI;QACR,OAAO,EAAE;YACP,OAAO,EAAE;gBACP,OAAO;gBACP,qEAAqE;gBACrE,sEAAsE;gBACtE,8CAA8C;gBAC9C,QAAQ,EAAE,GAAG,CAAC,QAAQ;gBACtB,OAAO,EAAE,GAAG,CAAC,OAAO;gBACpB,KAAK,EAAE,GAAG,CAAC,KAAK;gBAChB,QAAQ,EAAE,QAAQ,CAAC,QAAQ;gBAC3B,WAAW,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,CAAC;gBACzC,aAAa,EAAE,QAAQ,CAAC,aAAa;gBACrC,MAAM,EAAE,QAAQ;aACjB;YACD,MAAM,EAAE,mBAAmB;SAC5B;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,kBAAkB,CAChC,KAA0B,EAC1B,QAA8B;IAE9B,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO;YACrB,MAAM,QAAQ,GAAG,MAAM,oBAAoB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;YAC3E,OAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,qBAAqB,CACnC,OAAuB,EACvB,OAAqD;IAErD,OAAO,KAAK,EAAE,GAAW,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAC3F,CAAC"}

package/dist/cjs/communication/status.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Estados de entrega e classificação de falha.
+ *
+ * `sent` significa "o provider aceitou" — o único desfecho que o e-mail
+ * consegue afirmar. WhatsApp e SMS informam depois, por webhook, se a mensagem
+ * chegou ao aparelho, e só o WhatsApp informa se foi aberta.
+ *
+ * Colapsar "aceito" e "entregue" faria a tela afirmar entrega que ninguém
+ * confirmou — que é precisamente a pergunta do escritório quando o cliente diz
+ * "não recebi nada".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANNEL_REPORTS = void 0;
+exports.channelReports = channelReports;
+exports.advanceStatus = advanceStatus;
+exports.isRetryable = isRetryable;
+exports.statusForOutcome = statusForOutcome;
+/**
+ * Até onde cada canal consegue informar.
+ *
+ * SMS nunca alcança `read`, e nenhum provider de SMS devolve isso — mapear um
+ * `delivered` de SMS para `read` "para uniformizar" produziria uma tela
+ * afirmando que o cliente LEU uma cobrança que ninguém sabe se ele leu. É a
+ * equivalência falsa que este mapa existe para impedir.
+ */
+exports.CHANNEL_REPORTS = {
+    email: ['queued', 'sent', 'failed'],
+    whatsapp: ['queued', 'sent', 'delivered', 'read', 'failed', 'opted_out'],
+    sms: ['queued', 'sent', 'delivered', 'failed', 'opted_out'],
+    notification: ['queued', 'sent', 'read', 'failed'],
+};
+/** O canal é capaz de relatar este estado? Consultado ANTES de gravar um webhook. */
+function channelReports(channel, status) {
+    return exports.CHANNEL_REPORTS[channel].includes(status);
+}
+/** Ordem de progresso. Um webhook atrasado nunca deve REGREDIR o estado. */
+const RANK = {
+    queued: 0,
+    sent: 1,
+    delivered: 2,
+    read: 3,
+    failed: 4,
+    opted_out: 5,
+};
+/**
+ * Aplica um estado novo sobre o atual.
+ *
+ * Webhooks chegam fora de ordem — `delivered` depois de `read` acontece, e
+ * aceitar cegamente faria a mensagem "desler". `failed` e `opted_out` são
+ * terminais e nunca são sobrescritos por progresso: um `delivered` que chega
+ * depois de uma falha registrada é ruído do provider, não correção.
+ */
+function advanceStatus(current, incoming) {
+    if (current === 'failed' || current === 'opted_out')
+        return current;
+    return RANK[incoming] > RANK[current] ? incoming : current;
+}
+/**
+ * Erro permanente nunca deve ser retentado, por mais que o contador permita.
+ *
+ * `unavailable` e `opted_out` também retornam falso, mas por razão oposta: não
+ * são falhas de entrega, e não devem sequer consumir uma tentativa.
+ */
+function isRetryable(kind) {
+    return kind === 'temporary';
+}
+/**
+ * Estado que o desfecho assenta, ou `null` quando não assenta nenhum.
+ *
+ * `temporary` não assenta: a ação continua agendada para nova tentativa.
+ * `unavailable` não é tentativa — não gasta retry e não marca falha de entrega.
+ */
+function statusForOutcome(kind) {
+    switch (kind) {
+        case 'sent':
+            return 'sent';
+        case 'opted_out':
+            return 'opted_out';
+        case 'permanent':
+            return 'failed';
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/cjs/communication/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../../src/communication/status.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAsBH,wCAEC;AAoBD,sCAGC;AAQD,kCAEC;AAQD,4CAWC;AAtED;;;;;;;GAOG;AACU,QAAA,eAAe,GAAkD;IAC5E,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC;IACnC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,CAAC;IACxE,GAAG,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,CAAC;IAC3D,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC;CACnD,CAAC;AAEF,qFAAqF;AACrF,SAAgB,cAAc,CAAC,OAAmB,EAAE,MAAsB;IACxE,OAAO,uBAAe,CAAC,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;AACnD,CAAC;AAED,4EAA4E;AAC5E,MAAM,IAAI,GAAmC;IAC3C,MAAM,EAAE,CAAC;IACT,IAAI,EAAE,CAAC;IACP,SAAS,EAAE,CAAC;IACZ,IAAI,EAAE,CAAC;IACP,MAAM,EAAE,CAAC;IACT,SAAS,EAAE,CAAC;CACb,CAAC;AAEF;;;;;;;GAOG;AACH,SAAgB,aAAa,CAAC,OAAuB,EAAE,QAAwB;IAC7E,IAAI,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,WAAW;QAAE,OAAO,OAAO,CAAC;IACpE,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;AAC7D,CAAC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,IAAyB;IACnD,OAAO,IAAI,KAAK,WAAW,CAAC;AAC9B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,IAAyB;IACxD,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,MAAM;YACT,OAAO,MAAM,CAAC;QAChB,KAAK,WAAW;YACd,OAAO,WAAW,CAAC;QACrB,KAAK,WAAW;YACd,OAAO,QAAQ,CAAC;QAClB;YACE,OAAO,IAAI,CAAC;IAChB,CAAC;AACH,CAAC"}

package/dist/cjs/communication/stores/onboarding.js

@@ -0,0 +1,135 @@
+"use strict";
+/**
+ * Persistência da sessão de Embedded Signup (migração 0044).
+ *
+ * Duas operações, e a segunda é a que carrega toda a segurança do fluxo:
+ * `consumeOnboardingSession` é **atômica e única**. Ela não lê para depois
+ * decidir — ela escreve com a condição embutida, e quem não conseguir escrever
+ * não consumiu. Um `SELECT` seguido de `UPDATE` deixaria uma janela em que duas
+ * requisições simultâneas com o mesmo `state` passariam as duas, e o desfecho
+ * disso é dois vínculos criados para uma autorização só.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONBOARDING_SESSION_TTL_MS = void 0;
+exports.openOnboardingSession = openOnboardingSession;
+exports.consumeOnboardingSession = consumeOnboardingSession;
+exports.failOnboardingSession = failOnboardingSession;
+exports.recordOnboardingAssets = recordOnboardingAssets;
+exports.latestOnboardingSession = latestOnboardingSession;
+const shared_1 = require("@baruk/shared");
+const onboarding_js_1 = require("../onboarding.js");
+function mapSession(r) {
+    return {
+        id: r.id,
+        tenantId: r.tenant_id,
+        product: r.product,
+        brand: r.brand,
+        channel: r.channel,
+        provider: r.provider,
+        status: r.status,
+        expiresAt: r.expires_at.toISOString(),
+        createdAt: r.created_at.toISOString(),
+        wabaRef: r.waba_ref,
+        phoneRef: r.phone_ref,
+        failureCode: r.failure_code,
+    };
+}
+const COLUMNS = `
+  id, tenant_id, product, brand, channel, provider, status,
+  expires_at, created_at, waba_ref, phone_ref, failure_code
+`;
+/**
+ * Janela de vida da sessão.
+ *
+ * Curta porque o fluxo do Embedded Signup leva minutos, não horas, e uma janela
+ * generosa só amplia o intervalo em que um `state` capturado ainda vale. Longa o
+ * bastante para o cliente terminar a verificação do número, que é o passo lento.
+ */
+exports.ONBOARDING_SESSION_TTL_MS = 30 * 60 * 1000;
+/** Abre uma sessão `pending`. Roda dentro do contexto do tenant (RLS FORCE). */
+async function openOnboardingSession(tx, input) {
+    const now = input.now ?? new Date();
+    const expiresAt = new Date(now.getTime() + (input.ttlMs ?? exports.ONBOARDING_SESSION_TTL_MS));
+    const rows = await tx `
+    INSERT INTO channel_onboarding_session
+      (id, tenant_id, product, brand, channel, provider, state_hash, created_by, expires_at)
+    VALUES
+      (${(0, shared_1.uuidv7)()}, ${input.tenantId}, ${input.product}, ${input.brand},
+       'whatsapp', 'meta_whatsapp', ${input.stateHash}, ${input.createdBy ?? null},
+       ${expiresAt.toISOString()})
+    RETURNING ${tx.unsafe(COLUMNS)}
+  `;
+    return mapSession(rows[0]);
+}
+/**
+ * Consome o `state` — uma vez, e só se ainda estiver na janela.
+ *
+ * O `UPDATE ... WHERE status = 'pending' AND expires_at > now()` é a garantia:
+ * duas requisições concorrentes disputam a mesma linha e apenas uma vê
+ * `count = 1`. A segunda recebe `not_pending`, que é a verdade.
+ *
+ * A distinção entre `unknown_state` e `not_pending` fica no servidor e **não vai
+ * para a resposta HTTP**: dizer ao cliente qual das duas foi transformaria a
+ * rota num oráculo de "este state existe neste tenant".
+ */
+async function consumeOnboardingSession(tx, input) {
+    const state = input.state?.trim() ?? '';
+    if (!state)
+        return { ok: false, reason: 'unknown_state' };
+    const stateHash = (0, onboarding_js_1.hashSignupState)(state);
+    const now = input.now ?? new Date();
+    const rows = await tx `
+    UPDATE channel_onboarding_session
+       SET status = 'consumed', consumed_at = ${now.toISOString()}, updated_at = now()
+     WHERE state_hash = ${stateHash}
+       AND status = 'pending'
+       AND expires_at > ${now.toISOString()}
+    RETURNING ${tx.unsafe(COLUMNS)}
+  `;
+    const row = rows[0];
+    if (row)
+        return { ok: true, session: mapSession(row) };
+    // Não conseguiu consumir. A linha existe (e não está mais elegível) ou nunca
+    // existiu neste tenant — a RLS já respondeu por essa segunda hipótese.
+    const existing = await tx `
+    SELECT id FROM channel_onboarding_session WHERE state_hash = ${stateHash} LIMIT 1
+  `;
+    return { ok: false, reason: existing[0] ? 'not_pending' : 'unknown_state' };
+}
+/**
+ * Marca uma sessão já consumida como falha, com a CLASSE do erro.
+ *
+ * Chamada depois de o `state` ter sido consumido e a troca com a Meta ter
+ * falhado. O status não volta para `pending`: o `code` pode ter sido gasto na
+ * tentativa, e reabrir a sessão convidaria a uma segunda troca que a Meta
+ * recusaria por motivo diferente do real.
+ */
+async function failOnboardingSession(tx, id, failureCode) {
+    await tx `
+    UPDATE channel_onboarding_session
+       SET status = 'failed', failure_code = ${failureCode.slice(0, 60)}, updated_at = now()
+     WHERE id = ${id}
+  `;
+}
+/** Registra os identificadores devolvidos pelo fluxo. Não são segredo. */
+async function recordOnboardingAssets(tx, id, refs) {
+    await tx `
+    UPDATE channel_onboarding_session
+       SET waba_ref = ${refs.wabaRef ?? null},
+           phone_ref = ${refs.phoneRef ?? null},
+           updated_at = now()
+     WHERE id = ${id}
+  `;
+}
+/** A última sessão do tenant neste canal — é o que a tela mostra. */
+async function latestOnboardingSession(tx) {
+    const rows = await tx `
+    SELECT ${tx.unsafe(COLUMNS)}
+      FROM channel_onboarding_session
+     WHERE channel = 'whatsapp'
+     ORDER BY created_at DESC
+     LIMIT 1
+  `;
+    return rows[0] ? mapSession(rows[0]) : null;
+}
+//# sourceMappingURL=onboarding.js.map

package/dist/cjs/communication/stores/onboarding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding.js","sourceRoot":"","sources":["../../../../src/communication/stores/onboarding.ts"],"names":[],"mappings":"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"}