@phygitallabs/tapquest-core 2.7.0 → 2.9.0

package/src/modules/session-replay/types/index.ts

@@ -0,0 +1,147 @@
+/**
+ * OpenReplay Session Replay Types
+ *
+ * Type definitions for OpenReplay session replay configuration and options
+ */
+
+/**
+ * OpenReplay Configuration Options
+ */
+export interface OpenReplayConfig {
+    /**
+     * OpenReplay project key (required)
+     * Get this from your OpenReplay dashboard
+     */
+    projectKey?: string;
+
+    /**
+     * Custom ingest endpoint URL (optional)
+     * For self-hosted OpenReplay instances
+     */
+    ingestPoint?: string;
+
+    /**
+     * Enable user ID tracking (optional)
+     * When enabled, the tracker will automatically set user IDs
+     * @default false
+     */
+    userIdEnabled?: boolean;
+
+    /**
+     * Custom function to get user ID (optional)
+     * If not provided and userIdEnabled is true, a UUID will be generated
+     */
+    getUserId?: () => string;
+
+    /**
+     * Enable debug mode (optional)
+     * Shows debug logs in console when enabled
+     * @default false
+     */
+    debug?: boolean;
+
+    /**
+     * Capture exceptions automatically (optional)
+     * @default true
+     */
+    captureExceptions?: boolean;
+
+    /**
+     * Capture performance metrics (optional)
+     * @default true
+     */
+    capturePerformance?: boolean;
+
+    /**
+     * Network tracking options (optional)
+     */
+    network?: {
+        /**
+         * Capture network payload data
+         * @default true
+         */
+        capturePayload?: boolean;
+
+        /**
+         * Sanitizer function for network data
+         * Use this to redact sensitive information
+         */
+        sanitizer?: (data: any) => any;
+    };
+
+    /**
+     * Console log tracking options (optional)
+     */
+    console?: {
+        /**
+         * Console log levels to capture
+         * @default ["error", "warn", "log"]
+         */
+        levels?: Array<"error" | "warn" | "log" | "info" | "debug">;
+    };
+
+    /**
+     * Privacy settings
+     */
+    obscureTextEmails?: boolean;
+    obscureTextNumbers?: boolean;
+    obscureInputEmails?: boolean;
+
+    /**
+     * Disable secure mode (for development)
+     * @default false in production, true in development
+     */
+    __DISABLE_SECURE_MODE?: boolean;
+}
+
+/**
+ * Session Replay Provider Props
+ */
+export interface SessionReplayProviderProps {
+    children: React.ReactNode;
+    config?: OpenReplayConfig;
+}
+
+/**
+ * Tracker State
+ * Internal state for the tracker context reducer
+ */
+export interface TrackerState {
+    tracker: any | null;
+    config: OpenReplayConfig;
+}
+
+/**
+ * Tracker Actions
+ */
+export type TrackerAction =
+    | { type: "init" }
+    | { type: "start" }
+    | { type: "setUserId"; payload: string }
+    | { type: "setMetadata"; payload: Record<string, any> };
+
+/**
+ * Tracker Context Value
+ * Methods available through the TrackerContext
+ */
+export interface TrackerContextValue {
+    /**
+     * Initialize the OpenReplay tracker
+     * Must be called before startTracking
+     */
+    initTracker: () => void;
+
+    /**
+     * Start tracking the session
+     * Must call initTracker first
+     */
+    startTracking: () => void;
+
+    /**
+     * Set or update the user ID for the current session
+     * @param userId - The user ID to set
+     */
+    setUserId: (userId: string) => void;
+
+    setMetadata: (metadata: Record<string, any>) => void;
+}

package/src/modules/session-replay/utils/index.ts

@@ -0,0 +1,12 @@
+import { getDeviceUid } from "../../auth/helpers";
+
+export const getSessionUserId = (userId?: string): string | null => {
+    if (userId) {
+        return userId;
+    }
+    return getDeviceUid();
+};
+
+export const isBrowser = (): boolean => {
+    return typeof window !== "undefined";
+};

