@greatapps/common 1.1.789 → 1.1.791

package/src/index.ts

@@ -54,6 +54,8 @@ export { useProject } from "./modules/projects/hooks/find-project.hook";
 export { useCreateProject } from "./modules/projects/hooks/create-project.hook";
 export { useUpdateProject } from "./modules/projects/hooks/update-project.hook";
 export { useDeleteProject } from "./modules/projects/hooks/delete-project.hook";
+export { useAddProjectUsers } from "./modules/projects/hooks/add-project-users.hook";
+export { useRemoveProjectUsers } from "./modules/projects/hooks/remove-project-users.hook";
 export type {
   Project,
   ProjectsPage,
@@ -97,6 +99,11 @@ export { useHasPlanAddon } from "./modules/plans/hooks/use-has-plan-addon.hook";
 export { useCalculateSubscription } from "./modules/subscriptions/hooks/calculate-subscription.hook";
 export { useUpdateSubscriptionPlan } from "./modules/subscriptions/hooks/update-subscription-plan.hook";
 export { useUpdateSubscriptionPayment } from "./modules/subscriptions/hooks/update-subscription-payment.hook";
+export { useCancelSubscription } from "./modules/subscriptions/hooks/cancel-subscription.hook";
+export { useCreateSubscription } from "./modules/subscriptions/hooks/create-subscription.hook";
+export { useSubscriptionById } from "./modules/subscriptions/hooks/find-subscription-by-id.hook";
+export { usePendingPixStatus } from "./modules/subscriptions/hooks/pending-pix-status.hook";
+export { useIaCreditOperations } from "./modules/ia-credits/hooks/ia-credit-operations.hook";
 export { useCards, CARDS_QUERY_KEY } from "./modules/cards/hooks/cards.hook";
 export { useCardById } from "./modules/cards/hooks/card-by-id.hook";
 export { useCreateCard } from "./modules/cards/hooks/create-card.hook";
@@ -109,6 +116,8 @@ export { useHandleDeleteCard } from "./modules/cards/hooks/handle-delete-card.ho
 export { useCharges } from "./modules/charges/hooks/charges.hook";
 export { useChargeById } from "./modules/charges/hooks/charge-by-id.hook";
 export { useChargeAction } from "./modules/charges/hooks/charge-action.hook";
+export { useNotaFiscal } from "./modules/charges/hooks/nota-fiscal.hook";
+export { useRefreshChargePix } from "./modules/charges/hooks/refresh-pix.hook";
 export { useIaCredits } from "./modules/ia-credits/hooks/ia-credits.hook";
 export type {
   IaCreditsSummary,
@@ -179,6 +188,12 @@ export {
   usePlans,
   PLANS_QUERY_KEY,
 } from "./modules/plans/hooks/list-plans.hook";
+export { useUiPlans } from "./modules/plans/hooks/use-ui-plans.hook";
+export { useEnrichedPlans } from "./modules/plans/hooks/use-enriched-plans.hook";
+export {
+  getPlanTooltips,
+  HIDDEN_PLAN_IDS,
+} from "./modules/plans/constants/plan-tooltips.constants";
 export type { BillingPeriod } from "./modules/subscriptions/types/billing-period.type";
 export type {
   CalculateSubscriptionRequest,
@@ -248,6 +263,9 @@ export {
   getPriceFromCalculatedData,
   getOriginalPriceFromCalculatedData,
   periodicityToBillingPeriod,
+  getPlanBadgePercents,
+  getCatalogBadgePercents,
+  USD_CATALOG_MAX_ANNUAL_DISCOUNT_PERCENT,
 } from "./modules/subscriptions/utils/periodicity";
 export { useBuyCreditsModal } from "./store/useBuyCreditsModal";
 export { useCreditsDisabledModal } from "./store/useCreditsDisabledModal";
@@ -273,6 +291,7 @@ export {
 } from "./components/modals/cards/CardFormFields";
 export type { CardFormData } from "./components/modals/cards/CardFormFields";
 export { Skeleton } from "./components/ui/feedback/Skeleton";
+export { SegmentedControl } from "./components/ui/form/SegmentedControl";
 export { PaymentInfoCard } from "./components/ui/data-display/PaymentInfoCard";
 export { CardBrandIcon } from "./components/ui/data-display/CardBrandIcons";
 export { GoogleIcon } from "./components/ui/data-display/GoogleIcon";
@@ -516,6 +535,7 @@ export type { ModalData } from "./store/useModalManager";
 
 // Enums
 export { AccountSectionType } from "./enums/AccountSectionType";
+export { WorkspaceSectionType } from "./enums/WorkspaceSectionType";
 
 // Hooks
 export { default as usePasswordVisibility } from "./hooks/usePasswordVisibility";
@@ -588,6 +608,11 @@ export {
   useDeleteAccount,
   ACCOUNT_USERS_QUERY_KEY,
 } from "./modules/accounts/hooks/useAccountManagement";
+export { useAccountMembers } from "./modules/accounts/hooks/use-account-members.hook";
+export { useCreateAccountUser } from "./modules/accounts/hooks/create-account-user.hook";
+export { useAddUserProjects } from "./modules/accounts/hooks/add-user-projects.hook";
+export { useRemoveUserProjects } from "./modules/accounts/hooks/remove-user-projects.hook";
+export type { AccountMembersPage } from "./modules/accounts/hooks/use-account-members.hook";
 export { useViaCep } from "./modules/accounts/hooks/useViaCep";
 export { useAccountToken } from "./modules/accounts/hooks/use-account-token.hook";
 export { useRequiredBillingData } from "./modules/accounts/hooks/use-required-billing-data.hook";
@@ -614,7 +639,33 @@ export type {
 
 export { default as AccountModals } from "./components/account/AccountModals";
 export { useAccountModals } from "./store/useAccountModals";
-export type { AccountModalsConfig } from "./store/useAccountModals";
+export type { AccountModalsConfig, MyAccountSection } from "./store/useAccountModals";
+export { useProjectFlows } from "./store/useProjectFlows";
+export type { ProjectSheetState } from "./store/useProjectFlows";
+export { useAffiliateFlows } from "./store/useAffiliateFlows";
+export { useTeamFlows } from "./store/useTeamFlows";
+export type { UserSheetState } from "./store/useTeamFlows";
+export type {
+  WorkspaceActions,
+  SubscriptionActions,
+  ProjectsActions,
+  TeamActions,
+  AffiliatesActions,
+} from "./components/account/types/workspace-actions.type";
+
+// Account Hub deep link
+export { AccountHubFlow } from "./enums/AccountHubFlow";
+export {
+  ACCOUNT_HUB_SECTION_PARAM,
+  ACCOUNT_HUB_FLOW_PARAM,
+  ACCOUNT_HUB_COUPON_PARAM,
+} from "./modules/accounts/constants/account-hub-link.constants";
+export { LEGACY_ACCOUNT_ROUTES } from "./modules/accounts/constants/legacy-account-routes.constants";
+export type { AccountHubLink, LegacyAccountRouteTarget } from "./modules/accounts/types/account-hub-link.type";
+export { parseAccountHubLink } from "./modules/accounts/utils/parse-account-hub-link";
+export { buildAccountHubUrl } from "./modules/accounts/utils/build-account-hub-url";
+export { mapLegacyAccountRoute } from "./modules/accounts/utils/map-legacy-account-route";
+export { default as useAccountHubActions } from "./components/account/hooks/useAccountHubActions";
 
 export { ModalManager } from "./components/modals/ModalManager";
 export { Modals } from "./components/modals/Modals";
@@ -625,6 +676,10 @@ export { default as ConfirmGlobalPreferencesModal } from "./components/account/C
 export { MyProfileSection } from "./components/account/sections/MyProfileSection";
 export { PreferencesSection } from "./components/account/sections/PreferencesSection";
 export { SecuritySection } from "./components/account/sections/SecuritySection";
+export { SubscriptionSection } from "./components/account/sections/SubscriptionSection";
+export { ProjectsSection } from "./components/account/sections/ProjectsSection";
+export { TeamSection } from "./components/account/sections/TeamSection";
+export { AffiliatesSection } from "./components/account/sections/AffiliatesSection";
 export { ChangePasswordSection } from "./components/account/sections/ChangePasswordSection";
 export { ChangeEmailModal } from "./components/account/sections/ChangeEmailModal";
 export { ChangePhoneModal } from "./components/account/sections/ChangePhoneModal";

package/src/infra/http/paged.ts

@@ -0,0 +1,24 @@
+import { apiFetch } from './api-fetch';
+
+type ApiFetchOptions = Parameters<typeof apiFetch>[1];
+
+export interface Paged {
+  data: unknown[];
+  total: number;
+}
+
+export function nextPageParam<T extends Paged>(lastPage: T, allPages: T[]): number | undefined {
+  const loaded = allPages.reduce(
+    (sum, page) => sum + (Array.isArray(page.data) ? page.data.length : 0),
+    0,
+  );
+  return typeof lastPage.total === 'number' && loaded < lastPage.total ? allPages.length + 1 : undefined;
+}
+
+export async function apiFetchPaged<T extends Paged>(path: string, options?: ApiFetchOptions): Promise<T> {
+  const body = await apiFetch<T>(path, options);
+  if (!('data' in body) || !Array.isArray(body.data)) {
+    throw new Error(`${path} answered outside the paged contract`);
+  }
+  return body;
+}

package/src/middleware.ts

@@ -1,4 +1,5 @@
 export { createAuthMiddleware } from './middlewares/create-auth-middleware';
+export { createLegacyAccountRoutesMiddleware } from './middlewares/create-legacy-account-routes-middleware';
 export { createMiddlewareChain } from './middlewares/chain';
 export type { MiddlewareConfig, MiddlewareFunction, MiddlewareResult } from './middlewares/types';
 export { continueChain, stopChain } from './middlewares/types';

package/src/middlewares/create-auth-middleware.ts

@@ -1,13 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server';
 
 import { continueChain, MiddlewareConfig, MiddlewareFunction, MiddlewareResult, stopChain } from './types';
+import { isRouteEquals } from './is-route-equals';
 import { whitelabelService } from '../modules/whitelabel/services/whitelabel.service';
 import { isSameSiteUrl } from '../utils/redirect';
 
-function isRouteEquals(pathname: string, routes: string[]): boolean {
-  return routes.some((route) => pathname === route || pathname.startsWith(`${route}/`));
-}
-
 interface CreateAuthMiddlewareOptions {
   publicRoutes?: string[];
   authRoutes?: string[];

package/src/middlewares/create-legacy-account-routes-middleware.ts

@@ -0,0 +1,54 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+import { continueChain, MiddlewareFunction, stopChain } from './types';
+import { isRouteEquals } from './is-route-equals';
+import { LEGACY_ACCOUNT_ROUTES } from '../modules/accounts/constants/legacy-account-routes.constants';
+import { mapLegacyAccountRoute } from '../modules/accounts/utils/map-legacy-account-route';
+import { whitelabelService } from '../modules/whitelabel/services/whitelabel.service';
+import { isSameSiteUrl, resolveSafeRedirect } from '../utils/redirect';
+
+interface CreateLegacyAccountRoutesMiddlewareOptions {
+  authRoutes: string[];
+}
+
+export function createLegacyAccountRoutesMiddleware(
+  options: CreateLegacyAccountRoutesMiddlewareOptions
+): MiddlewareFunction {
+  return async (request: NextRequest) => {
+    const { pathname, searchParams } = request.nextUrl;
+    const token = process.env.DUMMY_AUTH_TOKEN || request.cookies.get('greatapps')?.value;
+    if (!token) return continueChain();
+
+    const isAuthRoute = isRouteEquals(pathname, options.authRoutes);
+    const isLegacyRoute = LEGACY_ACCOUNT_ROUTES.includes(pathname);
+    if (!isAuthRoute && !isLegacyRoute) return continueChain();
+
+    const host = request.headers.get('host') || '';
+    const whitelabel = await whitelabelService.getTokenByDomain(host).catch(() => null);
+    const pagesUrl = whitelabel?.pages_url;
+
+    if (!pagesUrl || !isSameSiteUrl(pagesUrl, host)) {
+      console.error('[legacy-account-routes] pages_url ausente ou fora do site do host da requisição', {
+        host,
+        pathname,
+        whitelabelId: whitelabel?.id,
+        pagesUrl,
+      });
+      return continueChain();
+    }
+
+    if (isAuthRoute) {
+      const redirect = searchParams.get('redirect');
+      const target = resolveSafeRedirect(redirect, host.split(':')[0], pagesUrl);
+      const destination = target.startsWith('/') ? new URL(target, pagesUrl) : new URL(target);
+      return stopChain(NextResponse.redirect(destination));
+    }
+
+    const mapped = mapLegacyAccountRoute(pathname, searchParams);
+    if (!mapped) return continueChain();
+
+    const destination = new URL(mapped.pathname, pagesUrl);
+    destination.search = mapped.searchParams.toString();
+    return stopChain(NextResponse.redirect(destination));
+  };
+}

package/src/middlewares/is-route-equals.ts

@@ -0,0 +1,3 @@
+export function isRouteEquals(pathname: string, routes: string[]): boolean {
+  return routes.some((route) => pathname === route || pathname.startsWith(`${route}/`));
+}

package/src/modules/accounts/actions/account-management.action.ts

@@ -84,7 +84,28 @@ export async function deleteAccountAction(data: DeleteAccountRequest) {
 }
 
 export async function createAccountUserAction(user: CreateAccountUserRequest) {
-  return safeMutationAction(() => accountService.createAccountUser(user));
+  return safeMutationAction(async () => {
+    const userResult = await findUserById();
+    const profile = userResult.success ? userResult.data?.profile : undefined;
+
+    if (profile !== UserProfile.owner && profile !== UserProfile.admin) {
+      throw new ApiError('Você não tem permissão para executar esta ação', 'FORBIDDEN', 403);
+    }
+
+    return accountService.createAccountUser(user);
+  });
+}
+
+export async function checkUserExistsAction(email: string) {
+  return safeServerAction(() => accountService.checkUserExists(email));
+}
+
+export async function addUserProjectsAction(userId: number, projectIds: number[]) {
+  return safeMutationAction(() => accountService.addUserProjects(userId, projectIds));
+}
+
+export async function removeUserProjectsAction(userId: number, projectIds: number[]) {
+  return safeMutationAction(() => accountService.removeUserProjects(userId, projectIds));
 }
 
 export async function changePasswordAction(data: ChangePasswordRequest) {

package/src/modules/accounts/constants/account-hub-link.constants.ts

@@ -0,0 +1,3 @@
+export const ACCOUNT_HUB_SECTION_PARAM = 'account';
+export const ACCOUNT_HUB_FLOW_PARAM = 'flow';
+export const ACCOUNT_HUB_COUPON_PARAM = 'coupon';

package/src/modules/accounts/constants/legacy-account-routes.constants.ts

@@ -0,0 +1 @@
+export const LEGACY_ACCOUNT_ROUTES = ['/', '/subscriptions', '/my-projects', '/my-teams', '/affiliates', '/notifications'];

package/src/modules/accounts/handlers/list-account-members.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 { accountService } from '../services/account.service';
+import type { AccountUsersPaginationParams } from '../types';
+
+const NUMERIC_FIELDS = ['page', 'limit', 'notInProject', 'firstId'] as const;
+
+export function createListAccountMembersHandler() {
+  return async function GET(req: NextRequest) {
+    return safeRouteHandler(() =>
+      accountService.listAccountMembers(
+        parseNumericFields<AccountUsersPaginationParams>(
+          searchParamsToParams<AccountUsersPaginationParams>(req.nextUrl.searchParams),
+          NUMERIC_FIELDS
+        )
+      )
+    );
+  };
+}

package/src/modules/accounts/hooks/add-user-projects.hook.ts

@@ -0,0 +1,72 @@
+'use client';
+
+import { useMutation, useQueryClient, type QueryKey } from '@tanstack/react-query';
+import { useTranslations } from 'next-intl';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { addUserProjectsAction } from '../actions/account-management.action';
+import { ACCOUNT_USERS_QUERY_KEY } from './useAccountManagement';
+import type { AccountMembersPage } from './use-account-members.hook';
+
+type AddUserProjectsVariables = {
+  userId?: number;
+  projects: { id: number; title: string }[];
+};
+
+type AddUserProjectsContext = {
+  previousData: [QueryKey, AccountMembersPage | undefined][];
+};
+
+/** Vincula projetos ao usuário, já refletindo a mudança na lista da equipe antes da resposta. */
+export function useAddUserProjects() {
+  const translate = useTranslations();
+  const queryClient = useQueryClient();
+  const accountUsersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY]);
+  const membersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY, 'members']);
+
+  return useMutation({
+    mutationFn: async (variables: AddUserProjectsVariables) => {
+      if (!variables.userId) {
+        throw new Error(translate('common.account.workspace.team.invalidUser'));
+      }
+      if (variables.projects.length === 0) return;
+
+      return withAction(addUserProjectsAction)(
+        variables.userId,
+        variables.projects.map((project) => project.id)
+      );
+    },
+
+    onMutate: async (variables): Promise<AddUserProjectsContext> => {
+      await queryClient.cancelQueries({ queryKey: membersKey });
+
+      const previousData = queryClient.getQueriesData<AccountMembersPage>({ queryKey: membersKey });
+
+      previousData.forEach(([key, data]) => {
+        if (!data) return;
+
+        const users = data.users.map((user) => {
+          if (user.id !== variables.userId) return user;
+
+          const existingIds = new Set((user.projects || []).map((project) => project.id));
+          const projectsToAppend = variables.projects.filter((project) => !existingIds.has(project.id));
+          const projects = [...(user.projects || []), ...projectsToAppend];
+
+          return { ...user, projects, total_projects: projects.length };
+        });
+
+        queryClient.setQueryData(key, { ...data, users });
+      });
+
+      return { previousData };
+    },
+
+    onError: (_error, _variables, context) => {
+      context?.previousData.forEach(([key, data]) => queryClient.setQueryData(key, data));
+    },
+
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: accountUsersKey });
+    },
+  });
+}

