@greatapps/common 1.1.97 → 1.1.99

package/src/modules/users/hooks/messages.hook.ts

@@ -1,58 +1,60 @@
-'use client';
-
-import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { listMessagesAction } from '../action/list-messages.action';
-import { markMessageAsReadAction } from '../action/mark-message-as-read.action';
-import { markAllMessagesAsReadAction } from '../action/mark-all-messages-as-read.action';
-import { safeServerAction } from '../../../utils/safeServerAction';
-import type { FindMessagesParams } from '../schema/messages.schema';
-
-export const MESSAGES_QUERY_KEY = ['messages'];
-
-const INFINITE_MESSAGES_PAGE_SIZE = 10;
-
-export function useMessages(params?: Partial<FindMessagesParams>) {
-  return useQuery({
-    queryKey: [...MESSAGES_QUERY_KEY, params],
-    queryFn: () => safeServerAction(listMessagesAction, params),
-  });
-}
-
-export function useInfiniteMessages(params?: Partial<Omit<FindMessagesParams, 'page' | 'limit'>>) {
-  return useInfiniteQuery({
-    queryKey: [...MESSAGES_QUERY_KEY, 'infinite', params],
-    queryFn: ({ pageParam }) =>
-      safeServerAction(listMessagesAction, {
-        ...params,
-        page: pageParam as number,
-        limit: INFINITE_MESSAGES_PAGE_SIZE,
-      }),
-    getNextPageParam: (lastPage, allPages) => {
-      const loaded = allPages.reduce((sum, p) => sum + p.data.length, 0);
-      return loaded < lastPage.total ? allPages.length + 1 : undefined;
-    },
-    initialPageParam: 1,
-  });
-}
-
-export function useMarkMessageAsRead() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: (messageId: string) => safeServerAction(markMessageAsReadAction, messageId),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: MESSAGES_QUERY_KEY });
-    },
-  });
-}
-
-export function useMarkAllMessagesAsRead() {
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: () => safeServerAction(markAllMessagesAsReadAction),
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: MESSAGES_QUERY_KEY });
-    },
-  });
-}
+'use client';
+
+import { useInfiniteQuery, useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { listMessagesAction } from '../action/list-messages.action';
+import { markMessageAsReadAction } from '../action/mark-message-as-read.action';
+import { markAllMessagesAsReadAction } from '../action/mark-all-messages-as-read.action';
+import { withAction } from '../../../utils/withAction';
+import type { FindMessagesParams } from '../schema/messages.schema';
+
+export const MESSAGES_QUERY_KEY = ['messages'];
+
+const INFINITE_MESSAGES_PAGE_SIZE = 10;
+
+export function useMessages(params?: Partial<FindMessagesParams>) {
+  return useQuery({
+    queryKey: [...MESSAGES_QUERY_KEY, params],
+    queryFn: withAction(() => listMessagesAction(params)),
+  });
+}
+
+export function useInfiniteMessages(params?: Partial<Omit<FindMessagesParams, 'page' | 'limit'>>) {
+  return useInfiniteQuery({
+    queryKey: [...MESSAGES_QUERY_KEY, 'infinite', params],
+    queryFn: ({ pageParam }) =>
+      withAction(() =>
+        listMessagesAction({
+          ...params,
+          page: pageParam as number,
+          limit: INFINITE_MESSAGES_PAGE_SIZE,
+        })
+      )(),
+    getNextPageParam: (lastPage, allPages) => {
+      const loaded = allPages.reduce((sum, p) => sum + p.data.length, 0);
+      return loaded < lastPage.total ? allPages.length + 1 : undefined;
+    },
+    initialPageParam: 1,
+  });
+}
+
+export function useMarkMessageAsRead() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(markMessageAsReadAction),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: MESSAGES_QUERY_KEY });
+    },
+  });
+}
+
+export function useMarkAllMessagesAsRead() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: withAction(markAllMessagesAsReadAction),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: MESSAGES_QUERY_KEY });
+    },
+  });
+}

package/src/providers/auth.provider.tsx

