@greatapps/common 1.1.24 → 1.1.26

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

@@ -1,57 +1,236 @@
 import 'server-only';
 
-import { cookies } from 'next/headers';
-import { apiClient } from '@greatapps/common/server';
-import { ApiError, JWTPayload, User, buildQueryParams } from '@greatapps/common';
-import { Account, AccountUsersPaginationParams, GetAccountDataResponse, ListAccountUsersResponse } from '../types';
-
-/**
- * Service para gerenciar usuários da conta
- * Executado apenas no servidor (server-only)
- */
+import { api } from '../../../infra/api/client';
+import { ApiError } from '../../../infra/api/types';
+import { buildQueryParams } from '../../../infra/utils/params';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { fileToBase64 } from '../../../utils/file/index';
+import type {
+  Account,
+  AccountUsersPaginationParams,
+  ChangePasswordRequest,
+  ChangePasswordResponse,
+  ChangeUserPhotoResponse,
+  CreateAccountUserRequest,
+  CreateAccountUserResponse,
+  DeleteAccountResponse,
+  DeleteAccountUserResponse,
+  GetAccountDataResponse,
+  ListAccountUsersResponse,
+  UpdateAccountRequest,
+  UpdateAccountResponse,
+  UpdateAccountUserRequest,
+  UpdateAccountUserResponse,
+} from '../types';
+
 class AccountService {
-    /**
-     * Obtém o contexto do usuário a partir do JWT
-     * @private
-     */
-    async getUserContext(): Promise<{
-        id_account: number;
-        id_user: number;
-    }> {
-        const cookieStore = await cookies();
-        const token = cookieStore.get('greatapps')?.value;
-
-        if (!token) {
-            throw new ApiError('Usuário não autenticado', 'NOT_AUTHENTICATED', 401);
-        }
-
-        try {
-            const payload = JSON.parse(atob(token.split('.')[1])) as JWTPayload;
-
-            return {
-                id_account: payload.id_account,
-                id_user: payload.id_user,
-            };
-        } catch (error) {
-            throw new ApiError('Token inválido', 'INVALID_TOKEN', 401);
-        }
-    }
-
-    async findCurrentAccount(): Promise<Account> {
-        const { id_account } = await this.getUserContext();
-
-        const response = await apiClient.get<GetAccountDataResponse>(`/accounts/${id_account}`);
-
-        if (response.status === 0 || !response.data?.[0]) {
-            throw new ApiError(
-                response.message || 'Erro ao buscar dados da conta',
-                'GET_ACCOUNT_FAILED',
-                400
-            );
-        }
-
-        return response.data[0];
+  async findCurrentAccount(): Promise<Account> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.get<GetAccountDataResponse>(`/accounts/${id_account}`);
+
+    if (response.status === 0 || !response.data?.[0]) {
+      throw new ApiError(
+        response.message || 'Erro ao buscar dados da conta',
+        'GET_ACCOUNT_FAILED',
+        400
+      );
+    }
+
+    return response.data[0];
+  }
+
+  async listAccountUsers(params?: Partial<AccountUsersPaginationParams>) {
+    const { id_account } = await getUserContext();
+    const queryParams = buildQueryParams(params);
+    const endpoint = `/accounts/${id_account}/users?${queryParams}`;
+    const response = await api.apps.get<ListAccountUsersResponse>(endpoint);
+
+    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);
+    const response = await api.apps.put<ChangeUserPhotoResponse>(
+      `/accounts/${id_account}/users/${userId}/file/photo`,
+      { file: base64 }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao mudar foto do usuário',
+        'CHANGE_USER_PHOTO_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
+
+  async deleteAccountUser(userId: number): Promise<DeleteAccountUserResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.delete<DeleteAccountUserResponse>(
+      `/accounts/${id_account}/users/${userId}`
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao deletar usuário', 'DELETE_USER_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  async deleteAccount(): Promise<DeleteAccountResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.delete<DeleteAccountResponse>(`/accounts/${id_account}`);
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao deletar conta', 'DELETE_ACCOUNT_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  async createAccountUser(user: CreateAccountUserRequest): Promise<CreateAccountUserResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.post<CreateAccountUserResponse>(
+      `/accounts/${id_account}/users`,
+      {
+        ...user,
+        photo: user.photo ? await fileToBase64(user.photo) : null,
+      }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao criar usuário', 'CREATE_USER_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  private async resolvePhotoField(user: UpdateAccountUserRequest): Promise<{ photo?: string | null }> {
+    if (user.photo === undefined) return {};
+    const photo =
+      user.photo != null && typeof user.photo !== 'string'
+        ? await fileToBase64(user.photo)
+        : user.photo;
+    return { photo };
+  }
+
+  async updateAccountUser(user: UpdateAccountUserRequest): Promise<UpdateAccountUserResponse> {
+    const { id_account, id_user } = await getUserContext();
+    const response = await api.apps.put<UpdateAccountUserResponse>(
+      `/accounts/${id_account}/users/${id_user}`,
+      { ...user, ...(await this.resolvePhotoField(user)) }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar usuário',
+        'UPDATE_USER_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
+
+  async updateAccountUserById(
+    userId: number,
+    user: UpdateAccountUserRequest
+  ): Promise<UpdateAccountUserResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.put<UpdateAccountUserResponse>(
+      `/accounts/${id_account}/users/${userId}`,
+      { ...user, ...(await this.resolvePhotoField(user)) }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar usuário',
+        'UPDATE_USER_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
+
+  async updateAccount(data: UpdateAccountRequest): Promise<UpdateAccountResponse> {
+    const { id_account } = await getUserContext();
+    const response = await api.apps.put<UpdateAccountResponse>(`/accounts/${id_account}`, data);
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao atualizar conta',
+        'UPDATE_ACCOUNT_FAILED',
+        400
+      );
     }
+
+    return response;
+  }
+
+  async requestContactReset(type: 'email' | 'phone', newContact: string): Promise<void> {
+    const { id_account, id_user } = await getUserContext();
+    const response = await api.apps.post<{ status: number; message: string }>(
+      `/accounts/${id_account}/users/${id_user}/resetContact/request`,
+      { type, newContact }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao solicitar alteração',
+        'REQUEST_CONTACT_RESET_FAILED',
+        400
+      );
+    }
+  }
+
+  async confirmContactReset(type: 'email' | 'phone', token: string, newContact: string): Promise<void> {
+    const { id_account, id_user } = await getUserContext();
+    const response = await api.apps.post<{ status: number; message: string }>(
+      `/accounts/${id_account}/users/${id_user}/resetContact/confirm`,
+      { type, token, newContact }
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Código inválido ou expirado',
+        'CONFIRM_CONTACT_RESET_FAILED',
+        400
+      );
+    }
+  }
+
+  async changePassword(data: ChangePasswordRequest): Promise<ChangePasswordResponse> {
+    const { id_account, id_user } = await getUserContext();
+    const response = await api.apps.put<ChangePasswordResponse>(
+      `/accounts/${id_account}/users/${id_user}/action/changePassword`,
+      data
+    );
+
+    if (response.status === 0) {
+      throw new ApiError(
+        response.message || 'Erro ao alterar senha',
+        'CHANGE_PASSWORD_FAILED',
+        400
+      );
+    }
+
+    return response;
+  }
 }
 
 export const accountService = new AccountService();

package/src/modules/accounts/services/two-factor.service.ts

@@ -0,0 +1,98 @@
+import 'server-only';
+
+import { ApiError } from '../../../infra/api/types';
+import { getUserContext } from '../../auth/utils/get-user-context';
+import { findWhitelabel } from '../../whitelabel/actions/find-whitelabel.action';
+import type { TwoFactorActionResponse, TwoFactorGenerateResponse } from '../types';
+
+const TWO_FA_BASE_URL = process.env.R2_2FA_URL || 'https://r2-2fa.greatapps.dev.br';
+
+class TwoFactorService {
+  private async request<T>(path: string, body?: object): Promise<T> {
+    const { id, token } = await findWhitelabel();
+    const { id_account, id_user } = await getUserContext();
+
+    const url = `${TWO_FA_BASE_URL}/v1/${id}/account/${id_account}/users/${id_user}/2fa/${path}`;
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        authorization: token,
+      },
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({})) as Record<string, unknown>;
+      throw new ApiError(
+        (errorData.message as string) || `HTTP error ${response.status}`,
+        'HTTP_ERROR',
+        response.status
+      );
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async generate(): Promise<TwoFactorGenerateResponse> {
+    const response = await this.request<TwoFactorGenerateResponse>('generate');
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao gerar QR Code', 'GENERATE_2FA_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  async confirm(code: string): Promise<TwoFactorActionResponse> {
+    const response = await this.request<TwoFactorActionResponse>('confirm', { code });
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Código inválido', 'CONFIRM_2FA_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  async verify(code: string): Promise<TwoFactorActionResponse> {
+    const response = await this.request<TwoFactorActionResponse>('verify', { code });
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Código inválido', 'VERIFY_2FA_FAILED', 400);
+    }
+
+    return response;
+  }
+
+  async disable(): Promise<TwoFactorActionResponse> {
+    const { id, token } = await findWhitelabel();
+    const { id_account, id_user } = await getUserContext();
+
+    const url = `${TWO_FA_BASE_URL}/v1/${id}/account/${id_account}/users/${id_user}/2fa`;
+
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: { authorization: token },
+    });
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({})) as Record<string, unknown>;
+      throw new ApiError(
+        (errorData.message as string) || `HTTP error ${response.status}`,
+        'HTTP_ERROR',
+        response.status
+      );
+    }
+
+    const data = await response.json() as TwoFactorActionResponse;
+
+    if (data.status === 0) {
+      throw new ApiError(data.message || 'Erro ao desabilitar 2FA', 'DISABLE_2FA_FAILED', 400);
+    }
+
+    return data;
+  }
+}
+
+export const twoFactorService = new TwoFactorService();

