@phygitallabs/tapquest-core 2.8.0 → 2.9.1

package/src/modules/auth/store/authStore.ts

@@ -0,0 +1,577 @@
+import { create } from "zustand";
+import { immer } from "zustand/middleware/immer";
+import { UserData } from "../types/user-data";
+import {
+  createJSONStorage,
+  devtools,
+  persist,
+  subscribeWithSelector,
+} from "zustand/middleware";
+import { AuthEventCallbacks } from "../types/auth";
+
+import {
+  authService,
+  ProtoSendVerifyCodeResponse,
+  ProtoSignInResponse,
+  ProtoSignUpResponse,
+  ProtoVerifyEmailResponse,
+  SendVerifyCodeRequest,
+  verifyCodeService,
+  VerifyEmailRequest,
+  tokenStorage,
+  ProtoRefreshTokenResponse,
+  OAuthSignInResponse,
+  ResetPasswordRequest,
+  ProtoResetPasswordResponse,
+  ChangePasswordRequest,
+  ProtoChangePasswordResponse,
+} from "@phygitallabs/authentication";
+
+import { CALLBACK_URL } from "../constants";
+
+// Cleanup functions interface
+export interface AuthCleanupFunctions {
+  clearQueryCache?: () => void;
+  clearOrganization?: () => void;
+  clearHeaders?: () => void;
+  clearCustomData?: () => void;
+}
+
+// Simplified auth state interface
+interface AuthState {
+  // User data
+  user: UserData | null;
+
+  isSignedIn: boolean;
+  isInitialized: boolean;
+
+  // Single loading state
+  isLoading: boolean;
+
+  // Error state
+  error: string | null;
+
+  // Cleanup functions
+  cleanupFunctions: AuthCleanupFunctions;
+
+  // Event callbacks
+  eventCallbacks: AuthEventCallbacks;
+}
+
+// Simplified actions interface
+interface AuthActions {
+  setCleanupFunctions: (
+    cleanupFunctions: Partial<AuthCleanupFunctions>
+  ) => void;
+
+  // Event management
+  addEventCallbacks: (callbacks: AuthEventCallbacks) => () => void;
+
+  // Core auth actions
+  signInWithEmail: (
+    email: string,
+    password: string,
+    updateHeaders?: (headers: Record<string, string>) => void,
+    updateAuthenticationHeaders?: (headers: Record<string, string>) => void
+  ) => Promise<ProtoSignInResponse>;
+  signInWithGoogle: () => Promise<OAuthSignInResponse>;
+  signUpWithEmail: (
+    email: string,
+    password: string
+  ) => Promise<ProtoSignUpResponse>;
+  signOut: () => Promise<void>;
+  sendPasswordResetEmail: (email: string) => Promise<void>;
+  resetPassword: (
+    data: ResetPasswordRequest
+  ) => Promise<ProtoResetPasswordResponse>;
+  changePassword: (
+    data: ChangePasswordRequest
+  ) => Promise<ProtoChangePasswordResponse>;
+  verifyEmailCode: (
+    data: VerifyEmailRequest
+  ) => Promise<ProtoVerifyEmailResponse>;
+  sendVerifyCode: (
+    data: SendVerifyCodeRequest
+  ) => Promise<ProtoSendVerifyCodeResponse>;
+  refreshToken: (refreshToken?: string) => Promise<ProtoRefreshTokenResponse>;
+
+  // Simple state management
+  clearError: () => void;
+
+  // Setters
+  setUser: (user: UserData | null) => void;
+  patchUser: (user: Partial<UserData>) => void;
+  setIsSignedIn: (isSignedIn: boolean) => void;
+  setIsInitialized: (isInitialized: boolean) => void;
+  setIsLoading: (isLoading: boolean) => void;
+
+  // Initialization
+  initialize: () => void;
+  syncAuthState: () => void;
+}
+
+// Store structure with actions grouped
+interface AuthStoreState extends AuthState {
+  actions: AuthActions;
+}
+
+type AuthStore = AuthStoreState;
+
+// Initial state
+const initialState: AuthState = {
+  user: null,
+  isSignedIn: false,
+  isInitialized: false,
+  isLoading: false,
+  error: null,
+  cleanupFunctions: {},
+  eventCallbacks: {},
+};
+
+// Create the auth store
+export const useAuthStore :any = create<AuthStore>()(
+  devtools(
+    persist(
+      subscribeWithSelector(
+        immer((set, get) => ({
+          ...initialState,
+          actions: {
+            setIsLoading: (isLoading: boolean) =>
+              set((state) => {
+                state.isLoading = isLoading;
+              }),
+
+            setCleanupFunctions: (
+              newCleanupFunctions: Partial<AuthCleanupFunctions>
+            ) =>
+              set((state) => {
+                state.cleanupFunctions = {
+                  ...state.cleanupFunctions,
+                  ...newCleanupFunctions,
+                };
+              }),
+
+            // Event management
+            addEventCallbacks: (callbacks: AuthEventCallbacks) => {
+              set((state) => {
+                state.eventCallbacks = {
+                  ...state.eventCallbacks,
+                  ...callbacks,
+                };
+              });
+
+              // Return cleanup function
+              return () => {
+                set((state) => {
+                  state.eventCallbacks = {
+                    ...state.eventCallbacks,
+                    ...callbacks,
+                  };
+                });
+              };
+            },
+
+            // Sign in with email and password
+            signInWithEmail: async (email: string, password: string) => {
+              const { eventCallbacks } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const response = await authService.signIn({
+                  email,
+                  password,
+                });
+
+                if (response?.data?.idToken && response?.data?.refreshToken) {
+                  // Store tokens in tokenStorage only
+                  tokenStorage.setTokens({
+                    idToken: response.data.idToken,
+                    refreshToken: response.data.refreshToken,
+                  });
+
+                  // Update auth state
+                  set((state) => {
+                    state.isSignedIn = true;
+                  });
+
+                  eventCallbacks.onLoginSuccess?.(response.data.idToken);
+                }
+
+                return response;
+              } catch (error: any) {
+                // Check if error has code 7 (email not verified)
+                if (error?.response?.data?.code === 7) {
+                  // Return a special response for email verification needed
+                  return {
+                    data: undefined,
+                    message: "Email verification required",
+                    code: 7,
+                  };
+                }
+
+                const errorMessage =
+                  error instanceof Error ? error.message : "Login failed";
+
+                set((state) => {
+                  state.error = errorMessage;
+                });
+
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+
+            // Sign in with Google
+            signInWithGoogle: async () => {
+              const { eventCallbacks } = get();
+              try {
+                //get current domain
+                const currentDomain = CALLBACK_URL;
+
+                const userData =
+                  await authService.getOAuthSignInUrl(currentDomain);
+                return userData;
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error
+                    ? error.message
+                    : "Google sign in failed";
+
+                set((state) => {
+                  state.error = errorMessage;
+                });
+
+                eventCallbacks.onLoginError?.(new Error(errorMessage));
+
+                throw error;
+              }
+            },
+
+            // Sign up with email and password
+            signUpWithEmail: async (email: string, password: string) => {
+              const { eventCallbacks } = get();
+
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const response = await authService.signUp({
+                  email,
+                  password,
+                });
+
+                if (response.data) {
+                  eventCallbacks.onSignupSuccess?.();
+                }
+
+                return response;
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error ? error.message : "Signup failed";
+
+                set((state) => {
+                  state.error = errorMessage;
+                });
+
+                eventCallbacks.onSignupError?.(new Error(errorMessage));
+
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                  state.user = null;
+                  state.isSignedIn = false;
+                });
+              }
+            },
+
+            // Sign out
+            signOut: async () => {
+              const { eventCallbacks, cleanupFunctions } = get();
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                set((state) => {
+                  state.user = null;
+                  state.isSignedIn = false;
+                  state.error = null;
+                });
+                const isTokenExpired = tokenStorage.isTokenExpired();
+                if (isTokenExpired) {
+                  tokenStorage.clearTokens();
+                  localStorage.clear();
+                  return;
+                }
+                await authService.logout();
+
+                // Clear tokenStorage first
+                localStorage.clear();
+                tokenStorage.clearTokens();
+
+                // Execute default cleanup functions
+                try {
+                  cleanupFunctions.clearQueryCache?.();
+                  cleanupFunctions.clearOrganization?.();
+                  cleanupFunctions.clearCustomData?.();
+                  cleanupFunctions.clearHeaders?.();
+                } catch (cleanupError) {
+                  console.warn("Error during logout cleanup:", cleanupError);
+                  // Don't fail logout if cleanup fails
+                }
+
+                // Call onLogoutSuccess callback
+                eventCallbacks.onLogoutSuccess?.();
+
+                // Update state AFTER callback to prevent AuthLayout interference
+              } catch (error) {
+                console.log(error);
+                const errorMessage =
+                  error instanceof Error ? error.message : "Logout failed";
+
+                set((state) => {
+                  state.error = errorMessage;
+                });
+
+                eventCallbacks.onLogoutError?.(new Error(errorMessage));
+
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+
+            // Send password reset email
+            sendPasswordResetEmail: async (email: string) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                await verifyCodeService.forgotPassword({
+                  email,
+                });
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error
+                    ? error.message
+                    : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+
+            resetPassword: async (data: ResetPasswordRequest) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const resetPasswordResponse =
+                  await verifyCodeService.resetPassword(data);
+                return resetPasswordResponse;
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error
+                    ? error.message
+                    : "Failed to reset password";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+
+            changePassword: async (data: ChangePasswordRequest) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const changePasswordResponse =
+                  await verifyCodeService.changePassword(data);
+                return changePasswordResponse;
+              } catch (error) {
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+
+            verifyEmailCode: async (data: VerifyEmailRequest) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const verifyEmailResponse =
+                  await verifyCodeService.verifyEmail(data);
+                return verifyEmailResponse;
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error
+                    ? error.message
+                    : "Failed to send reset email";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            sendVerifyCode: async (data: SendVerifyCodeRequest) => {
+              set((state) => {
+                state.isLoading = true;
+                state.error = null;
+              });
+
+              try {
+                const sendVerifyCodeResponse =
+                  await verifyCodeService.sendVerifyCode(data);
+                return sendVerifyCodeResponse;
+              } catch (error) {
+                const errorMessage =
+                  error instanceof Error
+                    ? error.message
+                    : "Failed to send verify code";
+                set((state) => {
+                  state.error = errorMessage;
+                });
+                throw error;
+              } finally {
+                set((state) => {
+                  state.isLoading = false;
+                });
+              }
+            },
+            refreshToken: async (refreshToken?: string) => {
+              const refreshTokenResponse = await authService.refreshToken({
+                refreshToken:
+                  refreshToken ?? tokenStorage.getRefreshToken() ?? "",
+              });
+              return refreshTokenResponse;
+            },
+
+            // Clear error
+            clearError: () =>
+              set((state) => {
+                state.error = null;
+              }),
+
+            setUser: (user: UserData | null) =>
+              set((state) => {
+                state.user = user;
+              }),
+
+            setIsSignedIn: (isSignedIn: boolean) =>
+              set((state) => {
+                state.isSignedIn = isSignedIn;
+              }),
+
+            setIsInitialized: (isInitialized: boolean) =>
+              set((state) => {
+                state.isInitialized = isInitialized;
+              }),
+
+            patchUser: (user: Partial<UserData>) =>
+              set((state) => {
+                if (state.user) {
+                  state.user = { ...state.user, ...user };
+                } else {
+                  state.user = user as UserData;
+                }
+              }),
+
+            // Initialize the store - check if user is already authenticated from tokenStorage
+            initialize: () => {
+              set((state) => {
+                const token = tokenStorage.getAuthToken();
+                state.isSignedIn = !!token;
+                state.isInitialized = true;
+              });
+            },
+
+            // Sync auth state from tokenStorage (called when axios interceptor updates tokens)
+            syncAuthState: () => {
+              set((state) => {
+                const token = tokenStorage.getAuthToken();
+                const wasSignedIn = state.isSignedIn;
+                state.isSignedIn = !!token;
+
+                // If auth state changed, trigger callbacks
+                if (wasSignedIn !== state.isSignedIn) {
+                  if (state.isSignedIn) {
+                    state.eventCallbacks?.onAuthStateChange?.(state.user, true);
+                  } else {
+                    state.eventCallbacks?.onAuthStateChange?.(null, false);
+                  }
+                }
+              });
+            },
+          },
+        }))
+      ),
+      {
+        version: 1,
+        name: "auth-store",
+        storage: createJSONStorage(() => localStorage),
+        partialize: (state) => ({
+          isSignedIn: state.isSignedIn,
+          user: state.user,
+        }),
+      }
+    )
+  )
+);
+
+export const useAuth = () => {
+  const user = useAuthStore((state: any) => state.user);
+  const isSignedIn = useAuthStore((state: any) => state.isSignedIn);
+  const isInitialized = useAuthStore((state: any) => state.isInitialized);
+  const isLoading = useAuthStore((state: any) => state.isLoading);
+  const error = useAuthStore((state: any) => state.error);
+  const actions = useAuthStore((state: any) => state.actions);
+
+  return {
+    user,
+    isSignedIn,
+    isInitialized,
+    isLoading,
+    error,
+    ...actions,
+  };
+};
+

