@phygitallabs/tapquest-core 4.5.0 → 4.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phygitallabs/tapquest-core",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,6 +23,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "@openreplay/tracker": "^16.4.10",
     "@phygitallabs/achievement": "latest",
     "@phygitallabs/api-core": "latest",
     "@phygitallabs/authentication": "latest",

package/src/constants/firebase.ts

@@ -0,0 +1,36 @@
+import { EnvironmentType } from "../types/common";
+
+const FIREBASE_ENV = {
+    dev:{
+        "apiKey": "AIzaSyBFReJURBrU3hyiVvHHhMKcruiyy3mkEks",
+        "authDomain": "phy-nomion-staging.firebaseapp.com",
+        "projectId": "phy-nomion-staging",
+        "storageBucket": "phy-nomion-staging.appspot.com",
+        "messagingSenderId": "445937266499",
+        "appId": "1:445937266499:web:9ce9b49c13dcecd9b889f6",
+        "measurementId": "G-GWYSS45K15"
+    },
+    staging:{
+        "apiKey": "AIzaSyAXrJB8n4eZyq43kb9pUSelz9vfkJLHRK8",
+        "authDomain": "phygital-388705.firebaseapp.com",
+        "projectId": "phygital-388705",
+        "storageBucket": "assets-fygito",
+        "messagingSenderId": "174350081236",
+        "appId": "1:174350081236:web:da29144bf47cf775a5af41",
+        "measurementId": "G-JVHVWXMDC9"
+    },
+    production:{
+        "apiKey": "AIzaSyAXrJB8n4eZyq43kb9pUSelz9vfkJLHRK8",
+        "authDomain": "phygital-388705.firebaseapp.com",
+        "projectId": "phygital-388705",
+        "storageBucket": "assets-fygito",
+        "messagingSenderId": "174350081236",
+        "appId": "1:174350081236:web:da29144bf47cf775a5af41",
+        "measurementId": "G-JVHVWXMDC9"
+    },
+}
+
+export const firebaseConfig = (env: EnvironmentType) => {
+    return FIREBASE_ENV[env];
+  };
+  

package/src/index.ts

@@ -16,6 +16,8 @@ export * from "./modules/generate-certificate";
 
 export * from "./modules/data-tracking";
 
+export * from "./modules/session-replay";
+
 export * from "./providers";
 
 export * from "./modules/achivementWithReward";
@@ -23,3 +25,5 @@ export * from "./modules/achivementWithReward";
 export * from "./modules/send-email";
 
 export * from "./helper";
+
+export * from "./modules/session-replay";

package/src/modules/achievement/hooks/index.ts

@@ -75,97 +75,3 @@ export const useManyAchievementProgress = (
     });
 };
 
