@greatapps/common 1.1.98 → 1.1.100

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

@@ -1,261 +1,90 @@
-"use server";
-
-import { accountService } from "../services/account.service";
-import { ApiError } from "../../../infra/api/types";
-import type {
-  AccountUsersPaginationParams,
-  AccountUsersActionResult,
-  ChangePasswordActionResult,
-  ChangePasswordRequest,
-  ContactResetResult,
-  CreateAccountUserRequest,
-  DeleteAccountActionResult,
-  DeleteUserActionResult,
-  TwoFactorActionResult,
-  TwoFactorGenerateResult,
-  UpdateAccountActionResult,
-  UpdateAccountRequest,
-  UpdateAccountUserRequest,
-  UpdateUserActionResult,
-} from "../types";
-import { twoFactorService } from "../services/two-factor.service";
-
-export async function listAccountUsersAction(
-  params?: AccountUsersPaginationParams
-): Promise<AccountUsersActionResult> {
-  try {
-    const { users, total } = await accountService.listAccountUsers(params);
-    return { success: true, data: users, total };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao listar usuários. Tente novamente.",
-    };
-  }
-}
-
-export async function updateUserAction(
-  user: UpdateAccountUserRequest
-): Promise<UpdateUserActionResult> {
-  try {
-    const result = await accountService.updateAccountUser(user);
-    return { success: true, data: result };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao atualizar usuário. Tente novamente.",
-    };
-  }
-}
-
-export async function updateAccountUserByIdAction(
-  userId: number,
-  user: UpdateAccountUserRequest
-): Promise<UpdateUserActionResult> {
-  try {
-    const result = await accountService.updateAccountUserById(userId, user);
-    return { success: true, data: result };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao atualizar usuário. Tente novamente.",
-    };
-  }
-}
-
-export async function updateAccountAction(
-  data: UpdateAccountRequest
-): Promise<UpdateAccountActionResult> {
-  try {
-    await accountService.updateAccount(data);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao atualizar conta. Tente novamente.",
-    };
-  }
-}
-
-export async function deleteAccountUserAction(
-  userId: number
-): Promise<DeleteUserActionResult> {
-  try {
-    await accountService.deleteAccountUser(userId);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao remover usuário. Tente novamente.",
-    };
-  }
-}
-
-export async function deleteAccountAction(): Promise<DeleteAccountActionResult> {
-  try {
-    await accountService.deleteAccount();
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Erro ao excluir conta. Tente novamente." };
-  }
-}
-
-export async function createAccountUserAction(
-  user: CreateAccountUserRequest
-): Promise<AccountUsersActionResult> {
-  try {
-    const result = await accountService.createAccountUser(user);
-    return { success: true, data: result.data };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Erro ao criar usuário. Tente novamente." };
-  }
-}
-
-export async function changePasswordAction(
-  data: ChangePasswordRequest
-): Promise<ChangePasswordActionResult> {
-  try {
-    await accountService.changePassword(data);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Erro ao alterar senha. Tente novamente." };
-  }
-}
-
-export async function requestEmailChangeAction(
-  newEmail: string
-): Promise<ContactResetResult> {
-  try {
-    await accountService.requestContactReset("email", newEmail);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error:
-        "E-mail já existente ou ocorreu um erro. Tente novamente mais tarde.",
-    };
-  }
-}
-
-export async function confirmEmailChangeAction(
-  token: string,
-  newEmail: string
-): Promise<ContactResetResult> {
-  try {
-    await accountService.confirmContactReset("email", token, newEmail);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Código inválido ou expirado. Tente novamente.",
-    };
-  }
-}
-
-export async function requestPhoneChangeAction(
-  newPhone: string
-): Promise<ContactResetResult> {
-  try {
-    await accountService.requestContactReset("phone", newPhone);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error:
-        "Número já existente ou ocorreu um erro. Tente novamente mais tarde.",
-    };
-  }
-}
-
-export async function confirmPhoneChangeAction(
-  token: string,
-  newPhone: string
-): Promise<ContactResetResult> {
-  try {
-    await accountService.confirmContactReset("phone", token, newPhone);
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Código inválido ou expirado. Tente novamente.",
-    };
-  }
-}
-
-export async function generateTwoFactorAction(): Promise<TwoFactorGenerateResult> {
-  try {
-    const result = await twoFactorService.generate();
-    return {
-      success: true,
-      qrcode: result.data.qrcode,
-      backupCodes: result.data.backup_codes,
-    };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Erro ao gerar QR Code. Tente novamente." };
-  }
-}
-
-export async function confirmTwoFactorAction(
-  code: string
-): Promise<TwoFactorActionResult> {
-  try {
-    await twoFactorService.confirm(code);
-    await accountService.updateAccountUser({ two_factor_authentication: true });
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Código inválido. Tente novamente." };
-  }
-
-  return { success: true };
-}
-
-export async function disableTwoFactorAction(
-  code: string
-): Promise<TwoFactorActionResult> {
-  try {
-    await twoFactorService.verify(code);
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return { success: false, error: "Código inválido. Tente novamente." };
-  }
-
-  try {
-    await twoFactorService.disable();
-    return { success: true };
-  } catch (error) {
-    if (error instanceof ApiError)
-      return { success: false, error: error.message };
-    return {
-      success: false,
-      error: "Erro ao desabilitar 2FA. Tente novamente.",
-    };
-  }
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { accountService } from '../services/account.service';
+import type {
+  AccountUsersPaginationParams,
+  ChangePasswordRequest,
+  CreateAccountUserRequest,
+  UpdateAccountRequest,
+  UpdateAccountUserRequest,
+} from '../types';
+import { twoFactorService } from '../services/two-factor.service';
+
+export function listAccountUsersAction(params?: AccountUsersPaginationParams) {
+  return safeServerAction(async () => {
+    const { users, total } = await accountService.listAccountUsers(params);
+    return { data: users, total };
+  });
+}
+
+export function updateUserAction(user: UpdateAccountUserRequest) {
+  return safeServerAction(() => accountService.updateAccountUser(user));
+}
+
+export function updateAccountUserByIdAction(
+  userId: number,
+  user: UpdateAccountUserRequest
+) {
+  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
+}
+
+export function updateAccountAction(data: UpdateAccountRequest) {
+  return safeServerAction(() => accountService.updateAccount(data));
+}
+
+export function deleteAccountUserAction(userId: number) {
+  return safeServerAction(() => accountService.deleteAccountUser(userId));
+}
+
+export function deleteAccountAction() {
+  return safeServerAction(() => accountService.deleteAccount());
+}
+
+export function createAccountUserAction(user: CreateAccountUserRequest) {
+  return safeServerAction(() => accountService.createAccountUser(user));
+}
+
+export function changePasswordAction(data: ChangePasswordRequest) {
+  return safeServerAction(() => accountService.changePassword(data));
+}
+
+export function requestEmailChangeAction(newEmail: string) {
+  return safeServerAction(() => accountService.requestContactReset('email', newEmail));
+}
+
+export function confirmEmailChangeAction(token: string, newEmail: string) {
+  return safeServerAction(() => accountService.confirmContactReset('email', token, newEmail));
+}
+
+export function requestPhoneChangeAction(newPhone: string) {
+  return safeServerAction(() => accountService.requestContactReset('phone', newPhone));
+}
+
+export function confirmPhoneChangeAction(token: string, newPhone: string) {
+  return safeServerAction(() => accountService.confirmContactReset('phone', token, newPhone));
+}
+
+export function generateTwoFactorAction() {
+  return safeServerAction(async () => {
+    const result = await twoFactorService.generate();
+    return {
+      qrcode: result.data.qrcode,
+      backupCodes: result.data.backup_codes,
+    };
+  });
+}
+
+export function confirmTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.confirm(code);
+    await accountService.updateAccountUser({ two_factor_authentication: true });
+  });
+}
+
+export function disableTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.verify(code);
+    await twoFactorService.disable();
+  });
+}

