@greatapps/common 1.0.0

package/src/modules/auth/hooks/useUserQuery.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { useQuery, useQueryClient, UseQueryOptions } from '@tanstack/react-query';
+import { User } from '../../users/schema';
+
+export const USER_QUERY_KEY = ['user'];
+
+async function fetchUser(): Promise<User | null> {
+  const { findUserById: getUserDataAction } = await import('../../users/action/find-user-by-id.action');
+  const result = await getUserDataAction();
+  return result.success && result.data ? result.data : null;
+}
+
+async function validateUserSession(): Promise<boolean> {
+  const { validateSessionAction } = await import('../actions/validate-session.action');
+  return await validateSessionAction();
+}
+
+export function useUserQuery() {
+  return useQuery({
+    queryKey: USER_QUERY_KEY,
+    queryFn: fetchUser,
+    staleTime: 5 * 60 * 1000,
+    gcTime: 10 * 60 * 1000,
+    retry: false,
+  });
+}
+
+export function useUserValidateSession(options?: UseQueryOptions) {
+  return useQuery({
+    queryKey: ['user-validate-session'],
+    queryFn: validateUserSession,
+    retry: false,
+    staleTime: 5 * 60 * 1000,
+    ...options,
+    refetchOnMount: 'always',
+    refetchOnWindowFocus: true,
+  });
+}
+
+export function useInvalidateUser() {
+  const queryClient = useQueryClient();
+  return () => queryClient.invalidateQueries({ queryKey: USER_QUERY_KEY });
+}
+
+export function useSetUserData() {
+  const queryClient = useQueryClient();
+  return (user: User | null) => queryClient.setQueryData(USER_QUERY_KEY, user);
+}

package/src/modules/auth/schema.ts

@@ -0,0 +1,220 @@
+import { User } from '../users/schema';
+
+export interface ClientInfo {
+  location: GeoLocation;
+  ip: string;
+  timezone: string;
+  agent: string;
+}
+
+export interface LoginApiResponse {
+  status: 0 | 1;
+  message: string;
+  cookie?: string;
+  two_factor_authentication?: boolean;
+}
+
+export interface GeoLocation {
+  continent: string;
+  country: string;
+  region: string;
+  city: string;
+  latitude: string;
+  longitude: string;
+}
+
+export interface AuthState {
+  user: User | null;
+  isAuthenticated: boolean;
+  isLoading: boolean;
+}
+
+export interface LoginRequest {
+  email: string;
+  password: string;
+  rememberMe?: boolean;
+}
+
+export interface LoginResponse {
+  user: User;
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+}
+
+export interface RegisterRequest {
+  accountName: string;
+  businessType: number;
+  name: string;
+  lastName?: string;
+  email: string;
+  phone: string;
+  password: string;
+  gender: number;
+  rg?: string;
+  cpf?: string;
+  acceptTerms: boolean;
+}
+
+export interface RegisterApiRequest {
+  name: string;
+  bussiness_type: number;
+  language: string;
+  timezone: string;
+  currency: string;
+  user: {
+    id_api: string;
+    name: string;
+    last_name: string;
+    rg: string;
+    cpf: string;
+    gender: number;
+    email: string;
+    phone: string;
+    password: string;
+    profile: string;
+    language: string;
+  };
+  subscription: {
+    type: string;
+    id_cupom: string;
+    id_plan: number;
+    due_date: string;
+    id_product: number;
+  };
+}
+
+export interface RegisterApiResponse {
+  status: 0 | 1;
+  message: string;
+  data?: Array<{
+    id: number;
+    id_wl: number;
+    name: string;
+    language: string;
+    timezone: string;
+    currency: string;
+    verified: boolean;
+    user: {
+      id: number;
+      id_account: number;
+      id_api: number;
+      name: string;
+      last_name: string | null;
+      ddi: string;
+      phone: string;
+      email: string;
+      password: string;
+      gender: number;
+      two_factor_authentication: boolean;
+      profile: string;
+      language: string;
+      photo: string | null;
+    };
+    subscription: Array<{
+      id: number;
+      id_account: number;
+      type: string;
+      id_product: number;
+      id_plan: number;
+      active: boolean;
+    }>;
+  }>;
+  total?: number;
+}
+
+export interface RegisterResponse {
+  user: User;
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+  requiresEmailVerification: boolean;
+}
+
+export interface ForgotPasswordRequest {
+  email: string;
+}
+
+export interface ForgotPasswordResponse {
+  status: 0 | 1;
+  message: string;
+}
+
+export interface ValidateForgotPasswordRequest {
+  email: string;
+  token: string;
+}
+
+export interface ValidateForgotPasswordResponse {
+  status: 0 | 1;
+  message: string;
+}
+
+export interface ResetPasswordRequest {
+  email: string;
+  token: string;
+  password: string;
+}
+
+export interface ResetPasswordResponse {
+  status: 0 | 1;
+  message: string;
+}
+
+export interface VerifyEmailRequest {
+  token: string;
+}
+
+export interface VerifyEmailResponse {
+  message: string;
+  user: User;
+}
+
+export interface ResendVerificationRequest {
+  email: string;
+}
+
+export interface ResendVerificationResponse {
+  message: string;
+  expiresAt: string;
+}
+
+export interface RefreshTokenRequest {
+  refreshToken: string;
+}
+
+export interface RefreshTokenResponse {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+}
+
+export interface SessionKeepRequest {
+  location: GeoLocation;
+  ip: string;
+  timezone: string;
+  agent: string;
+  cookie: string;
+}
+
+export interface SessionKeepResponse {
+  status: 0 | 1;
+  message: string;
+}
+
+export interface LogoutRequest {
+  location: GeoLocation;
+  ip: string;
+  timezone: string;
+  agent: string;
+  cookie: string;
+}
+
+export interface LogoutApiResponse {
+  status: 0 | 1;
+  message: string;
+}
+
+export interface LogoutResponse {
+  success: boolean;
+}

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

