@phygitallabs/tapquest-core 2.0.0

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

@@ -0,0 +1,161 @@
+import {
+    deviceUIDKey,
+    chipAuthTokenKey,
+    retryAttemptsRefreshToken,
+    accessTokenKey,
+    refreshTokenKey,
+    userInfoKey,
+} from "../constants";
+
+import { v4 as uuidv4 } from "uuid";
+
+export const generateDeviceId = async (): Promise<string> => {
+    try {
+        const deviceFingerprint = await generateDeviceFingerprint();
+        return deviceFingerprint;
+    } catch (error) {
+        console.error("Error generating device fingerprint:", error);
+        return uuidv4();
+    }
+};
+
+const generateDeviceFingerprint = async (): Promise<string> => {
+    const timestamp = new Date().toISOString(); // UTC timestamp
+
+    const fingerprintRaw = [
+        navigator.userAgent,
+        navigator.language,
+        screen.width,
+        screen.height,
+        screen.colorDepth,
+        Intl.DateTimeFormat().resolvedOptions().timeZone,
+        navigator.platform,
+        navigator.hardwareConcurrency,
+        timestamp, // Include timestamp
+    ].join("::");
+
+    const encoder = new TextEncoder();
+    const data = encoder.encode(fingerprintRaw);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const fingerprint = hashArray
+        .map((b) => b.toString(16).padStart(2, "0"))
+        .join("");
+    return fingerprint;
+};
+
+export default generateDeviceFingerprint;
+
+
+export const getDeviceUid = () => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(deviceUIDKey);
+};
+
+export const setDeviceUid = (deviceId: string) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(deviceUIDKey, deviceId);
+};
+
+export const removeDeviceUid = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(deviceUIDKey);
+};
+
+export const checkDeviceUid = async (): Promise<string> => {
+    // if (typeof window === "undefined") return null;
+
+    let deviceUID = getDeviceUid();
+
+    if (!deviceUID) {
+        deviceUID = await generateDeviceId();
+        setDeviceUid(deviceUID);
+    }
+
+    return deviceUID;
+};
+
+// CHIP AUTH TOKEN
+export const getChipAuthToken = () => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(chipAuthTokenKey);
+};
+
+export const setChipAuthToken = (value: string) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(chipAuthTokenKey, value);
+};
+
+export const removeChipAuthToken = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(chipAuthTokenKey);
+};
+
+// RETRY ATTEMPTS
+export const getRetryAttemptsRefreshToken = () => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(retryAttemptsRefreshToken);
+};
+
+export const setRetryAttemptsRefreshToken = (value: string) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(retryAttemptsRefreshToken, value);
+};
+
+// ACCESS TOKEN
+export const getAccessToken = () => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(accessTokenKey);
+};
+
+export const setAccessToken = (value: string) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(accessTokenKey, value);
+};
+
+export const removeAccessToken = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(accessTokenKey);
+};
+
+// REFRESH TOKEN
+export const getRefreshToken = () => {
+    if (typeof window === "undefined") return null;
+    return localStorage.getItem(refreshTokenKey);
+};
+
+export const setRefreshToken = (value: string) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(refreshTokenKey, value);
+};
+
+export const removeRefreshToken = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(refreshTokenKey);
+};
+
+// USER INFO
+export const getUserInfo = () => {
+    if (typeof window === "undefined") return null;
+    const userInfo = localStorage.getItem(userInfoKey);
+    if (!userInfo) return null;
+    try {
+        return JSON.parse(userInfo);
+    } catch (error) {
+        console.error("Failed to parse stored user data:", error);
+        return null;
+    }
+};
+
+export const setUserInfo = (userData: any) => {
+    if (typeof window === "undefined") return;
+    localStorage.setItem(userInfoKey, JSON.stringify(userData));
+};
+
+export const removeUserInfo = () => {
+    if (typeof window === "undefined") return;
+    localStorage.removeItem(userInfoKey);
+};
+
+export { createRefreshTokenFunction } from "./refreshToken";
+export type { RefreshTokenConfig } from "./refreshToken";

package/src/modules/auth/helpers/refreshToken.ts