package/src/modules/accounts/types.ts

@@ -53,4 +53,161 @@ export interface GetAccountDataResponse {
     message: string;
     data: Account[];
     total: number;
+}
+
+// ============================================================================
+// Account User Management
+// ============================================================================
+
+export interface AccountUsersActionResult {
+    success: boolean;
+    data?: User[];
+    total?: number;
+    error?: string;
+}
+
+export interface CreateAccountUserRequest {
+    name: string;
+    email: string;
+    password?: string;
+    profile: UserProfile;
+    language: string;
+    id_api?: number;
+    last_name: string;
+    ddi: string;
+    phone: string;
+    rg?: string;
+    cpf?: string;
+    gender: number;
+    receive_sms?: boolean;
+    receive_email?: boolean;
+    photo?: File | null;
+    projects?: number[];
+}
+
+export interface CreateAccountUserResponse {
+    status: 0 | 1;
+    message: string;
+    data: User[];
+}
+
+export interface UpdateAccountUserRequest {
+    name?: string;
+    email?: string;
+    password?: string;
+    profile?: UserProfile;
+    language?: string;
+    id_api?: number;
+    last_name?: string;
+    ddi?: string;
+    phone?: string;
+    rg?: string;
+    cpf?: string;
+    gender?: number;
+    receive_sms?: boolean;
+    receive_email?: boolean;
+    photo?: File | string | null;
+    projects?: number[];
+}
+
+export interface UpdateAccountUserResponse {
+    status: 0 | 1;
+    message: string;
+    data: User[];
+}
+
+export interface ChangeUserPhotoResponse {
+    status: 0 | 1;
+    message?: string;
+}
+
+export interface DeleteAccountUserResponse {
+    status: 0 | 1;
+    message?: string;
+}
+
+export interface DeleteAccountResponse {
+    status: 0 | 1;
+    message?: string;
+}
+
+export interface DeleteAccountActionResult {
+    success: boolean;
+    error?: string;
+}
+
+export interface DeleteUserActionResult {
+    success: boolean;
+    error?: string;
+}
+
+export interface UpdateAccountRequest {
+    currency?: string;
+    timezone?: string;
+}
+
+export interface UpdateAccountResponse {
+    status: 0 | 1;
+    message: string;
+}
+
+export interface UpdateAccountActionResult {
+    success: boolean;
+    error?: string;
+}
+
+export interface UpdateUserActionResult {
+    success: boolean;
+    data?: UpdateAccountUserResponse;
+    error?: string;
+}
+
+export interface ChangePasswordRequest {
+    currentPassword: string;
+    newPassword: string;
+}
+
+export interface ChangePasswordResponse {
+    status: 0 | 1;
+    message: string;
+}
+
+export interface ChangePasswordActionResult {
+    success: boolean;
+    error?: string;
+}
+
+export interface ContactResetResult {
+    success: boolean;
+    error?: string;
+}
+
+// ============================================================================
+// Two-Factor Authentication
+// ============================================================================
+
+export interface TwoFactorGenerateResponse {
+    status: 0 | 1;
+    message: string;
+    data: {
+        qrcode: string;
+        backup_codes: string[];
+    };
+}
+
+export interface TwoFactorActionResponse {
+    status: 0 | 1;
+    message: string;
+}
+
+export interface TwoFactorGenerateResult {
+    success: boolean;
+    qrcode?: string;
+    backupCodes?: string[];
+    error?: string;
+}
+
+export interface TwoFactorActionResult {
+    success: boolean;
+    error?: string;
 }

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

