@greatapps/common 1.1.263 → 1.1.265

package/src/infra/api/client.ts

@@ -1,5 +1,5 @@
-import { ApiError } from './types';
-import { findWhitelabel } from '../../modules/whitelabel/actions/find-whitelabel.action';
+import { ApiError } from "./types";
+import { findWhitelabel } from "../../modules/whitelabel/actions/find-whitelabel.action";
 
 export interface ApiClientOptions {
   /**
@@ -7,66 +7,88 @@ export interface ApiClientOptions {
    * Padrão false: `{base}/v1/{locale}/{wlId}{endpoint}`.
    */
   omitApiVersion?: boolean;
+
+  /** Habilita logs detalhados das requisições (útil para desenvolvimento) */
+  emitLogs?: boolean;
 }
 
 export interface RequestConfig extends RequestInit {
   timeout?: number;
   /** Padrão `json`. Use `text` quando a API devolve corpo não-JSON. */
-  responseType?: 'json' | 'text';
+  responseType?: "json" | "text";
 }
 
 class ApiClient {
   private readonly baseUrl: string;
-  private readonly apiVersion = 'v1';
-  private readonly apiLocale = 'pt-br';
+  private readonly apiVersion = "v1";
+  private readonly apiLocale = "pt-br";
   private readonly omitApiVersion: boolean;
+  private readonly emitLogs: boolean = false;
 
   constructor(baseUrl: string, options?: ApiClientOptions) {
-    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.baseUrl = baseUrl.replace(/\/$/, "");
     this.omitApiVersion = options?.omitApiVersion ?? false;
+    this.emitLogs = options?.emitLogs ?? false;
   }
 
-  private async buildUrl(endpoint: string, whiteLabelId: number): Promise<string> {
+  private async buildUrl(
+    endpoint: string,
+    whiteLabelId: number,
+  ): Promise<string> {
     const wlPath = this.omitApiVersion
       ? `/${this.apiLocale}/${whiteLabelId}`
       : `/${this.apiVersion}/${this.apiLocale}/${whiteLabelId}`;
-    const path = endpoint.startsWith('/') ? endpoint : `/${endpoint}`;
+    const path = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
     const url = `${this.baseUrl}${wlPath}${path}`;
-    console.log('[ApiClient] buildUrl', {
-      baseURL: this.baseUrl,
-      whiteLabelId,
-      endpoint,
-      fullUrl: url,
-    });
+    if (this.emitLogs) {
+      console.log("[ApiClient] buildUrl", {
+        baseURL: this.baseUrl,
+        whiteLabelId,
+        endpoint,
+        fullUrl: url,
+      });
+    }
     return url;
   }
 
-  private async getDefaultHeaders(token: string, isFormData = false): Promise<HeadersInit> {
-    console.log('[ApiClient] getDefaultHeaders', {
-      token: token.substring(0, 20) + '...',
-    });
+  private async getDefaultHeaders(
+    token: string,
+    isFormData = false,
+  ): Promise<HeadersInit> {
+    if (this.emitLogs) {
+      console.log("[ApiClient] getDefaultHeaders", {
+        token: token.substring(0, 20) + "...",
+      });
+    }
 
     const headers: HeadersInit = {
       authorization: token,
     };
 
     if (!isFormData) {
-      headers['Content-Type'] = 'application/json';
+      headers["Content-Type"] = "application/json";
     }
 
     return headers;
   }
 
   async request<T>(endpoint: string, config: RequestConfig = {}): Promise<T> {
-    console.log('[ApiClient] request called', { endpoint, method: config.method });
+    if (this.emitLogs) {
+      console.log("[ApiClient] request called", {
+        endpoint,
+        method: config.method,
+      });
+    }
 
-    const { timeout = 30000, responseType = 'json', ...fetchConfig } = config;
+    const { timeout = 30000, responseType = "json", ...fetchConfig } = config;
 
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeout);
 
     try {
-      console.log('[ApiClient] Building URL and headers...');
+      if (this.emitLogs) {
+        console.log("[ApiClient] Building URL and headers...");
+      }
 
       const { id, token } = await findWhitelabel();
 
@@ -75,11 +97,12 @@ class ApiClient {
         this.getDefaultHeaders(token, fetchConfig.body instanceof FormData),
       ]);
 
-      console.log('[ApiClient] Fetching', {
-        url,
-        method: fetchConfig.method,
-        headers: defaultHeaders,
-      });
+      if (this.emitLogs)
+        console.log("[ApiClient] Fetching", {
+          url,
+          method: fetchConfig.method,
+          headers: defaultHeaders,
+        });
 
       const response = await fetch(url, {
         ...fetchConfig,
@@ -90,87 +113,127 @@ class ApiClient {
         signal: controller.signal,
       });
 
-      console.log('[ApiClient] Response received', { status: response.status, ok: response.ok });
+      if (this.emitLogs)
+        console.log("[ApiClient] Response received", {
+          status: response.status,
+          ok: response.ok,
+        });
 
       if (!response.ok) {
         const errBody = await response.text();
         let message = `HTTP error ${response.status}`;
-        let code = 'HTTP_ERROR';
+        let code = "HTTP_ERROR";
         try {
           const errorData = JSON.parse(errBody) as Record<string, unknown>;
-          if (typeof errorData.message === 'string') message = errorData.message;
-          if (typeof errorData.code === 'string') code = errorData.code;
+          if (typeof errorData.message === "string")
+            message = errorData.message;
+          if (typeof errorData.code === "string") code = errorData.code;
         } catch {
           if (errBody.trim()) message = errBody.trim();
         }
-        console.error('[ApiClient] Request failed', { status: response.status, message });
+        console.error("[ApiClient] Request failed", {
+          status: response.status,
+          message,
+        });
         throw new ApiError(message, code, response.status);
       }
 
-      if (responseType === 'text') {
+      if (responseType === "text") {
         return (await response.text()) as T;
       }
 
       const data = (await response.json()) as T;
-      console.log('[ApiClient] Request successful', { hasData: !!data });
+      if (this.emitLogs)
+        console.log("[ApiClient] Request successful", { hasData: !!data });
       return data;
     } catch (error) {
-      console.error('[ApiClient] Request error', { error });
+      if (this.emitLogs) console.error("[ApiClient] Request error", { error });
 
       if (error instanceof ApiError) {
         throw error;
       }
 
       if (error instanceof Error) {
-        if (error.name === 'AbortError') {
-          throw new ApiError('Tempo de requisição excedido', 'TIMEOUT', 408);
+        if (error.name === "AbortError") {
+          throw new ApiError("Tempo de requisição excedido", "TIMEOUT", 408);
         }
-        throw new ApiError(error.message, 'NETWORK_ERROR', 0);
+        throw new ApiError(error.message, "NETWORK_ERROR", 0);
       }
 
-      throw new ApiError('Erro desconhecido', 'UNKNOWN_ERROR', 500);
+      throw new ApiError("Erro desconhecido", "UNKNOWN_ERROR", 500);
     } finally {
       clearTimeout(timeoutId);
     }
   }
 
   async get<T>(endpoint: string, config?: RequestConfig): Promise<T> {
-    return this.request<T>(endpoint, { ...config, method: 'GET' });
+    return this.request<T>(endpoint, { ...config, method: "GET" });
   }
 
-  async post<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+  async post<T>(
+    endpoint: string,
+    data?: unknown,
+    config?: RequestConfig,
+  ): Promise<T> {
     return this.request<T>(endpoint, {
       ...config,
-      method: 'POST',
-      body: data instanceof FormData ? data : data ? JSON.stringify(data) : undefined,
+      method: "POST",
+      body:
+        data instanceof FormData
+          ? data
+          : data
+            ? JSON.stringify(data)
+            : undefined,
     });
   }
 
-  async put<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+  async put<T>(
+    endpoint: string,
+    data?: unknown,
+    config?: RequestConfig,
+  ): Promise<T> {
     return this.request<T>(endpoint, {
       ...config,
-      method: 'PUT',
-      body: data instanceof FormData ? data : data ? JSON.stringify(data) : undefined,
+      method: "PUT",
+      body:
+        data instanceof FormData
+          ? data
+          : data
+            ? JSON.stringify(data)
+            : undefined,
     });
   }
 
-  async patch<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+  async patch<T>(
+    endpoint: string,
+    data?: unknown,
+    config?: RequestConfig,
+  ): Promise<T> {
     return this.request<T>(endpoint, {
       ...config,
-      method: 'PATCH',
-      body: data instanceof FormData ? data : data ? JSON.stringify(data) : undefined,
+      method: "PATCH",
+      body:
+        data instanceof FormData
+          ? data
+          : data
+            ? JSON.stringify(data)
+            : undefined,
     });
   }
 
   async delete<T>(endpoint: string, config?: RequestConfig): Promise<T> {
-    return this.request<T>(endpoint, { ...config, method: 'DELETE' });
+    return this.request<T>(endpoint, { ...config, method: "DELETE" });
   }
 }
 
 const api = {
-  apps: new ApiClient(process.env.GAPPS_R3_API_URL || 'https://r3-api.greatapps.dev.br'),
-  pages: new ApiClient(process.env.GPAGES_R3_API_URL || 'https://r3-api.greatpages.dev.br'),
-}
+  apps: new ApiClient(
+    process.env.GAPPS_R3_API_URL || "https://r3-api.greatapps.dev.br",
+  ),
+  pages: new ApiClient(
+    process.env.GPAGES_R3_API_URL || "https://r3-api.greatpages.dev.br",
+  ),
+};
 
 /** @deprecated use api.apps */
 export const apiClient = api.apps;

package/src/middleware.ts

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

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

@@ -1,91 +1,91 @@
-'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 async function listAccountUsersAction(params?: AccountUsersPaginationParams) {
-  return safeServerAction(async () => {
-    const { users, total } = await accountService.listAccountUsers(params);
-    return { data: users, total };
-  });
-}
-
-export async function updateUserAction(user: UpdateAccountUserRequest) {
-  return safeServerAction(() => accountService.updateAccountUser(user));
-}
-
-export async function updateAccountUserByIdAction(
-  userId: number,
-  user: UpdateAccountUserRequest
-) {
-  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
-}
-
-export async function updateAccountAction(data: UpdateAccountRequest) {
-  return safeServerAction(() => accountService.updateAccount(data));
-}
-
-export async function deleteAccountUserAction(userId: number) {
-  return safeServerAction(() => accountService.deleteAccountUser(userId));
-}
-
-export async function deleteAccountAction() {
-  return safeServerAction(() => accountService.deleteAccount());
-}
-
-export async function createAccountUserAction(user: CreateAccountUserRequest) {
-  return safeServerAction(() => accountService.createAccountUser(user));
-}
-
-export async function changePasswordAction(data: ChangePasswordRequest) {
-  return safeServerAction(() => accountService.changePassword(data));
-}
-
-export async function requestEmailChangeAction(newEmail: string) {
-  return safeServerAction(() => accountService.requestContactReset('email', newEmail));
-}
-
-export async function confirmEmailChangeAction(token: string, newEmail: string) {
-  return safeServerAction(() => accountService.confirmContactReset('email', token, newEmail));
-}
-
-export async function requestPhoneChangeAction(newPhone: string, ddi?: string) {
-  return safeServerAction(() => accountService.requestContactReset('phone', newPhone, ddi));
-}
-
-export async function confirmPhoneChangeAction(token: string, newPhone: string, ddi?: string) {
-  return safeServerAction(() => accountService.confirmContactReset('phone', token, newPhone, ddi));
-}
-
-export async function generateTwoFactorAction() {
-  return safeServerAction(async () => {
-    const result = await twoFactorService.generate();
-    return {
-      qrcode: result.data.qrcode,
-      backupCodes: result.data.backup_codes,
-    };
-  });
-}
-
-export async function confirmTwoFactorAction(code: string) {
-  return safeServerAction(async () => {
-    await twoFactorService.confirm(code);
-    await accountService.updateAccountUser({ two_factor_authentication: true });
-  });
-}
-
-export async function disableTwoFactorAction(code: string) {
-  return safeServerAction(async () => {
-    await twoFactorService.verify(code);
-    await twoFactorService.disable();
-    await accountService.updateAccountUser({ two_factor_authentication: false });
-  });
-}
+'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 async function listAccountUsersAction(params?: AccountUsersPaginationParams) {
+  return safeServerAction(async () => {
+    const { users, total } = await accountService.listAccountUsers(params);
+    return { data: users, total };
+  });
+}
+
+export async function updateUserAction(user: UpdateAccountUserRequest) {
+  return safeServerAction(() => accountService.updateAccountUser(user));
+}
+
+export async function updateAccountUserByIdAction(
+  userId: number,
+  user: UpdateAccountUserRequest
+) {
+  return safeServerAction(() => accountService.updateAccountUserById(userId, user));
+}
+
+export async function updateAccountAction(data: UpdateAccountRequest) {
+  return safeServerAction(() => accountService.updateAccount(data));
+}
+
+export async function deleteAccountUserAction(userId: number) {
+  return safeServerAction(() => accountService.deleteAccountUser(userId));
+}
+
+export async function deleteAccountAction() {
+  return safeServerAction(() => accountService.deleteAccount());
+}
+
+export async function createAccountUserAction(user: CreateAccountUserRequest) {
+  return safeServerAction(() => accountService.createAccountUser(user));
+}
+
+export async function changePasswordAction(data: ChangePasswordRequest) {
+  return safeServerAction(() => accountService.changePassword(data));
+}
+
+export async function requestEmailChangeAction(newEmail: string) {
+  return safeServerAction(() => accountService.requestContactReset('email', newEmail));
+}
+
+export async function confirmEmailChangeAction(token: string, newEmail: string) {
+  return safeServerAction(() => accountService.confirmContactReset('email', token, newEmail));
+}
+
+export async function requestPhoneChangeAction(newPhone: string, ddi?: string) {
+  return safeServerAction(() => accountService.requestContactReset('phone', newPhone, ddi));
+}
+
+export async function confirmPhoneChangeAction(token: string, newPhone: string, ddi?: string) {
+  return safeServerAction(() => accountService.confirmContactReset('phone', token, newPhone, ddi));
+}
+
+export async function generateTwoFactorAction() {
+  return safeServerAction(async () => {
+    const result = await twoFactorService.generate();
+    return {
+      qrcode: result.data.qrcode,
+      backupCodes: result.data.backup_codes,
+    };
+  });
+}
+
+export async function confirmTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.confirm(code);
+    await accountService.updateAccountUser({ two_factor_authentication: true });
+  });
+}
+
+export async function disableTwoFactorAction(code: string) {
+  return safeServerAction(async () => {
+    await twoFactorService.verify(code);
+    await twoFactorService.disable();
+    await accountService.updateAccountUser({ two_factor_authentication: false });
+  });
+}

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

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

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

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

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

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

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

@@ -1,22 +1,22 @@
-'use client';
-
-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 function useCurrentAccount() {
-  return useQuery({
-    queryKey: ACCOUNT_QUERY_KEY,
-    queryFn: withAction(findCurrentAccount),
-    staleTime: 0,
-    gcTime: 10 * 60 * 1000,
-    retry: false,
-  });
-}
-
-export function useInvalidateAccount() {
-  const queryClient = useQueryClient();
-  return () => queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
-}
+'use client';
+
+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 function useCurrentAccount() {
+  return useQuery({
+    queryKey: ACCOUNT_QUERY_KEY,
+    queryFn: withAction(findCurrentAccount),
+    staleTime: 0,
+    gcTime: 10 * 60 * 1000,
+    retry: false,
+  });
+}
+
+export function useInvalidateAccount() {
+  const queryClient = useQueryClient();
+  return () => queryClient.invalidateQueries({ queryKey: ACCOUNT_QUERY_KEY });
+}