@greatapps/common 1.1.786 → 1.1.787

package/src/modules/subscriptions/hooks/find-active-subscription.hook.ts

@@ -1,22 +1,12 @@
 "use client";
 
-import { useQuery } from "@tanstack/react-query";
-import { apiFetch } from "../../../infra/http/api-fetch";
-import type { PaginatedSuccessResult } from "../../../infra/api/types";
-import type { Subscription } from "../types/subscription.type";
-import { SUBSCRIPTIONS_QUERY_KEY } from "../constants/query-keys.constants";
-import { useAuthQueryKey } from "../../../hooks/useAuthQueryKey";
+import { useCurrentSubscription } from "./use-current-subscription.hook";
 
+/**
+ * @deprecated Use `useCurrentSubscription`, mesma leitura (mesma chave de
+ * cache, uma única requisição); só o nome muda para o vocabulário certo
+ * ("corrente", não "ativa"). Sai na 1.1.784.
+ */
 export function useActiveSubscription() {
-  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, "active"]);
-
-  return useQuery({
-    queryKey,
-    queryFn: ({ signal }) =>
-      apiFetch<PaginatedSuccessResult<Subscription>>('/api/subscriptions', {
-        params: { limit: 1 },
-        signal,
-      }),
-    staleTime: 10_000,
-  });
+  return useCurrentSubscription();
 }

package/src/modules/subscriptions/hooks/use-current-subscription.hook.ts

@@ -0,0 +1,38 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { PaginatedSuccessResult, SuccessResult } from '../../../infra/api/types';
+import type { Subscription } from '../types/subscription.type';
+import { SUBSCRIPTIONS_QUERY_KEY } from '../constants/query-keys.constants';
+
+/**
+ * A assinatura corrente do plano da conta, pela regra única do backend
+ * (contrato de domínio nunca é corrente; encerrada é decidida por `active`).
+ *
+ * Devolvida na mesma forma paginada de `useSubscriptions`/`useActiveSubscription`
+ * (`{ data: [sub] }`) para não exigir mudança nos call sites que já leem
+ * `data?.[0]`: só a URL e a regra por trás mudam.
+ */
+export function useCurrentSubscription() {
+  const queryKey = useAuthQueryKey([...SUBSCRIPTIONS_QUERY_KEY, 'current']);
+
+  return useQuery({
+    queryKey,
+    queryFn: async ({ signal }): Promise<PaginatedSuccessResult<Subscription>> => {
+      const result = await apiFetch<SuccessResult<Subscription | null>>(
+        '/api/subscriptions/current',
+        { signal },
+      );
+      const subscription = result.data ?? null;
+
+      return {
+        success: true,
+        data: subscription ? [subscription] : [],
+        total: subscription ? 1 : 0,
+      };
+    },
+    staleTime: 10_000,
+  });
+}

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