package/src/modules/auth/types/auth.ts

@@ -0,0 +1,29 @@
+import { UserData } from "./user-data";
+
+export interface LoginForm {
+    email: string;
+    password: string;
+}
+
+export interface ForgotPasswordForm {
+    email: string;
+}
+
+export interface SignUpForm {
+    email: string;
+    password: string;
+}
+
+// Event callback types
+export interface AuthEventCallbacks {
+    onLoginSuccess?: (token: string) => void | Promise<void>;
+    onLoginError?: (error: Error) => void | Promise<void>;
+    onLogoutSuccess?: () => void | Promise<void>;
+    onLogoutError?: (error: Error) => void | Promise<void>;
+    onSignupSuccess?: () => void | Promise<void>;
+    onSignupError?: (error: Error) => void | Promise<void>;
+    onAuthStateChange?: (
+        user?: UserData | null,
+        isSignedIn?: boolean
+    ) => void | Promise<void>;
+}

package/src/modules/auth/types/user-data.ts

@@ -0,0 +1,38 @@
+import { UserAddressDetail, UserModel } from "@phygitallabs/api-core";
+
+export enum OrgUserRole {
+  ORGANIZATION_OWNER = "ORGANIZATION_OWNER",
+  ORGANIZATION_ADMIN = "ORGANIZATION_ADMIN",
+  ORGANIZATION_EDITOR = "ORGANIZATION_EDITOR",
+  ORGANIZATION_VIEWER = "ORGANIZATION_VIEWER",
+}
+
+export enum UserType {
+  C,
+  B,
+}
+
+enum PortalUserRole {
+  ADMIN = "ADMIN",
+  USER = "USER",
+  PORTAL_ADMIN_RW = "PORTAL_ADMIN_RW",
+  PORTAL_ADMIN_RO = "PORTAL_ADMIN_RO",
+}
+
+export enum UserRole {
+  ADMIN = "ADMIN",
+  USER = "USER",
+  ORGANIZATION_OWNER = OrgUserRole.ORGANIZATION_OWNER,
+  ORGANIZATION_ADMIN = OrgUserRole.ORGANIZATION_ADMIN,
+  ORGANIZATION_EDITOR = OrgUserRole.ORGANIZATION_EDITOR,
+  ORGANIZATION_VIEWER = OrgUserRole.ORGANIZATION_VIEWER,
+  PORTAL_ADMIN_RW = PortalUserRole.PORTAL_ADMIN_RW,
+  PORTAL_ADMIN_RO = PortalUserRole.PORTAL_ADMIN_RO,
+}
+
+export interface UserData extends UserModel {
+  provider?: string;
+  accessToken: string;
+  exp: number;
+  addressDetail: UserAddressDetail;
+}

