@greatapps/common 1.1.744 → 1.1.746

package/src/i18n/messages/en-us.ts

@@ -432,6 +432,37 @@ const messages = {
       knowPlans: 'View plans',
     },
   },
+  subscription: {
+    frozen: {
+      banner: {
+        message: 'Your account resources are blocked due to missing payment.',
+        regularize: 'Update subscription',
+      },
+      warningBanner: {
+        message: 'Payment overdue: your account resources will be blocked on {freezeDate}. Pay now to keep your access.',
+        details: 'Details',
+      },
+      modal: {
+        title: 'Your account resources are blocked',
+        description: 'We could not identify your payment, so these resources are blocked:',
+        warningTitle: 'Your resources will be blocked on {freezeDate}',
+        warningDescription: 'Your payment is overdue. If we do not identify it by then, these resources will be blocked:',
+        keepsWorking: 'Your published pages stay online and your leads keep coming in. Everything is restored automatically once the payment goes through.',
+        resources: {
+          pages: 'Publishing, creating and editing pages',
+          projects: 'Creating and editing projects',
+          leadsExport: 'Exporting leads',
+          pageSettings: 'Page settings, including lead notifications',
+          domains: 'Connecting new domains',
+          users: 'Inviting users and changing team permissions',
+          abTests: 'Creating and editing A/B tests',
+          uploads: 'Uploading images, PDFs and other files',
+          integrations: 'Managing integrations',
+        },
+        cta: 'Update subscription',
+      },
+    },
+  },
   forms: {
     combobox: {
       placeholder: 'Select an option',

package/src/i18n/messages/es-es.ts

@@ -433,6 +433,37 @@ const messages = {
       knowPlans: 'Conoce nuestros planes',
     },
   },
+  subscription: {
+    frozen: {
+      banner: {
+        message: 'Los recursos de tu cuenta están bloqueados por falta de pago.',
+        regularize: 'Regularizar suscripción',
+      },
+      warningBanner: {
+        message: 'Pago atrasado: los recursos de tu cuenta se bloquearán el {freezeDate}. Regulariza para no perder el acceso.',
+        details: 'Detalles',
+      },
+      modal: {
+        title: 'Los recursos de tu cuenta están bloqueados',
+        description: 'No identificamos el pago, así que estos recursos están bloqueados:',
+        warningTitle: 'Tus recursos se bloquearán el {freezeDate}',
+        warningDescription: 'El pago está atrasado. Si no lo identificamos hasta entonces, estos recursos se bloquearán:',
+        keepsWorking: 'Tus páginas publicadas siguen en línea y tus leads se siguen capturando. Todo vuelve automáticamente en cuanto se identifique el pago.',
+        resources: {
+          pages: 'Publicar, crear y editar páginas',
+          projects: 'Crear y editar proyectos',
+          leadsExport: 'Exportar leads',
+          pageSettings: 'Configuración de la página, incluidas las notificaciones de leads',
+          domains: 'Conectar nuevos dominios',
+          users: 'Invitar usuarios y cambiar permisos del equipo',
+          abTests: 'Crear y editar pruebas A/B',
+          uploads: 'Subir imágenes, PDF y otros archivos',
+          integrations: 'Gestionar integraciones',
+        },
+        cta: 'Regularizar suscripción',
+      },
+    },
+  },
   forms: {
     combobox: {
       placeholder: 'Selecciona una opción',

package/src/i18n/messages/pt-br.ts

@@ -448,6 +448,40 @@ const messages = {
     },
   },
 
+  // Congelamento por falta de pagamento (date_due + 7d) — banner, aviso de
+  // véspera e modal única entre as 3 aplicações.
+  subscription: {
+    frozen: {
+      banner: {
+        message: 'Os recursos da sua conta estão bloqueados por falta de pagamento.',
+        regularize: 'Regularizar assinatura',
+      },
+      warningBanner: {
+        message: 'Pagamento em atraso: os recursos da sua conta serão bloqueados em {freezeDate}. Regularize para não perder o acesso.',
+        details: 'Detalhes',
+      },
+      modal: {
+        title: 'Recursos da sua conta bloqueados',
+        description: 'O pagamento não foi identificado, então estes recursos estão bloqueados:',
+        warningTitle: 'Seus recursos serão bloqueados em {freezeDate}',
+        warningDescription: 'O pagamento está em atraso. Se não for identificado até lá, estes recursos serão bloqueados:',
+        keepsWorking: 'Suas páginas publicadas continuam no ar e seus leads seguem sendo capturados. Assim que o pagamento for identificado, tudo volta automaticamente.',
+        resources: {
+          pages: 'Publicar, criar e editar páginas',
+          projects: 'Criar e editar projetos',
+          leadsExport: 'Exportar leads',
+          pageSettings: 'Configurações da página, incluindo notificações de leads',
+          domains: 'Conectar novos domínios',
+          users: 'Convidar usuários e alterar permissões da equipe',
+          abTests: 'Criar e editar testes A/B',
+          uploads: 'Enviar imagens, PDFs e outros arquivos',
+          integrations: 'Gerenciar integrações',
+        },
+        cta: 'Regularizar assinatura',
+      },
+    },
+  },
+
   // Nomes dos idiomas exibidos no seletor.
   // Planos: features e main features (mapApiPlanToUiPlan).
   plans: {

package/src/index.ts

@@ -84,9 +84,12 @@ export { useSubscriptions } from "./modules/subscriptions/hooks/list-subscriptio
 export {
   SUBSCRIPTIONS_QUERY_KEY,
   CHARGES_QUERY_KEY,
+  FREEZE_NOTICE_QUERY_KEY,
 } from "./modules/subscriptions/constants/query-keys.constants";
 export { useActiveSubscription } from "./modules/subscriptions/hooks/find-active-subscription.hook";
 export { useCancelledSubscriptionGuard } from "./modules/subscriptions/hooks/use-cancelled-subscription-guard";
+export { useAccountFreeze } from "./modules/subscriptions/hooks/use-account-freeze.hook";
+export { useFreezeNotice } from "./modules/subscriptions/hooks/use-freeze-notice.hook";
 export { usePlanById } from "./modules/plans/hooks/use-plan-by-id.hook";
 export { useHasPlanAddon } from "./modules/plans/hooks/use-has-plan-addon.hook";
 export { useCalculateSubscription } from "./modules/subscriptions/hooks/calculate-subscription.hook";
@@ -199,6 +202,14 @@ export {
 export { SUBSCRIPTION_GRACE_PERIOD_DAYS } from "./modules/subscriptions/constants/subscription.constants";
 export { getSubscriptionCancellationState } from "./modules/subscriptions/utils/get-subscription-cancellation-state";
 export type { SubscriptionCancellationState } from "./modules/subscriptions/utils/get-subscription-cancellation-state";
+export {
+  ACCOUNT_FREEZE_AFTER_DAYS,
+  FREEZE_WARNING_DAYS_BEFORE,
+} from "./modules/subscriptions/constants/subscription.constants";
+export { getAccountFreezeState } from "./modules/subscriptions/utils/get-account-freeze-state";
+export type { AccountFreezeState } from "./modules/subscriptions/utils/get-account-freeze-state";
+export { getAccountFreezeDate } from "./modules/subscriptions/utils/get-account-freeze-date";
+export type { FreezeNotice } from "./modules/subscriptions/types/freeze-notice.type";
 export {
   useCountPages,
   COUNT_PAGES_QUERY_KEY,
@@ -216,6 +227,7 @@ export { useAccountDeletionWarningModal } from "./store/useAccountDeletionWarnin
 export { default as BuyCreditsModal } from "./components/modals/BuyCreditsModal";
 export { default as CreditsDisabledModal } from "./components/modals/CreditsDisabledModal";
 export { default as PaidPlanRequiredModal } from "./components/modals/PaidPlanRequiredModal";
+export { default as AccountFrozenModal } from "./components/modals/AccountFrozenModal";
 export { default as AccountDeletionWarningModal } from "./components/modals/AccountDeletionWarningModal";
 export { default as RequiredBillingDataModal } from "./components/modals/billing/RequiredBillingDataModal";
 export { default as AddCardModal } from "./components/modals/cards/AddCardModal";
@@ -294,6 +306,8 @@ export { SubscriptionBanner } from "./components/navigation/SubscriptionBanner";
 export { OverdueInvoiceBanner } from "./components/navigation/OverdueInvoiceBanner";
 export { UpcomingInvoiceBanner } from "./components/navigation/UpcomingInvoiceBanner";
 export { TrialBanner } from "./components/navigation/TrialBanner";
+export { FrozenAccountBanner } from "./components/navigation/FrozenAccountBanner";
+export { FreezeWarningBanner } from "./components/navigation/FreezeWarningBanner";
 export type { NavItemConfig } from "./components/navigation/subcomponents/NavItems";
 export { useMobileNavbarSheet } from "./store/useMobileNavbarSheet";
 

package/src/modules/auth/utils/assert-account-not-frozen.ts

@@ -0,0 +1,38 @@
+import "server-only";
+
+import { ApiError } from "../../../infra/api/types";
+import { listSubscriptionsAction } from "../../subscriptions/actions/list-subscriptions.action";
+import { getAccountFreezeState } from "../../subscriptions/utils/get-account-freeze-state";
+
+/**
+ * Bloqueia mutações de conta congelada por falta de pagamento (date_due + 7d).
+ *
+ * Fail-OPEN na leitura: falha de rede/payload ao consultar billing não pode
+ * travar cliente adimplente. Diferente do assertManagementSubscription
+ * (default-deny) porque ali o risco é liberar entitlement não contratado; aqui
+ * o gate primário já é este server action, e o caso vencido (expired) continua
+ * coberto pelo assertManagementSubscription rodando ao lado.
+ */
+export async function assertAccountNotFrozen(): Promise<void> {
+  const result = await listSubscriptionsAction({ active: true });
+
+  if (!result.success) {
+    console.error(
+      "[assertAccountNotFrozen] failed to read subscription context:",
+      result.error,
+    );
+    return;
+  }
+
+  const subscription = result.data?.data?.[0];
+
+  if (!subscription) return;
+
+  if (getAccountFreezeState(subscription) !== "frozen") return;
+
+  throw new ApiError(
+    "Sua conta está com os recursos bloqueados por falta de pagamento. Regularize a assinatura para liberar.",
+    "ACCOUNT_FROZEN",
+    403,
+  );
+}

package/src/modules/projects/services/projects.service.ts

@@ -5,6 +5,7 @@ import { ApiError } from '../../../infra/api/types';
 import { buildQueryParams } from '../../../infra/utils/params';
 import { getUserContext } from '../../auth/utils/get-user-context';
 import { assertManagementSubscription } from '../../auth/utils/assert-management-subscription';
+import { assertAccountNotFrozen } from '../../auth/utils/assert-account-not-frozen';
 import {
   Project,
   ProjectSchema,
@@ -80,6 +81,7 @@ class ProjectsService {
 
   async create(data: CreateProjectRequest): Promise<Project> {
     await assertManagementSubscription();
+    await assertAccountNotFrozen();
     const { id_account, id_user } = await getUserContext();
     const url = `/account/${id_account}/user/${id_user}/projects`;
 
@@ -102,6 +104,7 @@ class ProjectsService {
 
   async update(projectId: number, data: UpdateProjectRequest): Promise<Project> {
     await assertManagementSubscription();
+    await assertAccountNotFrozen();
     const { id_account, id_user } = await getUserContext();
     const url = `/account/${id_account}/user/${id_user}/projects/${projectId}`;
 

package/src/modules/subscriptions/actions/ack-freeze-notice.action.ts

@@ -0,0 +1,8 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { subscriptionsService } from '../services/subscriptions.service';
+
+export async function ackFreezeNoticeAction(cycle: string) {
+  return safeMutationAction(() => subscriptionsService.ackFreezeNotice(cycle));
+}

package/src/modules/subscriptions/constants/query-keys.constants.ts

@@ -1,3 +1,5 @@
 export const SUBSCRIPTIONS_QUERY_KEY = ['subscriptions'] as const;
 
 export const CHARGES_QUERY_KEY = ['charges'] as const;
+
+export const FREEZE_NOTICE_QUERY_KEY = ['freeze-notice'] as const;

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

@@ -1,5 +1,13 @@
 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/handlers/freeze-notice.handler.ts

@@ -0,0 +1,10 @@
+import 'server-only';
+
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { subscriptionsService } from '../services/subscriptions.service';
+
+export function createFreezeNoticeHandler() {
+  return async function GET() {
+    return safeRouteHandler(() => subscriptionsService.getFreezeNotice());
+  };
+}

package/src/modules/subscriptions/hooks/use-account-freeze.hook.ts

@@ -0,0 +1,44 @@
+'use client';
+
+import { useCallback } from 'react';
+import { UserProfile } from '../../users/schema';
+import { useAuth } from '../../../providers/auth.provider';
+import { useModalManager } from '../../../store/useModalManager';
+import { useActiveSubscription } from './find-active-subscription.hook';
+import { getAccountFreezeState } from '../utils/get-account-freeze-state';
+import { getAccountFreezeDate } from '../utils/get-account-freeze-date';
+
+export function useAccountFreeze() {
+  const { user } = useAuth();
+  const { openModal } = useModalManager();
+  const {
+    data: { data: [subscription] = [] } = {},
+  } = useActiveSubscription();
+
+  const isViewer = user?.profile === UserProfile.viewer;
+  const state = getAccountFreezeState(subscription);
+  const isFrozen = state === 'frozen';
+  const isWarning = state === 'warning';
+  const freezeDate = getAccountFreezeDate(subscription);
+
+  const guardAction = useCallback(
+    (action?: () => void) => {
+      if (!isViewer && isFrozen) {
+        openModal('accountFrozenModal');
+        return false;
+      }
+
+      action?.();
+      return true;
+    },
+    [openModal, isViewer, isFrozen]
+  );
+
+  return {
+    state,
+    isFrozen,
+    isWarning,
+    freezeDate,
+    guardAction,
+  };
+}

package/src/modules/subscriptions/hooks/use-freeze-notice.hook.ts

@@ -0,0 +1,42 @@
+'use client';
+
+import { useCallback } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { withAction } from '../../../utils/withAction';
+import { ackFreezeNoticeAction } from '../actions/ack-freeze-notice.action';
+import { FREEZE_NOTICE_QUERY_KEY } from '../constants/query-keys.constants';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { FreezeNotice } from '../types/freeze-notice.type';
+
+/**
+ * Modal única do congelamento (D4): pending quando `frozen && !acknowledged`.
+ * ack() marca o episódio (id_subscription + date_due) como visto no gapps-r3-api
+ * — reaparece só se um novo ciclo congelar de novo.
+ */
+export function useFreezeNotice() {
+  const queryClient = useQueryClient();
+  const queryKey = useAuthQueryKey([...FREEZE_NOTICE_QUERY_KEY]);
+
+  const query = useQuery({
+    queryKey,
+    queryFn: ({ signal }) => apiFetch<FreezeNotice>('/api/notices/freeze', { signal }),
+    staleTime: 10_000,
+  });
+
+  const mutation = useMutation({
+    mutationFn: (cycle: string) => withAction(ackFreezeNoticeAction)(cycle),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey });
+    },
+  });
+
+  const pending = !!query.data?.frozen && !query.data?.acknowledged;
+  const cycle = query.data?.cycle ?? null;
+
+  const ack = useCallback(() => {
+    if (cycle) mutation.mutate(cycle);
+  }, [cycle, mutation]);
+
+  return { pending, cycle, ack };
+}

package/src/modules/subscriptions/services/subscriptions.service.ts

@@ -26,6 +26,7 @@ import {
   SubscriptionPendingPixResponseSchema,
   type SubscriptionPendingPixResponse,
 } from "../types/pix-pending.type";
+import type { FreezeNotice } from "../types/freeze-notice.type";
 
 /**
  * Timeout das mutations de assinatura que ESCREVEM (action/plan e action/payment).
@@ -181,6 +182,44 @@ class SubscriptionsService {
 
     return { success: true };
   }
+
+  async getFreezeNotice(): Promise<FreezeNotice> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.get<ApiActionResult<FreezeNotice>>(
+      `/accounts/${id_account}/notices/freeze`,
+    );
+
+    if (response.status === 0 || !response.data) {
+      throw new ApiError(
+        (response.status === 0 ? response.message : "") ||
+          "Erro ao consultar aviso de congelamento",
+        "GET_FREEZE_NOTICE_FAILED",
+        400,
+      );
+    }
+
+    return response.data;
+  }
+
+  async ackFreezeNotice(cycle: string): Promise<SuccessResult<void>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<ApiActionResult<void>>(
+      `/accounts/${id_account}/notices/freeze/ack`,
+      { cycle },
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao confirmar aviso de congelamento",
+        "ACK_FREEZE_NOTICE_FAILED",
+        400,
+      );
+    }
+
+    return { success: true };
+  }
 }
 
 export const subscriptionsService = new SubscriptionsService();

package/src/modules/subscriptions/types/freeze-notice.type.ts

@@ -0,0 +1,5 @@
+export interface FreezeNotice {
+  frozen: boolean;
+  cycle: string | null;
+  acknowledged: boolean;
+}

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

@@ -0,0 +1,40 @@
+import {
+  ACCOUNT_FREEZE_AFTER_DAYS,
+  FREEZE_ELIGIBLE_WHITELABEL_ID,
+} from "../constants/subscription.constants";
+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">
+    | undefined
+    | null,
+): Date | null {
+  if (!subscription) return null;
+
+  if (subscription.type !== "client") return null;
+
+  if (Number(subscription.id_wl) !== FREEZE_ELIGIBLE_WHITELABEL_ID) return null;
+
+  const dueDate = toCalendarDate(subscription.date_due);
+
+  if (!dueDate) return null;
+
+  const result = new Date(dueDate);
+  result.setDate(result.getDate() + ACCOUNT_FREEZE_AFTER_DAYS);
+  return result;
+}

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

@@ -0,0 +1,43 @@
+import { FREEZE_WARNING_DAYS_BEFORE } from "../constants/subscription.constants";
+import { toCalendarDate } from "../../../infra/utils/date";
+import { getAccountFreezeDate } from "./get-account-freeze-date";
+import { getSubscriptionCancellationState } from "./get-subscription-cancellation-state";
+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<
+        Subscription,
+        "type" | "active" | "date_due" | "date_cancellation" | "id_wl"
+      >
+    | undefined
+    | null,
+): AccountFreezeState {
+  if (!subscription) return "none";
+
+  if (getSubscriptionCancellationState(subscription) !== "none") return "none";
+
+  const freezeDate = getAccountFreezeDate(subscription);
+  if (!freezeDate) return "none";
+
+  const today = toCalendarDate(new Date());
+  if (!today) return "none";
+
+  if (today.getTime() >= freezeDate.getTime()) return "frozen";
+
+  const warningDate = new Date(freezeDate);
+  warningDate.setDate(warningDate.getDate() - FREEZE_WARNING_DAYS_BEFORE);
+
+  if (today.getTime() >= warningDate.getTime()) return "warning";
+
+  return "none";
+}

package/src/server.ts

@@ -11,6 +11,7 @@ export { assertManagementPermission } from './modules/auth/utils/assert-manageme
 export { assertManagementSubscription } from './modules/auth/utils/assert-management-subscription';
 export { assertSubscriptionAddon } from './modules/auth/utils/assert-subscription-addon';
 export { assertPaidSubscription } from './modules/auth/utils/assert-paid-subscription';
+export { assertAccountNotFrozen } from './modules/auth/utils/assert-account-not-frozen';
 export { subscriptionsService } from './modules/subscriptions/services/subscriptions.service';
 export { plansService } from './modules/plans/services/plans.service';
 export { cardsService } from './modules/cards/services/cards.service';
@@ -27,6 +28,7 @@ export { findUserById } from './modules/users/action/find-user-by-id.action';
 export { findCurrentAccount } from './modules/accounts/actions/find-current-account.action';
 export { getAccountTokenAction } from './modules/accounts/actions/get-account-token.action';
 export { listSubscriptionsAction } from './modules/subscriptions/actions/list-subscriptions.action';
+export { ackFreezeNoticeAction } from './modules/subscriptions/actions/ack-freeze-notice.action';
 export { calculateSubscriptionAction } from './modules/subscriptions/actions/calculate-subscription.action';
 export { updateSubscriptionPlanAction } from './modules/subscriptions/actions/update-subscription-plan.action';
 export { updateSubscriptionPaymentAction } from './modules/subscriptions/actions/update-subscription-payment.action';