@greatapps/common 1.0.0

package/src/infra/api/client.ts

@@ -0,0 +1,142 @@
+import 'server-only';
+import { ApiError } from './types';
+import { findWhitelabel } from '../../modules/whitelabel/actions/find-whitelabel.action';
+
+const API_BASE_URL = process.env.R3_API_URL || 'https://r3-api.greatapps.dev.br';
+const API_VERSION = 'v1';
+const API_LOCALE = 'pt-br';
+
+interface RequestConfig extends RequestInit {
+  timeout?: number;
+}
+
+class ApiClient {
+  private async buildUrl(endpoint: string, whiteLabelId: number): Promise<string> {
+    const url = `${API_BASE_URL}/${API_VERSION}/${API_LOCALE}/${whiteLabelId}${endpoint}`;
+    console.log('[ApiClient] buildUrl', {
+      baseURL: API_BASE_URL,
+      whiteLabelId,
+      endpoint,
+      fullUrl: url,
+    });
+    return url;
+  }
+
+  private async getDefaultHeaders(token: string): Promise<HeadersInit> {
+    console.log('[ApiClient] getDefaultHeaders', {
+      token: token.substring(0, 20) + '...',
+    });
+
+    const headers: HeadersInit = {
+      'Content-Type': 'application/json',
+      authorization: token,
+    };
+
+    return headers;
+  }
+
+  async request<T>(endpoint: string, config: RequestConfig = {}): Promise<T> {
+    console.log('[ApiClient] request called', { endpoint, method: config.method });
+
+    const { timeout = 30000, ...fetchConfig } = config;
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      console.log('[ApiClient] Building URL and headers...');
+
+      const { id, token } = await findWhitelabel();
+
+      const [url, defaultHeaders] = await Promise.all([
+        this.buildUrl(endpoint, id),
+        this.getDefaultHeaders(token),
+      ]);
+
+      console.log('[ApiClient] Fetching', {
+        url,
+        method: fetchConfig.method,
+        headers: defaultHeaders,
+      });
+
+      const response = await fetch(url, {
+        ...fetchConfig,
+        headers: {
+          ...defaultHeaders,
+          ...fetchConfig.headers,
+        },
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      console.log('[ApiClient] Response received', { status: response.status, ok: response.ok });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as Record<string, unknown>;
+        console.error('[ApiClient] Request failed', { status: response.status, errorData });
+        throw new ApiError(
+          (errorData.message as string) || `HTTP error ${response.status}`,
+          (errorData.code as string) || 'HTTP_ERROR',
+          response.status
+        );
+      }
+
+      const data = (await response.json()) as T;
+      console.log('[ApiClient] Request successful', { hasData: !!data });
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      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);
+        }
+        throw new ApiError(error.message, 'NETWORK_ERROR', 0);
+      }
+
+      throw new ApiError('Erro desconhecido', 'UNKNOWN_ERROR', 500);
+    }
+  }
+
+  async get<T>(endpoint: string, config?: RequestConfig): Promise<T> {
+    return this.request<T>(endpoint, { ...config, method: 'GET' });
+  }
+
+  async post<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+    return this.request<T>(endpoint, {
+      ...config,
+      method: 'POST',
+      body: data ? JSON.stringify(data) : undefined,
+    });
+  }
+
+  async put<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+    return this.request<T>(endpoint, {
+      ...config,
+      method: 'PUT',
+      body: data ? JSON.stringify(data) : undefined,
+    });
+  }
+
+  async patch<T>(endpoint: string, data?: unknown, config?: RequestConfig): Promise<T> {
+    return this.request<T>(endpoint, {
+      ...config,
+      method: 'PATCH',
+      body: data ? JSON.stringify(data) : undefined,
+    });
+  }
+
+  async delete<T>(endpoint: string, config?: RequestConfig): Promise<T> {
+    return this.request<T>(endpoint, { ...config, method: 'DELETE' });
+  }
+}
+
+export { ApiClient };
+export const apiClient = new ApiClient();

package/src/infra/api/types.ts