@@ -0,0 +1,63 @@
+import mem from "mem";
+import { setUserInfo, removeUserInfo, getUserInfo, getRefreshToken } from "./index";
+
+// Internal configuration - managed by tapquest-core
+const REFRESH_TOKEN_CONFIG = {
+  maxAge: 10000, // 10 seconds cache
+} as const;
+
+export interface RefreshTokenConfig {
+  firebaseApiKey: string;
+}
+
+const createRefreshTokenFunction = (config: RefreshTokenConfig) => {
+  const refreshTokenFn = async () => {
+    try {
+      const session = getUserInfo();
+      const refreshToken = getRefreshToken();
+
+      if (!refreshToken) {
+        removeUserInfo();
+        return;
+      }
+
+      const params = new URLSearchParams();
+      params.append("grant_type", "refresh_token");
+      params.append("refresh_token", refreshToken);
+
+      const fetchData = {
+        method: "POST",
+        headers: new Headers({
+          "Content-Type": "application/x-www-form-urlencoded;charset=UTF-8",
+        }),
+        body: params,
+      };
+
+      const response = await fetch(
+        `https://securetoken.googleapis.com/v1/token?key=${config.firebaseApiKey}`,
+        fetchData
+      );
+      const data = await response.json();
+
+      if (data.error) {
+        removeUserInfo();
+        return;
+      }
+
+      const newSession = {
+        ...session,
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+      };
+      setUserInfo(newSession);
+
+      return newSession;
+    } catch {
+      removeUserInfo();
+    }
+  };
+
+  return mem(refreshTokenFn, { maxAge: REFRESH_TOKEN_CONFIG.maxAge });
+};
+
+export { createRefreshTokenFunction };

package/src/modules/auth/index.ts

@@ -0,0 +1,20 @@
+// Export types
+export type {
+  UserData,
+  UserRole,
+  SignInProvider,
+  AuthResponse,
+  AuthService,
+  FirebaseConfig,
+  UseAuthReturn,
+  AuthProviderProps,
+  AuthCallbacks,
+} from './types';
+
+// Export hooks and providers
+// export { useAuth } from './hooks';
+export { useAuth, AuthProvider } from './providers';
+
+// Export constants and helpers
+export * from './constants';
+export * from './helpers';

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

