@greatapps/common 1.1.789 → 1.1.791

package/src/modules/accounts/utils/is-my-account-section.ts

@@ -0,0 +1,12 @@
+import { AccountSectionType } from '../../../enums/AccountSectionType';
+import { WorkspaceSectionType } from '../../../enums/WorkspaceSectionType';
+import type { MyAccountSection } from '../../../store/useAccountModals';
+
+const MY_ACCOUNT_SECTION_VALUES: readonly string[] = [
+  ...Object.values(AccountSectionType),
+  ...Object.values(WorkspaceSectionType),
+];
+
+export function isMyAccountSection(value: string): value is MyAccountSection {
+  return MY_ACCOUNT_SECTION_VALUES.includes(value);
+}

package/src/modules/accounts/utils/map-legacy-account-route.ts

@@ -0,0 +1,108 @@
+import { AccountHubFlow } from '../../../enums/AccountHubFlow';
+import { AccountSectionType } from '../../../enums/AccountSectionType';
+import { WorkspaceSectionType } from '../../../enums/WorkspaceSectionType';
+import { ACCOUNT_HUB_COUPON_PARAM, ACCOUNT_HUB_FLOW_PARAM, ACCOUNT_HUB_SECTION_PARAM } from '../constants/account-hub-link.constants';
+import type { LegacyAccountRouteTarget } from '../types/account-hub-link.type';
+
+function withoutParams(searchParams: URLSearchParams, keys: string[]): URLSearchParams {
+  const result = new URLSearchParams(searchParams);
+  keys.forEach((key) => result.delete(key));
+  return result;
+}
+
+function mapRootRoute(searchParams: URLSearchParams): LegacyAccountRouteTarget {
+  const openPlans = searchParams.get('openPlans') === 'true';
+  const openProfile = searchParams.get('openProfile') === 'true';
+  const target = withoutParams(searchParams, ['openPlans', 'openProfile']);
+
+  if (openPlans) {
+    target.set(ACCOUNT_HUB_SECTION_PARAM, WorkspaceSectionType.SUBSCRIPTION);
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.PLANS);
+  } else if (openProfile) {
+    target.set(ACCOUNT_HUB_SECTION_PARAM, AccountSectionType.MY_PROFILE);
+  }
+
+  return { pathname: '/', searchParams: target };
+}
+
+function mapSubscriptionsRoute(searchParams: URLSearchParams): LegacyAccountRouteTarget {
+  const target = withoutParams(searchParams, [
+    'tab',
+    'openAddons',
+    'openReactivate',
+    'openReceiptDetails',
+    'coupon',
+    'period',
+  ]);
+  target.set(ACCOUNT_HUB_SECTION_PARAM, WorkspaceSectionType.SUBSCRIPTION);
+
+  if (searchParams.get('openReceiptDetails') === 'true') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.RECEIPT);
+    return { pathname: '/', searchParams: target };
+  }
+
+  if (searchParams.get('openReactivate') === 'true') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.REACTIVATE);
+    return { pathname: '/', searchParams: target };
+  }
+
+  if (searchParams.get('openAddons') === 'true') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.ADDONS);
+    return { pathname: '/', searchParams: target };
+  }
+
+  if (searchParams.get('tab') === 'plans') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.PLANS);
+    const coupon = searchParams.get('coupon');
+    if (coupon) target.set(ACCOUNT_HUB_COUPON_PARAM, coupon);
+  }
+
+  return { pathname: '/', searchParams: target };
+}
+
+function mapProjectsRoute(searchParams: URLSearchParams): LegacyAccountRouteTarget {
+  const target = withoutParams(searchParams, ['createNew', 'projectId']);
+  target.set(ACCOUNT_HUB_SECTION_PARAM, WorkspaceSectionType.PROJECTS);
+
+  if (searchParams.get('createNew') === 'true') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.CREATE_PROJECT);
+  }
+
+  return { pathname: '/', searchParams: target };
+}
+
+function mapTeamRoute(searchParams: URLSearchParams): LegacyAccountRouteTarget {
+  const target = withoutParams(searchParams, ['createNew']);
+  target.set(ACCOUNT_HUB_SECTION_PARAM, WorkspaceSectionType.TEAM);
+
+  if (searchParams.get('createNew') === 'true') {
+    target.set(ACCOUNT_HUB_FLOW_PARAM, AccountHubFlow.ADD_USER);
+  }
+
+  return { pathname: '/', searchParams: target };
+}
+
+function mapAffiliatesRoute(searchParams: URLSearchParams): LegacyAccountRouteTarget {
+  const target = new URLSearchParams(searchParams);
+  target.set(ACCOUNT_HUB_SECTION_PARAM, WorkspaceSectionType.AFFILIATES);
+  return { pathname: '/', searchParams: target };
+}
+
+export function mapLegacyAccountRoute(pathname: string, searchParams: URLSearchParams): LegacyAccountRouteTarget | null {
+  switch (pathname) {
+    case '/':
+      return mapRootRoute(searchParams);
+    case '/subscriptions':
+      return mapSubscriptionsRoute(searchParams);
+    case '/my-projects':
+      return mapProjectsRoute(searchParams);
+    case '/my-teams':
+      return mapTeamRoute(searchParams);
+    case '/affiliates':
+      return mapAffiliatesRoute(searchParams);
+    case '/notifications':
+      return { pathname: '/notifications', searchParams: new URLSearchParams(searchParams) };
+    default:
+      return null;
+  }
+}