@@ -0,0 +1,79 @@
+import z from 'zod';
+
+export const PaginationParamsSchema = z.object({
+  page: z.number().min(1).optional().default(20),
+  limit: z.number().optional().default(20),
+});
+
+export interface PaginationParams extends z.infer<typeof PaginationParamsSchema> {}
+
+export const SearchParamsSchema = z.object({
+  search: z.string().optional(),
+});
+
+export interface SearchParams extends z.infer<typeof SearchParamsSchema> {}
+
+export const SortParamsSchema = z.object({
+  sort: z.string().optional(),
+});
+
+export interface SortParams extends z.infer<typeof SortParamsSchema> {}
+
+export interface ApiSuccessResult<T> {
+  status: 1;
+  data?: T;
+}
+
+export interface ApiPaginatedSuccessResult<T> extends Omit<ApiSuccessResult<T>, 'data'> {
+  data: T[];
+  total: number;
+}
+
+export interface ApiErrorResult {
+  status: 0;
+  message: string;
+}
+
+export type ApiActionResult<T> = ApiSuccessResult<T> | ApiErrorResult;
+export type ApiPaginatedActionResult<T> = ApiPaginatedSuccessResult<T> | ApiErrorResult;
+
+export interface SuccessResult<T> {
+  success: true;
+  data?: T;
+  total?: number;
+}
+
+export interface PaginatedSuccessResult<T> extends Omit<SuccessResult<T>, 'data'> {
+  data: T[];
+  total: number;
+}
+
+export interface ErrorResult {
+  success: false;
+  error?: string;
+}
+
+export type ActionResult<T> = SuccessResult<T> | ErrorResult;
+export type PaginatedActionResult<T> = PaginatedSuccessResult<T> | ErrorResult;
+
+export class ApiError extends Error {
+  public readonly code: string;
+  public readonly statusCode: number;
+
+  constructor(message: string, code: string = 'UNKNOWN_ERROR', statusCode: number = 500) {
+    super(message);
+    this.name = 'ApiError';
+    this.code = code;
+    this.statusCode = statusCode;
+  }
+
+  static isApiError(error: unknown): error is ApiError {
+    return error instanceof ApiError;
+  }
+}
+
+export interface ApiResponse<T = unknown> {
+  status: 0 | 1;
+  message?: string;
+  data?: T;
+}

package/src/infra/utils/client-info.ts

@@ -0,0 +1,35 @@
+import { headers } from 'next/headers';
+import { NextRequest } from 'next/server';
+import { ClientInfo } from '../../modules/auth/schema';
+
+export async function getClientInfoFromRequest(request?: NextRequest): Promise<ClientInfo> {
+  let headerStore: Headers;
+
+  if (request) {
+    // Middleware context
+    headerStore = request.headers;
+  } else {
+    // Server action context
+    const nextHeaders = await headers();
+    headerStore = nextHeaders as unknown as Headers;
+  }
+
+  return {
+    location: {
+      continent:
+        headerStore.get('cf-ipcountry') || headerStore.get('x-vercel-ip-country') || 'Unknown',
+      country: headerStore.get('x-vercel-ip-country') || 'Unknown',
+      region: headerStore.get('x-vercel-ip-country-region') || 'Unknown',
+      city: headerStore.get('x-vercel-ip-city') || 'Unknown',
+      latitude: headerStore.get('x-vercel-ip-latitude') || '0',
+      longitude: headerStore.get('x-vercel-ip-longitude') || '0',
+    },
+    ip:
+      headerStore.get('cf-connecting-ip') ||
+      headerStore.get('x-forwarded-for') ||
+      headerStore.get('x-real-ip') ||
+      'Unknown',
+    timezone: headerStore.get('cf-timezone') || 'America/Sao_Paulo',
+    agent: headerStore.get('user-agent') || 'Unknown',
+  };
+}

package/src/infra/utils/clsx.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

package/src/infra/utils/params.ts