@@ -7,10 +7,10 @@ import {
   useContext,
   useMemo,
 } from "react";
+import { useQueryClient } from "@tanstack/react-query";
 import {
   useUserQuery,
   useSetUserData,
-  useInvalidateUser,
   useUserValidateSession,
 } from "../modules/auth/hooks/useUserQuery";
 import { useLogin } from "../modules/auth/hooks/login.hook";
@@ -26,10 +26,7 @@ export type LoginResult =
   | { result: "success" }
   | { result: "two_factor_required"; cookie: string }
   | { result: "error"; message: string };
-import {
-  useCurrentAccount,
-  useInvalidateAccount,
-} from "../modules/accounts/hooks/current-account.hook";
+import { useCurrentAccount } from "../modules/accounts/hooks/current-account.hook";
 import { useRouter } from "next/navigation";
 
 interface AuthContextProps extends AuthState {
@@ -51,9 +48,8 @@ export function AuthProvider({ children }: AuthProviderProps) {
   const { data: account, isLoading: isAccountLoading } = useCurrentAccount();
   const { isLoading: isSessionLoading } = useUserValidateSession();
 
+  const queryClient = useQueryClient();
   const setUserData = useSetUserData();
-  const invalidateUser = useInvalidateUser();
-  const invalidateAccount = useInvalidateAccount();
 
   const router = useRouter();
 
@@ -79,37 +75,34 @@ export function AuthProvider({ children }: AuthProviderProps) {
         return { result: "two_factor_required", cookie: data.cookie };
       }
 
+      queryClient.clear();
       setUserData(data.user);
 
-      invalidateUser();
-      invalidateAccount();
-
       return { result: "success" };
     },
-    [setUserData, invalidateUser, invalidateAccount]
+    [queryClient, setUserData]
   );
 
   const register = useCallback(
     async (data: RegisterRequest): Promise<void> => {
       await registerMutate(data, {
         onSuccess: (data) => {
-          invalidateUser();
-          invalidateAccount();
+          queryClient.clear();
           setUserData(data.user);
         },
       });
     },
-    [setUserData, invalidateUser, invalidateAccount]
+    [queryClient, setUserData]
   );
 
   const logout = useCallback(async (): Promise<void> => {
     await logoutMutate(undefined, {
       onSuccess: () => {
-        invalidateUser();
+        queryClient.clear();
         router.push("/login");
       },
     });
-  }, [setUserData]);
+  }, [queryClient, router]);
 
   const value: AuthContextProps = useMemo(
     () => ({

package/src/utils/safeServerAction.ts

@@ -1,27 +1,21 @@
-export class ServerActionError extends Error {
-  status: number;
+import { isRedirectError } from 'next/dist/client/components/redirect-error';
+import { ApiError } from '../infra/api/types';
+import type { ActionResult } from '../infra/api/types';
 
-  constructor(message: string, status: number) {
-    super(message);
-    this.name = 'ServerActionError';
-    this.status = status;
+export async function safeServerAction<T>(
+  fn: () => Promise<T>
+): Promise<ActionResult<T>> {
+  try {
+    const data = await fn();
+    return { success: true, data };
+  } catch (error) {
+    if (isRedirectError(error)) throw error;
+    const message =
+      error instanceof ApiError
+        ? error.message
+        : error instanceof Error
+          ? error.message
+          : 'Erro desconhecido';
+    return { success: false, error: message };
   }
 }
-
-export async function safeServerAction<
-  TArgs extends any[],
-  TResult extends Record<string, any>,
->(
-  action: (...args: TArgs) => Promise<TResult>,
-  ...args: TArgs
-): Promise<Omit<TResult, 'error'>> {
-  const result: TResult = await action(...args);
-
-  if (result.status === 0 || result.result === 'error' || result.error) {
-    const msg = result.message || result.error || 'Erro na ação';
-    throw new ServerActionError(msg, result.status || 0);
-  }
-
-  const { error, ...successData } = result;
-  return successData as Omit<TResult, 'error'>;
-}

package/src/utils/withAction.ts

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