package/src/modules/accounts/actions/find-current-account.action.ts

@@ -1,8 +1,9 @@
 'use server';
 
-import { accountService } from "../services/account.service";
-import { Account } from "../types";
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { accountService } from '../services/account.service';
+import type { Account } from '../types';
 
-export async function findCurrentAccount(): Promise<Account> {
-    return await accountService.findCurrentAccount();
+export function findCurrentAccount() {
+  return safeServerAction<Account>(() => accountService.findCurrentAccount());
 }

package/src/modules/accounts/actions/list-currencies.action.ts

@@ -1,7 +1,8 @@
-'use server';
-
-import { currencyService } from '../services/currency.service';
-
-export async function listCurrenciesAction() {
-  return currencyService.fetchOptions();
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { currencyService } from '../services/currency.service';
+
+export function listCurrenciesAction() {
+  return safeServerAction(() => currencyService.fetchOptions());
+}

package/src/modules/accounts/actions/list-timezones.action.ts

@@ -1,7 +1,8 @@
-'use server';
-
-import { timezoneService } from '../services/timezone.service';
-
-export async function listTimezonesAction() {
-  return timezoneService.fetchOptions();
-}
+'use server';
+
+import { safeServerAction } from '../../../utils/safeServerAction';
+import { timezoneService } from '../services/timezone.service';
+
+export function listTimezonesAction() {
+  return safeServerAction(() => timezoneService.fetchOptions());
+}

package/src/modules/accounts/hooks/current-account.hook.tsx

@@ -1,14 +1,15 @@
-"use client";
+'use client';
 
-import { useQuery, useQueryClient } from "@tanstack/react-query";
-import { findCurrentAccount } from "../actions/find-current-account.action";
+import { useQuery, useQueryClient } from '@tanstack/react-query';
+import { findCurrentAccount } from '../actions/find-current-account.action';
+import { withAction } from '../../../utils/withAction';
 
-export const ACCOUNT_QUERY_KEY = ["account"];
+export const ACCOUNT_QUERY_KEY = ['account'];
 
 export function useCurrentAccount() {
   return useQuery({
     queryKey: ACCOUNT_QUERY_KEY,
-    queryFn: findCurrentAccount,
+    queryFn: withAction(findCurrentAccount),
     staleTime: 0,
     gcTime: 10 * 60 * 1000,
     retry: false,

package/src/modules/accounts/hooks/useAccountManagement.ts

@@ -1,83 +1,85 @@
-'use client';
-
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { USER_QUERY_KEY } from '../../auth/hooks/useUserQuery';
-import { ACCOUNT_QUERY_KEY } from './current-account.hook';
-import type {
-  UpdateAccountRequest,
-  UpdateAccountUserRequest,
-  DeleteUserActionResult,
-  DeleteAccountActionResult,
-} from '../types';
-import {
-  updateUserAction,
-  updateAccountAction,
-  updateAccountUserByIdAction,
-  deleteAccountUserAction,
-  deleteAccountAction,
-} from '../actions/account-management.action';
-import type { UseMutationOptions } from '@tanstack/react-query';
-
-const ACCOUNT_USERS_QUERY_KEY = ['account-users'];
-
-export function useUpdateAccount() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (data: UpdateAccountRequest) => updateAccountAction(data),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
-      queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
-    },
-  });
-}
-
-export function useUpdateAccountUser() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: updateUserAction,
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
-      queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
-    },
-  });
-}
-
-export function useUpdateAccountUserById() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: ({ userId, ...user }: UpdateAccountUserRequest & { userId: number }) =>
-      updateAccountUserByIdAction(userId, user),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
-    },
-  });
-}
-
-export function useDeleteAccountUser(
-  options?: UseMutationOptions<DeleteUserActionResult, Error, number>
-) {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (userId: number) => deleteAccountUserAction(userId),
-    ...options,
-    onSuccess: (...params) => {
-      options?.onSuccess?.(...params);
-      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
-    },
-  });
-}
-
-export function useDeleteAccount(
-  options?: UseMutationOptions<DeleteAccountActionResult, Error, void>
-) {
-  return useMutation({
-    mutationFn: () => deleteAccountAction(),
-    ...options,
-  });
-}
+'use client';
+
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { USER_QUERY_KEY } from '../../auth/hooks/useUserQuery';
+import { ACCOUNT_QUERY_KEY } from './current-account.hook';
+import type {
+  UpdateAccountRequest,
+  UpdateAccountUserRequest,
+  DeleteAccountUserResponse,
+  DeleteAccountResponse,
+} from '../types';
+import {
+  updateUserAction,
+  updateAccountAction,
+  updateAccountUserByIdAction,
+  deleteAccountUserAction,
+  deleteAccountAction,
+} from '../actions/account-management.action';
+import { withAction } from '../../../utils/withAction';
+import type { UseMutationOptions } from '@tanstack/react-query';
+
+const ACCOUNT_USERS_QUERY_KEY = ['account-users'];
+
+export function useUpdateAccount() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(updateAccountAction),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
+      queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
+    },
+  });
+}
+
+export function useUpdateAccountUser() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(updateUserAction),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
+      queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
+    },
+  });
+}
+
+export function useUpdateAccountUserById() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(({ userId, ...user }: UpdateAccountUserRequest & { userId: number }) =>
+      updateAccountUserByIdAction(userId, user)
+    ),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
+    },
+  });
+}
+
+export function useDeleteAccountUser(
+  options?: UseMutationOptions<DeleteAccountUserResponse, Error, number>
+) {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(deleteAccountUserAction),
+    ...options,
+    onSuccess: (...params) => {
+      options?.onSuccess?.(...params);
+      queryClient.invalidateQueries({ queryKey: ACCOUNT_USERS_QUERY_KEY });
+    },
+  });
+}
+
+export function useDeleteAccount(
+  options?: UseMutationOptions<DeleteAccountResponse, Error, void>
+) {
+  return useMutation({
+    mutationFn: withAction(deleteAccountAction),
+    ...options,
+  });
+}