@@ -144,10 +144,12 @@ class AuthService {
   async logout(clientInfo: ClientInfo): Promise<LogoutResponse> {
     const cookie = await getAuthCookie();
 
+
     if (!cookie) {
       throw new ApiError('Usuário não autenticado', 'NOT_AUTHENTICATED', 401);
     }
 
+
     const payload: LogoutRequest = {
       location: clientInfo.location,
       ip: clientInfo.ip,
@@ -156,14 +158,16 @@ class AuthService {
       cookie,
     };
 
-    const response = await apiClient.post<LogoutApiResponse>('/auth/logout', payload);
+    try {
+      const response = await apiClient.post<LogoutApiResponse>('/auth/logout', payload);
 
-    if (response.status === 0) {
-      throw new ApiError(response.message || 'Erro ao realizar logout', 'LOGOUT_FAILED', 400);
+      if (response.status === 0) {
+        throw new ApiError(response.message || 'Erro ao realizar logout', 'LOGOUT_FAILED', 400);
+      }
+    } finally {
+      await removeAuthCookie();
     }
 
-    await removeAuthCookie();
-
     return {
       success: true,
     };

package/src/server.ts

@@ -15,6 +15,27 @@ export { validateSessionAction } from './modules/auth/actions/validate-session.a
 export { listSubscriptionsAction } from './modules/subscriptions/actions/list-subscriptions.action';
 export { listIaCreditsAction } from './modules/ia-credits/actions/list-ia-credits.action';
 
+// Account Services & Actions (server-only)
+export { accountService } from './modules/accounts/services/account.service';
+export { twoFactorService } from './modules/accounts/services/two-factor.service';
+export {
+  listAccountUsersAction,
+  updateUserAction,
+  updateAccountAction,
+  updateAccountUserByIdAction,
+  deleteAccountUserAction,
+  deleteAccountAction,
+  createAccountUserAction,
+  changePasswordAction,
+  requestEmailChangeAction,
+  confirmEmailChangeAction,
+  requestPhoneChangeAction,
+  confirmPhoneChangeAction,
+  generateTwoFactorAction,
+  confirmTwoFactorAction,
+  disableTwoFactorAction,
+} from './modules/accounts/actions/account-management.action';
+
 // Server Utils
 export { getClientInfoFromRequest } from './infra/utils/client-info';
 export { getUserContext } from './modules/auth/utils/get-user-context';

package/src/utils/browser/clipboard.ts

@@ -0,0 +1,34 @@
+export const copyToClipboard = async (text: string): Promise<boolean> => {
+  try {
+    if (navigator.clipboard && navigator.clipboard.writeText) {
+      await navigator.clipboard.writeText(text);
+      return true;
+    }
+
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    textArea.style.position = 'fixed';
+    textArea.style.left = '-9999px';
+    textArea.style.top = '-9999px';
+    document.body.appendChild(textArea);
+    textArea.focus();
+    textArea.select();
+
+    const success = document.execCommand('copy');
+    document.body.removeChild(textArea);
+    return success;
+  } catch (error) {
+    console.error('Erro ao copiar para clipboard:', error);
+    return false;
+  }
+};
+
+export const readFromClipboard = async (): Promise<string | null> => {
+  try {
+    const text = await navigator.clipboard.readText();
+    return text;
+  } catch (error) {
+    console.error('Erro ao ler do clipboard:', error);
+    return null;
+  }
+};

package/src/utils/file/index.ts

@@ -0,0 +1,5 @@
+export const fileToBase64 = async (file: File): Promise<string> => {
+  const buffer = Buffer.from(await file.arrayBuffer());
+  const mimeType = file.type || 'application/octet-stream';
+  return `data:${mimeType};base64,${buffer.toString('base64')}`;
+};