-// export const useManyAchievementWithProgress = (
-//     params: UseManyAchievementWithProgressParams,
-//     options?: {
-//         achievementOptions?: Partial<UseQueryOptions>;
-//         progressOptions?: Partial<UseQueryOptions>;
-//     }
-// ): UseManyAchievementWithProgressReturn => {
-//     // Fetch achievements with retry logic
-//     const achievementsQuery = useManyAchievements(
-//         {
-//             ...(params.achievementIds?.length && { ids: params.achievementIds }),
-//         },
-//         {
-//             retry: (failureCount: number, error: Error) => {
-//                 // Retry up to 3 times with exponential backoff
-//                 if (failureCount < 3) {
-//                     console.warn(`Achievement fetch failed, retrying... (${failureCount + 1}/3)`, error);
-//                     return true;
-//                 }
-//                 return false;
-//             },
-//             retryDelay: (attemptIndex: number) => Math.min(1000 * 2 ** attemptIndex, 30000),
-//             staleTime: 5 * 60 * 1000, // 5 minutes
-//             gcTime: 10 * 60 * 1000, // 10 minutes
-//             ...options?.achievementOptions,
-//         }
-//     );
-
-//     // Prepare achievement IDs for progress query
-//     const achievementIds = useMemo(() => {
-//         if (params.achievementIds?.length) {
-//             return params.achievementIds;
-//         }
-//         return achievementsQuery.data?.data?.map((a: any) => a.id) || [];
-//     }, [params.achievementIds, achievementsQuery.data]);
-
-//     // Fetch progress with retry logic (dependent on achievements)
-//     const progressQuery = useManyAchievementProgress(
-//         {
-//             achievementIds,
-//             userId: params.userId,
-//             deviceUid: params.deviceUid,
-//             applicationId: params.applicationId,
-//         },
-//         {
-//             enabled: achievementIds.length > 0
-//         }
-//     );
-
-//     // Combine data with error flags
-//     const combinedData = useMemo((): AchievementWithProgress[] => {
-//         const achievements = achievementsQuery.data?.data || [];
-//         const progressData = progressQuery.data || [];
-
-//         return achievements.map((achievement: any) => {
-//             const progress = progressData.find((p: any) => p.achievementId === achievement.id) || null;
-
-//             return {
-//                 achievement,
-//                 progress,
-//                 hasAchievementError: !!achievementsQuery.error,
-//                 hasProgressError: !!progressQuery.error,
-//             };
-//         });
-//     }, [achievementsQuery.data, progressQuery.data, achievementsQuery.error, progressQuery.error]);
-
-//     // Refetch functions
-//     const refetchAchievements = () => {
-//         console.log("Manually refetching achievements...");
-//         achievementsQuery.refetch();
-//     };
-
-//     const refetchProgress = () => {
-//         console.log("Manually refetching progress...");
-//         progressQuery.refetch();
-//     };
-
-//     const refetchAll = () => {
-//         console.log("Manually refetching all data...");
-//         Promise.all([achievementsQuery.refetch(), progressQuery.refetch()]);
-//     };
-
-//     return {
-//         data: combinedData,
-//         isLoading: achievementsQuery.isLoading || (achievementIds.length > 0 && progressQuery.isLoading),
-//         isSuccess: achievementsQuery.isSuccess && (achievementIds.length === 0 || progressQuery.isSuccess),
-//         achievementsError: achievementsQuery.error as Error | null,
-//         progressError: progressQuery.error as Error | null,
-//         refetchAchievements,
-//         refetchProgress,
-//         refetchAll,
-//     };
-// };
-

package/src/modules/achivementWithReward/hooks/achivementPlusRewardModel.ts

@@ -10,7 +10,20 @@ interface GroupRewardData {
   reward_models: EntityRewardModel[][];
 }
 
