@greatapps/common 1.1.751 → 1.1.752

package/src/modules/ia-credits/hooks/purchase-ia-credits.hook.ts

@@ -0,0 +1,43 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { PurchaseIaCreditsResultSchema } from '../types/ai-credits-offer.type';
+import type { PurchaseIaCreditsInput, PurchaseIaCreditsResult } from '../types/ai-credits-offer.type';
+
+/**
+ * Compra de créditos de IA — avulsa comum OU a oferta de primeira compra (`offer` no input). POSTa
+ * na rota local `/api/subscriptions/:id/credits/purchase` (`createPurchaseIaCreditsHandler`), que
+ * repassa CRU pro gapps-r3-api. A resposta:
+ * - `{ status: 1, data: [{ credited }] }` — cartão pago, créditos concedidos na hora.
+ * - `{ status: 2, client_secret }` — cartão pediu 3DS (confirmar com `confirmPaymentIfRequired`
+ *   e re-postar o MESMO input: a chave de idempotência do backend devolve a mesma cobrança já paga).
+ * - `{ status: 0, message }` — recusado ou inelegível.
+ *
+ * Um hook só pros dois fluxos (avulsa e oferta): quem recusa PIX na oferta é o backend, o front
+ * não precisa saber a regra.
+ */
+export function usePurchaseIaCredits() {
+  const queryClient = useQueryClient();
+  const iaCreditsKey = useAuthQueryKey(['ia-credits']);
+
+  return useMutation({
+    mutationFn: async (
+      input: PurchaseIaCreditsInput & { subscriptionId: number | string }
+    ): Promise<PurchaseIaCreditsResult> => {
+      const response = await fetch(`/api/subscriptions/${input.subscriptionId}/credits/purchase`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          ...(input.offer ? { offer: input.offer } : { quantity: input.quantity }),
+          payment_method: input.paymentMethod,
+          ...(input.idCard ? { id_card: input.idCard } : {}),
+        }),
+      });
+      return PurchaseIaCreditsResultSchema.parse(await response.json());
+    },
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: iaCreditsKey });
+    },
+  });
+}

package/src/modules/ia-credits/hooks/use-offer-eligibility.hook.ts

