@greatapps/common 1.1.790 → 1.1.791

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

@@ -1,301 +1,401 @@
-import "server-only";
-
-import { api } from "../../../infra/api/client";
-import {
-  ApiError,
-  ApiActionResult,
-  ApiPaginatedActionResult,
-  PaginatedSuccessResult,
-  SuccessResult,
-} from "../../../infra/api/types";
-import { buildQueryParams } from "../../../infra/utils/params";
-import { assertManagementPermission } from "../../auth/utils/assert-management-permission";
-import { getUserContext } from "../../auth/utils/get-user-context";
-import {
-  Subscription,
-  SubscriptionSchema,
-  FindSubscriptionsParams,
-  type ChargeNowResult,
-} from "../types/subscription.type";
-import {
-  type CalculateSubscriptionRequest,
-  type CalculateSubscriptionResponse,
-  type UpdateSubscriptionPlanRequest,
-  CalculateSubscriptionResponseSchema,
-} from "../types/calculate-subscription.type";
-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).
- *
- * O default do ApiClient é 30s. Essas duas rotas caem no mesmo motor pesado do
- * backend (planEdit delega pra paymentEdit) — troca de método de pagamento, mandato
- * PIX recorrente Woovi, void-and-replace de fatura — e passam de 30s com alguma
- * frequência: em produção elas aparecem como `outcome=canceled` com wallTime ~29.9s.
- *
- * O problema não é o usuário ver "Tempo excedido": é que o abort MATA o worker no
- * meio da saga. Se o corte cai depois de criar o mandato Woovi e suprimir a fatura
- * de ciclo, sobra mandato órfão + fatura sem dunning, o usuário não recebe QR nenhum
- * e a próxima tentativa cria um segundo mandato. Deixar a request terminar converte
- * uma escrita parcial numa escrita completa.
- *
- * Não é a solução definitiva — a rota deveria ser assíncrona (202 + polling no
- * correlation_id). É o teto que dá folga enquanto isso.
- *
- * Só nas mutations: calculateSubscription é idempotente (não escreve nada), então
- * um timeout nela não deixa rastro e não precisa esperar mais.
- */
-const SUBSCRIPTION_WRITE_TIMEOUT_MS = 60000;
-
-export type UpdateSubscriptionPlanResponse =
-  | Subscription
-  | SubscriptionPendingPixResponse;
-
-class SubscriptionsService {
-  async listSubscriptions(
-    params?: Partial<FindSubscriptionsParams>,
-  ): Promise<PaginatedSuccessResult<Subscription>> {
-    const { id_account } = await getUserContext();
-
-    const query = buildQueryParams(
-      params as Record<string, string | boolean | undefined>,
-    );
-    const url = `/accounts/${id_account}/subscriptions${query ? `?${query}` : ""}`;
-
-    const response =
-      await api.apps.get<ApiPaginatedActionResult<Subscription>>(url);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao listar assinaturas",
-        "LIST_SUBSCRIPTIONS_FAILED",
-        400,
-      );
-    }
-
-    const data = response.data.map((item) => SubscriptionSchema.parse(item));
-
-    return {
-      data,
-      total: response.total,
-      success: true,
-    } satisfies PaginatedSuccessResult<Subscription>;
-  }
-
-  /**
-   * A assinatura corrente do plano da conta, pela regra única do backend
-   * (`GET .../subscriptions/action/current`): contrato de domínio nunca é
-   * corrente, encerrada é decidida por `active`. Sem `id_product`, paridade
-   * com hoje (melhor rank entre todos os produtos, nunca item/domínio).
-   */
-  async getCurrentSubscription(
-    params?: { id_product?: number },
-  ): Promise<SuccessResult<Subscription | null>> {
-    const { id_account } = await getUserContext();
-
-    const query = buildQueryParams(
-      params as Record<string, string | number | undefined>,
-    );
-    const url = `/accounts/${id_account}/subscriptions/action/current${query ? `?${query}` : ""}`;
-
-    const response = await api.apps.get<ApiPaginatedActionResult<Subscription>>(url);
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao consultar assinatura corrente",
-        "GET_CURRENT_SUBSCRIPTION_FAILED",
-        400,
-      );
-    }
-
-    const raw = response.data[0];
-
-    return {
-      success: true,
-      data: raw ? SubscriptionSchema.parse(raw) : null,
-    };
-  }
-
-  async calculateSubscription(
-    data: CalculateSubscriptionRequest,
-  ): Promise<SuccessResult<CalculateSubscriptionResponse>> {
-    const { id_account } = await getUserContext();
-
-    const response = await api.apps.post<
-      ApiActionResult<CalculateSubscriptionResponse>
-    >(`/accounts/${id_account}/subscriptions/action/calculate`, data);
-
-    console.log("Calculate subscription response:", {
-      response,
-      data: JSON.stringify(data, null, 2),
-    });
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao calcular assinatura",
-        "CALCULATE_SUBSCRIPTION_FAILED",
-        400,
-      );
-    }
-
-    return {
-      success: true,
-      data: CalculateSubscriptionResponseSchema.parse(response.data),
-    };
-  }
-
-  async updateSubscriptionPlan(
-    subscriptionId: number | string,
-    data: UpdateSubscriptionPlanRequest,
-  ): Promise<
-    SuccessResult<UpdateSubscriptionPlanResponse | null> & { client_secret?: string }
-  > {
-    await assertManagementPermission('manage_subscriptions');
-    const { id_account } = await getUserContext();
-
-    const response = await api.apps.put<
-      ApiActionResult<UpdateSubscriptionPlanResponse | UpdateSubscriptionPlanResponse[]> & {
-        client_secret?: string;
-      }
-    >(
-      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/plan`,
-      data,
-      { timeout: SUBSCRIPTION_WRITE_TIMEOUT_MS },
-    );
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao atualizar plano",
-        "UPDATE_SUBSCRIPTION_PLAN_FAILED",
-        400,
-      );
-    }
-
-    const raw = Array.isArray(response.data) ? response.data[0] : response.data;
-
-    // Preserva resposta pix-pending (id: null, pending: true, pix: {...})
-    // pra clientes poderem rotear o user pra fluxo dedicado de pix em vez
-    // de tratar como subscription comum. Caso contrário, parseia como
-    // Subscription (compatível com o comportamento antigo de devolver { id }).
-    let parsed: UpdateSubscriptionPlanResponse | null = null;
-    if (raw) {
-      const pixResult = SubscriptionPendingPixResponseSchema.safeParse(raw);
-      parsed = pixResult.success ? pixResult.data : SubscriptionSchema.parse(raw);
-    }
-
-    return {
-      success: true,
-      data: parsed,
-      ...(response.client_secret ? { client_secret: response.client_secret } : {}),
-    };
-  }
-
-  async updateSubscriptionPayment(
-    subscriptionId: number | string,
-    data: {
-      id_card?: string;
-      payment_method_id?: string;
-      payment_method: number;
-      charge_now?: boolean;
-    },
-  ): Promise<
-    SuccessResult<void> & {
-      applied: boolean;
-      client_secret?: string;
-      charge_now?: ChargeNowResult;
-    }
-  > {
-    await assertManagementPermission("manage_subscriptions");
-    const { id_account } = await getUserContext();
-
-    /* O `status: 2` do guard de 3DS pendente não cabe em `ApiActionResult`, que só conhece 0 e 1.
-     * Declarar o terceiro estado aqui é o que permite tratá-lo — sem isso o TypeScript apaga o
-     * ramo como inalcançável e o caso volta a atravessar como sucesso. */
-    const response = await api.apps.put<
-      (ApiActionResult<void> | { status: 2; message?: string }) & {
-        charge_now?: ChargeNowResult;
-        client_secret?: string;
-      }
-    >(
-      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/payment`,
-      data,
-      { timeout: SUBSCRIPTION_WRITE_TIMEOUT_MS },
-    );
-
-    if (response.status === 0) {
-      throw new ApiError(
-        response.message || "Erro ao atualizar método de pagamento",
-        "UPDATE_SUBSCRIPTION_PAYMENT_FAILED",
-        400,
-      );
-    }
-
-    /* `status: 2` NÃO é sucesso: o guard de 3DS pendente do paymentEdit devolve esse status sem
-     * aplicar a troca, e como só o `status === 0` era tratado como erro, a chamada caía no
-     * `success: true` e a tela dizia "sua assinatura passou a ser cobrada neste cartão" para uma
-     * troca que não aconteceu — descartando junto o `client_secret` que resolveria a pendência.
-     *
-     * Por isso o retorno carrega `applied`: quem chama precisa poder distinguir "trocou" de
-     * "não trocou, conclua o pagamento pendente primeiro". */
-    if (response.status === 2) {
-      return {
-        success: true,
-        applied: false,
-        ...(response.client_secret ? { client_secret: response.client_secret } : {}),
-      };
-    }
-
-    /* O desfecho da cobrança imediata precisa atravessar: descartá-lo (como este método fazia com
-     * o corpo inteiro) apagaria tanto a recusa quanto o `client_secret` do 3DS, e a tela
-     * anunciaria "tudo certo" para uma fatura que continua em aberto. */
-    return {
-      success: true,
-      applied: true,
-      ...(response.charge_now ? { charge_now: response.charge_now } : {}),
-    };
-  }
-
-  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();
+import "server-only";
+
+import { api } from "../../../infra/api/client";
+import {
+  ApiError,
+  ApiActionResult,
+  ApiPaginatedActionResult,
+  PaginatedSuccessResult,
+  SuccessResult,
+} from "../../../infra/api/types";
+import { buildQueryParams } from "../../../infra/utils/params";
+import { assertManagementPermission } from "../../auth/utils/assert-management-permission";
+import { getUserContext } from "../../auth/utils/get-user-context";
+import {
+  Subscription,
+  SubscriptionSchema,
+  FindSubscriptionsParams,
+  type ChargeNowResult,
+} from "../types/subscription.type";
+import type { CancelSubscriptionRequest } from "../types/cancel-subscription.type";
+import {
+  isPendingPixCreateSubscriptionResponse,
+  CreateSubscriptionPendingPixResponseSchema,
+  type CreateSubscriptionRequest,
+  type CreateSubscriptionResponse,
+} from "../types/create-subscription.type";
+import {
+  PendingPixStatusDataSchema,
+  type PendingPixStatusData,
+} from "../types/pending-pix-status.type";
+import {
+  type CalculateSubscriptionRequest,
+  type CalculateSubscriptionResponse,
+  type UpdateSubscriptionPlanRequest,
+  CalculateSubscriptionResponseSchema,
+} from "../types/calculate-subscription.type";
+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).
+ *
+ * O default do ApiClient é 30s. Essas duas rotas caem no mesmo motor pesado do
+ * backend (planEdit delega pra paymentEdit) — troca de método de pagamento, mandato
+ * PIX recorrente Woovi, void-and-replace de fatura — e passam de 30s com alguma
+ * frequência: em produção elas aparecem como `outcome=canceled` com wallTime ~29.9s.
+ *
+ * O problema não é o usuário ver "Tempo excedido": é que o abort MATA o worker no
+ * meio da saga. Se o corte cai depois de criar o mandato Woovi e suprimir a fatura
+ * de ciclo, sobra mandato órfão + fatura sem dunning, o usuário não recebe QR nenhum
+ * e a próxima tentativa cria um segundo mandato. Deixar a request terminar converte
+ * uma escrita parcial numa escrita completa.
+ *
+ * Não é a solução definitiva — a rota deveria ser assíncrona (202 + polling no
+ * correlation_id). É o teto que dá folga enquanto isso.
+ *
+ * Só nas mutations: calculateSubscription é idempotente (não escreve nada), então
+ * um timeout nela não deixa rastro e não precisa esperar mais.
+ */
+const SUBSCRIPTION_WRITE_TIMEOUT_MS = 60000;
+
+export type UpdateSubscriptionPlanResponse =
+  | Subscription
+  | SubscriptionPendingPixResponse;
+
+class SubscriptionsService {
+  async listSubscriptions(
+    params?: Partial<FindSubscriptionsParams>,
+  ): Promise<PaginatedSuccessResult<Subscription>> {
+    const { id_account } = await getUserContext();
+
+    const query = buildQueryParams(
+      params as Record<string, string | boolean | undefined>,
+    );
+    const url = `/accounts/${id_account}/subscriptions${query ? `?${query}` : ""}`;
+
+    const response =
+      await api.apps.get<ApiPaginatedActionResult<Subscription>>(url);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao listar assinaturas",
+        "LIST_SUBSCRIPTIONS_FAILED",
+        400,
+      );
+    }
+
+    const data = response.data.map((item) => SubscriptionSchema.parse(item));
+
+    return {
+      data,
+      total: response.total,
+      success: true,
+    } satisfies PaginatedSuccessResult<Subscription>;
+  }
+
+  /**
+   * A assinatura corrente do plano da conta, pela regra única do backend
+   * (`GET .../subscriptions/action/current`): contrato de domínio nunca é
+   * corrente, encerrada é decidida por `active`. Sem `id_product`, paridade
+   * com hoje (melhor rank entre todos os produtos, nunca item/domínio).
+   */
+  async getCurrentSubscription(
+    params?: { id_product?: number },
+  ): Promise<SuccessResult<Subscription | null>> {
+    const { id_account } = await getUserContext();
+
+    const query = buildQueryParams(
+      params as Record<string, string | number | undefined>,
+    );
+    const url = `/accounts/${id_account}/subscriptions/action/current${query ? `?${query}` : ""}`;
+
+    const response = await api.apps.get<ApiPaginatedActionResult<Subscription>>(url);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao consultar assinatura corrente",
+        "GET_CURRENT_SUBSCRIPTION_FAILED",
+        400,
+      );
+    }
+
+    const raw = response.data[0];
+
+    return {
+      success: true,
+      data: raw ? SubscriptionSchema.parse(raw) : null,
+    };
+  }
+
+  async calculateSubscription(
+    data: CalculateSubscriptionRequest,
+  ): Promise<SuccessResult<CalculateSubscriptionResponse>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<
+      ApiActionResult<CalculateSubscriptionResponse>
+    >(`/accounts/${id_account}/subscriptions/action/calculate`, data);
+
+    console.log("Calculate subscription response:", {
+      response,
+      data: JSON.stringify(data, null, 2),
+    });
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao calcular assinatura",
+        "CALCULATE_SUBSCRIPTION_FAILED",
+        400,
+      );
+    }
+
+    return {
+      success: true,
+      data: CalculateSubscriptionResponseSchema.parse(response.data),
+    };
+  }
+
+  async updateSubscriptionPlan(
+    subscriptionId: number | string,
+    data: UpdateSubscriptionPlanRequest,
+  ): Promise<
+    SuccessResult<UpdateSubscriptionPlanResponse | null> & { client_secret?: string }
+  > {
+    await assertManagementPermission('manage_subscriptions');
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.put<
+      ApiActionResult<UpdateSubscriptionPlanResponse | UpdateSubscriptionPlanResponse[]> & {
+        client_secret?: string;
+      }
+    >(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/plan`,
+      data,
+      { timeout: SUBSCRIPTION_WRITE_TIMEOUT_MS },
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao atualizar plano",
+        "UPDATE_SUBSCRIPTION_PLAN_FAILED",
+        400,
+      );
+    }
+
+    const raw = Array.isArray(response.data) ? response.data[0] : response.data;
+
+    // Preserva resposta pix-pending (id: null, pending: true, pix: {...})
+    // pra clientes poderem rotear o user pra fluxo dedicado de pix em vez
+    // de tratar como subscription comum. Caso contrário, parseia como
+    // Subscription (compatível com o comportamento antigo de devolver { id }).
+    let parsed: UpdateSubscriptionPlanResponse | null = null;
+    if (raw) {
+      const pixResult = SubscriptionPendingPixResponseSchema.safeParse(raw);
+      parsed = pixResult.success ? pixResult.data : SubscriptionSchema.parse(raw);
+    }
+
+    return {
+      success: true,
+      data: parsed,
+      ...(response.client_secret ? { client_secret: response.client_secret } : {}),
+    };
+  }
+
+  async updateSubscriptionPayment(
+    subscriptionId: number | string,
+    data: {
+      id_card?: string;
+      payment_method_id?: string;
+      payment_method: number;
+      charge_now?: boolean;
+    },
+  ): Promise<
+    SuccessResult<void> & {
+      applied: boolean;
+      client_secret?: string;
+      charge_now?: ChargeNowResult;
+    }
+  > {
+    await assertManagementPermission("manage_subscriptions");
+    const { id_account } = await getUserContext();
+
+    /* O `status: 2` do guard de 3DS pendente não cabe em `ApiActionResult`, que só conhece 0 e 1.
+     * Declarar o terceiro estado aqui é o que permite tratá-lo — sem isso o TypeScript apaga o
+     * ramo como inalcançável e o caso volta a atravessar como sucesso. */
+    const response = await api.apps.put<
+      (ApiActionResult<void> | { status: 2; message?: string }) & {
+        charge_now?: ChargeNowResult;
+        client_secret?: string;
+      }
+    >(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/payment`,
+      data,
+      { timeout: SUBSCRIPTION_WRITE_TIMEOUT_MS },
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao atualizar método de pagamento",
+        "UPDATE_SUBSCRIPTION_PAYMENT_FAILED",
+        400,
+      );
+    }
+
+    /* `status: 2` NÃO é sucesso: o guard de 3DS pendente do paymentEdit devolve esse status sem
+     * aplicar a troca, e como só o `status === 0` era tratado como erro, a chamada caía no
+     * `success: true` e a tela dizia "sua assinatura passou a ser cobrada neste cartão" para uma
+     * troca que não aconteceu — descartando junto o `client_secret` que resolveria a pendência.
+     *
+     * Por isso o retorno carrega `applied`: quem chama precisa poder distinguir "trocou" de
+     * "não trocou, conclua o pagamento pendente primeiro". */
+    if (response.status === 2) {
+      return {
+        success: true,
+        applied: false,
+        ...(response.client_secret ? { client_secret: response.client_secret } : {}),
+      };
+    }
+
+    /* O desfecho da cobrança imediata precisa atravessar: descartá-lo (como este método fazia com
+     * o corpo inteiro) apagaria tanto a recusa quanto o `client_secret` do 3DS, e a tela
+     * anunciaria "tudo certo" para uma fatura que continua em aberto. */
+    return {
+      success: true,
+      applied: true,
+      ...(response.charge_now ? { charge_now: response.charge_now } : {}),
+    };
+  }
+
+  async findSubscriptionById(subscriptionId: string | number): Promise<SuccessResult<Subscription>> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.get<ApiPaginatedActionResult<Subscription>>(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}`
+    );
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError("Assinatura não encontrada", "FIND_SUBSCRIPTION_FAILED", 400);
+    }
+
+    return { success: true, data: SubscriptionSchema.parse(response.data[0]) };
+  }
+
+  async cancelSubscription(
+    subscriptionId: number | string,
+    data: CancelSubscriptionRequest
+  ): Promise<SuccessResult<void>> {
+    await assertManagementPermission("manage_subscriptions");
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.put<ApiActionResult<void>>(
+      `/accounts/${id_account}/subscriptions/${subscriptionId}/action/cancel`,
+      data
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao cancelar assinatura",
+        "CANCEL_SUBSCRIPTION_FAILED",
+        400
+      );
+    }
+
+    return { success: true };
+  }
+
+  /** Contratação de plano. Pode devolver um pix pendente no lugar da assinatura. */
+  async createSubscription(
+    data: CreateSubscriptionRequest
+  ): Promise<PaginatedSuccessResult<CreateSubscriptionResponse> & { client_secret?: string }> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.post<
+      ApiPaginatedActionResult<CreateSubscriptionResponse> & { client_secret?: string }
+    >(`/accounts/${id_account}/subscriptions`, data);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao criar assinatura",
+        "CREATE_SUBSCRIPTION_FAILED",
+        400
+      );
+    }
+
+    return {
+      success: true,
+      data: (response.data ?? []).map((item) =>
+        isPendingPixCreateSubscriptionResponse(item)
+          ? CreateSubscriptionPendingPixResponseSchema.parse(item)
+          : SubscriptionSchema.parse(item)
+      ),
+      total: response.total,
+      ...(response.client_secret ? { client_secret: response.client_secret } : {}),
+    };
+  }
+
+  /** Status do pix pendente, consultado em polling enquanto o cliente paga. */
+  async findPendingPixStatus(correlationId: string): Promise<SuccessResult<PendingPixStatusData>> {
+    const { id_account } = await getUserContext();
+
+    const response = await api.apps.get<ApiPaginatedActionResult<PendingPixStatusData>>(
+      `/accounts/${id_account}/subscriptions/pending-pix/${encodeURIComponent(correlationId)}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || "Erro ao consultar o status do Pix",
+        "FIND_PENDING_PIX_STATUS_FAILED",
+        400
+      );
+    }
+
+    if (!response.data?.length) {
+      throw new ApiError("Pix pendente não encontrado", "PENDING_PIX_NOT_FOUND", 404);
+    }
+
+    return { success: true, data: PendingPixStatusDataSchema.parse(response.data[0]) };
+  }
+
+  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();