@greatapps/common 1.1.790 → 1.1.792

package/src/modules/coupons/handlers/find-coupon-by-id.handler.ts

@@ -0,0 +1,15 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { parseId } from '../../../infra/route/parse-id';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { couponsService } from '../services/coupons.service';
+
+export function createFindCouponByIdHandler() {
+  return async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+    return safeRouteHandler(async () => {
+      const { id } = await params;
+      return couponsService.getCouponById(parseId(id));
+    });
+  };
+}

package/src/modules/coupons/hooks/use-coupon-by-code.hook.ts

@@ -0,0 +1,16 @@
+'use client';
+
+import { useMutation } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import type { SuccessResult } from '../../../infra/api/types';
+import type { Coupon } from '../types/coupon.type';
+
+/** Validação de cupom digitado na troca de plano. */
+export function useCouponByCode() {
+  return useMutation<Coupon | undefined, Error, string>({
+    mutationFn: async (code) => {
+      const result = await apiFetch<SuccessResult<Coupon>>('/api/coupons', { params: { code } });
+      return result.data;
+    },
+  });
+}

package/src/modules/coupons/hooks/use-coupon-by-id.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 { COUPON_QUERY_KEY } from '../constants/query-keys.constants';
+import type { Coupon } from '../types/coupon.type';
+
+/** Cupom aplicado na assinatura, para explicar o valor cobrado. */
+export function useCouponById(id: number | string | null | undefined) {
+  const queryKey = useAuthQueryKey([...COUPON_QUERY_KEY, id]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) => apiFetch<SuccessResult<Coupon>>(`/api/coupons/${id}`, { signal }),
+    enabled: id != null,
+    staleTime: 5 * 60 * 1000,
+  });
+}

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

@@ -0,0 +1,54 @@
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { ApiError, type ApiPaginatedActionResult, type SuccessResult } from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { CouponSchema, type Coupon } from '../types/coupon.type';
+
+/** Conta da sessão quando houver — o cupom também é consultado em fluxo sem login. */
+async function resolveAccountId(): Promise<number | undefined> {
+  try {
+    const { id_account } = await getUserContext();
+    return id_account;
+  } catch {
+    return undefined;
+  }
+}
+
+class CouponsService {
+  async getCouponById(id: number | string): Promise<SuccessResult<Coupon>> {
+    const id_account = await resolveAccountId();
+    const query = buildQueryParams({ id_account });
+    const url = query ? `/coupons/${id}?${query}` : `/coupons/${id}`;
+
+    const response = await api.apps.get<ApiPaginatedActionResult<Coupon>>(url);
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError('Cupom não encontrado', 'GET_COUPON_BY_ID_FAILED', 404);
+    }
+
+    return { success: true, data: CouponSchema.parse(response.data[0]) };
+  }
+
+  async getCouponByCode(code: string): Promise<SuccessResult<Coupon>> {
+    const id_account = await resolveAccountId();
+    const query = buildQueryParams({ code, id_account });
+
+    const response = await api.apps.get<ApiPaginatedActionResult<Coupon>>(`/coupons?${query}`);
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError('Cupom não encontrado ou inválido', 'GET_COUPON_BY_CODE_FAILED', 404);
+    }
+
+    const coupon = CouponSchema.parse(response.data[0]);
+
+    if (!coupon.active) {
+      throw new ApiError('Cupom inativo', 'COUPON_INACTIVE', 400);
+    }
+
+    return { success: true, data: coupon };
+  }
+}
+
+export const couponsService = new CouponsService();

package/src/modules/coupons/types/coupon.type.ts