package/src/modules/accounts/utils/parse-account-hub-link.ts

@@ -0,0 +1,21 @@
+import { AccountHubFlow } from '../../../enums/AccountHubFlow';
+import {
+  ACCOUNT_HUB_COUPON_PARAM,
+  ACCOUNT_HUB_FLOW_PARAM,
+  ACCOUNT_HUB_SECTION_PARAM,
+} from '../constants/account-hub-link.constants';
+import type { AccountHubLink } from '../types/account-hub-link.type';
+import { isAccountHubFlow } from './is-account-hub-flow';
+import { isMyAccountSection } from './is-my-account-section';
+
+export function parseAccountHubLink(searchParams: URLSearchParams): AccountHubLink | null {
+  const section = searchParams.get(ACCOUNT_HUB_SECTION_PARAM);
+  if (!section || !isMyAccountSection(section)) return null;
+
+  const flow = searchParams.get(ACCOUNT_HUB_FLOW_PARAM);
+  const resolvedFlow = flow && isAccountHubFlow(flow) ? flow : undefined;
+  const couponCode =
+    resolvedFlow === AccountHubFlow.PLANS ? (searchParams.get(ACCOUNT_HUB_COUPON_PARAM) ?? undefined) : undefined;
+
+  return { section, flow: resolvedFlow, couponCode };
+}

package/src/modules/affiliates/actions/ensure-affiliate.action.ts

@@ -0,0 +1,9 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { affiliatesService } from '../services/affiliates.service';
+import type { EnsureAffiliateRequest } from '../types/affiliate.type';
+
+export async function ensureAffiliateAction(body: EnsureAffiliateRequest) {
+  return safeMutationAction(() => affiliatesService.ensureAffiliate(body));
+}

package/src/modules/affiliates/actions/request-deposit.action.ts

@@ -0,0 +1,9 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { affiliatesService } from '../services/affiliates.service';
+import type { RequestDepositRequest } from '../types/affiliate.type';
+
+export async function requestDepositAction(body: RequestDepositRequest) {
+  return safeMutationAction(() => affiliatesService.requestDeposit(body));
+}

package/src/modules/affiliates/actions/update-affiliate.action.ts

@@ -0,0 +1,9 @@
+'use server';
+
+import { safeMutationAction } from '../../../utils/safeMutationAction';
+import { affiliatesService } from '../services/affiliates.service';
+import type { UpdateAffiliateRequest } from '../types/affiliate.type';
+
+export async function updateAffiliateAction(body: UpdateAffiliateRequest) {
+  return safeMutationAction(() => affiliatesService.updateAffiliate(body));
+}

package/src/modules/affiliates/constants/affiliate.constants.ts

