@greatapps/common 1.1.715 → 1.1.716

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

@@ -1,37 +1,73 @@
-import 'server-only';
-
-import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, PaginatedSuccessResult } from '../../../infra/api/types';
-import { getUserContext } from '../../auth/utils/get-user-context';
-import { IaCreditOperation, IaCreditOperationSchema } from '../types';
-
-class IaCreditsService {
-  async listOperations(
-    subscriptionId: number | string
-  ): Promise<PaginatedSuccessResult<IaCreditOperation>> {
-    const { id_account } = await getUserContext();
-
-    const endpoint = `/accounts/${id_account}/subscriptions/${subscriptionId}/items/balance/list?page=1&limit=20&sort=id:DESC`;
-
-    const response = await api.apps.get<ApiPaginatedActionResult<IaCreditOperation>>(endpoint);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || 'Erro ao listar créditos de IA',
-        'LIST_IA_CREDITS_FAILED',
-        400
-      );
-    }
-
-    const raw = response.data ?? [];
-    const data = raw.map((item) => IaCreditOperationSchema.parse(item));
-
-    return {
-      data,
-      total: response.total ?? data.length,
-      success: true,
-    };
-  }
-}
-
-export const iaCreditsService = new IaCreditsService();
+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 {
+  IaCreditAddBatch,
+  IaCreditAddBatchSchema,
+  IaCreditOperation,
+  IaCreditsSummaryData,
+} from '../types';
+
+class IaCreditsService {
+  async getSummaryData(
+    subscriptionId: number | string
+  ): Promise<SuccessResult<IaCreditsSummaryData>> {
+    const { id_account } = await getUserContext();
+
+    const [availableCredits, addBatches] = await Promise.all([
+      this.fetchCurrentBalance(id_account, subscriptionId),
+      this.fetchAddBatches(id_account, subscriptionId),
+    ]);
+
+    return { success: true, data: { availableCredits, addBatches } };
+  }
+
+  // Saldo atual = balance_after_operation da última operação do extrato
+  // (sort id:DESC, limit=1). Já é o saldo do usuário, não precisa recalcular.
+  private async fetchCurrentBalance(
+    idAccount: number | string,
+    subscriptionId: number | string
+  ): Promise<number> {
+    const endpoint = `/accounts/${idAccount}/subscriptions/${subscriptionId}/items/balance/list?page=1&limit=1&sort=id:DESC`;
+
+    const response = await api.apps.get<ApiPaginatedActionResult<IaCreditOperation>>(endpoint);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao consultar saldo de créditos de IA',
+        'GET_IA_CREDITS_BALANCE_FAILED',
+        400
+      );
+    }
+
+    const balance = (response.data ?? [])[0]?.balance_after_operation;
+    return balance == null ? 0 : Number(balance);
+  }
+
+  // Lotes de adição com added/consumed/remaining já agregados pelo backend.
+  // sort id:DESC garante que os lotes mais recentes (não expirados) entram
+  // primeiro no limite; lotes expirados são filtrados no hook.
+  private async fetchAddBatches(
+    idAccount: number | string,
+    subscriptionId: number | string
+  ): Promise<IaCreditAddBatch[]> {
+    const endpoint = `/accounts/${idAccount}/subscriptions/${subscriptionId}/items/balance/list/add?page=1&limit=100&sort=id:DESC`;
+
+    const response = await api.apps.get<ApiPaginatedActionResult<IaCreditAddBatch>>(endpoint);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar lotes de créditos de IA',
+        'LIST_IA_CREDITS_ADDS_FAILED',
+        400
+      );
+    }
+
+    const raw = response.data ?? [];
+    return raw.map((item) => IaCreditAddBatchSchema.parse(item));
+  }
+}
+
+export const iaCreditsService = new IaCreditsService();

package/src/modules/ia-credits/types.ts

@@ -1,5 +1,11 @@
 import z from 'zod';
 