@@ -0,0 +1,70 @@
+import z from 'zod';
+
+export const CouponPeriodicitySchema = z.union([
+  z.literal('30'),
+  z.literal('180'),
+  z.literal('365'),
+  z.literal('any'),
+]);
+export type CouponPeriodicity = z.infer<typeof CouponPeriodicitySchema>;
+
+export const CouponPaymentMethodSchema = z.union([
+  z.literal('billet'),
+  z.literal('pix'),
+  z.literal('card'),
+  z.literal('any'),
+]);
+export type CouponPaymentMethod = z.infer<typeof CouponPaymentMethodSchema>;
+
+export const CouponAppliesToSchema = z.object({
+  id: z.string().nullish(),
+  id_plan: z.number().nullish(),
+  name: z.string().nullish(),
+});
+export type CouponAppliesTo = z.infer<typeof CouponAppliesToSchema>;
+
+export const CouponStripeDataSchema = z
+  .object({
+    periodicity: CouponPeriodicitySchema.optional(),
+    payment_method: CouponPaymentMethodSchema.optional(),
+    usable: z.boolean().optional(),
+    usable_global: z.boolean().optional(),
+    invalid_reason: z.string().nullable().optional(),
+    percent_off: z.number().nullable().optional(),
+    amount_off: z.number().nullable().optional(),
+    applies_to: z.array(CouponAppliesToSchema).nullable().optional(),
+    type: z.string().optional(),
+    /**
+     * Stripe: 'once' | 'repeating' | 'forever'. String tolerante de propósito — um enum estrito
+     * derrubaria o parse do cupom inteiro num valor novo do backend.
+     */
+    duration: z.string().nullish(),
+    duration_in_months: z.number().nullish(),
+  })
+  .passthrough();
+export type CouponStripeData = z.infer<typeof CouponStripeDataSchema>;
+
+export const CouponSchema = z.object({
+  id: z.number(),
+  id_wl: z.number().optional(),
+  id_affiliate: z.number().nullable().optional(),
+  title: z.string(),
+  code: z.string(),
+  discount: z.number(),
+  discount_type: z.number().nullable(),
+  date: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  active: z.boolean(),
+  deleted: z
+    .union([z.number(), z.boolean()])
+    .transform((val) => val === 1 || val === true)
+    .optional()
+    .default(false),
+  stripe_coupon_id: z.string().nullable().optional(),
+  stripe_promo_id: z.string().nullable().optional(),
+  stripe_data: CouponStripeDataSchema.nullable().optional(),
+  datetime_add: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_alt: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+  datetime_del: z.union([z.date(), z.coerce.date()]).nullable().optional(),
+});
+
+export type Coupon = z.infer<typeof CouponSchema>;

package/src/modules/coupons/utils/coupon-restrictions.ts