@@ -0,0 +1,11 @@
+/** Comissão total do programa: o desconto do cupom sai dela (cupom de 5% paga 10% de comissão). */
+export const AFFILIATE_TOTAL_COMMISSION_PERCENT = 15;
+
+export const AFFILIATE_TERMS_URL = 'https://www.greatpages.com.br/afiliados';
+
+/** Contato do financeiro mostrado no saque. */
+export const AFFILIATE_FINANCE_EMAIL = 'financeiro@greatsoftwares.com.br';
+
+/** Termo de uso aceito ao entrar no programa (diferente da página de regras do menu). */
+export const AFFILIATE_PROGRAM_TERMS_URL =
+  'https://www.greatsoftwares.com.br/termo-de-uso-afiliados';

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

@@ -0,0 +1,7 @@
+// Mesmas bases do gapps, para as mutations de afiliado de lá invalidarem estas leituras.
+export const AFFILIATE_QUERY_KEY = ['affiliate'] as const;
+export const AFFILIATE_REPORT_ANALYTICS_QUERY_KEY = ['affiliate-report-analytics'] as const;
+export const AFFILIATE_TRANSACTIONS_QUERY_KEY = ['affiliate-transactions'] as const;
+export const AFFILIATE_COUPONS_QUERY_KEY = ['coupons'] as const;
+export const AFFILIATE_LEADS_QUERY_KEY = ['affiliate-leads'] as const;
+export const WITHDRAWAL_LIMITS_QUERY_KEY = ['withdrawal-limits'] as const;

package/src/modules/affiliates/handlers/affiliate-report-analytics.handler.ts

@@ -0,0 +1,16 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { searchParamsToParams } from '../../../infra/route/search-params';
+import { affiliatesService } from '../services/affiliates.service';
+import type { ReportAnalyticsParams } from '../types/affiliate.type';
+
+export function createAffiliateReportAnalyticsHandler() {
+  return async function GET(req: NextRequest) {
+    return safeRouteHandler(() => {
+      const { date_start = '', date_end = '' } = searchParamsToParams<ReportAnalyticsParams>(req.nextUrl.searchParams);
+      return affiliatesService.reportAnalytics({ date_start, date_end });
+    });
+  };
+}

package/src/modules/affiliates/handlers/affiliate-withdrawal-limits.handler.ts

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

package/src/modules/affiliates/handlers/current-affiliate.handler.ts

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

package/src/modules/affiliates/handlers/list-affiliate-coupons.handler.ts

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

package/src/modules/affiliates/handlers/list-affiliate-leads.handler.ts

@@ -0,0 +1,23 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { parseNumericFields } from '../../../infra/route/parse-numeric';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { searchParamsToParams } from '../../../infra/route/search-params';
+import { affiliatesService } from '../services/affiliates.service';
+import type { ListAffiliateLeadsParams } from '../types/affiliate.type';
+
+const NUMERIC_FIELDS = ['page', 'limit'] as const;
+
+export function createListAffiliateLeadsHandler() {
+  return async function GET(req: NextRequest) {
+    return safeRouteHandler(() =>
+      affiliatesService.listLeads(
+        parseNumericFields<ListAffiliateLeadsParams>(
+          searchParamsToParams<ListAffiliateLeadsParams>(req.nextUrl.searchParams),
+          NUMERIC_FIELDS
+        )
+      )
+    );
+  };
+}

package/src/modules/affiliates/handlers/list-affiliate-transactions.handler.ts

@@ -0,0 +1,23 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { parseNumericFields } from '../../../infra/route/parse-numeric';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { searchParamsToParams } from '../../../infra/route/search-params';
+import { affiliatesService } from '../services/affiliates.service';
+import type { ListAffiliateTransactionsParams } from '../types/affiliate.type';
+
+const NUMERIC_FIELDS = ['page', 'limit'] as const;
+
+export function createListAffiliateTransactionsHandler() {
+  return async function GET(req: NextRequest) {
+    return safeRouteHandler(() =>
+      affiliatesService.listTransactions(
+        parseNumericFields<ListAffiliateTransactionsParams>(
+          searchParamsToParams<ListAffiliateTransactionsParams>(req.nextUrl.searchParams),
+          NUMERIC_FIELDS
+        )
+      )
+    );
+  };
+}

