@greatapps/common 1.0.0

package/src/modules/whitelabel/schema.ts

@@ -0,0 +1,49 @@
+export interface WhitelabelData {
+  id: number;
+  deleted: number;
+  datetime_alt: string;
+  datetime_del: string | null;
+  datetime_add: string;
+  id_account: number;
+  active: boolean;
+  name: string;
+  email: string;
+  email_financial: string;
+  email_transactional: string;
+  domain: string;
+  domain_free: string;
+  url_api: string;
+  url_cname: string;
+  url_help: string;
+  url_login: string;
+  url_site: string;
+  url_signup: string;
+  url_use_terms: string;
+  url_cookies_policies: string;
+  url_privacy_policies: string;
+  url_video_link: string;
+  favicon: string;
+  logo: string;
+  cor_pri: string;
+  cor_sec: string;
+  codes: string;
+  external_contracting: boolean;
+  external_contracting_link_contracting: string;
+  external_contracting_link_plans: string;
+}
+
+export interface WhitelabelApiResponse {
+  status: number;
+  total: number;
+  data: WhitelabelData[];
+}
+
+export interface WhitelabelTokenData extends WhitelabelData {
+  token: string;
+}
+
+export interface WhitelabelTokenApiResponse {
+  status: number;
+  total: number;
+  data: WhitelabelTokenData[];
+}

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

@@ -0,0 +1,77 @@
+import 'server-only';
+
+import greatCache from '@greatapps/cache';
+import { ApiError } from '../../../infra/api/types';
+import { WhitelabelTokenApiResponse, WhitelabelTokenData } from '../schema';
+
+class WhitelabelService {
+  private getApiUrl(): string {
+    const apiUrl = process.env.R3_API_URL;
+    if (!apiUrl) {
+      throw new ApiError('R3_API_URL not configured', 'CONFIG_ERROR', 500);
+    }
+    return apiUrl;
+  }
+
+  private getToken(): string {
+    const token = process.env.WHITELABEL_TOKEN_MASTER;
+    if (!token) {
+      throw new ApiError('WHITELABEL_TOKEN_MASTER not configured', 'CONFIG_ERROR', 500);
+    }
+    return token;
+  }
+
+  async getTokenByDomain(hostname: string): Promise<WhitelabelTokenData> {
+    hostname = 'greatapps.com.br';
+
+    const apiUrl = this.getApiUrl();
+    const whitelabelMasterToken = this.getToken();
+
+    const url = `${apiUrl}/v1/pt-br/1/whitelabel/${hostname}/token`;
+
+    console.log('[WhitelabelService] Fetching token for domain', { url });
+
+    const cache = new greatCache({
+      service: 'whitelabel-service',
+      version: '1.0',
+      domain: 'whitelabel-cache.greatapps.com.br',
+      ambient: process.env.NODE_ENV || 'development',
+    });
+
+    const cachedData = await cache.select(`whitelabel-token-${hostname}`);
+
+    if (cachedData.status == 1 && 'data' in cachedData && cachedData.data) {
+      console.log('[WhitelabelService] Cache hit for domain', { hostname });
+
+      return JSON.parse(cachedData.data) as WhitelabelTokenData;
+    }
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        authorization: whitelabelMasterToken,
+      },
+    });
+
+    if (!response.ok) {
+      console.error('[WhitelabelService] Failed to fetch whitelabel token', { response });
+      throw new ApiError(
+        `Failed to fetch whitelabel token: ${response.status}`,
+        'FETCH_ERROR',
+        response.status
+      );
+    }
+
+    const result: WhitelabelTokenApiResponse = await response.json();
+
+    if (result.status !== 1 || !result.data?.length) {
+      throw new ApiError('Whitelabel token not found', 'TOKEN_NOT_FOUND', 404);
+    }
+
+    await cache.insert(`whitelabel-token-${hostname}`, JSON.stringify(result.data[0]), 604800);
+
+    return result.data[0];
+  }
+}
+
+export const whitelabelService = new WhitelabelService();

package/src/providers/auth.provider.tsx