package/src/modules/auth/utils/user.ts

@@ -0,0 +1,21 @@
+import { UserData, UserRole, UserType } from "../types/user-data";
+import { UserModel } from "@phygitallabs/api-core";
+import jwtDecode from "jwt-decode";
+
+export const transformProtoUserData = (user: UserModel, accessToken: string): UserData => {
+  const userData = { ...user } as UserData;
+  let tokenDecoded: any = {};
+
+  try {
+    tokenDecoded = jwtDecode(accessToken);
+  } catch (error) {
+    console.warn("Failed to decode token in transformUserData:", error);
+  }
+
+  userData.exp = tokenDecoded.exp || 0;
+  userData.accessToken = accessToken || "";
+  userData.roles = tokenDecoded?.roles || [UserRole.USER];
+  userData.account_type = tokenDecoded?.account_type || UserType.C;
+  userData.picture = user.picture || "";
+  return userData;
+};

package/src/modules/data-tracking/hooks/index.ts

@@ -1,4 +1,5 @@
 import posthog from "posthog-js";
+import { useSessionReplay } from "../../../modules/session-replay";
 
 declare global {
     interface Window {
@@ -43,6 +44,8 @@ const pushEventToPosthog = (eventName: string, eventData: Record<string, any>) =
 };
 
 function useDataTracking() {
+    const { setUserId, setMetadata } = useSessionReplay();
+
     const trackEvent = (eventName: string, eventData: Record<string, any>, useTools?: ("gtm" | "ga" | "posthog")[]) => {
 
         useTools = useTools || ["gtm"];
@@ -58,8 +61,29 @@ function useDataTracking() {
         }
     };
 
+    const trackUserIdentify = (userInfo: Record<string, any>) => {
+        posthog.identify(userInfo.email, {
+            email: userInfo.email,
+            name: userInfo.name,
+            avatar: userInfo.avatar,
+            uid: userInfo.uid,
+          });
+
+        setUserId(userInfo.id);
+
+        setMetadata({
+            user_email: userInfo.email
+        })
+    }
+
+    const trackLogoutEvent = () => {
+        posthog.capture("user_signed_out");
+    }
+
     return {
-        trackEvent
+        trackEvent,
+        trackUserIdentify,
+        trackLogoutEvent
     };
 }