package/src/modules/affiliates/hooks/use-affiliate-coupons.hook.ts

@@ -0,0 +1,19 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { PaginatedSuccessResult } from '../../../infra/api/types';
+import type { AffiliateCoupon } from '../types/affiliate.type';
+import { AFFILIATE_COUPONS_QUERY_KEY } from '../constants/query-keys.constants';
+
+export function useAffiliateCoupons(options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...AFFILIATE_COUPONS_QUERY_KEY, 'current']);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<PaginatedSuccessResult<AffiliateCoupon>>('/api/affiliates/current/coupons', { signal }),
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/affiliates/hooks/use-affiliate-leads.hook.ts

@@ -0,0 +1,27 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { PaginatedSuccessResult } from '../../../infra/api/types';
+import type { AffiliateLead, ListAffiliateLeadsParams } from '../types/affiliate.type';
+import { DEFAULT_LIST_AFFILIATE_LEADS_PARAMS } from '../types/affiliate.type';
+import { AFFILIATE_LEADS_QUERY_KEY } from '../constants/query-keys.constants';
+
+export function useAffiliateLeads(
+  params: ListAffiliateLeadsParams = {},
+  options: { enabled?: boolean } = {}
+) {
+  const queryParams = { ...DEFAULT_LIST_AFFILIATE_LEADS_PARAMS, ...params };
+  const queryKey = useAuthQueryKey([...AFFILIATE_LEADS_QUERY_KEY, 'current', queryParams]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<PaginatedSuccessResult<AffiliateLead>>('/api/affiliates/current/leads', {
+        params: queryParams,
+        signal,
+      }),
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/affiliates/hooks/use-affiliate-report-analytics.hook.ts

@@ -0,0 +1,19 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { SuccessResult } from '../../../infra/api/types';
+import type { ReportAnalyticsData, ReportAnalyticsParams } from '../types/affiliate.type';
+import { AFFILIATE_REPORT_ANALYTICS_QUERY_KEY } from '../constants/query-keys.constants';
+
+export function useAffiliateReportAnalytics(params: ReportAnalyticsParams, options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...AFFILIATE_REPORT_ANALYTICS_QUERY_KEY, 'current', params]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<SuccessResult<ReportAnalyticsData>>('/api/affiliates/current/report-analytics', { params, signal }),
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/affiliates/hooks/use-affiliate-transactions.hook.ts

@@ -0,0 +1,25 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { PaginatedSuccessResult } from '../../../infra/api/types';
+import type { AffiliateTransaction, ListAffiliateTransactionsParams } from '../types/affiliate.type';
+import { AFFILIATE_TRANSACTIONS_QUERY_KEY } from '../constants/query-keys.constants';
+
+export function useAffiliateTransactions(
+  params: ListAffiliateTransactionsParams,
+  options: { enabled?: boolean } = {}
+) {
+  const queryKey = useAuthQueryKey([...AFFILIATE_TRANSACTIONS_QUERY_KEY, 'current', params]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<PaginatedSuccessResult<AffiliateTransaction>>('/api/affiliates/current/transactions', {
+        params,
+        signal,
+      }),
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/affiliates/hooks/use-current-affiliate.hook.ts

@@ -0,0 +1,19 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { SuccessResult } from '../../../infra/api/types';
+import type { Affiliate } from '../types/affiliate.type';
+import { AFFILIATE_QUERY_KEY } from '../constants/query-keys.constants';
+
+/** Afiliado da conta logada; `data` nulo quando a conta ainda não participa do programa. */
+export function useCurrentAffiliate(options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...AFFILIATE_QUERY_KEY, 'current']);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) => apiFetch<SuccessResult<Affiliate | null>>('/api/affiliates/current', { signal }),
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/affiliates/hooks/use-ensure-affiliate.hook.ts

@@ -0,0 +1,24 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { ensureAffiliateAction } from '../actions/ensure-affiliate.action';
+import { AFFILIATE_QUERY_KEY, AFFILIATE_COUPONS_QUERY_KEY } from '../constants/query-keys.constants';
+import { DEFAULT_AFFILIATE_DISCOUNTS } from '../types/affiliate.type';
+
+/** Entrada no programa de afiliados: cria o afiliado da conta com os cupons padrão. */
+export function useEnsureAffiliate() {
+  const queryClient = useQueryClient();
+  const affiliateKey = useAuthQueryKey([...AFFILIATE_QUERY_KEY]);
+  const couponsKey = useAuthQueryKey([...AFFILIATE_COUPONS_QUERY_KEY]);
+
+  return useMutation({
+    mutationFn: ({ gestorName, discounts = DEFAULT_AFFILIATE_DISCOUNTS }: { gestorName: string; discounts?: number[] }) =>
+      withAction(ensureAffiliateAction)({ gestor_name: gestorName, discounts }),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: affiliateKey });
+      queryClient.invalidateQueries({ queryKey: couponsKey });
+    },
+  });
+}

