@baruk/core 0.1.0 → 0.2.0

package/dist/subscription-billing/service.js

@@ -0,0 +1,818 @@
+import { ConflictError, NotFoundError, ValidationError, uuidv7 } from '@baruk/shared';
+import { withContext } from '../db/context.js';
+import { appendAudit } from '../audit/audit.js';
+import { hashPassword } from '../auth/password.js';
+import { assignSystemRole, ensureMembership, ensureOrganization, ensureTenant, } from '../tenancy/provisioning.js';
+import { ensureProductCatalog, ensureTenantProduct } from '../products/repository.js';
+import { deriveEntitlements } from '../entitlements/derive.js';
+import { sendEmail } from '../mail/resend.js';
+import { applySubscriptionEvent, cancelSubscription, changePlan, startTrial } from './reconcile.js';
+import { dunningStepsAsEvents } from './dunning.js';
+import { resolveSubscriptionBillingProvider } from './provider/registry.js';
+import { appendDomainEvents, backofficeSummary, ensureSaasPlanCatalog, getPlan, getSubscription, insertWebhookEvent, listAllSubscriptions, listBillingEvents, listExecutedDunningSteps, listFailedWebhookEvents, listInvoices, listPublicPlans, listSubscriptionsForCron, lockTenantBilling, markWebhookEvent, recordDunningStep, setSubscriptionProviderRefs, upsertInvoice, upsertSubscription, withOperatorContext, } from './repository.js';
+import { DEFAULT_PRODUCT_KEY, SAAS_PLANS } from './plans.js';
+import { singleProductRegistry } from './product-config.js';
+function asRegistry(source) {
+    return 'resolve' in source ? source : singleProductRegistry(source);
+}
+function providerFor(cfg) {
+    return resolveSubscriptionBillingProvider(cfg.provider, {
+        apiKey: cfg.apiKey,
+        webhookSecret: cfg.webhookSecret,
+        mode: cfg.mode,
+        baseUrl: cfg.baseUrl,
+        fetchImpl: cfg.fetchImpl,
+    });
+}
+function todayOf(nowIso) {
+    return nowIso.slice(0, 10);
+}
+function addDays(nowIso, days) {
+    const d = new Date(nowIso);
+    d.setUTCDate(d.getUTCDate() + days);
+    return d.toISOString().slice(0, 10);
+}
+function addMonths(nowIso, months) {
+    const d = new Date(nowIso);
+    d.setUTCMonth(d.getUTCMonth() + months);
+    return d.toISOString().slice(0, 10);
+}
+function daysBetween(fromDate, toDate) {
+    return Math.floor((new Date(`${toDate}T00:00:00Z`).getTime() - new Date(`${fromDate}T00:00:00Z`).getTime()) /
+        86_400_000);
+}
+/** Mapeia o status da assinatura para o status do tenant (suspensão é decisão do cron). */
+function tenantStatusFor(status) {
+    switch (status) {
+        case 'trialing':
+            return 'trial';
+        case 'active':
+            return 'active';
+        case 'past_due':
+            return 'active'; // acesso segue no grace period; cron decide suspender
+        case 'canceled':
+            return 'churned';
+        default:
+            return null;
+    }
+}
+async function syncTenantStatus(tx, tenantId, status) {
+    const next = tenantStatusFor(status);
+    if (!next)
+        return;
+    await tx `UPDATE tenant SET status = ${next}, updated_at = now() WHERE id = ${tenantId} AND status <> 'suspended'`;
+}
+// ── Catálogo ─────────────────────────────────────────────────────────────────
+export { listPublicPlans, getPlan, ensureSaasPlanCatalog };
+/** Seed do catálogo padrão (chamado pelo seed do core). */
+export async function seedSaasPlans(db) {
+    await ensureProductCatalog(db);
+    await ensureSaasPlanCatalog(db, SAAS_PLANS);
+}
+function slugify(name) {
+    return name
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40);
+}
+/**
+ * Cadastro self-service (Fase 17): cria usuário + tenant em TRIAL + organização +
+ * membership com papel `owner` + entitlement do produto + assinatura `trialing`.
+ * Idempotência: e-mail já cadastrado → 409 (nunca sobrescreve credencial existente).
+ */
+export async function signupSelfService(db, input, nowIso) {
+    const email = input.email.trim().toLowerCase();
+    if (!/^[^@\s]+@[^@\s]+\.[^@\s]+$/.test(email))
+        throw new ValidationError('E-mail inválido');
+    if (input.password.length < 8)
+        throw new ValidationError('Senha deve ter ao menos 8 caracteres');
+    if (!input.companyName.trim())
+        throw new ValidationError('Nome da empresa é obrigatório');
+    const plan = await getPlan(db, input.planKey);
+    if (!plan || !plan.isActive || !plan.isPublic) {
+        throw new ValidationError(`Plano indisponível: ${input.planKey}`);
+    }
+    const existing = await db `
+    SELECT id FROM "user" WHERE email = ${email} AND deleted_at IS NULL
+  `;
+    if (existing[0]) {
+        throw new ConflictError('Já existe uma conta com este e-mail. Faça login para continuar.');
+    }
+    // Código único do tenant a partir do nome (sufixo em caso de colisão).
+    const base = slugify(input.companyName) || 'escritorio';
+    let code = base;
+    for (let i = 2;; i += 1) {
+        const clash = await db `
+      SELECT id FROM tenant WHERE lower(code) = lower(${code}) AND deleted_at IS NULL
+    `;
+        if (!clash[0])
+            break;
+        code = `${base}-${i}`;
+        if (i > 50) {
+            code = `${base}-${uuidv7().slice(-6)}`;
+            break;
+        }
+    }
+    // INSERT puro (não upsert): o papel de app pode CRIAR credencial, nunca
+    // sobrescrever (REVOKE UPDATE em user_credential — anti account-takeover).
+    // A checagem de e-mail acima já garante que o usuário é novo.
+    const userRows = await db `
+    INSERT INTO "user" (id, email, full_name, user_type, auth_provider)
+    VALUES (${uuidv7()}, ${email}, ${input.fullName.trim()}, 'staff', 'password')
+    RETURNING id
+  `;
+    const user = { id: userRows[0].id, email };
+    await db `
+    INSERT INTO user_credential (user_id, password_hash)
+    VALUES (${user.id}, ${hashPassword(input.password)})
+  `;
+    const tenantId = await ensureTenant(db, {
+        code,
+        displayName: input.companyName.trim(),
+        status: 'trial',
+        primaryProduct: 'contabil',
+    });
+    await ensureOrganization(db, tenantId, input.companyName.trim());
+    await ensureMembership(db, tenantId, user.id);
+    await assignSystemRole(db, tenantId, user.id, 'owner');
+    await ensureProductCatalog(db);
+    await ensureTenantProduct(db, tenantId, 'contabil');
+    const trialEndsAt = addDays(nowIso, plan.trialDays > 0 ? plan.trialDays : 14);
+    const { subscription, domainEvents } = startTrial(tenantId, plan.key, trialEndsAt, nowIso);
+    await withContext(db, { tenantId, userId: user.id }, async (tx) => {
+        const row = await upsertSubscription(tx, { tenantId, planKey: plan.key, subscription });
+        await appendDomainEvents(tx, row.rowId, domainEvents);
+        await appendAudit(tx, {
+            actorId: user.id,
+            action: 'signup',
+            resourceType: 'saas_subscription',
+            resourceId: row.rowId,
+            metadata: { planKey: plan.key, trialEndsAt },
+            ip: input.ip ?? null,
+            userAgent: input.userAgent ?? null,
+        });
+    });
+    return { tenantId, tenantCode: code, userId: user.id, planKey: plan.key, trialEndsAt };
+}
+export function standingFor(sub) {
+    if (!sub)
+        return { ok: false, reason: 'none' };
+    switch (sub.status) {
+        case 'active':
+            return { ok: true, reason: 'ok' };
+        case 'trialing':
+            return { ok: true, reason: 'trialing' };
+        case 'past_due':
+            return { ok: false, reason: 'past_due' };
+        case 'paused':
+            return { ok: false, reason: 'paused' };
+        default:
+            return { ok: false, reason: 'canceled' };
+    }
+}
+/** Entitlements finos derivados do plano (EntitlementSource 'PLAN', v0.1 stateless). */
+export function entitlementsForPlan(sub, plan, nowIso) {
+    if (!sub || !plan)
+        return [];
+    const standing = standingFor(sub);
+    const targetGrants = standing.ok
+        ? plan.modules.map((moduleCode) => ({ moduleCode, source: 'PLAN', expiresAt: null }))
+        : [];
+    return deriveEntitlements({
+        tenantId: sub.tenantId,
+        subscriptionId: sub.subscriptionId,
+        targetGrants,
+        current: [],
+        now: nowIso,
+    });
+}
+export async function subscriptionOverview(db, ctx, nowIso) {
+    const { sub, invoices, events } = await withContext(db, ctx, async (tx) => {
+        const sub0 = await getSubscription(tx);
+        return {
+            sub: sub0,
+            invoices: sub0 ? await listInvoices(tx) : [],
+            events: sub0 ? await listBillingEvents(tx, 20) : [],
+        };
+    });
+    // Fora da transação: getPlan usa outra conexão do pool — dentro dela seria
+    // um segundo checkout de conexão com transação aberta (deadlock de pool).
+    const plan = sub ? await getPlan(db, sub.planKey) : null;
+    return {
+        subscription: sub,
+        plan,
+        standing: standingFor(sub),
+        invoices,
+        entitlements: entitlementsForPlan(sub, plan, nowIso),
+        events,
+    };
+}
+/**
+ * Inicia o checkout do plano no gateway da plataforma. A atribuição do webhook
+ * de volta ao tenant usa `externalReference = "<tenantId>:<planKey>"` (RFC §9).
+ * Em modo 'disabled' não há gateway: o fluxo comercial segue e a ativação é
+ * manual (backoffice) — nunca cobra por falta de configuração.
+ */
+export async function startCheckout(db, ctx, source, planKey, _nowIso, productKey = DEFAULT_PRODUCT_KEY) {
+    const plan = await getPlan(db, planKey, productKey);
+    if (!plan || !plan.isActive || !plan.isPublic) {
+        throw new ValidationError(`Plano indisponível: ${planKey}`);
+    }
+    if (plan.periodicity !== 'monthly') {
+        // O checkout certificado cria link RECURRENT MENSAL; vender outra
+        // periodicidade cobraria errado. Suporte a ciclo anual é v0.2.
+        throw new ValidationError('Este plano ainda não está disponível para contratação online.');
+    }
+    // A conta de gateway e a URL de retorno saem do PRODUTO do plano — nunca de
+    // uma configuração global. É isso que impede o checkout de um produto voltar
+    // para o domínio de outro, ou cobrar na conta errada.
+    const cfg = asRegistry(source).resolve({ productKey: plan.productKey, tenantId: ctx.tenantId });
+    const provider = providerFor(cfg);
+    if (provider.mode === 'disabled') {
+        return { mode: 'disabled', provider: provider.name, url: null };
+    }
+    // 1) Leitura curta (transação própria) — nada de rede com transação aberta.
+    const snapshot = await withContext(db, ctx, async (tx) => {
+        const tenantRows = await tx `
+      SELECT display_name FROM tenant WHERE id = ${ctx.tenantId}
+    `;
+        const userRows = await tx `
+      SELECT email FROM "user" WHERE id = ${ctx.userId}
+    `;
+        const sub = await getSubscription(tx);
+        return {
+            tenantName: tenantRows[0]?.display_name ?? 'Tenant Baruk',
+            email: userRows[0]?.email ?? null,
+            existingCustomerId: sub?.providerCustomerId ?? null,
+            subRowId: sub?.rowId ?? null,
+        };
+    });
+    // 2) Gateway (até ~24s de rede) — sem transação e sem conexão do pool presa.
+    const customer = snapshot.existingCustomerId
+        ? { externalId: snapshot.existingCustomerId }
+        : await provider.ensureCustomer({
+            tenantId: ctx.tenantId,
+            name: snapshot.tenantName,
+            email: snapshot.email,
+        });
+    const checkout = await provider.createCheckout({
+        tenantId: ctx.tenantId,
+        planKey: plan.key,
+        amountBRL: plan.amountCents / 100,
+        customerExternalId: customer.externalId,
+        returnUrl: `${cfg.webBaseUrl}/checkout/retorno`,
+        description: `Assinatura Baruk — plano ${plan.name}`,
+    });
+    // 3) Persistência curta: SOMENTE as referências de provider (nunca o estado
+    // da assinatura — um webhook pode tê-la mudado durante a chamada de rede).
+    await withContext(db, ctx, async (tx) => {
+        await lockTenantBilling(tx, ctx.tenantId);
+        await setSubscriptionProviderRefs(tx, ctx.tenantId, provider.name, customer.externalId);
+        await appendAudit(tx, {
+            actorId: ctx.userId,
+            action: 'checkout_started',
+            resourceType: 'saas_subscription',
+            resourceId: snapshot.subRowId,
+            metadata: { planKey: plan.key, provider: provider.name, mode: provider.mode },
+        });
+    });
+    return { mode: provider.mode, provider: provider.name, url: checkout.url };
+}
+/**
+ * Lê o `externalReference` que voltou do gateway.
+ *
+ * Formato canônico: `"<tenantId>:<productKey>:<planKey>"`. O formato antigo de
+ * duas partes (`"<tenantId>:<planKey>"`) continua aceito para os payment links
+ * emitidos antes do multi-produto — nesses casos o produto é o Contábil, o
+ * único que existia. Sem o produto explícito, um evento de um produto poderia
+ * reconciliar a assinatura de outro no mesmo tenant.
+ */
+function parseAttribution(event) {
+    const ref = event.externalReference;
+    if (!ref)
+        return null;
+    const parts = ref.split(':');
+    if (parts.length === 3) {
+        const [tenantId, productKey, planKey] = parts;
+        if (!tenantId || !productKey || !planKey)
+            return null;
+        return { tenantId, productKey, planKey };
+    }
+    if (parts.length === 2) {
+        const [tenantId, planKey] = parts;
+        if (!tenantId || !planKey)
+            return null;
+        return { tenantId, productKey: DEFAULT_PRODUCT_KEY, planKey };
+    }
+    return null;
+}
+/**
+ * Processa um webhook do gateway: verifica autenticidade → dedup por
+ * `externalEventId` → resolve tenant via `externalReference` → reconcilia via
+ * domínio puro → espelha fatura → sincroniza tenant.status → audita.
+ * A rota SEMPRE responde 200 após o dedup (regra dos 15 não-200 do ASAAS).
+ */
+export async function processWebhook(db, source, headers, rawBody, payload, nowIso, productKey = DEFAULT_PRODUCT_KEY) {
+    // O segredo do webhook é da CONTA do produto. Como a verificação acontece
+    // antes de qualquer parsing, o produto tem de vir de fora — na prática, da
+    // própria URL cadastrada no gateway (uma por conta).
+    const cfg = asRegistry(source).resolve({ productKey });
+    const provider = providerFor(cfg);
+    if (!provider.verifyWebhook(headers, rawBody)) {
+        return { outcome: 'unauthorized' };
+    }
+    const event = provider.parseWebhookEvent(payload);
+    if (!event)
+        return { outcome: 'ignored' };
+    const webhookId = await insertWebhookEvent(db, {
+        provider: provider.name,
+        externalEventId: event.externalEventId,
+        eventType: event.eventType,
+        payload,
+    });
+    if (!webhookId)
+        return { outcome: 'duplicate' };
+    return reconcileStoredWebhookEvent(db, provider, event, webhookId, nowIso, productKey);
+}
+/**
+ * Reconcilia um evento JÁ persistido em `saas_webhook_event` (caminho comum do
+ * webhook inbound e do reprocessamento de eventos `failed` pelo cron).
+ */
+async function reconcileStoredWebhookEvent(db, provider, event, webhookId, nowIso, expectedProductKey = DEFAULT_PRODUCT_KEY) {
+    const attribution = parseAttribution(event);
+    if (!attribution) {
+        await markWebhookEvent(db, webhookId, 'ignored', null, 'externalReference ausente/inválida');
+        return { outcome: 'ignored' };
+    }
+    // ISOLAMENTO FINANCEIRO: a conta que assinou o webhook é a conta de UM
+    // produto. Se o evento alega pertencer a outro, alguém configurou a URL
+    // errada no gateway — ou é tentativa de mover dinheiro entre produtos.
+    // Recusar é obrigatório: reconciliar aqui escreveria na assinatura errada.
+    if (attribution.productKey !== expectedProductKey) {
+        await markWebhookEvent(db, webhookId, 'ignored', null, `produto divergente: evento=${attribution.productKey} conta=${expectedProductKey}`);
+        return { outcome: 'ignored' };
+    }
+    try {
+        const plan = await getPlan(db, attribution.planKey, attribution.productKey);
+        const { tenantId } = attribution;
+        const applied = await withContext(db, { tenantId }, async (tx) => {
+            await lockTenantBilling(tx, tenantId);
+            const current = await getSubscription(tx);
+            // Guarda de ordenação (webhook atrasado): um OVERDUE que chega DEPOIS do
+            // pagamento do mesmo ciclo (período corrente ainda vigente) é obsoleto —
+            // aplicá-lo marcaria past_due uma assinatura em dia. Política de
+            // orquestração; o domínio puro certificado permanece intocado.
+            if (event.invoice?.status === 'overdue' &&
+                current?.status === 'active' &&
+                current.currentPeriodEnd != null &&
+                current.currentPeriodEnd >= todayOf(nowIso)) {
+                return 'overdue obsoleto — período corrente já pago';
+            }
+            // Sem plano conhecido E sem assinatura existente não há o que reconciliar —
+            // persistir criaria uma linha órfã com plano arbitrário.
+            if (!plan && !current) {
+                return `plano desconhecido (${attribution.planKey}) sem assinatura existente`;
+            }
+            // Guarda anti-ressurreição: pagamento ANTERIOR ao cancelamento não desfaz
+            // um cancelamento explícito — reativação exige checkout novo.
+            if (current?.status === 'canceled' &&
+                current.canceledAt != null &&
+                (event.invoice?.status === 'received' || event.invoice?.status === 'confirmed') &&
+                event.invoice.paidAt != null &&
+                new Date(event.invoice.paidAt).getTime() < new Date(current.canceledAt).getTime()) {
+                return 'pagamento anterior ao cancelamento — reativação exige novo checkout';
+            }
+            // Atribuição de plano: em assinatura ATIVA o plano vem do estado interno
+            // (fonte de verdade) — payment link antigo com externalReference de plano
+            // anterior NÃO reverte um upgrade. Em ativação (trial/dormente), vale o
+            // plano efetivamente pago (externalReference).
+            const effectivePlanKey = current?.status === 'active' ? current.planKey : (plan?.key ?? null);
+            const { subscription, domainEvents } = applySubscriptionEvent({
+                current,
+                tenantId,
+                planKey: effectivePlanKey,
+                event,
+                now: nowIso,
+            });
+            // Evento informativo (ex.: PENDING) para tenant sem assinatura: nada a
+            // persistir — gravar o placeholder criaria uma assinatura 'canceled'
+            // fantasma e marcaria o tenant como churned.
+            if (!current && domainEvents.length === 0) {
+                return 'evento sem transição para tenant sem assinatura';
+            }
+            let next = subscription;
+            // Backfill: past_due nascido de trial não tem currentPeriodEnd — a régua
+            // ancora no fim do trial (senão ficaria em limbo, sem régua nem suspensão).
+            if (next.status === 'past_due' && next.currentPeriodEnd == null) {
+                next = { ...next, currentPeriodEnd: current?.trialEndsAt ?? todayOf(nowIso) };
+            }
+            // Periodicidade: o domínio v0.1 renova sempre +1 mês; planos não mensais
+            // (ativação manual/backoffice) seguem o ciclo do plano.
+            if (next.status === 'active' &&
+                plan &&
+                plan.periodicity !== 'monthly' &&
+                next.currentPeriodEnd != null) {
+                next = {
+                    ...next,
+                    currentPeriodEnd: addMonths(nowIso, plan.periodicity === 'yearly' ? 12 : 3),
+                };
+            }
+            const row = await upsertSubscription(tx, {
+                tenantId,
+                planKey: effectivePlanKey ?? current?.planKey ?? next.items[0]?.planKey ?? 'starter',
+                subscription: next,
+                provider: provider.name,
+                providerCustomerId: event.externalCustomerId ?? null,
+                providerSubscriptionId: event.subscription?.externalId ?? null,
+            });
+            await appendDomainEvents(tx, row.rowId, domainEvents);
+            if (event.invoice) {
+                await upsertInvoice(tx, {
+                    tenantId,
+                    subscriptionRowId: row.rowId,
+                    provider: provider.name,
+                    externalId: event.invoice.externalId,
+                    status: event.invoice.status,
+                    amountCents: Math.abs(Math.round((event.invoice.value ?? 0) * 100)),
+                    dueDate: event.invoice.dueDate ?? null,
+                    paidAt: event.invoice.paidAt ?? null,
+                    invoiceUrl: event.invoice.invoiceUrl ?? null,
+                    description: event.invoice.description ?? null,
+                });
+            }
+            await syncTenantStatus(tx, tenantId, next.status);
+            await appendAudit(tx, {
+                actorType: 'system',
+                action: `webhook_${event.eventType}`,
+                resourceType: 'saas_subscription',
+                resourceId: row.rowId,
+                metadata: {
+                    provider: provider.name,
+                    externalEventId: event.externalEventId,
+                    status: next.status,
+                },
+            });
+            return null;
+        });
+        if (applied !== null) {
+            await markWebhookEvent(db, webhookId, 'ignored', attribution.tenantId, applied);
+            return { outcome: 'ignored', tenantId: attribution.tenantId };
+        }
+        await markWebhookEvent(db, webhookId, 'processed', attribution.tenantId);
+        return { outcome: 'processed', tenantId: attribution.tenantId };
+    }
+    catch (err) {
+        await markWebhookEvent(db, webhookId, 'failed', attribution.tenantId, err instanceof Error ? err.message : String(err));
+        return { outcome: 'failed', tenantId: attribution.tenantId };
+    }
+}
+// ── Gestão da assinatura (tenant) ────────────────────────────────────────────
+export async function changePlanForTenant(db, ctx, newPlanKey, nowIso) {
+    const plan = await getPlan(db, newPlanKey);
+    if (!plan || !plan.isActive)
+        throw new ValidationError(`Plano desconhecido: ${newPlanKey}`);
+    return withContext(db, ctx, async (tx) => {
+        await lockTenantBilling(tx, ctx.tenantId);
+        const current = await getSubscription(tx);
+        if (!current)
+            throw new NotFoundError('Nenhuma assinatura para este tenant');
+        if (current.status === 'canceled') {
+            throw new ValidationError('Assinatura cancelada — reative antes de trocar de plano.');
+        }
+        if (current.planKey === plan.key)
+            return current;
+        const { subscription, domainEvents } = changePlan(current, plan.key, nowIso);
+        const row = await upsertSubscription(tx, {
+            tenantId: ctx.tenantId,
+            planKey: plan.key,
+            subscription,
+        });
+        await appendDomainEvents(tx, row.rowId, domainEvents);
+        await appendAudit(tx, {
+            actorId: ctx.userId,
+            action: 'plan_changed',
+            resourceType: 'saas_subscription',
+            resourceId: row.rowId,
+            diff: { from: current.planKey, to: plan.key },
+        });
+        return row;
+    });
+}
+export async function cancelForTenant(db, ctx, nowIso) {
+    return withContext(db, ctx, async (tx) => {
+        await lockTenantBilling(tx, ctx.tenantId);
+        const current = await getSubscription(tx);
+        if (!current)
+            throw new NotFoundError('Nenhuma assinatura para este tenant');
+        if (current.status === 'canceled')
+            return current;
+        const { subscription, domainEvents } = cancelSubscription(current, nowIso);
+        const row = await upsertSubscription(tx, {
+            tenantId: ctx.tenantId,
+            planKey: current.planKey,
+            subscription,
+        });
+        await appendDomainEvents(tx, row.rowId, domainEvents);
+        await syncTenantStatus(tx, ctx.tenantId, subscription.status);
+        await appendAudit(tx, {
+            actorId: ctx.userId,
+            action: 'subscription_canceled',
+            resourceType: 'saas_subscription',
+            resourceId: row.rowId,
+        });
+        return row;
+    });
+}
+/**
+ * Reativação: assinatura cancelada/past_due volta pelo PAGAMENTO (checkout →
+ * webhook `received` reativa via reconcile). Este método só valida o estado e
+ * devolve o checkout; em modo 'disabled' a reativação é manual (backoffice).
+ */
+export async function reactivateForTenant(db, ctx, source, nowIso, productKey = DEFAULT_PRODUCT_KEY) {
+    const sub = await withContext(db, ctx, (tx) => getSubscription(tx, productKey));
+    if (!sub)
+        throw new NotFoundError('Nenhuma assinatura para este tenant');
+    if (sub.status === 'active' || sub.status === 'trialing') {
+        throw new ValidationError('Assinatura já está ativa.');
+    }
+    return startCheckout(db, ctx, source, sub.planKey, nowIso, sub.productKey);
+}
+// ── Backoffice (operadora) ───────────────────────────────────────────────────
+export async function backofficeListSubscriptions(db, filter = {}) {
+    return withOperatorContext(db, (tx) => listAllSubscriptions(tx, filter));
+}
+export async function backofficeOverview(db) {
+    return withOperatorContext(db, (tx) => backofficeSummary(tx));
+}
+export async function backofficeListWebhookEvents(db, limit = 100) {
+    const rows = await db `
+    SELECT id, tenant_id, provider, external_event_id, event_type, status, error, processed_at, created_at
+    FROM saas_webhook_event ORDER BY created_at DESC LIMIT ${limit}
+  `;
+    return rows.map((r) => ({
+        id: r.id,
+        tenantId: r.tenant_id ?? null,
+        provider: r.provider,
+        externalEventId: r.external_event_id,
+        eventType: r.event_type,
+        status: r.status,
+        error: r.error ?? null,
+        processedAt: r.processed_at ? new Date(r.processed_at).toISOString() : null,
+        createdAt: new Date(r.created_at).toISOString(),
+    }));
+}
+/**
+ * Ativação manual pela operadora (modo 'disabled' ou pagamento fora do gateway):
+ * simula uma fatura `received` e reconcilia pelo MESMO caminho do webhook —
+ * nenhuma transição de estado fora do domínio puro.
+ */
+export async function backofficeActivateSubscription(db, operatorEmail, tenantId, planKey, nowIso) {
+    const plan = await getPlan(db, planKey);
+    if (!plan)
+        throw new ValidationError(`Plano desconhecido: ${planKey}`);
+    return withContext(db, { tenantId }, async (tx) => {
+        await lockTenantBilling(tx, tenantId);
+        const current = await getSubscription(tx);
+        const manualEvent = {
+            externalEventId: `manual_${uuidv7()}`,
+            eventType: 'manual.activation',
+            kind: 'invoice',
+            invoice: {
+                externalId: `manual_${uuidv7()}`,
+                status: 'received',
+                value: plan.amountCents / 100,
+                paidAt: nowIso,
+                description: `Ativação manual (${operatorEmail})`,
+            },
+            externalReference: `${tenantId}:${plan.productKey ?? DEFAULT_PRODUCT_KEY}:${plan.key}`,
+        };
+        const { subscription, domainEvents } = applySubscriptionEvent({
+            current,
+            tenantId,
+            planKey: plan.key,
+            event: manualEvent,
+            now: nowIso,
+        });
+        const row = await upsertSubscription(tx, {
+            tenantId,
+            planKey: plan.key,
+            subscription,
+            provider: 'manual',
+        });
+        await appendDomainEvents(tx, row.rowId, domainEvents);
+        await upsertInvoice(tx, {
+            tenantId,
+            subscriptionRowId: row.rowId,
+            provider: 'manual',
+            externalId: manualEvent.invoice.externalId,
+            status: 'received',
+            amountCents: plan.amountCents,
+            paidAt: nowIso,
+            description: manualEvent.invoice.description ?? null,
+        });
+        await syncTenantStatus(tx, tenantId, subscription.status);
+        await appendAudit(tx, {
+            actorType: 'user',
+            action: 'backoffice_manual_activation',
+            resourceType: 'saas_subscription',
+            resourceId: row.rowId,
+            metadata: { operatorEmail, planKey: plan.key },
+        });
+        return row;
+    });
+}
+/**
+ * Reprocessa eventos de webhook `failed` recentes (rede de segurança para o
+ * caso "falhou após o dedup e respondemos 200"). Idempotente: reconciliar um
+ * efeito já refletido é no-op de domínio; o passo é chamado pelo cron.
+ */
+export async function retryFailedWebhookEvents(db, source, nowIso, limit = 25, productKey = DEFAULT_PRODUCT_KEY) {
+    const cfg = asRegistry(source).resolve({ productKey });
+    const provider = providerFor(cfg);
+    const failed = await listFailedWebhookEvents(db, limit);
+    let recovered = 0;
+    for (const row of failed) {
+        if (row.provider !== provider.name)
+            continue;
+        const event = provider.parseWebhookEvent(row.payload);
+        if (!event) {
+            await markWebhookEvent(db, row.id, 'ignored', null, 'payload não parseável no reprocessamento');
+            continue;
+        }
+        const result = await reconcileStoredWebhookEvent(db, provider, event, row.id, nowIso, productKey);
+        if (result.outcome === 'processed' || result.outcome === 'ignored')
+            recovered += 1;
+    }
+    return { retried: failed.length, recovered };
+}
+async function ownerEmailForTenant(tx, tenantId) {
+    const rows = await tx `
+    SELECT u.email FROM membership m
+    JOIN "user" u ON u.id = m.user_id
+    WHERE m.tenant_id = ${tenantId} AND m.deleted_at IS NULL AND m.status = 'active'
+    ORDER BY m.created_at ASC LIMIT 1
+  `;
+    return rows[0]?.email ?? null;
+}
+/**
+ * Executor de política temporal — idempotente, seguro para rodar a cada hora
+ * (Render Cron). Trial vencido → `past_due`; período vencido → `past_due`;
+ * `past_due` → régua de inadimplência (stepKey idempotente) + e-mail best-effort;
+ * atraso ≥ `suspendAfterDays` → tenant `suspended`.
+ */
+export async function runBillingCron(db, source, nowIso) {
+    const registry = asRegistry(source);
+    const today = todayOf(nowIso);
+    const report = {
+        examined: 0,
+        trialsExpired: 0,
+        periodsExpired: 0,
+        dunningStepsExecuted: 0,
+        tenantsSuspended: 0,
+        emailsSent: 0,
+        webhooksRetried: 0,
+        webhooksRecovered: 0,
+    };
+    // Rede de segurança: reprocessa webhooks que falharam após o dedup/200.
+    // Um passe por produto configurado — cada conta de gateway tem a sua fila.
+    for (const productKey of registry.productKeys()) {
+        const retry = await retryFailedWebhookEvents(db, registry, nowIso, 25, productKey);
+        report.webhooksRetried += retry.retried;
+        report.webhooksRecovered += retry.recovered;
+    }
+    const subs = await withOperatorContext(db, (tx) => listSubscriptionsForCron(tx, today));
+    report.examined = subs.length;
+    for (const sub of subs) {
+        // Isolamento de falha: um tenant quebrado não pode derrubar a régua dos demais.
+        try {
+            let dunningEmailTo = null;
+            // Política de suspensão, remetente e base pública são DO PRODUTO desta
+            // assinatura — nunca de uma configuração global compartilhada.
+            const cfg = registry.resolve({ productKey: sub.productKey, tenantId: sub.tenantId });
+            await withContext(db, { tenantId: sub.tenantId }, async (tx) => {
+                await lockTenantBilling(tx, sub.tenantId);
+                const loaded = await getSubscription(tx, sub.productKey);
+                if (!loaded)
+                    return; // sumiu entre o scan e o lock (ex.: tenant removido)
+                let current = loaded;
+                // 1. Trial vencido ou período vencido → past_due (evento canônico).
+                const trialExpired = current.status === 'trialing' &&
+                    current.trialEndsAt != null &&
+                    current.trialEndsAt < today;
+                const periodExpired = current.status === 'active' &&
+                    current.currentPeriodEnd != null &&
+                    current.currentPeriodEnd < today;
+                if (trialExpired || periodExpired) {
+                    const overdueEvent = {
+                        externalEventId: `cron_${today}_${current.subscriptionId}_overdue`,
+                        eventType: trialExpired ? 'cron.trial_expired' : 'cron.period_expired',
+                        kind: 'invoice',
+                        invoice: {
+                            externalId: `cron_${today}_${current.subscriptionId}`,
+                            status: 'overdue',
+                            value: 0,
+                        },
+                        externalReference: `${current.tenantId}:${current.productKey}:${current.planKey}`,
+                    };
+                    // Trial não tem `current` past_due-ável no reconcile? Tem: overdue exige assinatura existente — ok.
+                    const { subscription, domainEvents } = applySubscriptionEvent({
+                        current,
+                        tenantId: current.tenantId,
+                        planKey: current.planKey,
+                        event: overdueEvent,
+                        now: nowIso,
+                    });
+                    if (subscription.status === 'past_due' && current.status !== 'past_due') {
+                        if (trialExpired)
+                            report.trialsExpired += 1;
+                        else
+                            report.periodsExpired += 1;
+                        // Referência da régua: fim do trial ou do período.
+                        const reference = current.trialEndsAt ?? current.currentPeriodEnd ?? today;
+                        const next = {
+                            ...subscription,
+                            currentPeriodEnd: subscription.currentPeriodEnd ?? reference,
+                        };
+                        const row = await upsertSubscription(tx, {
+                            tenantId: current.tenantId,
+                            planKey: current.planKey,
+                            subscription: next,
+                        });
+                        await appendDomainEvents(tx, row.rowId, domainEvents);
+                        await appendAudit(tx, {
+                            actorType: 'automation',
+                            action: trialExpired ? 'trial_expired' : 'period_expired',
+                            resourceType: 'saas_subscription',
+                            resourceId: row.rowId,
+                        });
+                        current = (await getSubscription(tx));
+                    }
+                }
+                // 2. Régua de inadimplência (idempotente por stepKey + reference_date).
+                if (current.status === 'past_due') {
+                    const reference = current.currentPeriodEnd ?? current.trialEndsAt ?? today;
+                    const executed = await listExecutedDunningSteps(tx, current.rowId, reference);
+                    const events = dunningStepsAsEvents({ ...current, currentPeriodEnd: reference }, today, executed);
+                    for (const ev of events) {
+                        const stepKey = ev.data.dunningStep?.stepKey ??
+                            `step_${ev.sequence}`;
+                        await recordDunningStep(tx, {
+                            tenantId: current.tenantId,
+                            subscriptionRowId: current.rowId,
+                            stepKey,
+                            referenceDate: reference,
+                        });
+                        report.dunningStepsExecuted += 1;
+                    }
+                    if (events.length > 0) {
+                        await appendDomainEvents(tx, current.rowId, events);
+                        dunningEmailTo = await ownerEmailForTenant(tx, current.tenantId);
+                        await upsertSubscription(tx, {
+                            tenantId: current.tenantId,
+                            planKey: current.planKey,
+                            subscription: { ...current, sequence: current.sequence + events.length },
+                        });
+                    }
+                    // 3. Suspensão automática após o grace period.
+                    const overdueDays = daysBetween(reference, today);
+                    if (overdueDays >= cfg.suspendAfterDays) {
+                        const updated = await tx `
+            UPDATE tenant SET status = 'suspended', updated_at = now()
+            WHERE id = ${current.tenantId} AND status <> 'suspended'
+          `;
+                        if (updated.count > 0) {
+                            report.tenantsSuspended += 1;
+                            await appendAudit(tx, {
+                                actorType: 'automation',
+                                action: 'tenant_suspended_overdue',
+                                resourceType: 'tenant',
+                                resourceId: current.tenantId,
+                                metadata: { overdueDays },
+                            });
+                        }
+                    }
+                }
+            });
+            // Envio FORA da transação (best-effort com timeout): rede nunca segura o banco.
+            if (dunningEmailTo) {
+                const sent = await sendEmail(cfg.resendApiKey, {
+                    from: cfg.emailFrom,
+                    to: dunningEmailTo,
+                    subject: 'Sua assinatura Baruk está com pagamento pendente',
+                    html: `<p>Olá,</p><p>Identificamos uma pendência na assinatura da sua conta Baruk.</p><p>Regularize para manter seus serviços ativos: <a href="${cfg.webBaseUrl}/assinatura">gerenciar assinatura</a>.</p><p>Se o pagamento já foi feito, desconsidere este aviso.</p>`,
+                });
+                if (sent)
+                    report.emailsSent += 1;
+            }
+        }
+        catch (err) {
+            // Registrado e seguimos: a assinatura problemática fica para a próxima execução.
+            console.error(`billing-cron: falha ao processar tenant ${sub.tenantId}:`, err instanceof Error ? err.message : err);
+        }
+    }
+    return report;
+}
+//# sourceMappingURL=service.js.map