@@ -0,0 +1,27 @@
+export function buildQueryParams(
+  params?: Record<
+    string,
+    string | number | boolean | Date | null | undefined | string[] | number[] | boolean[] | Date[]
+  >
+) {
+  if (!params) {
+    return '';
+  }
+
+  const queryParams = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(params)) {
+    if (value === null || value === undefined || value === '') {
+      continue;
+    }
+
+    if (Array.isArray(value)) {
+      queryParams.set(key, value.join(','));
+    } else {
+
+      queryParams.set(key, value.toString());
+    }
+  }
+
+  return queryParams.toString();
+}

package/src/infra/utils/percentage.ts

@@ -0,0 +1,42 @@
+/**
+ * Calcula percentual de um valor em relação ao total
+ * @param current - Valor atual
+ * @param total - Valor total
+ * @returns Percentual (0-100)
+ */
+export const calculatePercentage = (current: number, total: number): number => {
+  if (total === 0) return 0;
+  return (current / total) * 100;
+};
+
+/**
+ * Calcula a circunferência de um círculo
+ * @param radius - Raio do círculo
+ * @returns Circunferência
+ */
+export const calculateCircumference = (radius: number): number => {
+  return 2 * Math.PI * radius;
+};
+
+/**
+ * Calcula o offset para circular progress
+ * @param percentage - Percentual de progresso (0-100)
+ * @param circumference - Circunferência do círculo
+ * @returns Valor do offset
+ */
+export const calculateCircularProgressOffset = (
+  percentage: number,
+  circumference: number
+): number => {
+  return circumference - (percentage / 100) * circumference;
+};
+
+/**
+ * Calcula raio de círculo baseado no tamanho e stroke
+ * @param size - Tamanho total
+ * @param strokeWidth - Largura do stroke
+ * @returns Raio calculado
+ */
+export const calculateRadius = (size: number, strokeWidth: number): number => {
+  return (size - strokeWidth) / 2;
+};

package/src/middlewares/chain.ts

@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+import { MiddlewareConfig } from './types';
+
+function shouldProcessPath(pathname: string, config: MiddlewareConfig): boolean {
+  const { excludePaths, includePaths } = config;
+
+  if (excludePaths?.length) {
+    const isExcluded = excludePaths.some(
+      (path) => pathname === path || pathname.startsWith(`${path}/`)
+    );
+    if (isExcluded) return false;
+  }
+
+  if (includePaths?.length) {
+    return includePaths.some((path) => pathname === path || pathname.startsWith(`${path}/`));
+  }
+
+  return true;
+}
+
+export function createMiddlewareChain(middlewares: MiddlewareConfig[]) {
+  return async function chainedMiddleware(request: NextRequest): Promise<NextResponse> {
+    const { pathname } = request.nextUrl;
+    let currentRequest = request;
+
+    for (const middleware of middlewares) {
+      if (!shouldProcessPath(pathname, middleware)) {
+        continue;
+      }
+
+      const result = await middleware.handler(currentRequest);
+
+      if (result.type === 'response') {
+        return result.response;
+      }
+
+      if (result.request) {
+        currentRequest = result.request;
+      }
+    }
+
+    return NextResponse.next();
+  };
+}

package/src/middlewares/create-auth-middleware.ts

@@ -0,0 +1,38 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+import { continueChain, MiddlewareConfig, MiddlewareFunction, MiddlewareResult, stopChain } from './types';
+
+function isRouteEquals(pathname: string, routes: string[]): boolean {
+  return routes.some((route) => pathname === route || pathname.startsWith(`${route}/`));
+}
+
+interface CreateAuthMiddlewareOptions {
+  publicRoutes?: string[];
+  authRoutes?: string[];
+}
+
+export function createAuthMiddleware(options?: CreateAuthMiddlewareOptions): MiddlewareFunction {
+  return (request: NextRequest) => {
+    const { pathname } = request.nextUrl;
+    const token = request.cookies.get('greatapps')?.value;
+    const isPublicRoute = isRouteEquals(pathname, options?.publicRoutes || []);
+    const isAuthRoute = isRouteEquals(pathname, options?.authRoutes || []);
+
+    if (token && isAuthRoute) {
+      return stopChain(NextResponse.redirect(new URL('/', request.url)));
+    }
+
+    if (!token && !isPublicRoute) {
+
+      const loginUrl = new URL('/login', request.url);
+
+      if (pathname !== '/') {
+        loginUrl.searchParams.set('redirect', pathname);
+      }
+
+      return stopChain(NextResponse.redirect(loginUrl));
+    }
+
+    return continueChain();
+  }
+}