@@ -0,0 +1,207 @@
+import { createContext, useEffect, ReactNode, useContext } from 'react';
+import { AuthService, AuthCallbacks } from '../types';
+
+import { useAppSelector, useAppDispatch } from '../../../store/hooks';
+import {
+  selectUser,
+  selectIsSignedIn,
+  selectIsLoading,
+  signIn as signInAction,
+  signOut as signOutAction,
+  updateScanStatus as updateScanStatusAction,
+  refreshUser as refreshUserAction,
+  setPending,
+  initializeFromStorage,
+} from '../store/authSlice';
+
+import { AuthResponse, UserData } from '../types';
+
+export interface AuthContextType {
+  authService: AuthService;
+  authCallbacks?: AuthCallbacks;
+  // User state
+  user: UserData;
+  isSignedIn: boolean;
+  isLoading: boolean;
+
+  // Auth actions
+  signInWithCredential: (email: string, password: string) => Promise<AuthResponse>;
+  signInWithGoogle: () => Promise<AuthResponse | null>;
+  signUp: (email: string, password: string) => Promise<AuthResponse>;
+  signOut: () => Promise<void>;
+
+  // Password actions
+  forgotPassword: (email: string) => Promise<void>;
+  sendEmailVerification: () => Promise<void>;
+  changePassword: (newPassword: string) => Promise<void>;
+
+  // User management
+  updateScanStatus: (status: boolean) => void;
+  refreshUser: (userData: UserData) => void;
+
+}
+
+export const AuthContext = createContext<AuthContextType | null>(null);
+
+export interface AuthProviderProps {
+  children: ReactNode;
+  authService: AuthService;
+  authCallbacks?: AuthCallbacks;
+}
+
+export function AuthProvider({ children, authService, authCallbacks }: AuthProviderProps) {
+  const dispatch = useAppDispatch();
+
+  useEffect(() => {
+    // Initialize auth state from localStorage
+    dispatch(initializeFromStorage());
+
+    // Set up auth state listener
+    const unsubscribe = authService.onAuthStateChanged((user) => {
+      if (user) {
+        dispatch(signInAction(user));
+
+        // Use auth callback for user identification
+        if (authCallbacks?.onUserIdentify && user.email) {
+          authCallbacks.onUserIdentify({
+            email: user.email,
+            name: user.displayName,
+            avatar: user.avatar,
+            uid: user.uid,
+          });
+        }
+
+        // Notify about successful sign in
+        if (authCallbacks?.onSignInSuccess) {
+          authCallbacks.onSignInSuccess(user);
+        }
+      } else {
+        dispatch(signOutAction());
+
+        // Use auth callback for reset
+        if (authCallbacks?.onTrackingReset) {
+          authCallbacks.onTrackingReset();
+        }
+      }
+      dispatch(setPending(false));
+    });
+
+    return () => {
+      unsubscribe();
+    };
+  }, [authService, dispatch, authCallbacks]);
+
+  // Redux selectors
+  const user = useAppSelector(selectUser);
+  const isSignedIn = useAppSelector(selectIsSignedIn);
+  const isLoading = useAppSelector(selectIsLoading);
+
+  // Auth actions with auth callbacks
+  const signInWithCredential = async (email: string, password: string): Promise<AuthResponse> => {
+    const result = await authService.signInWithEmailAndPassword(email, password);
+
+    if (result.data && authCallbacks?.onSignInSuccess) {
+      authCallbacks.onSignInSuccess(result.data);
+    } else if (result.errorCode && authCallbacks?.onSignInError) {
+      authCallbacks.onSignInError(result.errorCode);
+    }
+
+    return result;
+  };
+
+  const signInWithGoogle = async (): Promise<AuthResponse | null> => {
+    const result = await authService.signInWithGoogle();
+
+    if (result.data && authCallbacks?.onSignInSuccess) {
+      authCallbacks.onSignInSuccess(result.data);
+      return result;
+
+    } else if (result.errorCode && authCallbacks?.onSignInError) {
+      authCallbacks.onSignInError(result.errorCode);
+    }
+
+    return null;
+  };
+
+  const signUp = async (email: string, password: string): Promise<AuthResponse> => {
+    const result = await authService.signUp(email, password);
+
+    if (result.data && authCallbacks?.onSignUpSuccess) {
+      authCallbacks.onSignUpSuccess(result.data);
+    } else if (result.errorCode && authCallbacks?.onSignUpError) {
+      authCallbacks.onSignUpError(result.errorCode);
+    }
+
+    return result;
+  };
+
+  const signOut = async (): Promise<void> => {
+    await authService.signOut();
+    dispatch(signOutAction());
+
+    if (authCallbacks?.onSignOutSuccess) {
+      authCallbacks.onSignOutSuccess();
+    }
+  };
+
+  // Password actions
+  const forgotPassword = async (email: string): Promise<void> => {
+    return await authService.sendPasswordResetEmail(email);
+  };
+
+  const sendEmailVerification = async (): Promise<void> => {
+    return await authService.sendEmailVerification();
+  };
+
+  const changePassword = async (newPassword: string): Promise<void> => {
+    return await authService.changePassword(newPassword);
+  };
+
+  // User management
+  const updateScanStatus = (status: boolean): void => {
+    dispatch(updateScanStatusAction(status));
+  };
+
+  const refreshUser = (userData: UserData): void => {
+    dispatch(refreshUserAction(userData));
+  };
+
+  const contextValue: AuthContextType = {
+    authService,
+    authCallbacks,
+    // User state
+    user,
+    isSignedIn,
+    isLoading,
+
+    // Auth actions
+    signInWithCredential,
+    signInWithGoogle,
+    signUp,
+    signOut,
+
+    // Password actions
+    forgotPassword,
+    sendEmailVerification,
+    changePassword,
+
+    // User management
+    updateScanStatus,
+    refreshUser,
+  };
+
+  return (
+    <AuthContext.Provider value={contextValue}>
+      {children}
+    </AuthContext.Provider>
+  );
+}
+
+export const useAuth = () => {
+  const authContext = useContext(AuthContext);
+  if (!authContext) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+
+  return authContext;
+};

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

@@ -0,0 +1 @@
+export * from './AuthProvider';