@@ -0,0 +1,112 @@
+import type { BillingPeriod } from '../../subscriptions/types/billing-period.type';
+import type {
+  CouponPaymentMethod,
+  CouponPeriodicity,
+  CouponStripeData,
+} from '../types/coupon.type';
+
+export type CouponPaymentMethodUi = 'card' | 'boleto' | 'pix';
+
+/**
+ * Maps the coupon's periodicity constraint to the BillingPeriod allowed.
+ * Returns null when there's no restriction (`any` or undefined).
+ */
+export function couponAllowedBillingPeriod(
+  periodicity: CouponPeriodicity | undefined,
+): BillingPeriod | null {
+  if (!periodicity || periodicity === 'any') return null;
+  if (periodicity === '30') return 'monthly';
+  if (periodicity === '180') return 'semiannual';
+  if (periodicity === '365') return 'annual';
+  return null;
+}
+
+/**
+ * Returns the list of BillingPeriods that are BLOCKED by the coupon.
+ * Returns [] when there's no restriction.
+ */
+export function couponDisabledBillingPeriods(
+  periodicity: CouponPeriodicity | undefined,
+): BillingPeriod[] {
+  const allowed = couponAllowedBillingPeriod(periodicity);
+  if (allowed === null) return [];
+  const all: BillingPeriod[] = ['monthly', 'semiannual', 'annual'];
+  return all.filter((p) => p !== allowed);
+}
+
+/**
+ * Maps the coupon's payment_method constraint to the payment method UI allowed.
+ * Returns null when there's no restriction (`any` or undefined).
+ */
+export function couponAllowedPaymentMethod(
+  paymentMethod: CouponPaymentMethod | undefined,
+): CouponPaymentMethodUi | null {
+  if (!paymentMethod || paymentMethod === 'any') return null;
+  if (paymentMethod === 'billet') return 'boleto';
+  if (paymentMethod === 'card') return 'card';
+  if (paymentMethod === 'pix') return 'pix';
+  return null;
+}
+
+/**
+ * Returns the list of payment methods that are BLOCKED by the coupon.
+ */
+export function couponDisabledPaymentMethods(
+  paymentMethod: CouponPaymentMethod | undefined,
+): CouponPaymentMethodUi[] {
+  const allowed = couponAllowedPaymentMethod(paymentMethod);
+  if (allowed === null) return [];
+  const all: CouponPaymentMethodUi[] = ['card', 'boleto', 'pix'];
+  return all.filter((p) => p !== allowed);
+}
+
+/**
+ * Ofertas com payment_method "any" liberam todos os métodos de pagamento
+ * (incluindo boleto em mensal/semestral) — regra de negócio do time comercial.
+ */
+export function couponUnlocksAllPaymentMethods(
+  stripeData: CouponStripeData | null | undefined,
+): boolean {
+  if (!stripeData) return false;
+  if (stripeData.type !== 'offer') return false;
+  const pm = stripeData.payment_method;
+  return !pm || pm === 'any';
+}
+
+/**
+ * Convenience: extracts both restrictions from a stripe_data object.
+ *
+ * Restrições de método de pagamento (allowed/disabled) só valem para offers.
+ * Outros tipos de cupom (discount, etc.) são ignorados para método —
+ * o user pode pagar com cartão/boleto/pix livremente. Restrições de
+ * periodicidade continuam valendo para todos os tipos.
+ */
+export function getCouponRestrictions(stripeData: CouponStripeData | null | undefined) {
+  const isOffer = stripeData?.type === 'offer';
+  return {
+    allowedBillingPeriod: couponAllowedBillingPeriod(stripeData?.periodicity),
+    disabledBillingPeriods: couponDisabledBillingPeriods(stripeData?.periodicity),
+    allowedPaymentMethod: isOffer ? couponAllowedPaymentMethod(stripeData?.payment_method) : null,
+    disabledPaymentMethods: isOffer ? couponDisabledPaymentMethods(stripeData?.payment_method) : [],
+    unlocksAllPaymentMethods: couponUnlocksAllPaymentMethods(stripeData),
+  };
+}
+
+/**
+ * Checks if the coupon applies to a given plan.
+ * Returns true when:
+ *   - applies_to is empty/undefined (no restriction)
+ *   - OR applies_to contains only addon entries (id_plan null) — sem restrição de plano
+ *   - OR the plan is in the list
+ */
+export function isCouponApplicableToPlan(
+  stripeData: CouponStripeData | null | undefined,
+  idPlan: number | null | undefined,
+): boolean {
+  const appliesTo = stripeData?.applies_to;
+  if (!appliesTo || appliesTo.length === 0) return true;
+  const planEntries = appliesTo.filter((a) => a.id_plan != null);
+  if (planEntries.length === 0) return true;
+  if (idPlan == null) return true;
+  return planEntries.some((a) => a.id_plan === idPlan);
+}

package/src/modules/domains/handlers/count-domains.handler.ts

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

package/src/modules/domains/hooks/count-domains.hook.ts

@@ -0,0 +1,17 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+
+/** Domínios pagos já registrados na conta. */
+export function useCountDomains(options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey(['domains', 'count']);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) => apiFetch<number>('/api/domains/count', { signal }),
+    staleTime: 60_000,
+    enabled: options.enabled ?? true,
+  });
+}

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