@@ -0,0 +1,28 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { AI_CREDITS_OFFER_ELIGIBILITY_QUERY_KEY } from '../constants/ai-credits-offer.constants';
+import type { AiCreditsOfferEligibilityResponse } from '../types/ai-credits-offer.type';
+
+export interface UseAiCreditsOfferEligibilityOptions {
+  enabled?: boolean;
+}
+
+/**
+ * Elegibilidade da oferta de primeira compra de créditos de IA, resolvida SEMPRE no servidor
+ * (`GET /api/ai-credits-offer/eligibility`) — o `AiCreditsOfferGate` trata erro/timeout como
+ * inelegível (fail closed): sem confirmação do backend, a oferta não abre.
+ */
+export function useAiCreditsOfferEligibility(options: UseAiCreditsOfferEligibilityOptions = {}) {
+  const queryKey = useAuthQueryKey([...AI_CREDITS_OFFER_ELIGIBILITY_QUERY_KEY]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<AiCreditsOfferEligibilityResponse>('/api/ai-credits-offer/eligibility', { signal }),
+    enabled: options.enabled ?? true,
+    staleTime: 30_000,
+  });
+}

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,70 @@
+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;
+  /** Quantas vezes um estágio REPETÍVEL (campanha / sem crédito) já foi apresentado. */
+  repeatCount: number;
+}
+
+const EMPTY_RECORD: OfferStageRecord = {
+  stage: AiCreditsOfferStage.NONE,
+  lastSessionIat: 0,
+  repeatCount: 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}:${repeatCount}`. 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, rawRepeat] = 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,
+    repeatCount: Number(rawRepeat) || 0,
+  };
+}
+
+export function writeOfferStageCookie(
+  idAccount: number,
+  record: OfferStageRecord,
+  whitelabelDomain?: string | null
+): void {
+  if (typeof document === 'undefined') return;
+
+  const value = `${idAccount}:${record.stage}:${record.lastSessionIat}:${record.repeatCount}`;
+  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/plans/services/plans.service.ts

@@ -32,8 +32,8 @@ class PlansService {
     const sort = params?.sort ?? "id:ASC";
     const active = params?.active ?? "";
     const search = params?.search ?? "";
-    // v7: descarta as entradas v6 que não têm o campo pricing (ancoragem de preço)
-    return `${key}-${idWl}-${idAccount}-${sort}-${active}-${search}-v7`;
+    // v6: descarta as entradas v5 que ficaram vivas durante a janela sem cache
+    return `${key}-${idWl}-${idAccount}-${sort}-${active}-${search}-v6`;
   }
 
   /**
@@ -92,7 +92,7 @@ class PlansService {
 
   async findById(idPlan: number | string): Promise<SuccessResult<Plan>> {
     const { id_wl, id_account } = await getUserContext();
-    const cacheKey = this.buildCacheKey(`plan-${idPlan}-v3`, {
+    const cacheKey = this.buildCacheKey(`plan-${idPlan}-v2`, {
       id_wl,
       id_account: String(id_account),
     });

package/src/modules/plans/types/plan.type.ts

@@ -83,7 +83,6 @@ export type UiPlan = {
   originalPrice: string;
   price: string;
   pricingByPeriod?: PlanPricingByPeriod;
-  pricing?: PlanApiPricing;
   buttonVariant?: 'brand' | 'default';
   priceUnavailable?: boolean;
   items: PlanItem[];

package/src/modules/plans/utils/map-api-plan-to-ui.ts

@@ -172,7 +172,6 @@ function buildUiPlan(plan: Plan, currency: CurrencyCode, translate?: TranslateFn
     originalPrice: priceUnavailable ? unavailableLabel : formatCurrencyNumber(monthlyFinal, 2, currency),
     price: priceUnavailable ? unavailableLabel : formatCurrencyNumber(monthlyFinal, 2, currency),
     pricingByPeriod,
-    pricing: plan.pricing,
     priceUnavailable,
     items: currencyAwareItems,
   };

package/src/modules/subscriptions/types/calculate-subscription.type.ts

@@ -68,10 +68,6 @@ export const CalculateSubscriptionResponseSchema = z.object({
   month_original: z.number(),
   month_original_discount: z.number().optional().default(0),
   month_original_discount_cupom: z.number().optional().default(0),
-  // Preço "de" (âncora riscada) e badge de desconto declarado da vitrine. Ausentes
-  // quando não há ancoragem (whitelabel != 1, USD, grandfathered) — ver CONTRATO DE CAMPOS.
-  month_list: z.number().optional(),
-  month_badge_percent: z.number().optional(),
   semmester: z.number(),
   semmester_price: z.number().optional().default(0),
   semmester_discount: z.number(),
@@ -79,16 +75,12 @@ export const CalculateSubscriptionResponseSchema = z.object({
   semmester_original: z.number(),
   semmester_original_discount: z.number().optional().default(0),
   semmester_original_discount_cupom: z.number().optional().default(0),
-  semmester_list: z.number().optional(),
-  semmester_badge_percent: z.number().optional(),
   year: z.number(),
   year_discount: z.number(),
   year_discount_coupom: z.number().optional().default(0),
   year_original: z.number(),
   year_original_discount: z.number().optional().default(0),
   year_original_discount_cupom: z.number().optional().default(0),
-  year_list: z.number().optional(),
-  year_badge_percent: z.number().optional(),
   plan_extras: z.array(CalculateSubscriptionPlanExtraResponseSchema),
   target: CalculateSubscriptionTargetSchema.optional().nullable(),
 });

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]),
+  };
+};