@@ -0,0 +1,225 @@
+import 'server-only';
+
+import { cookies } from 'next/headers';
+
+import { apiClient } from '../../../infra/api/client';
+import { ApiError } from '../../../infra/api/types';
+import { User } from '../../users/schema';
+import {
+  ClientInfo,
+  ForgotPasswordRequest,
+  ForgotPasswordResponse,
+  GeoLocation,
+  LoginApiResponse,
+  LoginRequest,
+  LoginResponse,
+  LogoutApiResponse,
+  LogoutRequest,
+  LogoutResponse,
+  RegisterApiRequest,
+  RegisterApiResponse,
+  RegisterRequest,
+  RegisterResponse,
+  ResendVerificationRequest,
+  ResendVerificationResponse,
+  ResetPasswordRequest,
+  ResetPasswordResponse,
+  SessionKeepRequest,
+  SessionKeepResponse,
+  VerifyEmailRequest,
+  VerifyEmailResponse,
+} from '../schema';
+
+const AUTH_COOKIE_NAME = 'greatapps';
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
+
+async function setAuthCookie(token: string): Promise<void> {
+  const cookieStore = await cookies();
+  cookieStore.set(AUTH_COOKIE_NAME, token, {
+    httpOnly: true,
+    secure: process.env.NODE_ENV === 'production',
+    sameSite: 'lax',
+    maxAge: COOKIE_MAX_AGE,
+    path: '/',
+  });
+}
+
+async function removeAuthCookie(): Promise<void> {
+  const cookieStore = await cookies();
+  cookieStore.delete(AUTH_COOKIE_NAME);
+}
+
+async function getAuthCookie(): Promise<string | undefined> {
+  const cookieStore = await cookies();
+  return cookieStore.get(AUTH_COOKIE_NAME)?.value;
+}
+
+class AuthService {
+  async login(credentials: LoginRequest, clientInfo: ClientInfo): Promise<LoginResponse> {
+    const response = await apiClient.post<LoginApiResponse>('/auth/login', {
+      email: credentials.email,
+      password: credentials.password,
+      location: clientInfo.location,
+      ip: clientInfo.ip,
+      timezone: clientInfo.timezone,
+      agent: clientInfo.agent,
+    });
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'E-mail ou senha incorretos', 'LOGIN_FAILED', 401);
+    }
+
+    if (!response.cookie) {
+      throw new ApiError('Resposta de autenticação inválida', 'INVALID_RESPONSE', 500);
+    }
+
+    await setAuthCookie(response.cookie);
+
+    // O usuário completo será carregado pelo AuthProvider via getUserDataAction
+    return {
+      user: {} as User, // Placeholder, será preenchido pelo AuthProvider
+      accessToken: response.cookie,
+      refreshToken: '',
+      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1000).toISOString(),
+    };
+  }
+
+  async register(data: RegisterRequest): Promise<RegisterResponse> {
+    const today = new Date();
+    const trialEndDate = new Date(today);
+    trialEndDate.setDate(today.getDate() + 7); // 7 dias de trial
+
+    const payload: RegisterApiRequest = {
+      name: data.accountName,
+      bussiness_type: data.businessType,
+      language: 'pt-br',
+      timezone: 'America/Sao_Paulo',
+      currency: 'BRL',
+      user: {
+        id_api: '',
+        name: data.name,
+        last_name: data.lastName || '',
+        rg: data.rg || '',
+        cpf: data.cpf || '',
+        gender: data.gender,
+        email: data.email,
+        phone: data.phone,
+        password: data.password,
+        profile: 'owner',
+        language: 'pt-br',
+      },
+      subscription: {
+        type: 'trial',
+        id_cupom: '',
+        id_plan: 1,
+        due_date: trialEndDate.toISOString().split('T')[0],
+        id_product: 1,
+      },
+    };
+
+    const response = await apiClient.post<RegisterApiResponse>('/accounts', payload);
+
+    if (response.status === 0) {
+      throw new ApiError(response.message || 'Erro ao criar conta', 'REGISTER_FAILED', 400);
+    }
+
+    if (!response.data || response.data.length === 0) {
+      throw new ApiError('Resposta de registro inválida', 'INVALID_RESPONSE', 500);
+    }
+
+    const accountData = response.data[0];
+
+    // Retornar sem token pois o registro não retorna cookie diretamente
+    // O usuário precisará fazer login após o registro
+    // O usuário completo será carregado após o login
+    return {
+      user: {} as User, // Placeholder, será preenchido após login
+      accessToken: '',
+      refreshToken: '',
+      expiresAt: new Date(Date.now() + COOKIE_MAX_AGE * 1000).toISOString(),
+      requiresEmailVerification: !accountData.verified,
+    };
+  }
+
+  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,
+      timezone: clientInfo.timezone,
+      agent: clientInfo.agent,
+      cookie,
+    };
+
+    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);
+    }
+
+    await removeAuthCookie();
+
+    return {
+      success: true,
+    };
+  }
+
+  async forgotPassword(_data: ForgotPasswordRequest): Promise<ForgotPasswordResponse> {
+    throw new ApiError('Recuperação de senha não implementada', 'NOT_IMPLEMENTED', 501);
+  }
+
+  async resetPassword(_data: ResetPasswordRequest): Promise<ResetPasswordResponse> {
+    throw new ApiError('Redefinição de senha não implementada', 'NOT_IMPLEMENTED', 501);
+  }
+
+  async verifyEmail(_data: VerifyEmailRequest): Promise<VerifyEmailResponse> {
+    throw new ApiError('Verificação de email não implementada', 'NOT_IMPLEMENTED', 501);
+  }
+
+  async resendVerification(_data: ResendVerificationRequest): Promise<ResendVerificationResponse> {
+    throw new ApiError('Reenvio de verificação não implementado', 'NOT_IMPLEMENTED', 501);
+  }
+
+  async validateSession(clientInfo: ClientInfo): Promise<boolean> {
+    const cookie = await getAuthCookie();
+
+    if (!cookie) {
+      return false;
+    }
+
+    try {
+      const payload: SessionKeepRequest = {
+        location: clientInfo.location,
+        ip: clientInfo.ip,
+        timezone: clientInfo.timezone,
+        agent: clientInfo.agent,
+        cookie,
+      };
+
+      const response = await apiClient.post<SessionKeepResponse>('/auth/keep', payload);
+
+      return response.status === 1;
+    } catch (error) {
+      console.error('[AuthService] validateSession error', error);
+      return false;
+    }
+  }
+
+  async isAuthenticated(): Promise<boolean> {
+    const token = await getAuthCookie();
+    return !!token;
+  }
+
+  async getToken(): Promise<string | undefined> {
+    return getAuthCookie();
+  }
+}
+
+export const authService = new AuthService();
+
+export type { ClientInfo, GeoLocation };