+// has_expired pode vir null (ou ausente) da API — normaliza para boolean.
+const hasExpiredSchema = z
+  .boolean()
+  .nullish()
+  .transform((v) => v ?? false);
+
 export const IaCreditOperationSchema = z
   .object({
     id: z.union([z.number(), z.string()]),
@@ -15,7 +21,7 @@ export const IaCreditOperationSchema = z
     operation_ref: z.string().nullable().optional(),
     operation_origin: z.string().nullable().optional(),
     expiration_time: z.string().nullable(),
-    has_expired: z.boolean(),
+    has_expired: hasExpiredSchema,
     consumed_from_add_id: z.union([z.number(), z.string()]).nullable(),
     id_user_add: z.union([z.number(), z.string()]).nullable(),
     user_name: z.string().nullable().optional(),
@@ -24,6 +30,29 @@ export const IaCreditOperationSchema = z
 
 export type IaCreditOperation = z.infer<typeof IaCreditOperationSchema>;
 
+// Lote de créditos adicionados — agregado pelo backend em
+// /items/balance/list/add (added/consumed/remaining já calculados).
+export const IaCreditAddBatchSchema = z
+  .object({
+    id: z.union([z.number(), z.string()]),
+    added_credits: z.coerce.number(),
+    consumed_credits: z.coerce.number(),
+    remaining_credits: z.coerce.number(),
+    datetime_add: z.string().nullable(),
+    expiration_time: z.string().nullable(),
+    has_expired: hasExpiredSchema,
+  })
+  .passthrough();
+
+export type IaCreditAddBatch = z.infer<typeof IaCreditAddBatchSchema>;
+
+// Payload servido pelo route handler: saldo atual (balance_after_operation)
+// + lotes de adição, de onde o hook deriva o restante do sumário.
+export type IaCreditsSummaryData = {
+  availableCredits: number;
+  addBatches: IaCreditAddBatch[];
+};
+
 export type IaCreditsSummary = {
   totalCredits: number;
   usedCredits: number;

package/src/providers/auth.provider.tsx

@@ -46,6 +46,7 @@ import { useWhitelabelUrls, useWhitelabel } from "./whitelabel.provider";
 import { useWlQueryKey } from "../hooks/useAuthQueryKey";
 import { normalizeLocale } from "../i18n/normalize";
 import { setLocaleCookie } from "../utils/intl/locale-cookie";
+import { clearHexaPromo } from "../utils/cookies/hexa-promo";
 
 interface AuthContextProps extends AuthState {
   login: (credentials: LoginRequest) => Promise<LoginResult>;
@@ -220,6 +221,8 @@ export function AuthProvider({ children, publicRoutes = [] }: AuthProviderProps)
     } catch {
       // cookie já removido no servidor mesmo se a API falhou
     } finally {
+      // Limpa o estado da promo "Rumo ao Hexa" para reabrir a modal no próximo login.
+      clearHexaPromo();
       queryClient.clear();
       window.location.assign(resolveLogoutRedirect());
     }

package/src/store/useHexaPromoModal.ts

@@ -0,0 +1,13 @@
+import { useModalManager } from './useModalManager';
+
+const HEXA_PROMO_MODAL_KEY = 'hexaPromoModal';
+
+export const useHexaPromoModal = () => {
+  const { activeModal, openModal, closeModal } = useModalManager();
+
+  return {
+    open: activeModal === HEXA_PROMO_MODAL_KEY,
+    openModal: () => openModal(HEXA_PROMO_MODAL_KEY),
+    closeModal,
+  };
+};

package/src/utils/cookies/hexa-promo.ts

@@ -0,0 +1,114 @@
+/**
+ * Estado do "Rumo ao Hexa" promo modal — persistido em **cookies no domínio registrável
+ * pai** (ex.: `accounts.greatpages.dev.br` → `.greatpages.dev.br`) para serem compartilhados
+ * entre os subdomínios dos apps (accounts/gapps ↔ pages/gpages). Assim a janela de "3 minutos
+ * online" é cumulativa entre os apps e a modal abre **uma única vez** por sessão/dia,
+ * independente de em qual app o usuário esteja.
+ *
+ * São dois cookies:
+ * - `gpromo-hexa-since` = `<dia>|<timestampMs>` — início da janela de 3 min (gravado uma vez).
+ * - `gpromo-hexa-seen`  = `<dia>` — dia em que a modal já foi exibida.
+ *
+ * `<dia>` é a data local `YYYY-MM-DD`: vira automaticamente no dia seguinte, fazendo a modal
+ * reaparecer. No logout, ambos os cookies são limpos (ver `auth.provider`), então um novo
+ * login também faz a modal reaparecer.
+ *
+ * Em localhost (sem subdomínio) caem em cookies host-scoped — equivalente ao localStorage;
+ * cross-port não compartilha (limitação aceita no dev local).
+ */
+
+const SINCE_COOKIE = 'gpromo-hexa-since';
+const SEEN_COOKIE = 'gpromo-hexa-seen';
+const MAX_AGE_SECONDS = 60 * 60 * 24 * 2; // 2 dias — folga sobre a janela de 1 dia.
+
+function parentCookieDomain(): string | undefined {
+  if (typeof window === 'undefined') return undefined;
+  const host = window.location.hostname;
+  if (!host || host === 'localhost') return undefined;
+  // IP literal → sem atributo Domain (cookie host-scoped)
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) return undefined;
+  const parts = host.split('.');
+  if (parts.length < 2) return undefined;
+  // Tira o subdomínio mais à esquerda — `accounts.greatpages.dev.br` → `.greatpages.dev.br`
+  return '.' + parts.slice(1).join('.');
+}
+
+function readCookie(name: string): string | null {
+  if (typeof document === 'undefined') return null;
+  const m = document.cookie.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
+  if (!m) return null;
+  try {
+    return decodeURIComponent(m[1]);
+  } catch {
+    return null;
+  }
+}
+
+function writeCookie(name: string, value: string): void {
+  if (typeof document === 'undefined' || typeof window === 'undefined') return;
+  const domain = parentCookieDomain();
+  const parts = [
+    `${name}=${encodeURIComponent(value)}`,
+    'Path=/',
+    `Max-Age=${MAX_AGE_SECONDS}`,
+    'SameSite=Lax',
+    domain ? `Domain=${domain}` : '',
+    window.location.protocol === 'https:' ? 'Secure' : '',
+  ].filter(Boolean);
+  try {
+    document.cookie = parts.join('; ');
+  } catch {
+    // Se o navegador bloquear cookies, seguimos com a exibição única por sessão (timer no Gate).
+  }
+}
+
+function expireCookie(name: string): void {
+  if (typeof document === 'undefined' || typeof window === 'undefined') return;
+  const domain = parentCookieDomain();
+  const parts = [
+    `${name}=`,
+    'Path=/',
+    'Max-Age=0',
+    'SameSite=Lax',
+    domain ? `Domain=${domain}` : '',
+    window.location.protocol === 'https:' ? 'Secure' : '',
+  ].filter(Boolean);
+  try {
+    document.cookie = parts.join('; ');
+  } catch {
+    // noop
+  }
+}
+
+/** Chave do dia local (`YYYY-MM-DD`) usada para reabrir a modal a cada novo dia. */
+export function hexaPromoDayKey(): string {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`;
+}
+
+export function getHexaPromoSeenDay(): string | null {
+  return readCookie(SEEN_COOKIE);
+}
+
+export function setHexaPromoSeenDay(day: string): void {
+  writeCookie(SEEN_COOKIE, day);
+}
+
+export function getHexaPromoSince(): { day: string; ms: number } | null {
+  const raw = readCookie(SINCE_COOKIE);
+  if (!raw) return null;
+  const [day, msRaw] = raw.split('|');
+  const ms = Number(msRaw);
+  if (!day || !Number.isFinite(ms)) return null;
+  return { day, ms };
+}
+
+export function setHexaPromoSince(day: string, ms: number): void {
+  writeCookie(SINCE_COOKIE, `${day}|${ms}`);
+}
+
+/** Limpa o estado da promo (chamado no logout para reabrir a modal no próximo login). */
+export function clearHexaPromo(): void {
+  expireCookie(SINCE_COOKIE);
+  expireCookie(SEEN_COOKIE);
+}