package/src/modules/accounts/hooks/create-account-user.hook.ts

@@ -0,0 +1,21 @@
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { createAccountUserAction } from '../actions/account-management.action';
+import { ACCOUNT_USERS_QUERY_KEY } from './useAccountManagement';
+import type { CreateAccountUserRequest } from '../types';
+
+/** Cadastro de usuário da conta (envia o convite por e-mail). Restrito a owner/admin na action. */
+export function useCreateAccountUser() {
+  const queryClient = useQueryClient();
+  const accountUsersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY]);
+
+  return useMutation({
+    mutationFn: (user: CreateAccountUserRequest) => withAction(createAccountUserAction)(user),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: accountUsersKey });
+    },
+  });
+}

package/src/modules/accounts/hooks/remove-user-projects.hook.ts

@@ -0,0 +1,68 @@
+'use client';
+
+import { useMutation, useQueryClient, type QueryKey } from '@tanstack/react-query';
+import { useTranslations } from 'next-intl';
+import { withAction } from '../../../utils/withAction';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import { removeUserProjectsAction } from '../actions/account-management.action';
+import { ACCOUNT_USERS_QUERY_KEY } from './useAccountManagement';
+import type { AccountMembersPage } from './use-account-members.hook';
+
+type RemoveUserProjectsVariables = {
+  userId?: number;
+  projectIds: number[];
+};
+
+type RemoveUserProjectsContext = {
+  previousData: [QueryKey, AccountMembersPage | undefined][];
+};
+
+/** Desvincula projetos do usuário, já refletindo a mudança na lista da equipe antes da resposta. */
+export function useRemoveUserProjects() {
+  const translate = useTranslations();
+  const queryClient = useQueryClient();
+  const accountUsersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY]);
+  const membersKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY, 'members']);
+
+  return useMutation({
+    mutationFn: async (variables: RemoveUserProjectsVariables) => {
+      if (!variables.userId) {
+        throw new Error(translate('common.account.workspace.team.invalidUserRemove'));
+      }
+      if (variables.projectIds.length === 0) return;
+
+      return withAction(removeUserProjectsAction)(variables.userId, variables.projectIds);
+    },
+
+    onMutate: async (variables): Promise<RemoveUserProjectsContext> => {
+      await queryClient.cancelQueries({ queryKey: membersKey });
+
+      const previousData = queryClient.getQueriesData<AccountMembersPage>({ queryKey: membersKey });
+      const idsToRemove = new Set(variables.projectIds);
+
+      previousData.forEach(([key, data]) => {
+        if (!data) return;
+
+        const users = data.users.map((user) => {
+          if (user.id !== variables.userId) return user;
+
+          const projects = (user.projects || []).filter((project) => !idsToRemove.has(project.id));
+
+          return { ...user, projects, total_projects: projects.length };
+        });
+
+        queryClient.setQueryData(key, { ...data, users });
+      });
+
+      return { previousData };
+    },
+
+    onError: (_error, _variables, context) => {
+      context?.previousData.forEach(([key, data]) => queryClient.setQueryData(key, data));
+    },
+
+    onSettled: () => {
+      queryClient.invalidateQueries({ queryKey: accountUsersKey });
+    },
+  });
+}