package/src/modules/users/action/find-user-by-id.action.ts

@@ -0,0 +1,25 @@
+'use server';
+
+import { userService } from '../services/user.service';
+import { User } from '../schema';
+
+export async function findUserById(): Promise<{
+  success: boolean;
+  data?: User;
+  error?: string;
+}> {
+  try {
+    const user = await userService.findById();
+
+    return {
+      success: true,
+      data: user,
+    };
+  } catch (error) {
+    console.error('[findUserById] Error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Erro desconhecido',
+    };
+  }
+}

package/src/modules/users/schema.ts

@@ -0,0 +1,79 @@
+export enum UserProfile {
+  viewer = 'viewer',
+  collaborator = 'collaborator',
+  admin = 'admin',
+  owner = 'owner',
+}
+
+export interface User {
+  // Identificação
+  id: number;
+  id_wl: number;
+  id_account: number;
+  id_api: number;
+
+  // Dados pessoais
+  name: string;
+  last_name: string;
+  email: string;
+  ddi: string;
+  phone: string;
+  rg: string | null;
+  cpf: string | null;
+  gender: number;
+
+  // Autenticação e segurança
+  two_factor_authentication: boolean;
+
+  // Perfil e permissões
+  profile: UserProfile;
+
+  // Preferências
+  language: string;
+  receive_sms: boolean;
+  receive_email: boolean;
+  photo: string | null;
+
+  // Metadados
+  deleted: number;
+  datetime_alt: string;
+  datetime_del: string | null;
+  datetime_add: string;
+
+  total_projects: number;
+  projects: { id: number; title: string }[];
+
+  initials?: string;
+  emailVerified?: boolean;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+export interface GetUserDataResponse {
+  status: 0 | 1;
+  total: number;
+  data: User[];
+}
+
+export interface JWTPayload {
+  session: {
+    location: {
+      continent: string;
+      country: string;
+      region: string;
+      city: string;
+      latitude: string;
+      longitude: string;
+    };
+    ip: string;
+    timezone: string;
+    agent: string;
+    code: string | null;
+  };
+  id_wl: string;
+  id_account: number;
+  id_user: number;
+  iss: string;
+  aud: string;
+  iat: number;
+}

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

@@ -0,0 +1,63 @@
+import 'server-only';
+
+import { cookies } from 'next/headers';
+
+import { ApiError } from '../../../infra/api/types';
+import { GetUserDataResponse, JWTPayload, User } from '../schema';
+import { findWhitelabel } from '../../whitelabel/actions/find-whitelabel.action';
+
+const AUTH_COOKIE_NAME = 'greatapps';
+const API_BASE_URL = process.env.R3_API_URL || 'https://r3-api.greatapps.dev.br';
+
+class UserService {
+  private async getAuthToken(): Promise<string> {
+    const cookieStore = await cookies();
+    const token = cookieStore.get(AUTH_COOKIE_NAME)?.value;
+
+    if (!token) {
+      throw new ApiError('Não autenticado', 'NOT_AUTHENTICATED', 401);
+    }
+
+    return token;
+  }
+
+  private decodeJWT(token: string): JWTPayload {
+    try {
+      return JSON.parse(atob(token.split('.')[1])) as JWTPayload;
+    } catch {
+      throw new ApiError('Token inválido', 'INVALID_TOKEN', 401);
+    }
+  }
+
+  async findById(): Promise<User> {
+    const token = await this.getAuthToken();
+    const payload = this.decodeJWT(token);
+
+    const { id_wl, id_account, id_user } = payload;
+    const { token: wlToken } = await findWhitelabel();
+
+    const url = `${API_BASE_URL}/v1/pt-br/${id_wl}/accounts/${id_account}/users/${id_user}`;
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        authorization: wlToken,
+      },
+    });
+
+    if (!response.ok) {
+      throw new ApiError('Erro ao buscar dados do usuário', 'FETCH_ERROR', response.status);
+    }
+
+    const data = (await response.json()) as GetUserDataResponse;
+
+    if (data.status === 0 || !data.data || data.data.length === 0) {
+      throw new ApiError('Dados do usuário não encontrados', 'USER_NOT_FOUND', 404);
+    }
+
+    return data.data[0];
+  }
+}
+
+export const userService = new UserService();

package/src/modules/whitelabel/actions/find-whitelabel.action.ts

@@ -0,0 +1,20 @@
+import { headers } from "next/headers";
+import { whitelabelService } from "../services/whitelabel.service";
+import { ApiError } from "../../../infra/api/types";
+
+export async function findWhitelabel() {
+    const headersList = await headers();
+    const host = headersList.get('host');
+
+    if (!host) {
+        throw new ApiError('Host header not found', 'HOST_NOT_FOUND', 400);
+    }
+
+    const whitelabel = await whitelabelService.getTokenByDomain(host);
+
+    if (!whitelabel) {
+        throw new ApiError('Whitelabel not found', 'WL_NOT_FOUND', 404);
+    }
+
+    return whitelabel;
+}