@@ -86,6 +86,40 @@ class SubscriptionsService {
     } 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>> {

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

@@ -142,4 +142,6 @@ export interface FindSubscriptionsParams {
   date_hiring_start?: string;
   date_hiring_end?: string;
   limit?: number;
+  page?: number;
+  id_product?: number;
 }

package/src/modules/subscriptions/utils/group-subscriptions-by-product.ts

@@ -0,0 +1,23 @@
+import type { Subscription } from '../types/subscription.type';
+
+/**
+ * Agrupa assinaturas por `id_product`, preservando a ordem de chegada dentro
+ * de cada grupo. Base da seção "Domínios registrados" do painel e da aba
+ * Assinatura agrupada por produto no admin.
+ */
+export function groupSubscriptionsByProduct(
+  subscriptions: Subscription[],
+): Map<number, Subscription[]> {
+  const groups = new Map<number, Subscription[]>();
+
+  for (const subscription of subscriptions) {
+    const group = groups.get(subscription.id_product);
+    if (group) {
+      group.push(subscription);
+    } else {
+      groups.set(subscription.id_product, [subscription]);
+    }
+  }
+
+  return groups;
+}

package/src/modules/subscriptions/utils/has-active-paid-subscription.ts

@@ -1,9 +1,8 @@
 import { toCalendarDate, daysBetween } from "../../../infra/utils/date";
 import { getSubscriptionCancellationState } from "./get-subscription-cancellation-state";
+import { FREE_PLAN_ID } from "../constants/subscription.constants";
 import type { Subscription } from "../types/subscription.type";
 
-const FREE_PLAN_ID = 5;
-
 type SubscriptionSnapshot = Pick<
   Subscription,
   | "type"

package/src/modules/subscriptions/utils/has-paid-subscription.ts

@@ -1,6 +1,5 @@
 import type { Subscription } from '../types/subscription.type';
-
-const FREE_PLAN_ID = 5;
+import { FREE_PLAN_ID } from '../constants/subscription.constants';
 
 type PaidSubscriptionSnapshot = Pick<Subscription, 'type' | 'id_plan' | 'charged'>;
 

package/src/modules/subscriptions/utils/read-current-subscription.ts

@@ -0,0 +1,34 @@
+import "server-only";
+
+import { cache } from "react";
+
+import { ApiError } from "../../../infra/api/types";
+import { getCurrentSubscriptionAction } from "../actions/get-current-subscription.action";
+import type { Subscription } from "../types/subscription.type";
+
+/**
+ * Leitura única por request de "qual é a assinatura corrente do plano desta
+ * conta", deduplicada via React.cache. Os quatro gates de auth
+ * (`assertAccountNotFrozen`, `assertManagementSubscription`,
+ * `assertPaidSubscription`, `assertSubscriptionAddon`) chamam esta função em
+ * vez de repetir a própria leitura cada um: eram até 4 cópias da mesma
+ * pergunta disputando a mesma fila (0,7 a 7s cada, medido em produção).
+ *
+ * Lança em falha de leitura; `assertAccountNotFrozen` é o único chamador que
+ * precisa de fail-open, e faz isso capturando o erro no próprio call site.
+ */
+export const readCurrentSubscription = cache(
+  async (): Promise<Subscription | null> => {
+    const result = await getCurrentSubscriptionAction();
+
+    if (!result.success) {
+      throw new ApiError(
+        result.error || "Não foi possível validar a assinatura atual",
+        "SUBSCRIPTION_CONTEXT_FAILED",
+        403,
+      );
+    }
+
+    return result.data?.data ?? null;
+  },
+);

package/src/server.ts

@@ -28,6 +28,8 @@ 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 { getCurrentSubscriptionAction } from './modules/subscriptions/actions/get-current-subscription.action';
+export { readCurrentSubscription } from './modules/subscriptions/utils/read-current-subscription';
 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';

package/src/store/useMdSidebarStore.ts

@@ -1,21 +1,21 @@
 import { create } from "zustand";
+import { useEffect } from "react";
 import { readStorage, writeStorage } from "../utils/browser/safe-storage";
 
 const STORAGE_KEY = "md-sidebar-expanded";
 
-function getInitialState(): boolean {
-    return readStorage(STORAGE_KEY) === "true";
-}
-
 type MdSidebarStore = {
     isExpanded: boolean;
+    _hydrated: boolean;
     toggle: () => void;
     expand: () => void;
     collapse: () => void;
+    _hydrate: () => void;
 };
 
 export const useMdSidebarStore = create<MdSidebarStore>((set) => ({
-    isExpanded: getInitialState(),
+    isExpanded: false,
+    _hydrated: false,
     toggle: () => set((state) => {
         const next = !state.isExpanded;
         writeStorage(STORAGE_KEY, String(next));
@@ -29,4 +29,19 @@ export const useMdSidebarStore = create<MdSidebarStore>((set) => ({
         writeStorage(STORAGE_KEY, "false");
         return set({ isExpanded: false });
     },
+    _hydrate: () => {
+        const value = readStorage(STORAGE_KEY) === "true";
+        set({ isExpanded: value, _hydrated: true });
+    },
 }));
+
+export function useMdSidebarHydration() {
+    const hydrate = useMdSidebarStore((s) => s._hydrate);
+    const hydrated = useMdSidebarStore((s) => s._hydrated);
+
+    useEffect(() => {
+        if (!hydrated) {
+            hydrate();
+        }
+    }, [hydrate, hydrated]);
+}

package/src/utils/safeServerAction.ts

@@ -10,12 +10,10 @@ export async function safeServerAction<T>(
     return { success: true, data };
   } catch (error) {
     if (isRedirectError(error)) throw error;
-    const message =
-      error instanceof ApiError
-        ? error.message
-        : error instanceof Error
-          ? error.message
-          : 'Erro desconhecido';
+    if (error instanceof ApiError) {
+      return { success: false, error: error.message, code: error.code, statusCode: error.statusCode };
+    }
+    const message = error instanceof Error ? error.message : 'Erro desconhecido';
     return { success: false, error: message };
   }
 }

package/src/utils/withAction.ts

@@ -1,3 +1,4 @@
+import { ApiError } from '../infra/api/types';
 import type { ActionResult } from '../infra/api/types';
 
 export function withAction<TArgs extends any[], TData>(
@@ -6,7 +7,7 @@ export function withAction<TArgs extends any[], TData>(
   return async (...args) => {
     const result = await action(...args);
     if (!result.success) {
-      throw new Error(result.error ?? 'Erro desconhecido');
+      throw new ApiError(result.error, result.code, result.statusCode);
     }
     return result.data as TData;
   };