package/src/modules/accounts/hooks/use-account-members.hook.ts

@@ -0,0 +1,31 @@
+'use client';
+
+import { keepPreviousData, useQuery } from '@tanstack/react-query';
+import { apiFetch } from '../../../infra/http/api-fetch';
+import { useAuthQueryKey } from '../../../hooks/useAuthQueryKey';
+import type { User } from '../../users/schema';
+import type { AccountUsersPaginationParams } from '../types';
+import { ACCOUNT_USERS_QUERY_KEY } from './useAccountManagement';
+
+export interface AccountMembersPage {
+  users: User[];
+  total: number;
+}
+
+/**
+ * Lista paginada da equipe (`/api/account/members`). Fica sob `ACCOUNT_USERS_QUERY_KEY` e no formato
+ * `{ users, total }` para receber as invalidações e updates otimistas das mutations de usuário.
+ */
+export function useAccountMembers(params: AccountUsersPaginationParams, options: { enabled?: boolean } = {}) {
+  const queryKey = useAuthQueryKey([...ACCOUNT_USERS_QUERY_KEY, 'members', params]);
+
+  return useQuery({
+    queryKey,
+    queryFn: ({ signal }) =>
+      apiFetch<AccountMembersPage>('/api/account/members', { params, signal }),
+    placeholderData: keepPreviousData,
+    staleTime: 60_000,
+    retry: false,
+    enabled: options.enabled ?? true,
+  });
+}