package/src/middlewares/types.ts

@@ -0,0 +1,24 @@
+import { NextRequest, NextResponse } from 'next/server';
+
+export type MiddlewareResult =
+  | { type: 'response'; response: NextResponse }
+  | { type: 'next'; request?: NextRequest };
+
+export type MiddlewareFunction = (
+  request: NextRequest
+) => MiddlewareResult | Promise<MiddlewareResult>;
+
+export interface MiddlewareConfig {
+  name: string;
+  handler: MiddlewareFunction;
+  excludePaths?: string[];
+  includePaths?: string[];
+}
+
+export function continueChain(request?: NextRequest): MiddlewareResult {
+  return { type: 'next', request };
+}
+
+export function stopChain(response: NextResponse): MiddlewareResult {
+  return { type: 'response', response };
+}

package/src/middlewares/validate-session.ts

@@ -0,0 +1,116 @@
+'use server';
+
+import { redirect } from 'next/navigation';
+import { SessionKeepRequest, SessionKeepResponse } from '../types/auth';
+import { getWhitelabelServerData } from '../modules/whitelabel/whitelabel-token.server';
+import { getClientInfoFromRequest } from '../infra/utils/client-info';
+import { cookies, headers } from 'next/headers';
+
+const API_BASE_URL = process.env.R3_API_URL || 'https://r3-api.greatapps.dev.br';
+const API_VERSION = 'v1';
+const API_LOCALE = 'pt-br';
+
+async function redirectToLogin() {
+  const h = await headers();
+  const referer = h.get('referer') || '/';
+
+  if (!referer) {
+    redirect('/login');
+    return;
+  }
+
+  const url = new URL(referer);
+
+  if (['/login', '/register', '/forgot-password'].includes(url.pathname)) {
+    return;
+  }
+
+  redirect('/login');
+}
+
+export async function validateSession(): Promise<boolean> {
+  console.log('[validateSession] Starting session validation');
+
+  const cookieStore = await cookies();
+  const cookie = cookieStore.get('greatapps')?.value;
+
+    if (!cookie) {
+      console.log('[validateSession] No cookie found');
+      await redirectToLogin();
+      return false;
+    }
+
+  console.log('[validateSession] Cookie found:', cookie.substring(0, 30) + '...');
+
+  try {
+    // Busca dados do whitelabel
+    const whitelabel = await getWhitelabelServerData();
+
+    if (!whitelabel) {
+      console.error('[validateSession] Could not get whitelabel data');
+      await redirectToLogin();
+      return false;
+    }
+
+    console.log('[validateSession] Whitelabel data:', {
+      wlId: whitelabel.wlId,
+      hasToken: !!whitelabel.token,
+    });
+
+    const clientInfo = await getClientInfoFromRequest();
+
+    console.log('[validateSession] Client info:', {
+      ip: clientInfo.ip,
+      city: clientInfo.location.city,
+      country: clientInfo.location.country,
+      agent: clientInfo.agent.substring(0, 50) + '...',
+    });
+
+    const payload: SessionKeepRequest = {
+      location: clientInfo.location,
+      ip: clientInfo.ip,
+      timezone: clientInfo.timezone,
+      agent: clientInfo.agent,
+      cookie,
+    };
+
+    const url = `${API_BASE_URL}/${API_VERSION}/${API_LOCALE}/${whitelabel.wlId}/auth/keep`;
+
+    console.log('[validateSession] Calling API:', url);
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        authorization: whitelabel.token,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    console.log('[validateSession] API response status:', response.status);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('[validateSession] Session validation failed', {
+        status: response.status,
+        error: errorText,
+      });
+      cookieStore.delete('greatapps');
+      await redirectToLogin();
+      return false;
+    }
+
+    const data = (await response.json()) as SessionKeepResponse;
+
+    console.log('[validateSession] API response data:', data);
+
+    const isValid = data.status === 1;
+
+    console.log('[validateSession] Session is valid:', isValid);
+    return isValid;
+  } catch (error) {
+    console.error('[validateSession] Error validating session', error);
+    await redirectToLogin();
+    return false;
+  }
+}