@@ -0,0 +1,18 @@
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { getUserContext } from '../../auth/utils/get-user-context';
+
+class DomainsService {
+  /** Quantos domínios pagos a conta já usa — o piso de slots na troca de plano. */
+  async countPaid(): Promise<number> {
+    const { id_account } = await getUserContext();
+    const response = await api.pages.get<{ status: 0 | 1; total_paid: number }>(
+      `/account/${id_account}/domains`
+    );
+
+    return response.total_paid ?? 0;
+  }
+}
+
+export const domainsService = new DomainsService();

package/src/modules/ia-credits/handlers/list-ia-credit-operations.handler.ts

@@ -0,0 +1,14 @@
+import 'server-only';
+
+import type { NextRequest } from 'next/server';
+import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
+import { iaCreditsService } from '../services/ia-credits.service';
+
+export function createListIaCreditOperationsHandler() {
+  return async function GET(_req: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+    return safeRouteHandler(async () => {
+      const { id } = await params;
+      return iaCreditsService.listOperations(id);
+    });
+  };
+}

package/src/modules/ia-credits/hooks/ia-credit-operations.hook.ts

@@ -0,0 +1,33 @@
+'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 { useCurrentSubscription } from '../../subscriptions/hooks/use-current-subscription.hook';
+import type { IaCreditOperation } from '../types';
+
+/** Extrato bruto das operações de crédito de IA da assinatura corrente (relatório de uso). */
+export function useIaCreditOperations() {
+  const { data: subscriptionData, isPending: isSubscriptionLoading } = useCurrentSubscription();
+  const subscriptionId = subscriptionData?.data?.[0]?.id;
+
+  const queryKey = useAuthQueryKey(['ia-credits', 'operations', subscriptionId]);
+
+  const query = useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<PaginatedSuccessResult<IaCreditOperation>>(
+        `/api/subscriptions/${subscriptionId}/ia-credits/operations`,
+        { signal }
+      ),
+    enabled: subscriptionId != null,
+  });
+
+  return {
+    operations: query.data?.data ?? [],
+    isLoading: isSubscriptionLoading || query.isPending,
+    isError: query.isError,
+    error: query.error,
+  };
+}

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

@@ -1,13 +1,19 @@
 import 'server-only';
 
 import { api } from '../../../infra/api/client';
-import { ApiError, ApiPaginatedActionResult, SuccessResult } from '../../../infra/api/types';
+import {
+  ApiError,
+  ApiPaginatedActionResult,
+  PaginatedSuccessResult,
+  SuccessResult,
+} from '../../../infra/api/types';
 import { getUserContext } from '../../auth/utils/get-user-context';
 import { subscriptionsService } from '../../subscriptions/services/subscriptions.service';
 import {
   IaCreditAddBatch,
   IaCreditAddBatchSchema,
   IaCreditOperation,
+  IaCreditOperationSchema,
   IaCreditsSummaryData,
 } from '../types';
 import { AI_CREDITS_FIRST_PURCHASE_OFFER } from '../constants/ai-credits-offer.constants';
@@ -40,6 +46,31 @@ class IaCreditsService {
     return { success: true, data: { availableCredits, addBatches } };
   }
 