-function buildMappedAchievements(achievements: Achievement[], groupRewardData: GroupRewardData) {
+export interface AchievementWithRewardModel {
+  id: string;
+  name: string;
+  reward_model: EntityRewardModel | null;
+  subAchievements: {
+    id: string;
+    reward_model: EntityRewardModel | null;
+  }[];
+}
+
+function buildMappedAchievements(
+  achievements: Achievement[],
+  groupRewardData: GroupRewardData
+) {
   if (!groupRewardData?.reward_models) return [];
 
   const rewardModels = groupRewardData.reward_models;
@@ -22,9 +35,9 @@ function buildMappedAchievements(achievements: Achievement[], groupRewardData: G
       achievement.subAchievementIds?.map((subId: string, subIndex: number) => {
         const reward =
           rewardModels[
-          achievementIndex * (achievement.subAchievementIds?.length || 0) +
-          subIndex +
-          1
+            achievementIndex * (achievement.subAchievementIds?.length || 0) +
+              subIndex +
+              1
           ]?.[0] || null;
 
         return {
@@ -42,7 +55,12 @@ function buildMappedAchievements(achievements: Achievement[], groupRewardData: G
   });
 }
 
-const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardModelParams) => {
+const useAchivementPlusRewardModel = ({
+  campaignId,
+}: UseAchivementPlusRewardModelParams): {
+  mappedAchievements: AchievementWithRewardModel[];
+  isLoading: boolean;
+} => {
   const { data: achievements, isLoading: isLoadingAchievements } =
     useManyAchievements(
       {
@@ -59,6 +77,7 @@ const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardMod
       .map((achievement) => achievement.groupRewardId)
       .filter((id): id is string => id !== undefined);
   }, [achievements?.data]);
+
   const {
     mutate: fetchGroupRewardModels,
     data: groupRewardModelsData,
@@ -70,10 +89,14 @@ const useAchivementPlusRewardModel = ({ campaignId }: UseAchivementPlusRewardMod
     }
   }, [groupRewardIds, fetchGroupRewardModels]);
 
-  const mappedAchievements = useMemo(() => {
+  const mappedAchievements: AchievementWithRewardModel[] = useMemo(() => {
     if (!groupRewardModelsData?.data || !achievements?.data) return [];
-    return buildMappedAchievements(achievements.data, groupRewardModelsData.data);
+    return buildMappedAchievements(
+      achievements.data,
+      groupRewardModelsData.data
+    );
   }, [groupRewardModelsData, achievements?.data]);
+
   return {
     mappedAchievements,
     isLoading: isLoadingAchievements || isPendingGroupRewardModels,

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

@@ -2,9 +2,10 @@ import { useRef, useCallback, useEffect } from "react";
 import { useAuth } from "../store/authStore";
 import { tokenStorage } from "@phygitallabs/authentication";
 import { ALLOWED_ORIGINS } from "../constants";
+import { decodeJWTToken } from "../utils/user";
 
 export interface UseGoogleLoginOptions {
-  onSuccess?: () => void;
+  onSuccess?: (userData: any) => void;
   onError?: (error: string) => void;
   onPopupBlocked?: () => void;
   onPopupClosed?: () => void;
@@ -36,9 +37,11 @@ export function useGoogleLogin(options: UseGoogleLoginOptions = {}): UseGoogleLo
               refreshToken: newToken.data.refreshToken,
             });
 
+            const userData = decodeJWTToken(newToken.data.idToken);            
+
             setIsSignedIn(true);
             setIsLoading(false);
-            onSuccess?.();
+            onSuccess?.(userData);
           }
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : "Token refresh failed";

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

@@ -8,17 +8,12 @@ export function useTokenRefresher() {
   const handleRefreshToken = async () => {
     try {
       const isTokenExpired = tokenStorage.isTokenExpired();
+
       if (!isTokenExpired) {
         return;
       }
-      const newToken = await refreshToken();
-
-      if(newToken.data?.idToken && newToken.data?.refreshToken){
-        tokenStorage.setTokens({
-            idToken: newToken.data?.idToken,
-            refreshToken: newToken.data?.refreshToken,
-          });
-      }
+      
+      await refreshToken();
 
     } catch (error) {
       console.error("Failed to refresh token:", error);

package/src/modules/auth/providers/AuthProvider.tsx

@@ -4,7 +4,7 @@ import {
   tokenStorage,
 } from "@phygitallabs/authentication";
 import { useEffect } from "react";
-import { useAuthStore } from "../store/authStore";
+import {useAuthStore} from "../store/authStore";
 import { transformProtoUserData } from "../utils/user";
 import { userService } from "@phygitallabs/api-core";
 import { QueryClient } from "@tanstack/react-query";
@@ -70,8 +70,8 @@ const AuthStateManager = () => {
     let previousIsSignedIn = useAuthStore.getState().isSignedIn;
 
     const unsub = useAuthStore.subscribe(
-      (state: any) => [state.isSignedIn, state.user],
-      async ([isSignedIn]: [any]) => {
+      (state) => [state.isSignedIn, state.user],
+      async ([isSignedIn]) => {
         // Only run when isSignedIn actually changes
         if (isSignedIn === previousIsSignedIn) {
           return;

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

@@ -0,0 +1,290 @@
+// Client-side only imports
+let firebaseApp: any;
+let firebaseAuth: any;
+
+// Dynamic imports for client-side only
+const getFirebaseModules = async () => {
+  if (typeof window === 'undefined') {
+    throw new Error('Firebase can only be used in client environment');
+  }
+
+  if (!firebaseApp || !firebaseAuth) {
+    const [
+      { initializeApp, getApps },
+      {
+        getAuth,
+        signInWithEmailAndPassword,
+        createUserWithEmailAndPassword,
+        signInWithPopup,
+        GoogleAuthProvider,
+        signOut,
+        sendPasswordResetEmail,
+        sendEmailVerification,
+        updatePassword,
+        onAuthStateChanged,
+      }
+    ] = await Promise.all([
+      import("firebase/app"),
+      import("firebase/auth")
+    ]);
+
+    firebaseApp = { initializeApp, getApps };
+    firebaseAuth = {
+      getAuth,
+      signInWithEmailAndPassword,
+      createUserWithEmailAndPassword,
+      signInWithPopup,
+      GoogleAuthProvider,
+      signOut,
+      sendPasswordResetEmail,
+      sendEmailVerification,
+      updatePassword,
+      onAuthStateChanged,
+    };
+  }
+
+  return { firebaseApp, firebaseAuth };
+};
+
+import { AuthService, FirebaseConfig, AuthResponse, UserData, SignInProvider } from "../types";
+import { accessTokenKey, refreshTokenKey } from "../constants";
+
+export class FirebaseAuthService implements AuthService {
+  private app: any;
+  private auth: any;
+  private googleProvider: any;
+  private config: FirebaseConfig;
+  private initialized = false;
+
+  constructor(config: FirebaseConfig) {
+    this.config = config;
+    // Initialization will be done lazily in client environment
+  }
+
+  private async ensureInitialized() {
+    if (this.initialized) return;
+
+    const { firebaseApp, firebaseAuth } = await getFirebaseModules();
+
+    // Initialize Firebase app if not already initialized
+    if (!firebaseApp.getApps().length) {
+      this.app = firebaseApp.initializeApp(this.config);
+    } else {
+      this.app = firebaseApp.getApps()[0];
+    }
+
+    this.auth = firebaseAuth.getAuth(this.app);
+    this.googleProvider = new firebaseAuth.GoogleAuthProvider();
+    this.initialized = true;
+  }
+
+  private transformUserData(user: any): UserData {
+    return {
+      id: user.uid,
+      uid: user.uid,
+      userName: user.displayName || "",
+      displayName: user.displayName || "",
+      email: user.email || "",
+      refreshToken: user.refreshToken,
+      accessToken: (user as any).accessToken || "",
+      exp: (user as any).stsTokenManager?.expirationTime || 0,
+      emailVerified: user.emailVerified,
+      avatar: user.photoURL || "/images/default-avatar.jpg",
+      signInProvider: this.getSignInProvider(user),
+      role: undefined,
+      scanStatus: false,
+    };
+  }
+
+  private getSignInProvider(user: any): SignInProvider {
+    const providers = user.providerData.map((p: any) => p.providerId);
+    if (providers.includes("google.com")) return "google.com";
+    return "password";
+  }
+
+  private translateErrorCode(errorCode: string): string {
+    switch (errorCode) {
+      case "auth/invalid-email":
+        return "Email không hợp lệ";
+      case "auth/user-disabled":
+        return "Tài khoản đã bị khóa";
+      case "auth/wrong-password":
+        return "Tài khoản/mật khẩu không đúng";
+      case "auth/user-not-found":
+        return "Tài khoản/mật khẩu không đúng";
+      case "auth/weak-password":
+        return "Weak password! Please use stronger password.";
+      case "auth/email-already-in-use":
+        return "Email đã được sử dụng";
+      case "auth/account-exists-with-different-credential":
+        return "Tài khoản email đã được sử dụng bởi một phương thức đăng nhập khác";
+      case "auth/email-not-verified":
+        return "Email chưa được xác thực";
+      default:
+        return "Đã có lỗi xảy ra";
+    }
+  }
+
+  async signInWithEmailAndPassword(email: string, password: string): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signInResponse = await firebaseAuth.signInWithEmailAndPassword(this.auth, email, password);
+      const { user } = signInResponse;
+      const data = this.transformUserData(user);
+
+      const { emailVerified } = data;
+      if (!emailVerified) {
+        await this.signOut();
+        localStorage.removeItem("phygital-user-info");
+        localStorage.removeItem(accessTokenKey);
+        localStorage.removeItem(refreshTokenKey);
+        throw new Error("Email is not verified");
+      }
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signInWithGoogle(): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signInResponse = await firebaseAuth.signInWithPopup(this.auth, this.googleProvider);
+      const { user } = signInResponse;
+      const data = this.transformUserData(user);
+
+      const { emailVerified } = data;
+      if (!emailVerified) {
+        await this.signOut();
+        throw new Error("Email is not verified");
+      }
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signUp(email: string, password: string): Promise<AuthResponse> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      const signUpResponse = await firebaseAuth.createUserWithEmailAndPassword(this.auth, email, password);
+      const { user } = signUpResponse;
+      const data = this.transformUserData(user);
+
+      return {
+        errorCode: "",
+        data,
+      };
+    } catch (err: any) {
+      const errorCode = this.translateErrorCode(err.code);
+      return {
+        errorCode,
+        data: null,
+      };
+    }
+  }
+
+  async signOut(): Promise<void> {
+    try {
+      await this.ensureInitialized();
+      const { firebaseAuth } = await getFirebaseModules();
+      await firebaseAuth.signOut(this.auth);
+      // Tracking is now handled through callbacks in the consuming app
+    } catch (err) {
+      console.log("Firebase signOut error:", err);
+    }
+  }
+
+  async sendPasswordResetEmail(email: string): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    const actionCodeSettings = {
+      url: window.location.origin,
+      handleCodeInApp: true,
+    };
+    await firebaseAuth.sendPasswordResetEmail(this.auth, email, actionCodeSettings);
+  }
+
+  async sendEmailVerification(): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    if (!this.auth.currentUser) {
+      throw new Error("No current user");
+    }
+    const actionCodeSettings = {
+      url: window.location.origin,
+      handleCodeInApp: true,
+    };
+    await firebaseAuth.sendEmailVerification(this.auth.currentUser, actionCodeSettings);
+  }
+
+  async changePassword(newPassword: string): Promise<void> {
+    await this.ensureInitialized();
+    const { firebaseAuth } = await getFirebaseModules();
+    const user = this.auth.currentUser;
+    if (!user) {
+      throw new Error("No current user");
+    }
+    return firebaseAuth.updatePassword(user, newPassword);
+  }
+
+  onAuthStateChanged(callback: (user: UserData | null) => void): () => void {
+    // For client-side only usage, ensure initialization before setting up auth state listener
+    if (typeof window === 'undefined') {
+      return () => { }; // Return empty unsubscriber for server-side
+    }
+
+    // Set up the listener asynchronously
+    let unsubscriber: (() => void) | null = null;
+
+    this.ensureInitialized().then(async () => {
+      const { firebaseAuth } = await getFirebaseModules();
+      unsubscriber = firebaseAuth.onAuthStateChanged(this.auth, (user: any) => {
+        if (user && user.emailVerified) {
+          const userData = this.transformUserData(user);
+          callback(userData);
+        } else {
+          callback(null);
+        }
+      });
+    });
+
+    // Return unsubscriber function
+    return () => {
+      if (unsubscriber) {
+        unsubscriber();
+      }
+    };
+  }
+
+  getCurrentUser(): UserData | null {
+    if (typeof window === 'undefined' || !this.initialized) {
+      return null; // Return null for server-side or before initialization
+    }
+
+    const user = this.auth.currentUser;
+    if (user && user.emailVerified) {
+      return this.transformUserData(user);
+    }
+    return null;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { FirebaseAuthService } from "./FirebaseAuthService";
+
+interface AuthServiceConfig {
+  firebaseConfig: any;
+}
+
+let authServiceInstance: FirebaseAuthService | null = null;
+
+export const createAuthService = (config: AuthServiceConfig): FirebaseAuthService => {
+  if (!authServiceInstance) {
+    authServiceInstance = new FirebaseAuthService(config.firebaseConfig);
+  }
+  return authServiceInstance;
+};
+
+export const getAuthService = (): FirebaseAuthService | null => {
+  return authServiceInstance;
+};
+
+export const resetAuthService = (): void => {
+  authServiceInstance = null;
+};

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

@@ -0,0 +1,3 @@
+// Export Firebase auth service separately to avoid loading Firebase modules during SSR
+export { FirebaseAuthService } from './FirebaseAuthService';
+export { createAuthService, getAuthService, resetAuthService } from './authServiceFactory';