@greatapps/common 1.1.748 → 1.1.749

package/src/modules/ia-credits/services/ia-credits.service.ts

@@ -3,12 +3,28 @@ import 'server-only';
 import { api } from '../../../infra/api/client';
 import { ApiError, ApiPaginatedActionResult, SuccessResult } from '../../../infra/api/types';
 import { getUserContext } from '../../auth/utils/get-user-context';
+import { subscriptionsService } from '../../subscriptions/services/subscriptions.service';
 import {
   IaCreditAddBatch,
   IaCreditAddBatchSchema,
   IaCreditOperation,
   IaCreditsSummaryData,
 } from '../types';
+import { AI_CREDITS_FIRST_PURCHASE_OFFER } from '../constants/ai-credits-offer.constants';
+import type {
+  AiCreditsOfferEligibility,
+  PurchaseIaCreditsInput,
+  PurchaseIaCreditsResult,
+} from '../types/ai-credits-offer.type';
+
+/** Shape da API pra elegibilidade — `price_cents`/`anchor_cents` viram camelCase ao sair do service. */
+interface AiCreditsOfferEligibilityApiItem {
+  eligible: boolean;
+  reason: AiCreditsOfferEligibility['reason'];
+  credits: number;
+  price_cents: number | null;
+  anchor_cents: number | null;
+}
 
 class IaCreditsService {
   async getSummaryData(
@@ -68,6 +84,82 @@ class IaCreditsService {
     const raw = response.data ?? [];
     return raw.map((item) => IaCreditAddBatchSchema.parse(item));
   }
+
+  /**
+   * Elegibilidade da oferta de primeira compra, pra assinatura ATIVA da conta — resolvida aqui (e
+   * não recebida por parâmetro) porque o consumidor (`createGetAiCreditsOfferEligibilityHandler`)
+   * não tem id de assinatura: a rota é `/api/ai-credits-offer/eligibility`, sem `:id`.
+   *
+   * Sem assinatura ativa a resposta já sai inelegível — nem vale bater no backend, que exige
+   * `id_subscription` na URL.
+   */
+  async offerEligibility(): Promise<AiCreditsOfferEligibility> {
+    const { id_account } = await getUserContext();
+    const { data: subscriptions } = await subscriptionsService.listSubscriptions({ limit: 1 });
+    const subscription = subscriptions[0];
+
+    if (!subscription) {
+      return {
+        eligible: false,
+        reason: 'no_active_subscription',
+        credits: AI_CREDITS_FIRST_PURCHASE_OFFER.credits,
+        priceCents: null,
+        anchorCents: null,
+      };
+    }
+
+    const endpoint = `/accounts/${id_account}/subscriptions/${subscription.id}/items/balance/purchase-offer/${AI_CREDITS_FIRST_PURCHASE_OFFER.slug}`;
+    const response = await api.apps.get<ApiPaginatedActionResult<AiCreditsOfferEligibilityApiItem>>(
+      endpoint
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao consultar elegibilidade da oferta de créditos de IA',
+        'GET_OFFER_ELIGIBILITY_FAILED',
+        400
+      );
+    }
+
+    const raw = response.data[0];
+    if (!raw) {
+      throw new ApiError(
+        'Resposta vazia ao consultar elegibilidade da oferta de créditos de IA',
+        'GET_OFFER_ELIGIBILITY_EMPTY',
+        502
+      );
+    }
+
+    return {
+      eligible: raw.eligible,
+      reason: raw.reason,
+      credits: raw.credits,
+      priceCents: raw.price_cents,
+      anchorCents: raw.anchor_cents,
+    };
+  }
+
+  /**
+   * Compra de créditos de IA — avulsa comum (`offer` ausente) OU a oferta de primeira compra
+   * (`offer: AI_CREDITS_FIRST_PURCHASE_OFFER.slug`). Devolve o envelope CRU do gapps-r3-api
+   * (`status` 1/2/0), sem reembrulhar em `SuccessResult`: quem consome é sempre o hook de compra,
+   * que já sabe interpretar esses três status (ver `usePurchaseIaCredits`).
+   */
+  async purchase(
+    subscriptionId: number | string,
+    input: PurchaseIaCreditsInput
+  ): Promise<PurchaseIaCreditsResult> {
+    const { id_account } = await getUserContext();
+
+    return api.apps.post<PurchaseIaCreditsResult>(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}/items/balance/purchase`,
+      {
+        ...(input.offer ? { offer: input.offer } : { quantity: input.quantity }),
+        payment_method: input.paymentMethod,
+        ...(input.idCard ? { id_card: input.idCard } : {}),
+      }
+    );
+  }
 }
 
 export const iaCreditsService = new IaCreditsService();

package/src/modules/ia-credits/types/ai-credits-offer.type.ts

@@ -0,0 +1,87 @@
+import z from 'zod';
+import { PAYMENT_METHOD_CARD, PAYMENT_METHOD_PIX } from '../constants/ai-credits-offer.constants';
+
+/**
+ * `reason` é sempre um código de máquina do backend — nunca renderizar como texto: o modal usa uma
+ * mensagem de erro genérica já existente no catálogo (ver `AiCreditsOfferModal`).
+ */
+export type AiCreditsOfferIneligibilityReason =
+  | 'not_default_wl'
+  | 'gateway_not_supported'
+  | 'no_active_subscription'
+  | 'already_charged'
+  | 'has_paid_plan'
+  | 'has_card'
+  | 'offer_consumed'
+  | 'offer_card_only'
+  | null;
+
+export interface AiCreditsOfferEligibility {
+  eligible: boolean;
+  reason: AiCreditsOfferIneligibilityReason;
+  credits: number;
+  /** Preço promocional em centavos. `null` quando `eligible` é `false` sem cálculo de preço. */
+  priceCents: number | null;
+  /** Preço de tabela em centavos, derivado de `getAddonUnitPrice` no backend — nunca hardcoded. */
+  anchorCents: number | null;
+}
+
+/** Resposta do route handler local — a elegibilidade do backend + o carimbo da sessão de login. */
+export interface AiCreditsOfferEligibilityResponse extends AiCreditsOfferEligibility {
+  /** `iat` do JWT no momento da consulta — usado pelo gate para saber se é uma sessão nova. */
+  sessionIssuedAt: number;
+}
+
+export interface PurchaseIaCreditsInput {
+  /** Ignorado pelo backend quando `offer` é enviado (a oferta força a quantidade do pacote). */
+  quantity?: number;
+  paymentMethod: number;
+  idCard?: string;
+  /** Slug da oferta (`AI_CREDITS_FIRST_PURCHASE_OFFER.slug`). Ausente = compra avulsa comum. */
+  offer?: string;
+}
+
+/**
+ * Corpo aceito pela rota local de compra (`createPurchaseIaCreditsHandler`) — validado no handler
+ * porque o JSON do request não é confiável: `payment_method` fora do union (1 = cartão, 3 = pix,
+ * únicos métodos que o gapps-r3-api reconhece) nem chega a virar chamada de backend.
+ */
+export const PurchaseIaCreditsRequestBodySchema = z.object({
+  quantity: z.number().optional(),
+  payment_method: z.union([z.literal(PAYMENT_METHOD_CARD), z.literal(PAYMENT_METHOD_PIX)]),
+  id_card: z.string().optional(),
+  offer: z.string().optional(),
+});
+export type PurchaseIaCreditsRequestBody = z.infer<typeof PurchaseIaCreditsRequestBodySchema>;
+
+/** Envelope PIX dentro de `data`, presente só quando a compra foi feita com `payment_method: 3`. */
+const PurchaseIaCreditsPixDataSchema = z.object({
+  correlation_id: z.string().optional(),
+  qr_code: z.string().optional(),
+  qr_code_image: z.string().optional(),
+  payment_link: z.string().optional(),
+  expires_at: z.string().optional(),
+});
+
+/**
+ * Envelope CRU do gapps-r3-api — status 1 (pago), 2 (3DS pendente) ou 0 (recusado). Devolvido
+ * sem reembrulho pelo `createPurchaseIaCreditsHandler` (ver o comentário no handler); o hook valida
+ * a resposta contra este schema em vez de confiar cegamente no `fetch`.
+ */
+export const PurchaseIaCreditsResultSchema = z.object({
+  status: z.number(),
+  message: z.string().optional(),
+  client_secret: z.string().optional(),
+  data: z
+    .array(
+      z.object({
+        credited: z.number().optional(),
+        invoice_id: z.string().optional(),
+        pending: z.number().optional(),
+        payment_method: z.number().optional(),
+        pix: PurchaseIaCreditsPixDataSchema.optional(),
+      })
+    )
+    .optional(),
+});
+export type PurchaseIaCreditsResult = z.infer<typeof PurchaseIaCreditsResultSchema>;

package/src/modules/ia-credits/utils/offer-stage-cookie.ts

@@ -0,0 +1,66 @@
+import { cookieDomainFromDomain } from '../../../utils/intl/cookie-domain';
+import { AiCreditsOfferStage } from '../constants/ai-credits-offer.constants';
+
+const COOKIE_NAME = 'ai-credits-offer-stage';
+const ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
+
+export interface OfferStageRecord {
+  stage: AiCreditsOfferStage;
+  /** `iat` do JWT na sessão em que este estágio foi gravado — é o que diferencia "sessão nova". */
+  lastSessionIat: number;
+}
+
+const EMPTY_RECORD: OfferStageRecord = {
+  stage: AiCreditsOfferStage.NONE,
+  lastSessionIat: 0,
+};
+
+/**
+ * Cookie `ai-credits-offer-stage`, no domínio pai da whitelabel (`cookieDomainFromDomain` — mesmo
+ * mecanismo do cookie de locale, que por sua vez espelha o cookie de auth `greatapps`): sustenta a
+ * escada de estágios entre app/accounts/editor, 1 ano de validade.
+ *
+ * Valor: `${idAccount}:${stage}:${lastSessionIat}`. Registro de OUTRA conta
+ * (id diferente do gravado) lê como estágio zerado — last-writer-wins, aceito porque o cookie é por
+ * navegador e trocar de conta paga no mesmo device durante a janela da oferta é evento raro.
+ */
+export function readOfferStageCookie(idAccount: number): OfferStageRecord {
+  if (typeof document === 'undefined') return EMPTY_RECORD;
+
+  const match = new RegExp(`(?:^|;\\s*)${COOKIE_NAME}=([^;]+)`).exec(document.cookie);
+  if (!match) return EMPTY_RECORD;
+
+  const raw = decodeURIComponent(match[1]);
+  const [rawAccount, rawStage, rawIat] = raw.split(':');
+
+  if (Number(rawAccount) !== idAccount) return EMPTY_RECORD;
+
+  const stage = Number(rawStage);
+  if (!(stage in AiCreditsOfferStage)) return EMPTY_RECORD;
+
+  return {
+    stage,
+    lastSessionIat: Number(rawIat) || 0,
+  };
+}
+
+export function writeOfferStageCookie(
+  idAccount: number,
+  record: OfferStageRecord,
+  whitelabelDomain?: string | null
+): void {
+  if (typeof document === 'undefined') return;
+
+  const value = `${idAccount}:${record.stage}:${record.lastSessionIat}`;
+  const domain = cookieDomainFromDomain(whitelabelDomain);
+  const parts = [
+    `${COOKIE_NAME}=${encodeURIComponent(value)}`,
+    'path=/',
+    `max-age=${ONE_YEAR_SECONDS}`,
+    'samesite=lax',
+    domain ? `domain=${domain}` : '',
+    typeof window !== 'undefined' && window.location.protocol === 'https:' ? 'secure' : '',
+  ].filter(Boolean);
+
+  document.cookie = parts.join('; ');
+}

package/src/modules/subscriptions/constants/subscription.constants.ts

@@ -3,11 +3,6 @@ export const SUBSCRIPTION_GRACE_PERIOD_DAYS = 15;
 export const ACCOUNT_FREEZE_AFTER_DAYS = 7;
 export const FREEZE_WARNING_DAYS_BEFORE = 1;
 
-/* Congelamento só vale para a wl 1: o aviso de véspera e o e-mail de bloqueio saem do
- * cron `dailyNotifications` do gapps-r3-api, que só roda para ela. Congelar as demais
- * seria bloquear sem avisar. Espelhado nos gates dos dois backends. */
 export const FREEZE_ELIGIBLE_WHITELABEL_ID = 1;
 
-/* Stripe Smart Retries (dunning): até 8 tentativas de cobrança no cartão antes
- * do cancelamento automático. `tentativas restantes = MAX - attempt_count`. */
 export const MAX_PAYMENT_ATTEMPTS = 8;

package/src/modules/subscriptions/utils/get-account-freeze-date.ts

@@ -5,19 +5,6 @@ import {
 import { toCalendarDate } from "../../../infra/utils/date";
 import type { Subscription } from "../types/subscription.type";
 
-/**
- * Data em que a conta é congelada por falta de pagamento: date_due + ACCOUNT_FREEZE_AFTER_DAYS.
- *
- * Só congela assinatura `client` da whitelabel 1 — MESMA régua do
- * `isSubscriptionFrozen` (gapps-r3-api) e do `isAccountFrozen` (gpages-r3-api).
- * Se as três divergirem, o usuário é bloqueado por uma camada e liberado por outra.
- *
- * - `type !== "client"` cobre free, trial, partner e whitelabel de uma vez (a coluna
- *   aceita mais valores do que a lista que o SubscriptionBanner enumera).
- * - `id_wl !== 1`: o pipeline de aviso (cron `dailyNotifications` do gapps-r3-api) só
- *   existe para a wl 1. Congelar conta de whitelabel seria bloquear sem nunca avisar —
- *   o defeito do ID-5029 que este card existe para não repetir.
- */
 export function getAccountFreezeDate(
   subscription:
     | Pick<Subscription, "type" | "date_due" | "id_wl">

package/src/modules/subscriptions/utils/get-account-freeze-state.ts

@@ -6,13 +6,6 @@ import type { Subscription } from "../types/subscription.type";
 
 export type AccountFreezeState = "none" | "warning" | "frozen";
 
-/**
- * Estado de congelamento por falta de pagamento (date_due + ACCOUNT_FREEZE_AFTER_DAYS).
- *
- * Conta cancelada/pendente de cancelamento é tratada pelos ramos de cancelamento
- * (mesma ordem do SubscriptionBanner) — aqui sempre "none" nesse caso, pra não
- * disputar mensagem com o CancelledSubscriptionBanner/PendingCancellationBanner.
- */
 export function getAccountFreezeState(
   subscription:
     | Pick<

package/src/store/useAiCreditsOfferModal.ts

@@ -0,0 +1,24 @@
+import { useCallback } from 'react';
+import { useModalManager } from './useModalManager';
+
+/**
+ * Oferta de primeira compra de créditos de IA. Quem abre é o `AiCreditsOfferGate` (1s depois do
+ * gatilho decidir que é a vez dela) — daí não existir payload: a oferta é sempre a mesma.
+ *
+ * Os callbacks vão em `useCallback` (as ações do zustand já são estáveis): o gate arma um
+ * `setTimeout` num efeito que tem `openModal` nas dependências, e uma identidade nova a cada render
+ * limparia o timer antes de ele disparar — a oferta nunca abriria.
+ *
+ * O fechamento usa `closeModalByKey` e não `closeModal`: o modal abre o `addCardModal` por cima (a
+ * pilha do `useModalManager` empilha), e um `closeModal` disparado com o cartão em cima derrubaria
+ * o topo da pilha, não a oferta.
+ */
+export const useAiCreditsOfferModal = () => {
+  const { activeModal, openModal, closeModalByKey } = useModalManager();
+
+  return {
+    open: activeModal === 'aiCreditsOfferModal',
+    openModal: useCallback(() => openModal('aiCreditsOfferModal'), [openModal]),
+    closeModal: useCallback(() => closeModalByKey('aiCreditsOfferModal'), [closeModalByKey]),
+  };
+};