@@ -0,0 +1,113 @@
+"use client";
+
+import {
+  createContext,
+  ReactNode,
+  useCallback,
+  useContext,
+  useMemo,
+} from "react";
+import {
+  useUserQuery,
+  useSetUserData,
+  useInvalidateUser,
+  useUserValidateSession,
+} from "../modules/auth/hooks/useUserQuery";
+import { useLogin } from "../modules/auth/hooks/login.hook";
+import { useRegister } from "../modules/auth/hooks/register.hook";
+import { useLogout } from "../modules/auth/hooks/logout.hook";
+import {
+  AuthState,
+  LoginRequest,
+  RegisterRequest,
+} from "../modules/auth/schema";
+
+interface AuthContextProps extends AuthState {
+  login: (credentials: LoginRequest) => Promise<void>;
+  register: (data: RegisterRequest) => Promise<void>;
+  logout: () => Promise<void>;
+}
+
+export const AuthContext = createContext<AuthContextProps | undefined>(
+  undefined,
+);
+
+interface AuthProviderProps {
+  children: ReactNode;
+}
+
+export function AuthProvider({ children }: AuthProviderProps) {
+  const { data: user, isLoading: isQueryLoading } = useUserQuery();
+  const { isLoading: isSessionLoading } = useUserValidateSession();
+  const setUserData = useSetUserData();
+  const invalidateUser = useInvalidateUser();
+
+  const { mutateAsync: loginMutate, isPending: isLogging } = useLogin();
+  const { mutateAsync: registerMutate, isPending: isRegistering } =
+    useRegister();
+  const { mutateAsync: logoutMutate, isPending: isLoggingOut } = useLogout();
+
+  const isAuthenticated = !!user;
+  const isLoading =
+    isLogging ||
+    isRegistering ||
+    isLoggingOut ||
+    isQueryLoading ||
+    isSessionLoading;
+
+  const login = useCallback(
+    async (credentials: LoginRequest): Promise<void> => {
+      await loginMutate(credentials, {
+        onSuccess: (data) => {
+          invalidateUser();
+          setUserData(data.user);
+        },
+      });
+    },
+    [invalidateUser],
+  );
+
+  const register = useCallback(
+    async (data: RegisterRequest): Promise<void> => {
+      await registerMutate(data, {
+        onSuccess: (data) => {
+          invalidateUser();
+          setUserData(data.user);
+        },
+      });
+    },
+    [setUserData],
+  );
+
+  const logout = useCallback(async (): Promise<void> => {
+    await logoutMutate(undefined, {
+      onSuccess: () => {
+        invalidateUser();
+      },
+    });
+  }, [setUserData]);
+
+  const value: AuthContextProps = useMemo(
+    () => ({
+      user: user ?? null,
+      isAuthenticated,
+      isLoading,
+      login,
+      register,
+      logout,
+    }),
+    [user, isAuthenticated, isLoading, login, register, logout],
+  );
+
+  return <AuthContext.Provider value={value}>{children}</AuthContext.Provider>;
+}
+
+export function useAuth(): AuthContextProps {
+  const context = useContext(AuthContext);
+
+  if (context === undefined) {
+    throw new Error("useAuth deve ser usado dentro de um AuthProvider");
+  }
+
+  return context;
+}

package/src/providers/query.provider.tsx

@@ -0,0 +1,52 @@
+"use client";
+
+import {
+  QueryCache,
+  QueryClient,
+  QueryClientProvider,
+} from "@tanstack/react-query";
+import { ReactNode, useState } from "react";
+import dynamic from "next/dynamic";
+import { toast } from "sonner";
+
+// React Query Devtools só em desenvolvimento - remove do bundle de produção
+const ReactQueryDevtools =
+  process.env.NODE_ENV === "development"
+    ? dynamic(
+        () =>
+          import("@tanstack/react-query-devtools").then((mod) => ({
+            default: mod.ReactQueryDevtools,
+          })),
+        { ssr: false },
+      )
+    : () => null;
+
+interface QueryProviderProps {
+  children: ReactNode;
+}
+
+export function QueryProvider({ children }: QueryProviderProps) {
+  const [queryClient] = useState(
+    () =>
+      new QueryClient({
+        defaultOptions: {
+          queries: {
+            staleTime: 60 * 1000,
+            refetchOnWindowFocus: false,
+          },
+        },
+        queryCache: new QueryCache({
+          onError: (error) => {
+            toast.error(error.message);
+          },
+        }),
+      }),
+  );
+
+  return (
+    <QueryClientProvider client={queryClient}>
+      {children}
+      <ReactQueryDevtools initialIsOpen={false} />
+    </QueryClientProvider>
+  );
+}

package/src/providers/whitelabel.provider.tsx

@@ -0,0 +1,44 @@
+"use client";
+
+import { createContext, ReactNode, useContext } from "react";
+import { WhitelabelData } from "../modules/whitelabel/schema";
+
+interface WhitelabelContextProps {
+  whitelabel: WhitelabelData | null;
+}
+
+const WhitelabelContext = createContext<WhitelabelContextProps | undefined>(
+  undefined,
+);
+
+interface WhitelabelProviderProps {
+  children: ReactNode;
+  whitelabel: WhitelabelData | null;
+}
+
+export function WhitelabelProvider({
+  children,
+  whitelabel,
+}: WhitelabelProviderProps) {
+  return (
+    <WhitelabelContext.Provider
+      value={{
+        whitelabel,
+      }}
+    >
+      {children}
+    </WhitelabelContext.Provider>
+  );
+}
+
+export function useWhitelabel(): WhitelabelContextProps {
+  const context = useContext(WhitelabelContext);
+
+  if (context === undefined) {
+    throw new Error(
+      "useWhitelabel deve ser usado dentro de um WhitelabelProvider",
+    );
+  }
+
+  return context;
+}

package/src/store/useMdSidebarStore.ts

@@ -0,0 +1,15 @@
+import { create } from "zustand";
+
+type MdSidebarStore = {
+    isExpanded: boolean;
+    toggle: () => void;
+    expand: () => void;
+    collapse: () => void;
+};
+
+export const useMdSidebarStore = create<MdSidebarStore>((set) => ({
+    isExpanded: false,
+    toggle: () => set((state) => ({ isExpanded: !state.isExpanded })),
+    expand: () => set({ isExpanded: true }),
+    collapse: () => set({ isExpanded: false }),
+}));