package/src/modules/accounts/hooks/useCurrencies.ts

@@ -1,14 +1,15 @@
-'use client';
-
-import { useQuery } from '@tanstack/react-query';
-import { listCurrenciesAction } from '../actions/list-currencies.action';
-
-export const CURRENCIES_QUERY_KEY = ['currencies'];
-
-export function useCurrencies() {
-  return useQuery({
-    queryKey: CURRENCIES_QUERY_KEY,
-    queryFn: listCurrenciesAction,
-    staleTime: Infinity,
-  });
-}
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { listCurrenciesAction } from '../actions/list-currencies.action';
+import { withAction } from '../../../utils/withAction';
+
+export const CURRENCIES_QUERY_KEY = ['currencies'];
+
+export function useCurrencies() {
+  return useQuery({
+    queryKey: CURRENCIES_QUERY_KEY,
+    queryFn: withAction(listCurrenciesAction),
+    staleTime: Infinity,
+  });
+}

package/src/modules/accounts/hooks/useTimezones.ts

@@ -1,14 +1,15 @@
-'use client';
-
-import { useQuery } from '@tanstack/react-query';
-import { listTimezonesAction } from '../actions/list-timezones.action';
-
-export const TIMEZONES_QUERY_KEY = ['timezones'];
-
-export function useTimezones() {
-  return useQuery({
-    queryKey: TIMEZONES_QUERY_KEY,
-    queryFn: listTimezonesAction,
-    staleTime: Infinity,
-  });
-}
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { listTimezonesAction } from '../actions/list-timezones.action';
+import { withAction } from '../../../utils/withAction';
+
+export const TIMEZONES_QUERY_KEY = ['timezones'];
+
+export function useTimezones() {
+  return useQuery({
+    queryKey: TIMEZONES_QUERY_KEY,
+    queryFn: withAction(listTimezonesAction),
+    staleTime: Infinity,
+  });
+}