package/src/providers/ServicesProvider.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState, useMemo } from "react";
+import React, { useEffect, useState } from "react";
 import { QueryClient } from "@tanstack/react-query";
 import { PGLCoreServiceProvider } from "@phygitallabs/api-core";
 import { RewardServiceProvider } from "@phygitallabs/reward";
@@ -8,13 +8,7 @@ import { GenerateCertificateServiceProvider } from "@phygitallabs/generate-certi
 import serviceApiUrl from "../constants/service";
 import { APIConfig, ServiceConfig } from "../types/service";
 
-import { checkDeviceUid, getAccessToken, getRetryAttemptsRefreshToken, setRetryAttemptsRefreshToken, createRefreshTokenFunction } from "../modules/auth/helpers";
-
-import { httpMaxRetries } from "../modules/auth";
-
-import { useAuth } from "../modules/auth";
-
-import axios from "axios";
+import { checkDeviceUid } from "../modules/auth/helpers";
 
 interface ServicesProviderProps {
     children: React.ReactNode;
@@ -30,23 +24,10 @@ export const ServicesProvider: React.FC<ServicesProviderProps> = ({
         environment: "dev",
         version: "v1"
     },
-    firebaseConfig
 }) => {
-    const { refreshUser, signOut } = useAuth();
     const { environment, version } = apiConfig;
     const [commonServiceConfig, setCommonServiceConfig] = useState<ServiceConfig | null>(null);
 
-    // Create memoized refresh token function
-    const memoizedRefreshToken = useMemo(() => {
-        if (!firebaseConfig?.apiKey) {
-            console.warn("Firebase API key not provided, refresh token functionality will not work");
-            return null;
-        }
-        return createRefreshTokenFunction({
-            firebaseApiKey: firebaseConfig.apiKey
-        });
-    }, [firebaseConfig?.apiKey]);
-
     // Init client
     useEffect(() => {
         const initClient = async () => {
@@ -55,64 +36,11 @@ export const ServicesProvider: React.FC<ServicesProviderProps> = ({
 
                 const responseInterceptors = ({
                     onFulfilled: (response: any) => response,
-                    onRejected: async (error: any) => {
-
-                        // TODO: Remove
-                        // Feature: use refresh token to get new access token when token expired, have maximum `retry attempts`
-                        const originalRequest = error.config;
-
-                        if (error.response?.status === 401 && !originalRequest._retry) {
-                            const retryAttempts = parseInt(
-                                getRetryAttemptsRefreshToken() || "0",
-                                10
-                            );
-
-                            if (retryAttempts >= httpMaxRetries) {
-                                await signOut();
-                                return Promise.reject(error);
-                            }
-
-                            setRetryAttemptsRefreshToken(`${retryAttempts + 1}`);
-                            originalRequest._retry = true;
-
-                            try {
-                                if (!memoizedRefreshToken) {
-                                    await signOut();
-                                    return Promise.reject(error);
-                                }
-
-                                const result = await memoizedRefreshToken();
-
-                                if (result?.accessToken) {
-                                    originalRequest.headers[
-                                        "Authorization"
-                                    ] = `Bearer ${result.accessToken}`;
-
-                                    setRetryAttemptsRefreshToken("0");
-                                    
-                                    refreshUser(result);
-
-                                    return axios(originalRequest);
-                                }
-                            } catch (refreshError) {
-                                console.log("Failed to refresh token:", refreshError);
-                            }
-                        }
-
-                        return Promise.reject(error);
-                    },
+                    onRejected:  async (error: any) => Promise.reject(error),
                 })
 
                 const requestInterceptors = ({
-                    onFulfilled: (config: any) => {
-                        // Feature: set access token to request header
-                        const currentToken = getAccessToken();
-
-                        if (currentToken && !config.headers.Authorization) {
-                            config.headers.Authorization = `Bearer ${currentToken}`;
-                        }
-                        return config;
-                    },
+                    onFulfilled: (config: any) => config,
                     onRejected: (error: any) => Promise.reject(error),
                 })
 

package/src/providers/TapquestCoreProvider.tsx

@@ -1,64 +1,59 @@
 import React, { useMemo } from "react";
-import { Provider } from "react-redux";
-import { PersistGate } from "redux-persist/integration/react";
 
 import { ServicesProvider } from "./ServicesProvider";
 import { APIConfig } from "../types/service";
 import { QueryClient } from "@tanstack/react-query";
 
-import { store, persistor } from "../store";
-import { AuthCallbacks } from "../modules/auth/types";
-import { AuthProvider } from "../modules/auth/providers";
-import { FirebaseConfig } from "../modules/auth/types";
+import { AuthProvider } from "../modules/auth";
+import serviceApiUrl from "../constants/service";
+import { OpenReplayConfig, SessionReplayProvider } from "../modules/session-replay";
 
 interface TapquestCoreProviderProps {
   children: React.ReactNode;
   queryClient: QueryClient;
   apiConfig: APIConfig;
-  firebaseConfig?: FirebaseConfig;
-  authCallbacks?: AuthCallbacks;
 }
 
 export const TapquestCoreProvider: React.FC<TapquestCoreProviderProps> = ({
   children,
   queryClient,
   apiConfig,
-  firebaseConfig,
-  authCallbacks
+  // authCallbacks
 }) => {
+  const { environment } = apiConfig;
 
-  const internalAuthService = useMemo(() => {
-    if (firebaseConfig && typeof window !== "undefined") {
-      try {
-        // Dynamic import to avoid loading Firebase modules during build
-        const { createAuthService } = require("../modules/auth/services");
-        return createAuthService({ firebaseConfig });
-      } catch (error) {
-        console.warn("Failed to create auth service from firebase config:", error);
-        return null;
-      }
+  const sessionReplayConfig: OpenReplayConfig | undefined = useMemo(() => {
+    const projectKey = process.env.NEXT_PUBLIC_OPENREPLAY_PROJECT_KEY;
+
+    // Only configure if project key is provided
+    if (!projectKey) {
+      return undefined;
     }
 
-    return null;
-  }, [firebaseConfig]);
+    return {
+      projectKey,
+      ingestPoint: process.env.NEXT_PUBLIC_OPENREPLAY_INGEST_POINT,
+      debug: process.env.NODE_ENV === "development",
+      captureExceptions: true,
+      capturePerformance: true,
+      obscureTextEmails: true,
+      obscureInputEmails: true,
+    };
+  }, []);
 
   return (
-    <Provider store={store}>
-      <PersistGate loading={null} persistor={persistor}>
+    <SessionReplayProvider config={sessionReplayConfig}>
+      <ServicesProvider
+        queryClient={queryClient}
+        apiConfig={apiConfig}
+      >
         <AuthProvider
-          authService={internalAuthService}
-          authCallbacks={authCallbacks}
+          baseURL={`${serviceApiUrl[environment].API_BASE_URL}`}
+          queryClient={queryClient}
         >
-          <ServicesProvider
-            queryClient={queryClient}
-            apiConfig={apiConfig}
-            firebaseConfig={firebaseConfig}
-          >
-            {children}
-          </ServicesProvider>
+          {children}
         </AuthProvider>
-
-      </PersistGate>
-    </Provider>
+      </ServicesProvider>
+    </SessionReplayProvider>
   );
 };

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

@@ -1,63 +0,0 @@
-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/store/authSlice.ts

@@ -1,137 +0,0 @@
-import { createSlice, PayloadAction } from "@reduxjs/toolkit";
-import { UserData, UserRole } from "../types";
-import {
-  setUserInfo,
-  removeUserInfo,
-  getUserInfo,
-  setAccessToken,
-  setRefreshToken,
-  removeAccessToken,
-  removeRefreshToken,
-  getAccessToken,
-} from "../helpers";
-
-const defaultUser: UserData = {
-  uid: "",
-  id: "",
-  userName: "",
-  displayName: "",
-  avatar: "/images/default-avatar.jpg",
-  email: "",
-  exp: 0,
-  emailVerified: false,
-  refreshToken: "",
-  accessToken: "",
-  role: UserRole.NULL,
-  scanStatus: false,
-};
-
-export interface AuthState {
-  user: UserData;
-  isSignedIn: boolean;
-  pending: boolean;
-}
-
-const initialState: AuthState = {
-  user: defaultUser,
-  isSignedIn: false,
-  pending: true,
-};
-
-export const authSlice = createSlice<
-  AuthState,
-  {
-    signIn: (state: AuthState, action: PayloadAction<UserData>) => void;
-    signOut: (state: AuthState) => void;
-    updateScanStatus: (state: AuthState, action: PayloadAction<boolean>) => void;
-    refreshUser: (state: AuthState, action: PayloadAction<UserData>) => void;
-    setPending: (state: AuthState, action: PayloadAction<boolean>) => void;
-    initializeFromStorage: (state: AuthState) => void;
-  },
-  'auth'
->({
-  name: "auth",
-  initialState,
-  reducers: {
-    signIn: (state, action: PayloadAction<UserData>) => {
-      const userData = action.payload;
-      state.user = userData;
-      state.isSignedIn = true;
-      state.pending = false;
-
-      // Store in localStorage for persistence
-      setUserInfo(userData);
-      setAccessToken(userData.accessToken);
-      setRefreshToken(userData.refreshToken);
-    },
-    signOut: (state) => {
-      state.user = defaultUser;
-      state.isSignedIn = false;
-      state.pending = false;
-
-      // Clear localStorage
-      removeUserInfo();
-      removeAccessToken();
-      removeRefreshToken();
-    },
-    updateScanStatus: (state, action: PayloadAction<boolean>) => {
-      state.user.scanStatus = action.payload;
-
-      // Update localStorage
-      setUserInfo(state.user);
-    },
-    refreshUser: (state, action: PayloadAction<UserData>) => {
-      const userData = action.payload;
-      if (userData) {
-        state.user = userData;
-        state.isSignedIn = true;
-        state.pending = false;
-
-        // Update localStorage
-        setUserInfo(userData);
-        setAccessToken(userData.accessToken);
-        setRefreshToken(userData.refreshToken);
-      }
-    },
-    setPending: (state, action: PayloadAction<boolean>) => {
-      state.pending = action.payload;
-    },
-    initializeFromStorage: (state) => {
-      const storedUser = getUserInfo();
-      const accessToken = getAccessToken();
-
-      if (storedUser && accessToken) {
-        state.user = storedUser;
-        state.isSignedIn = true;
-      }
-      state.pending = false;
-    },
-  },
-});
-
-export const {
-  signIn,
-  signOut,
-  updateScanStatus,
-  refreshUser,
-  setPending,
-  initializeFromStorage,
-} = authSlice.actions;
-
-// Selectors
-export const selectAuth = (state: any) => state.auth;
-export const selectUser = (state: any) => state.auth.user;
-export const selectUserUId = (state: any) =>
-  state.auth.user.uid || state.auth.user.id;
-export const selectUserAccesstoken = (state: any) =>
-  state.auth.user.accessToken;
-export const selectUserEmail = (state: any) => state.auth.user.email;
-export const selectUsername = (state: any) => state.auth.user.userName;
-export const selectSignInProvider = (state: any) =>
-  state.auth.user.signInProvider;
-export const selectUserScanStatus = (state: any) =>
-  state.auth.user.scanStatus;
-export const selectIsSignedIn = (state: any) => state.auth.isSignedIn;
-export const selectIsLoading = (state: any) => state.auth.pending;
-
-export default authSlice.reducer;