package/src/modules/accounts/services/account.service.ts

@@ -3,12 +3,14 @@ import 'server-only';
 import { api } from '../../../infra/api/client';
 import { ApiError } from '../../../infra/api/types';
 import { buildQueryParams } from '../../../infra/utils/params';
+import { assertAccountNotFrozen } from '../../auth/utils/assert-account-not-frozen';
 import { getUserContext } from '../../auth/utils/get-user-context';
 import { fileToBase64 } from '../../../utils/file/index';
 import type { RequestConfig } from '../../../infra/api/client';
 import { buildWlOverride } from '../../auth/utils/build-wl-override';
 import type {
   Account,
+  AccountUserProjectsResponse,
   AccountUsersPaginationParams,
   ChangePasswordRequest,
   ChangePasswordResponse,
@@ -63,6 +65,31 @@ class AccountService {
     };
   }
 
+  /**
+   * Usuários da conta com projetos (`total_projects`, `projects`), escopados ao usuário logado:
+   * collaborator/viewer só veem quem divide projeto com eles.
+   */
+  async listAccountMembers(params?: Partial<AccountUsersPaginationParams>) {
+    const { id_account, id_user } = await getUserContext();
+    const queryParams = buildQueryParams({ ...params, scopeUserId: id_user });
+    const response = await api.apps.get<ListAccountUsersResponse>(
+      `/accounts/${id_account}/users?${queryParams}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao listar usuários',
+        'LIST_ACCOUNT_USERS_FAILED',
+        400
+      );
+    }
+
+    return {
+      users: response.data || [],
+      total: response.total || 0,
+    };
+  }
+
   async changeUserPhoto(userId: number, photo: File): Promise<ChangeUserPhotoResponse> {
     const { id_account } = await getUserContext();
     const base64 = await fileToBase64(photo);
@@ -221,6 +248,50 @@ class AccountService {
     }
   }
 
+  /** Checagem de e-mail já cadastrado, usada no cadastro de usuário antes de avançar de passo. */
+  async checkUserExists(email: string): Promise<{ exists: boolean }> {
+    const response = await api.apps.post<{ exist: boolean }>('/users/action/exists', { email });
+
+    return { exists: response.exist };
+  }
+
+  async addUserProjects(userId: number, projectIds: number[]): Promise<AccountUserProjectsResponse> {
+    await assertAccountNotFrozen();
+    const { id_account } = await getUserContext();
+    const response = await api.apps.post<AccountUserProjectsResponse>(
+      `/accounts/${id_account}/users/${userId}/action/addProjectsBatch`,
+      { projects: projectIds }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao vincular projetos ao usuário',
+        'ADD_USER_PROJECTS_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
+
+  async removeUserProjects(userId: number, projectIds: number[]): Promise<AccountUserProjectsResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.post<AccountUserProjectsResponse>(
+      `/accounts/${id_account}/users/${userId}/action/removeProjectsBatch`,
+      { projects: projectIds }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao desvincular projetos do usuário',
+        'REMOVE_USER_PROJECTS_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
+
   async changePassword(data: ChangePasswordRequest): Promise<ChangePasswordResponse> {
     const { id_account, id_user } = await getUserContext();
     const response = await api.apps.put<ChangePasswordResponse>(

package/src/modules/accounts/types/account-hub-link.type.ts

@@ -0,0 +1,13 @@
+import type { AccountHubFlow } from '../../../enums/AccountHubFlow';
+import type { MyAccountSection } from '../../../store/useAccountModals';
+
+export interface AccountHubLink {
+  section: MyAccountSection;
+  flow?: AccountHubFlow;
+  couponCode?: string;
+}
+
+export interface LegacyAccountRouteTarget {
+  pathname: string;
+  searchParams: URLSearchParams;
+}

package/src/modules/accounts/types.ts

@@ -44,8 +44,12 @@ export interface AccountUsersPaginationParams {
     page?: number;
     limit?: number;
     search?: string;
+    /** Busca por nome (a tela de equipe usa este, não `search`). */
+    name?: string;
     notInProject?: number;
     profiles?: UserProfile[];
+    /** Id do usuário listado primeiro (o próprio usuário na tela de equipe sem filtro). */
+    firstId?: number;
 }
 
 export interface GetAccountDataResponse {
@@ -122,6 +126,11 @@ export interface ChangeUserPhotoResponse {
     message?: string;
 }
 
+export interface AccountUserProjectsResponse {
+    status: 0 | 1;
+    message?: string;
+}
+
 export interface DeleteAccountUserResponse {
     status: 0 | 1;
     message?: string;

package/src/modules/accounts/utils/build-account-hub-url.ts

@@ -0,0 +1,14 @@
+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';
+
+export function buildAccountHubUrl(baseUrl: string, link: AccountHubLink, pathname = '/'): string {
+  const url = new URL(pathname, baseUrl);
+  url.searchParams.set(ACCOUNT_HUB_SECTION_PARAM, link.section);
+  if (link.flow) url.searchParams.set(ACCOUNT_HUB_FLOW_PARAM, link.flow);
+  if (link.couponCode) url.searchParams.set(ACCOUNT_HUB_COUPON_PARAM, link.couponCode);
+  return url.toString();
+}

package/src/modules/accounts/utils/is-account-hub-flow.ts

@@ -0,0 +1,7 @@
+import { AccountHubFlow } from '../../../enums/AccountHubFlow';
+
+const ACCOUNT_HUB_FLOW_VALUES: readonly string[] = Object.values(AccountHubFlow);
+
+export function isAccountHubFlow(value: string): value is AccountHubFlow {
+  return ACCOUNT_HUB_FLOW_VALUES.includes(value);
+}

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

@@ -0,0 +1,7 @@
+import { AccountSectionType } from '../../../enums/AccountSectionType';
+
+const ACCOUNT_SECTION_VALUES: readonly string[] = Object.values(AccountSectionType);
+
+export function isAccountSectionType(value: string): value is AccountSectionType {
+  return ACCOUNT_SECTION_VALUES.includes(value);
+}