package/src/modules/affiliates/hooks/use-request-deposit.hook.ts

@@ -0,0 +1,29 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { requestDepositAction } from '../actions/request-deposit.action';
+import {
+  AFFILIATE_QUERY_KEY,
+  AFFILIATE_TRANSACTIONS_QUERY_KEY,
+  WITHDRAWAL_LIMITS_QUERY_KEY,
+} from '../constants/query-keys.constants';
+import type { RequestDepositRequest } from '../types/affiliate.type';
+
+/** Solicitação de saque do saldo do afiliado. */
+export function useRequestDeposit() {
+  const queryClient = useQueryClient();
+  const affiliateKey = useAuthQueryKey([...AFFILIATE_QUERY_KEY]);
+  const transactionsKey = useAuthQueryKey([...AFFILIATE_TRANSACTIONS_QUERY_KEY]);
+  const withdrawalLimitsKey = useAuthQueryKey([...WITHDRAWAL_LIMITS_QUERY_KEY]);
+
+  return useMutation({
+    mutationFn: (body: RequestDepositRequest) => withAction(requestDepositAction)(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: affiliateKey });
+      queryClient.invalidateQueries({ queryKey: transactionsKey });
+      queryClient.invalidateQueries({ queryKey: withdrawalLimitsKey });
+    },
+  });
+}

package/src/modules/affiliates/hooks/use-update-affiliate.hook.ts

@@ -0,0 +1,24 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { updateAffiliateAction } from '../actions/update-affiliate.action';
+import { AFFILIATE_QUERY_KEY, WITHDRAWAL_LIMITS_QUERY_KEY } from '../constants/query-keys.constants';
+import type { UpdateAffiliateRequest } from '../types/affiliate.type';
+
+/** Conta de recebimento do afiliado (PIX e titular). */
+export function useUpdateAffiliate() {
+  const queryClient = useQueryClient();
+  const affiliateKey = useAuthQueryKey([...AFFILIATE_QUERY_KEY]);
+  const withdrawalLimitsKey = useAuthQueryKey([...WITHDRAWAL_LIMITS_QUERY_KEY]);
+
+  return useMutation({
+    mutationFn: (body: UpdateAffiliateRequest) => withAction(updateAffiliateAction)(body),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: affiliateKey });
+      // Trocar o documento do titular muda o tipo CPF/CNPJ — revalida os limites de saque.
+      queryClient.invalidateQueries({ queryKey: withdrawalLimitsKey });
+    },
+  });
+}

package/src/modules/affiliates/hooks/use-withdrawal-limits.hook.ts

@@ -0,0 +1,20 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { SuccessResult } from '../../../infra/api/types';
+import type { WithdrawalLimits } from '../types/affiliate.type';
+import { WITHDRAWAL_LIMITS_QUERY_KEY } from '../constants/query-keys.constants';
+
+/** Regras de saque do afiliado da conta: mínimo, teto mensal, nota fiscal e bloqueios. */
+export function useWithdrawalLimits(options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...WITHDRAWAL_LIMITS_QUERY_KEY, 'current']);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<SuccessResult<WithdrawalLimits>>('/api/affiliates/current/withdrawal-limits', { signal }),
+    enabled: options.enabled ?? true,
+  });
+}