@greatapps/common 1.1.70 → 1.1.73

package/src/modules/users/schema/messages.schema.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+
+export const MessageSchema = z.object({
+  id: z.string(),
+  deleted: z.number(),
+  datetime_alt: z.string().nullable(),
+  datetime_del: z.string().nullable(),
+  datetime_add: z.string(),
+  id_wl: z.number(),
+  id_account: z.number(),
+  id_user: z.number(),
+  status: z.number().nullable(),
+  type: z.string(),
+  subject: z.string(),
+  message: z.string(),
+  to: z.string(),
+  url: z.string(),
+});
+
+export type Message = z.infer<typeof MessageSchema>;
+
+export interface FindMessagesParams {
+  id_user: number;
+  type: string;
+  limit: number;
+  page: number;
+  order: 'asc' | 'desc';
+}
+
+export interface ListMessagesApiResponse {
+  status: 0 | 1;
+  total: number;
+  data: Message[];
+  totalUnread: number;
+  message?: string;
+}
+
+export interface MarkAsReadApiResponse {
+  status: 0 | 1;
+  message?: string;
+}
+
+export interface MarkAllAsReadApiResponse {
+  status: 0 | 1;
+  message?: string;
+}

package/src/modules/users/services/messages.service.ts

@@ -0,0 +1,48 @@
+import 'server-only';
+
+import { api } from '../../../infra/api/client';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import {
+  FindMessagesParams,
+  ListMessagesApiResponse,
+  MarkAsReadApiResponse,
+  MarkAllAsReadApiResponse,
+} from '../schema/messages.schema';
+
+class MessagesService {
+  async listMessages(
+    params?: Partial<FindMessagesParams>
+  ): Promise<ListMessagesApiResponse> {
+    const { id_account, id_user } = await getUserContext();
+
+    const query = buildQueryParams({
+      id_account,
+      id_user,
+      type: 'notification',
+      limit: 20,
+      page: 1,
+      order: 'desc',
+      ...params,
+    });
+
+    const url = `/accounts/${id_account}/messages${query ? `?${query}` : ''}`;
+    return api.apps.get<ListMessagesApiResponse>(url);
+  }
+
+  async markAsRead(messageId: string): Promise<MarkAsReadApiResponse> {
+    const { id_account } = await getUserContext();
+
+    const url = `/accounts/${id_account}/messages/${messageId}/action/markAsRead`;
+    return api.apps.put<MarkAsReadApiResponse>(url);
+  }
+
+  async markAllAsRead(): Promise<MarkAllAsReadApiResponse> {
+    const { id_account, id_user } = await getUserContext();
+
+    const url = `/accounts/${id_account}/messages/action/markAllAsRead`;
+    return api.apps.put<MarkAllAsReadApiResponse>(url, { id_user });
+  }
+}
+
+export const messagesService = new MessagesService();

package/src/providers/auth.provider.tsx

@@ -23,9 +23,9 @@ import {
 } from "../modules/auth/schema";
 
 export type LoginResult =
-  | { status: "success" }
-  | { status: "two_factor_required"; cookie: string }
-  | { status: "error"; message: string };
+  | { result: "success" }
+  | { result: "two_factor_required"; cookie: string }
+  | { result: "error"; message: string };
 import {
   useCurrentAccount,
   useInvalidateAccount,
@@ -75,11 +75,8 @@ export function AuthProvider({ children }: AuthProviderProps) {
     async (credentials: LoginRequest): Promise<LoginResult> => {
       const data = await loginMutate(credentials);
 
-      if (data.status == 0)
-        return { status: "error", message: data.message || "Login failed" };
-
-      if (data.twoFactorRequired) {
-        return { status: "two_factor_required", cookie: data.cookie };
+      if (data.result === "two_factor_required") {
+        return { result: "two_factor_required", cookie: data.cookie };
       }
 
       invalidateUser();
@@ -87,7 +84,7 @@ export function AuthProvider({ children }: AuthProviderProps) {
 
       setUserData(data.user);
 
-      return { status: "success" };
+      return { result: "success" };
     },
     [setUserData, invalidateUser, invalidateAccount]
   );

package/src/utils/safeServerAction.ts

@@ -0,0 +1,27 @@
+export class ServerActionError extends Error {
+  status: number;
+
+  constructor(message: string, status: number) {
+    super(message);
+    this.name = 'ServerActionError';
+    this.status = status;
+  }
+}
+
+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'>;
+}