+  /**
+   * Extrato bruto (add/subtract) das operações de crédito da assinatura, usado pelo relatório de
+   * uso. O summary agrega; aqui vão as operações uma a uma.
+   */
+  async listOperations(
+    subscriptionId: string | number
+  ): Promise<PaginatedSuccessResult<IaCreditOperation>> {
+    const { id_account } = await getUserContext();
+    const endpoint = `/accounts/${id_account}/subscriptions/${subscriptionId}/items/balance/list?page=1&limit=100&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_OPERATIONS_FAILED',
+        400
+      );
+    }
+
+    const data = (response.data ?? []).map((item) => IaCreditOperationSchema.parse(item));
+
+    return { success: true, data, total: response.total ?? data.length };
+  }
+
   // 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(

package/src/modules/pages/handlers/count-pages.handler.ts

@@ -1,12 +1,15 @@
 import 'server-only';
 
+import type { NextRequest } from 'next/server';
 import { safeRouteHandler } from '../../../infra/route/safe-route-handler';
 import { pagesService } from '../services/pages.service';
 
 export function createCountPagesHandler() {
-  return async function GET() {
+  return async function GET(request: NextRequest) {
     return safeRouteHandler(async () => ({
-      total: await pagesService.countPages(),
+      total: await pagesService.countPages({
+        published: request.nextUrl.searchParams.get('published') === 'true',
+      }),
     }));
   };
 }

package/src/modules/pages/hooks/count-published-pages.hook.ts

@@ -0,0 +1,26 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { PAGES_QUERY_KEY } from '../constants/query-keys.constants';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+
+export const COUNT_PUBLISHED_PAGES_QUERY_KEY = [...PAGES_QUERY_KEY, 'count', 'published'] as const;
+
+/** Páginas no ar: é o que o plano limita e o que o downgrade cobra. */
+export function useCountPublishedPages(options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...COUNT_PUBLISHED_PAGES_QUERY_KEY]);
+
+  return useQuery({
+    queryKey,
+    queryFn: async ({ signal }) => {
+      const result = await apiFetch<{ total: number }>('/api/pages/count', {
+        params: { published: true },
+        signal,
+      });
+      return result.total;
+    },
+    staleTime: 30_000,
+    enabled: options.enabled ?? true,
+  });
+}

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

@@ -5,10 +5,11 @@ import { ApiError, ApiPaginatedActionResult } from '../../../infra/api/types';
 import { getUserContext } from '../../auth/utils/get-user-context';
 
 class PagesService {
-  async countPages(): Promise<number> {
+  /** `published` conta só as páginas no ar — é o limite que o downgrade de plano cobra. */
+  async countPages({ published }: { published?: boolean } = {}): Promise<number> {
     const { id_account } = await getUserContext();
 
-    const url = `/account/${id_account}/pages?limit=1`;
+    const url = `/account/${id_account}/pages?limit=1${published ? '&published=true' : ''}`;
 
     const response = await api.pages.get<ApiPaginatedActionResult<unknown>>(url);
 

package/src/modules/plans/constants/plan-tooltips.constants.ts

@@ -0,0 +1,16 @@
+import type { PlanTooltips } from '../types/plan.type';
+
+type TranslateFn = (key: any, values?: Record<string, string | number>) => string;
+
+/** Tooltips dos recursos do card de plano — textos do catálogo, não do plano da conta. */
+export function getPlanTooltips(translate: TranslateFn): PlanTooltips {
+  return {
+    domains: translate('common.plans.tooltips.domains'),
+    users: translate('common.plans.tooltips.users'),
+    sharePages: translate('common.plans.tooltips.sharePages'),
+    projectManagement: translate('common.plans.tooltips.projectManagement'),
+  };
+}
+
+/** Planos fora da vitrine (legado/contratos especiais). */
+export const HIDDEN_PLAN_IDS = [411];

package/src/modules/plans/hooks/use-enriched-plans.hook.ts

@@ -0,0 +1,31 @@
+'use client';
+
+import { useMemo } from 'react';
+import { useUiPlans } from './use-ui-plans.hook';
+import { useCurrentSubscription } from '../../subscriptions/hooks/use-current-subscription.hook';
+import { periodicityToBillingPeriod } from '../../subscriptions/utils/periodicity';
+
+/** Catálogo marcando qual plano é o corrente (e em qual periodicidade), para a vitrine. */
+export function useEnrichedPlans() {
+  const plansQuery = useUiPlans();
+  const { data: subscriptionData } = useCurrentSubscription();
+  const activeSubscription = subscriptionData?.data?.[0] ?? null;
+
+  const data = useMemo(() => {
+    const plans = plansQuery.data ?? [];
+    if (!activeSubscription) return plans;
+
+    const currentPeriodicity = periodicityToBillingPeriod(activeSubscription.periodicity);
+
+    return plans.map((plan) => {
+      const isCurrentPlan = !!activeSubscription.active && plan.planId === activeSubscription.id_plan;
+      return {
+        ...plan,
+        isCurrentPlan,
+        currentPeriodicity: isCurrentPlan ? currentPeriodicity : undefined,
+      };
+    });
+  }, [plansQuery.data, activeSubscription]);
+
+  return { ...plansQuery, data, subscriptionId: activeSubscription?.id ?? null };
+}

package/src/modules/plans/hooks/use-ui-plans.hook.ts

@@ -0,0 +1,22 @@
+'use client';
+
+import { useMemo } from 'react';
+import { useTranslations } from 'next-intl';
+import { usePlans } from './list-plans.hook';
+import { mapApiPlanToUiPlanForCurrency } from '../utils/map-api-plan-to-ui';
+import { useCurrencyFormatter } from '../../accounts/hooks/use-currency-formatter.hook';
+import type { UiPlan } from '../types/plan.type';
+
+/** Catálogo do /plans já traduzido e com preços na moeda da conta (stripe_usd → USD). */
+export function useUiPlans() {
+  const plansQuery = usePlans();
+  const { currency } = useCurrencyFormatter();
+  const translate = useTranslations();
+
+  const data = useMemo<UiPlan[]>(() => {
+    const plans = plansQuery.data ?? [];
+    return plans.map(mapApiPlanToUiPlanForCurrency(currency, translate));
+  }, [plansQuery.data, currency, translate]);
+
+  return { ...plansQuery, data };
+}

package/src/modules/projects/hooks/add-project-users.hook.ts

@@ -0,0 +1,29 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { addProjectUserAction } from '../actions/add-project-user.action';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { ACCOUNT_USERS_QUERY_KEY } from '../../accounts/hooks/useAccountManagement';
+import { PROJECTS_BASE_KEY } from './list-projects.hook';
+
+/**
+ * Conecta vários usuários a um projeto de uma vez (usado ao salvar o sheet de projeto).
+ * Para conectar um único usuário com update otimista, use `useAddProjectUser`.
+ */
+export function useAddProjectUsers() {
+  const queryClient = useQueryClient();
+  const projectUsersKey = useAuthQueryKey(['project-users']);
+  const projectsKey = useAuthQueryKey([...PROJECTS_BASE_KEY]);
+  const accountUsersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY]);
+
+  return useMutation({
+    mutationFn: ({ projectId, userIds }: { projectId: number; userIds: number[] }) =>
+      withAction(addProjectUserAction)({ projectId, users: userIds }),
+    onSuccess: (_data, { projectId }) => {
+      queryClient.invalidateQueries({ queryKey: [...projectUsersKey, projectId] });
+      queryClient.invalidateQueries({ queryKey: projectsKey });
+      queryClient.invalidateQueries({ queryKey: accountUsersKey });
+    },
+  });
+}

package/src/modules/projects/hooks/list-all-account-users.hook.ts

@@ -1,7 +1,7 @@
 'use client';
 
 import { useInfiniteQuery } from '@tanstack/react-query';
-import { apiFetch } from '../../../infra/http/api-fetch';
+import { apiFetchPaged, nextPageParam } from '../../../infra/http/paged';
 import type { AccountUser, UsersPage } from '../types';
 import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
 
@@ -22,7 +22,7 @@ export function useListAllAccountUsers(search: string = '', projectId?: number)
   return useInfiniteQuery({
     queryKey,
     queryFn: ({ pageParam, signal }) =>
-      apiFetch<UsersPage<AccountUser>>('/api/account/users', {
+      apiFetchPaged<UsersPage<AccountUser>>('/api/account/users', {
         params: {
           search: search || undefined,
           page: pageParam as number,
@@ -31,10 +31,7 @@ export function useListAllAccountUsers(search: string = '', projectId?: number)
         },
         signal,
       }),
-    getNextPageParam: (lastPage, allPages) => {
-      const loaded = allPages.reduce((sum, p) => sum + p.data.length, 0);
-      return loaded < lastPage.total ? allPages.length + 1 : undefined;
-    },
+    getNextPageParam: nextPageParam,
     initialPageParam: 1,
   });
 }