package/src/modules/auth/actions/login.action.ts

@@ -0,0 +1,11 @@
+'use server';
+
+import { authService } from '../services/auth.service';
+import { LoginRequest, LoginResponse } from '../schema';
+import { getClientInfoFromRequest } from '../../../infra/utils/client-info';
+
+export async function loginAction(credentials: LoginRequest): Promise<LoginResponse> {
+  const clientInfo = await getClientInfoFromRequest();
+
+  return await authService.login(credentials, clientInfo)
+}

package/src/modules/auth/actions/logout.action.ts

@@ -0,0 +1,11 @@
+'use server';
+
+import { getClientInfoFromRequest } from "../../../infra/utils/client-info";
+import { LogoutResponse } from "../schema";
+import { authService } from "../services/auth.service";
+
+export async function logoutAction(): Promise<LogoutResponse> {
+  const clientInfo = await getClientInfoFromRequest();
+
+  return await authService.logout(clientInfo)
+}

package/src/modules/auth/actions/register.action.ts

@@ -0,0 +1,8 @@
+'use server';
+
+import { RegisterRequest, RegisterResponse } from "../schema";
+import { authService } from "../services/auth.service";
+
+export async function registerAction(data: RegisterRequest): Promise<RegisterResponse> {
+  return await authService.register(data)
+}

package/src/modules/auth/actions/validate-session.action.ts

@@ -0,0 +1,51 @@
+'use server';
+
+import { redirect } from 'next/navigation';
+import { cookies, headers } from 'next/headers';
+import { authService } from '../services/auth.service';
+import { getClientInfoFromRequest } from '../../../infra/utils/client-info';
+
+async function redirectToLogin() {
+  const h = await headers();
+  const referer = h.get('referer') || '/';
+
+  if (!referer) {
+    redirect('/login');
+    return;
+  }
+
+  const url = new URL(referer);
+
+  if (['/login', '/register', '/forgot-password'].includes(url.pathname)) {
+    return;
+  }
+
+  redirect('/login');
+}
+
+export async function validateSessionAction(): Promise<boolean> {
+  const cookieStore = await cookies();
+  const cookie = cookieStore.get('greatapps')?.value;
+
+  if (!cookie) {
+    await redirectToLogin();
+    return false;
+  }
+
+  try {
+    const clientInfo = await getClientInfoFromRequest();
+    const isValid = await authService.validateSession(clientInfo);
+
+    if (!isValid) {
+      cookieStore.delete('greatapps');
+      await redirectToLogin();
+      return false;
+    }
+
+    return true;
+  } catch (error) {
+    console.error('[validateSessionAction] Error:', error);
+    await redirectToLogin();
+    return false;
+  }
+}

package/src/modules/auth/hooks/login.hook.tsx

@@ -0,0 +1,10 @@
+"use client";
+
+import { useMutation } from "@tanstack/react-query";
+import { loginAction } from "../actions/login.action";
+
+export function useLogin() {
+  return useMutation({
+    mutationFn: loginAction,
+  });
+}

package/src/modules/auth/hooks/logout.hook.tsx

@@ -0,0 +1,10 @@
+"use client";
+
+import { useMutation } from "@tanstack/react-query";
+import { logoutAction } from "../actions/logout.action";
+
+export function useLogout() {
+  return useMutation({
+    mutationFn: logoutAction,
+  });
+}

package/src/modules/auth/hooks/register.hook.tsx

@@ -0,0 +1,10 @@
+"use client";
+
+import { useMutation } from "@tanstack/react-query";
+import { registerAction } from "../actions/register.action";
+
+export function useRegister() {
+  return useMutation({
+    mutationFn: registerAction,
+  });
+}