@ordentco/addons-auth-provider 0.9.135 → 0.9.136-mfe

package/src/auth.tsx

@@ -1,32 +1,40 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {createContext, useCallback, useContext, useMemo, useState, SetStateAction, useEffect, useRef} from "react";
-import { useRouter } from "next/router";
-import {AuthService} from "../services";
-// import { message } from "antd";
+import concat from "lodash/concat";
+import get from "lodash/get";
+import mergeWith from "lodash/mergeWith";
+import snakeCase from "lodash/snakeCase";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
 import { IdleTimerProvider } from "react-idle-timer";
-import { createProductAuthorities } from "../utils/auth";
+import { AuthService } from "../services";
 import {
   AuthorityLevelEnum,
   ChangePasswordType,
   ForgotPasswordType,
+  MultipaymentAuthorityEnum,
   ProductAuthoritiesType,
   ProductAuthorityType,
-  VerifyUserQuestion,
   ProductTypeEnum,
-  TransactionWorkflow,
-  MultipaymentAuthorityEnum,
+  StepType,
   TaskStatus,
-  StepType
+  TransactionWorkflow,
+  VerifyUserQuestion,
 } from "../types";
-// import { ArgsProps } from "antd/lib/message";
-import mergeWith from "lodash/mergeWith";
-import concat from "lodash/concat";
-import get from "lodash/get";
-import snakeCase from "lodash/snakeCase";
+import type { AuthRouter } from "./types/router";
+import { createProductAuthorities } from "../utils/auth";
 import { isEmpty } from "../utils/is-empty";
-// import {AxiosInstance} from "axios";
+import { OnboardingTourStatus } from "./types/onboarding";
 
 const FIFTEEN_MINUTES = 15 * 60 * 1000;
+const SESSION_VALIDITY_MS = 5 * 60 * 1000; // 5 minutes
+
+const initialProductAuthorities = createProductAuthorities();
 
 export enum UserType {
   BankAdmin = "bank-admin",
@@ -34,8 +42,6 @@ export enum UserType {
   CustomerUser = "customer-user",
 }
 
-const initialProductAuthorities = createProductAuthorities();
-
 interface AuthContextProps {
   token: string | null;
   authorities: Map<string, string[]>;
@@ -50,43 +56,74 @@ interface AuthContextProps {
   companyName: string;
   userMode: string;
   companyLevel: string;
+  isIntraday: boolean;
   userID: string | null;
   roleID: string | null;
   roleIDs: string[] | null;
   holdingID: string | null;
   isLoading: boolean | null;
+  onboardingTourStatus: OnboardingTourStatus;
   guard: () => void;
-  passwordLogin: (username: string, password: string, tokenFCM: string) => Promise<void>;
+  passwordLogin: (
+    username: string,
+    password: string,
+    tokenFCM: string
+  ) => Promise<void>;
   ssoLogin: (
     userId: string,
     sessionId: string,
     dtTime: string,
     onError?: (errorMessage: string) => void
   ) => Promise<void>;
-  logout: (type?:string) => Promise<void>;
-  canIApprove: (workflow: TransactionWorkflow.Root, status?:TaskStatus) => boolean;
+  logout: (type?: string) => Promise<void>;
+  canIApprove: (
+    workflow: TransactionWorkflow.Root,
+    status?: TaskStatus
+  ) => boolean;
   canIDelete: (product: string, status: TaskStatus) => boolean;
-  canIEdit: (workflow: TransactionWorkflow.Root, product : string, status: TaskStatus) => boolean;
+  canIEdit: (
+    workflow: TransactionWorkflow.Root,
+    product: string,
+    status: TaskStatus
+  ) => boolean;
   menuData: any[];
-  ssoQlolaLogin: (
-    request: string
-  ) => Promise<void>;
+  ssoQlolaLogin: (request: string) => Promise<void>;
   verifyUserQuestion: (payload: VerifyUserQuestion) => Promise<void>;
   verifyChangePasswordToken: (token: string) => Promise<void>;
   forgotPassword: (payload: ForgotPasswordType) => Promise<void>;
-  login: (username: string, password: string, branchCode: string, type?:string) => Promise<void>;
-  checkToChangePassword: (username: string, password: string, tokenFCM: string, branchCode: string) => Promise<void>;
-  passwordLoginWithCheck: (username: string, password: string, tokenFCM: string, branchCode: string) => Promise<void>;
+  login: (
+    username: string,
+    password: string,
+    branchCode: string,
+    type?: string
+  ) => Promise<void>;
+  checkToChangePassword: (
+    username: string,
+    password: string,
+    tokenFCM: string,
+    branchCode: string
+  ) => Promise<void>;
+  passwordLoginWithCheck: (
+    username: string,
+    password: string,
+    tokenFCM: string,
+    branchCode: string
+  ) => Promise<void>;
   requestChangePassword: (payload: ChangePasswordType) => Promise<void>;
-  action : any;
-  onLeaveAction : any;
-  setOnLeaveAction : any;
-  countryCode:string;
-  setToken: (value: (((prevState: (string | null)) => (string | null)) | string | null)) => void;
-  setIsLoading:  (value: (((prevState: boolean) => boolean) | boolean)) => void;
-  companyCode : string;
-  region : string;
-  checkToken : () => Promise<void>;
+  action: any;
+  onLeaveAction: any;
+  setOnLeaveAction: any;
+  countryCode: string;
+  setToken: (
+    value: ((prevState: string | null) => string | null) | string | null
+  ) => void;
+  setUserType: (
+    value: ((prevState: string | null) => string | null) | string | null
+  ) => void;
+  setIsLoading: (value: ((prevState: boolean) => boolean) | boolean) => void;
+  companyCode: string;
+  region: string;
+  checkToken: () => Promise<void>;
 }
 
 const AUTH_INITIAL_VALUES: AuthContextProps = {
@@ -101,74 +138,80 @@ const AUTH_INITIAL_VALUES: AuthContextProps = {
   companyName: "",
   userMode: "",
   companyLevel: "",
+  onboardingTourStatus: OnboardingTourStatus.Done,
   userID: null,
   roleID: null,
   roleIDs: null,
   holdingID: null,
   isLoading: false,
+  isIntraday: false,
   menus: [],
   loggedIn: false,
-  guard: function (): void {
+  guard: () => {
+    throw new Error("Function not implemented.");
+  },
+  passwordLogin: async () => {
     throw new Error("Function not implemented.");
   },
-  passwordLogin: function (_: string, __: string, ___: string): Promise<void> {
+  ssoLogin: async () => {
     throw new Error("Function not implemented.");
   },
-  ssoLogin: function (_: string, __: string, ___: string): Promise<void> {
+  logout: async () => {
     throw new Error("Function not implemented.");
   },
-  logout: function (_:string): Promise<void> {
+  canIApprove: () => {
     throw new Error("Function not implemented.");
   },
-  canIApprove: function (_workflow : TransactionWorkflow.Root, _status?:TaskStatus): boolean {
+  canIDelete: () => {
+    throw new Error("Function not implemented.");
+  },
+  canIEdit: () => {
     throw new Error("Function not implemented.");
   },
   menuData: [],
-  verifyUserQuestion: function (_payloa: VerifyUserQuestion): Promise<void> {
+  ssoQlolaLogin: async () => {
     throw new Error("Function not implemented.");
   },
-  verifyChangePasswordToken: function (_token: string): Promise<void> {
+  verifyUserQuestion: async () => {
     throw new Error("Function not implemented.");
   },
-  ssoQlolaLogin: function (_: string): Promise<void> {
+  verifyChangePasswordToken: async () => {
     throw new Error("Function not implemented.");
   },
-  login: function (_: string, __: string, ___: string, ____:string): Promise<void> {
+  forgotPassword: async () => {
     throw new Error("Function not implemented.");
   },
-  forgotPassword: function (_payload: ForgotPasswordType): Promise<void> {
+  login: async () => {
     throw new Error("Function not implemented.");
   },
-  checkToChangePassword: function (_: string, __: string, ___: string, ____: string): Promise<void> {
+  checkToChangePassword: async () => {
     throw new Error("Function not implemented.");
   },
-  passwordLoginWithCheck: function (_: string, __: string, ___: string, ____: string): Promise<void> {
+  passwordLoginWithCheck: async () => {
     throw new Error("Function not implemented.");
   },
-  requestChangePassword: function (_payload: ChangePasswordType): Promise<void> {
+  requestChangePassword: async () => {
     throw new Error("Function not implemented.");
   },
-  canIDelete: function (_product: string, _status: TaskStatus): boolean {
+  action: null,
+  onLeaveAction: null,
+  setOnLeaveAction: null,
+  countryCode: "",
+  setToken: () => {
     throw new Error("Function not implemented.");
   },
-  canIEdit: function (_workflow: TransactionWorkflow.Root, _product:string, _status: TaskStatus): boolean {
+  setIsLoading: () => {
     throw new Error("Function not implemented.");
   },
-  setIsLoading: function (_payload: SetStateAction<boolean>): Promise<void> {
+  setUserType: () => {
     throw new Error("Function not implemented.");
   },
-  setToken: function (_payload: SetStateAction<string | null>): Promise<void> {
+  companyCode: "",
+  region: "",
+
+  checkToken: async () => {
     throw new Error("Function not implemented.");
   },
-  action : null,
-  onLeaveAction : null,
-  setOnLeaveAction : null,
-  countryCode : "",
-  companyCode : "",
-  region : "",
-  checkToken : function () : Promise<void> {
-    throw new Error("Function not implemented");
-  }
 };
 
 // export const getStaticProps:GetStaticProps<{}> = async () => {
@@ -180,26 +223,49 @@ const AuthContext = createContext(AUTH_INITIAL_VALUES);
 export interface AuthProviderProps {
   children?: React.ReactNode;
   cookieName?: string;
-  apiUrl : string
+  apiUrl: string;
+  router: AuthRouter;
+  loginRoute?: string;
+  baseRoute?: string;
 }
 
-export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl }) => {
-  const router = useRouter();
+export const noopRouter: AuthRouter = {
+  push: () => {},
+  replace: () => {},
+  basePath: "",
+  asPath: "",
+  events: {
+    on: () => {},
+    off: () => {},
+  },
+};
+
+export const AuthProvider: React.FC<AuthProviderProps> = ({
+  children,
+  apiUrl,
+  router = noopRouter,
+  loginRoute = "/main-page",
+  baseRoute = "/",
+}) => {
   const [token, setToken] = useState<string | null>(() => {
     if (typeof window !== "undefined") {
-      const t = localStorage.getItem("access-token");
-      return t;
+      return localStorage.getItem("access-token");
     }
     return null;
   });
+
   const authService = useMemo(() => AuthService(), [apiUrl, token]);
-  const [authorities, setAuthorities] = useState<Map<string, string[]>>(new Map());
+  const [authorities, setAuthorities] = useState<Map<string, string[]>>(
+    () => new Map()
+  );
   const [username, setUsername] = useState<string>("Guest");
   const [userType, setUserType] = useState<string | null>(null);
   const [companyID, setCompanyID] = useState<string | null>(null);
   const [companyName, setCompanyName] = useState("");
   const [userMode, setUserMode] = useState<string>("");
   const [companyLevel, setCompanyLevel] = useState<string>("");
+  const [onboardingTourStatus, setOnboardingTourStatus] =
+    useState<OnboardingTourStatus>(OnboardingTourStatus.Done);
   const [userID, setUserID] = useState<string | null>(null);
   const [roleID, setRoleID] = useState<string | null>(null);
   const [roleIDs, setRoleIDs] = useState<string[]>([]);
@@ -208,9 +274,14 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
   const [_openModal, setOpenModal] = useState<boolean>(false);
   const [menus, setMenus] = useState<string[]>([]);
   const [isMinutes, setIsMinutes] = useState<number>(FIFTEEN_MINUTES);
+  const [isIntraday, setIsIntraday] = useState<boolean>(false);
   const [isLoading, setIsLoading] = useState<boolean>(false);
-  const [productAuthorities, setProductAuthorities] = useState<ProductAuthoritiesType>(initialProductAuthorities);
+  const [productAuthorities, setProductAuthorities] =
+    useState<ProductAuthoritiesType>(initialProductAuthorities);
   const [isAuthoritiesReady, setIsAuthoritiesReady] = useState(false);
+  const [sessionLastValidatedAt, setSessionLastValidatedAt] = useState<
+    number | null
+  >(null);
   const [menuData, setMenuData] = useState<any>([]);
   const [action, _setAction] = useState<any>({});
   const [onLeaveAction, setOnLeaveAction] = useState<any>({});
@@ -222,35 +293,60 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
   const loggedIn = useMemo(() => !!token, [token]);
 
   const guard = useCallback(async () => {
-    if (token) {
+    // Session Freshness Check
+    if (
+      sessionLastValidatedAt &&
+      Date.now() - sessionLastValidatedAt < SESSION_VALIDITY_MS
+    ) {
+      // Ensure authorities are marked as ready if the router reset them
+      if (!isAuthoritiesReady) setIsAuthoritiesReady(true);
+      return; // The context is fresh, so we exit immediately.
+    }
+
+    // No Token Check
+    if (!token) {
+      router.push(loginRoute);
+      return;
+    }
+
+    // --- Start Validation Flow ---
       setIsAuthoritiesReady(false);
-      let response:any;
+
+      let response: any;
+
       try {
         response = await authService.validateToken();
-      }
-      catch (error:any){
-        const agent = typeof window !== "undefined" && localStorage.getItem("agent");
-        if(agent === "qlola" && ![200].includes(error?.response?.data?.code || error?.response?.status)){
+      } catch (error: any) {
+        const agent =
+          typeof window !== "undefined" && localStorage.getItem("agent");
+        if (
+          agent === "qlola" &&
+        ![200].includes(error?.response?.data?.code || error?.response?.status)
+        ) {
           localStorage.removeItem("access-token");
           localStorage.removeItem("refresh-token");
 
           setToken(() => null);
+
+          setSessionLastValidatedAt(null);
           return window.close();
         }
         console.log({ error });
-        response = error
+        response = error;
       }
       const menu = await authService.validateMenu(token);
 
       if (menu.data.code !== 200 || !menu) setAlertMenuError(true);
 
-      const newMenuData = get(menu, 'data.data', [])
-      const newMenus = newMenuData.filter((item: any) => item.productName !== "").map((item: any) => item.productName)
+      const newMenuData = get(menu, "data.data", []);
+      const newMenus = newMenuData
+        .filter((item: any) => item.productName !== "")
+        .map((item: any) => item.productName);
       setMenus(newMenus);
       setMenuData(newMenuData);
 
-      if(response.status === 401) {
-        if(typeof  window !== "undefined") {
+      if (response.status === 401) {
+        if (typeof window !== "undefined") {
           const refreshToken = localStorage.getItem("refresh-token");
           if (refreshToken) {
             const refresh = await authService.refreshToken(refreshToken);
@@ -269,13 +365,18 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
 
         setToken(() => null);
 
-        router.push("/main-page?logout=true");
+        setSessionLastValidatedAt(null);
+
+        router?.push(`${loginRoute}?logout=true`);
 
         return;
       }
-      if(response?.data){
-        const {username, companyCode, userID, companyID} = response.data
-        localStorage.setItem("login", `${username}-${companyCode}-${userID}-${companyID}`);
+      if (response?.data) {
+        const { username, companyCode, userID, companyID } = response.data;
+        localStorage.setItem(
+          "login",
+          `${username}-${companyCode}-${userID}-${companyID}`
+        );
       }
       setRoleID(() => response.data.roleIDs[0]);
       setRoleIDs(() => response.data.roleIDs);
@@ -289,7 +390,11 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
       setCompanyCode(() => response?.data?.companyCode || "");
       setRegion(() => response.data.region || "");
       setUserMode(() => response.data?.userMode || "");
-      setCompanyLevel(() => response?.data?.companyLevel || "")
+      setCompanyLevel(() => response?.data?.companyLevel || "");
+      setIsIntraday(() => response?.data?.isIntraday || false);
+      setOnboardingTourStatus(
+        () => response?.data?.onboardingTourStatus || OnboardingTourStatus.Done
+      );
 
       const a = new Map<string, Array<string>>();
       const productRoles = response.data?.productRoles || [];
@@ -304,8 +409,10 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
       const privilegesRecords = { ...productAuthorities } as any;
 
       // use dynamic product roles! do not use hardcode!
-      const productTypeEnumValuesFromProductRoles = Array.from(a.keys())
-      const productTypeEnumValuesFromHardcode = Array.from(Object.values(ProductTypeEnum))
+      const productTypeEnumValuesFromProductRoles = Array.from(a.keys());
+      const productTypeEnumValuesFromHardcode = Array.from(
+        Object.values(ProductTypeEnum)
+      );
       const remainingProductTypeEnum = [
         productTypeEnumValuesFromProductRoles,
         productTypeEnumValuesFromHardcode,
@@ -315,7 +422,10 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
       const productTypeEnumKeyFromProductRoles = remainingProductTypeEnum.map(
         (item) => [snakeCase(item).toUpperCase(), item]
       ); // from product roles that not define by hardcode
-      const allProductTypeEnum = concat(productTypeEnumKeyFromHardcode, productTypeEnumKeyFromProductRoles);
+      const allProductTypeEnum = concat(
+        productTypeEnumKeyFromHardcode,
+        productTypeEnumKeyFromProductRoles
+      );
 
       // FIXME: delete this logic beacuse expose all product, need to get from variable productRoles / a!
       allProductTypeEnum.forEach(([productKey, productValue]) => {
@@ -328,50 +438,68 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         });
 
         productAuthority["anyAuthority"] = productRole.length > 0;
-        productAuthority["allAuthority"] = productRole.length >= Object.entries(AuthorityLevelEnum).length;
+        productAuthority["allAuthority"] =
+          productRole.length >= Object.entries(AuthorityLevelEnum).length;
 
-        privilegesRecords[productKey] = productAuthority as ProductAuthorityType;
+      privilegesRecords[productKey] = productAuthority as ProductAuthorityType;
       });
+
       // Combine Authority All Product Multipayment
-      if(!isEmpty(newMenuData.find((item:any)=> item.productName === MultipaymentAuthorityEnum['create']))){
+      if (
+        !isEmpty(
+          newMenuData.find(
+            (item: any) =>
+              item.productName === MultipaymentAuthorityEnum["create"]
+          )
+        )
+      ) {
         const menuDataMultipaymentCreate = newMenuData.find(
-          (item: any) => item.productName === MultipaymentAuthorityEnum['create']
+        (item: any) => item.productName === MultipaymentAuthorityEnum["create"]
         );
         const menuDataMultipayment = newMenuData.filter(
           (item: any) => item.parentID === menuDataMultipaymentCreate.menuID
         );
-        const multipaymentProducts = menuDataMultipayment.map((item: any) => item["name"])
+        const multipaymentProducts = menuDataMultipayment.map(
+          (item: any) => item["name"]
+        );
         multipaymentProducts.map((item: any) => {
-          privilegesRecords['MULTIPAYMENT'] = mergeWith(
-            privilegesRecords['MULTIPAYMENT'],
+          privilegesRecords["MULTIPAYMENT"] = mergeWith(
+            privilegesRecords["MULTIPAYMENT"],
             privilegesRecords[snakeCase(item).toUpperCase()],
             (objValue, srcValue) => objValue || srcValue
-          )
-        })
+          );
+        });
       }
 
       setProductAuthorities(privilegesRecords);
       setIsAuthoritiesReady(true);
 
-      return;
-    }
-
-    router.push("/main-page");
+      setSessionLastValidatedAt(Date.now());
   }, [token, authService]);
 
-  const canIApprove = (workflow: TransactionWorkflow.Root, status?: TaskStatus) => {
+  const canIApprove = (
+    workflow: TransactionWorkflow.Root,
+    status?: TaskStatus
+  ) => {
     if (!workflow?.workflow) return false;
 
-    const { header, currentStep, records, currentRoleIDs = [], createdBy, participantUserIDs } = workflow.workflow;
+    const {
+      header,
+      currentStep,
+      records,
+      currentRoleIDs = [],
+      createdBy,
+      participantUserIDs,
+    } = workflow.workflow;
 
-    const isMaker = createdBy.userID == userID
+    const isMaker = createdBy.userID == userID;
     const product = header?.productName as unknown as ProductTypeEnum;
     if (!product) return false;
 
     const productKey = snakeCase(product).toUpperCase();
     if (!productKey) return false;
 
-    // @ts-ignore
+    // @ts-expect-error product authorities key is a enum keyof
     const authority = productAuthorities[productKey];
     if (!authority) return false;
 
@@ -396,23 +524,39 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
       ];
 
       const participant = participants.find(
-        (p) => roleIDs.includes(`${p.roleID}`) && p.step === currentStep && p.userName === username
+        (p) =>
+          roleIDs.includes(`${p.roleID}`) &&
+          p.step === currentStep &&
+          p.userName === username
       );
 
       alreadyApprove = !!participant?.approvedAt;
     }
 
-    if (participantUserIDs && participantUserIDs?.includes(userID as string)) return false;
+    if (participantUserIDs?.includes(userID as string)) return false;
 
-    if (Number(userID) === Number(createdBy.userID) && currentStep !== "releaser") return false;
+    if (
+      Number(userID) === Number(createdBy.userID) &&
+      currentStep !== "releaser"
+    )
+      return false;
 
     const isCanIApprove =
-      (approve && currentStep === StepType.Signer && roleAllowed && !alreadyApprove && !isMaker) ||
+      (approve &&
+        currentStep === StepType.Signer &&
+        roleAllowed &&
+        !alreadyApprove &&
+        !isMaker) ||
       (verify &&
-        (currentStep === StepType.Verifier || currentStep === StepType.Checker) &&
+        (currentStep === StepType.Verifier ||
+          currentStep === StepType.Checker) &&
         roleAllowed &&
-        !alreadyApprove && !isMaker) ||
-      (release && currentStep === StepType.Releaser && roleAllowed && !alreadyApprove);
+        !alreadyApprove &&
+        !isMaker) ||
+      (release &&
+        currentStep === StepType.Releaser &&
+        roleAllowed &&
+        !alreadyApprove);
 
     if (status) {
       return isCanIApprove && status === TaskStatus.Pending;
@@ -425,14 +569,18 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     const productKey = snakeCase(product).toUpperCase();
     if (!productKey) return false;
 
-    // @ts-ignore
+    // @ts-expect-error product authorities key is a enum keyof
     const authority = productAuthorities[productKey];
     if (!authority) return false;
 
     return status === TaskStatus.Draft && get(authority, "delete");
   };
 
-  const canIEdit = (workflow: TransactionWorkflow.Root, product: string, status: TaskStatus) => {
+  const canIEdit = (
+    workflow: TransactionWorkflow.Root,
+    product: string,
+    status: TaskStatus
+  ) => {
     let newProduct = product;
 
     if (status === TaskStatus.Returned) {
@@ -447,27 +595,37 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     const productKey = snakeCase(product).toUpperCase();
     if (!productKey) return false;
 
-    // @ts-ignore
+    // @ts-expect-error product authorities key is a enum keyof
     const authority = productAuthorities[productKey];
     if (!authority) return false;
 
     const modify = get(authority, "modify");
 
-    return (status === TaskStatus.Draft || status === TaskStatus.Returned) && modify;
+    return (
+      (status === TaskStatus.Draft || status === TaskStatus.Returned) && modify
+    );
   };
 
   const passwordLogin = useCallback(
-    async (username: string, password: string, tokenFCM: string): Promise<void> => {
+    async (
+      username: string,
+      password: string,
+      tokenFCM: string
+    ): Promise<void> => {
       setIsLoading(true);
       try {
-        const response = await authService.passwordLogin(username, password, tokenFCM);
+        const response = await authService.passwordLogin(
+          username,
+          password,
+          tokenFCM
+        );
 
         setToken(() => response.data.data.accessToken);
 
         localStorage.setItem("access-token", response.data.data.accessToken);
         localStorage.setItem("refresh-token", response.data.data.refreshToken);
 
-        router.push("/");
+        router.push(baseRoute);
       } catch (error) {
         // if (error instanceof Error) message.error(error.message);
       } finally {
@@ -509,7 +667,9 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         const response = await authService.ssoLogin(userId, sessionId, dtTime);
 
         if (response.status !== 200) {
-          if (response.status === 409) setOpenModal(true);
+          if (response.status === 409) {
+            setOpenModal(true);
+          }
           return;
         }
 
@@ -518,7 +678,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         localStorage.setItem("access-token", response.data.data.accessToken);
         localStorage.setItem("refresh-token", response.data.data.refreshToken);
 
-        router.push("/");
+        router.push(baseRoute);
       } catch (error: any) {
         if (onError) {
           onError(error.message || "Login failed");
@@ -528,37 +688,50 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     [authService, router]
   );
 
-  const logout = useCallback(async (path = "/main-page?logout=true") => {
-    try {
-      // await authService.logout();
-      // await authService.logoutSSO("CBM");
-    } catch (error) {
-      // Handle errors from logout if needed
-    } finally {
-      localStorage.removeItem("access-token");
-      localStorage.removeItem("refresh-token");
-      localStorage.removeItem("login");
-      localStorage.removeItem("productMenu");
-      localStorage.removeItem("validateMenu");
-      document.cookie = "loggedIn=true; max-age=0";
-      document.cookie = "accessToken=; max-age=0";
-      sessionStorage.clear();
-      router.push(path);
-      setToken(() => null);
-      setMenus(() => []);
-      setMenuData(() => []);
-      setAuthorities(() => new Map());
+  const logout = useCallback(
+    async (path = `${loginRoute}?logout=true`) => {
+      try {
+        // await authService.logout();
+        // await authService.logoutSSO("CBM");
+      } catch (error) {
+        // Handle errors from logout if needed
+      } finally {
+        localStorage.removeItem("access-token");
+        localStorage.removeItem("refresh-token");
+        localStorage.removeItem("login");
+        localStorage.removeItem("productMenu");
+        localStorage.removeItem("validateMenu");
+        document.cookie = "loggedIn=true; max-age=0";
+        document.cookie = "accessToken=; max-age=0";
+        sessionStorage.clear();
+        router.push(path);
+        setToken(() => null);
 
-    }
-  }, [authService, router]);
+        setSessionLastValidatedAt(null);
+        setMenus(() => []);
+        setMenuData(() => []);
+        setAuthorities(() => new Map());
+      }
+    },
+    [authService, router]
+  );
 
-  const checkToChangePassword = async (username: string, password: string, tokenFCM: string, branchCode: string): Promise<void> => {
+  const checkToChangePassword = async (
+    username: string,
+    password: string,
+    tokenFCM: string,
+    branchCode: string
+  ): Promise<void> => {
     setIsLoading(true);
     try {
-      const checks = await authService.checkToChangePasswordLogin(username, password, branchCode);
+      const checks = await authService.checkToChangePasswordLogin(
+        username,
+        password,
+        branchCode
+      );
       const result = checks?.data;
       if (result?.data?.IsRedirectToChangePassword) {
-        router.replace(`/main-page/change-password?branch=${branchCode}`);
+        router?.replace?.(`/main-page/change-password?branch=${branchCode}`);
       } else {
         passwordLogin(username, password, tokenFCM);
       }
@@ -569,7 +742,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         setIsLoading(false);
       }, 1000);
     }
-  }
+  };
 
   const requestChangePassword = useCallback(
     async ({ ...payload }: ChangePasswordType): Promise<any> => {
@@ -578,7 +751,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         const response = await authService.requestChangePassword(payload);
         if (payload.type !== "new-login") {
           // message.success(response.data.message);
-          router.replace(`/main-page`);
+          router?.replace?.(`/main-page`);
         }
         return response;
       } catch (error) {
@@ -592,36 +765,40 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     [authService, router]
   );
 
-  const forgotPassword = async ({ ...payload }: ForgotPasswordType): Promise<any> => {
+  const forgotPassword = async ({
+    ...payload
+  }: ForgotPasswordType): Promise<any> => {
     setIsLoading(true);
     try {
       const response = await authService.forgotPassword(payload);
-      if(payload.type === "new-login"){
+      if (payload.type === "new-login") {
         return response;
       }
       // message.success(response.data.message);
-      return router.replace(`/main-page`);
+      return router?.replace?.(`/main-page`);
     } catch (error) {
-      if(payload.type === "new-login"){
+      if (payload.type === "new-login") {
         return Promise.reject(error);
       }
       if (error instanceof Error) {
         // message.error(
         //   "The information you have provided is incorrect, please try again."
         // );
-      };
+      }
     } finally {
       setIsLoading(false);
     }
-  }
+  };
 
-  const verifyUserQuestion = async ({ ...payload }: VerifyUserQuestion): Promise<any> => {
+  const verifyUserQuestion = async ({
+    ...payload
+  }: VerifyUserQuestion): Promise<any> => {
     setIsLoading(true);
     try {
       const response = await authService.verifyUserQuestion(payload);
       return response;
     } catch (err: any) {
-      if(payload.type === "new-login"){
+      if (payload.type === "new-login") {
         return Promise.reject(err);
       }
       if (err.response.data.code === 404) {
@@ -631,7 +808,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     } finally {
       setIsLoading(false);
     }
-  }
+  };
 
   const verifyChangePasswordToken = useCallback(
     async (token: string): Promise<any> => {
@@ -641,29 +818,45 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         const response = await authService.verifyChangePasswordToken(payload);
         const { isValid } = response.data;
         if (!isValid) {
-          router.push('/main-page');
-          return
+          router.push(loginRoute);
+          return;
         }
         return response;
-      } catch (error: any) {
+      } catch (error: unknown) {
+        if (error instanceof Error) {
+          console.error(error);
         // message.error(error.response.data.message);
-        router.push('/main-page');
+        router.push(loginRoute);
+        }
       } finally {
         setIsLoading(false);
       }
     },
     [authService, router]
-  )
+  );
 
-  const passwordLoginWithCheck = async (username: string, password: string, tokenFCM: string, branchCode: string): Promise<any> => {
+  const passwordLoginWithCheck = async (
+    username: string,
+    password: string,
+    tokenFCM: string,
+    branchCode: string
+  ): Promise<any> => {
     setIsLoading(true);
     try {
-      const response = await authService.passwordLogin(username, password, tokenFCM);
-      const checksChangePassword = await authService.checkToChangePasswordLogin(username, password, branchCode);
+      const response = await authService.passwordLogin(
+        username,
+        password,
+        tokenFCM
+      );
+      const checksChangePassword = await authService.checkToChangePasswordLogin(
+        username,
+        password,
+        branchCode
+      );
       const resultChangePassword = checksChangePassword?.data;
 
       if (resultChangePassword?.data?.IsRedirectToChangePassword) {
-        router.replace(`/main-page/change-password?branch=${branchCode}`);
+        router?.replace?.(`/main-page/change-password?branch=${branchCode}`);
       } else {
         setToken(() => response.data.data.accessToken);
 
@@ -671,14 +864,14 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
         localStorage.setItem("refresh-token", response.data.data.refreshToken);
         localStorage.setItem("locale", "id");
 
-        router.push("/");
+        router.push(baseRoute);
       }
     } catch (error) {
       // if (error instanceof Error) message.error(error.message);
     } finally {
       setIsLoading(false);
     }
-  }
+  };
 
   const ssoQlolaLogin = async (request: string) => {
     try {
@@ -689,14 +882,19 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
       localStorage.setItem("refresh-token", response.data.data.refreshToken);
       localStorage.setItem("agent", response.data.agent);
 
-      router.push("/");
+      router.push(baseRoute);
       return;
     } catch (err: any) {
       return Promise.reject(err);
     }
-  }
+  };
 
-  const login = async (username: string, password: string, branchCode: string, type?:string): Promise<any> => {
+  const login = async (
+    username: string,
+    password: string,
+    branchCode: string,
+    type?: string
+  ): Promise<any> => {
     setIsLoading(true);
     try {
       const response = await authService.login(username, password, branchCode);
@@ -711,18 +909,18 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
 
       if (data.isRedirectToChangePassword) {
         const token = data.changePasswordToken;
-        router.push(`/main-page/change-password?token=${token}`);
-        return
+        router.push(`${loginRoute}/change-password?token=${token}`);
+        return;
       }
 
-      if(type === "new-login"){
+      if (type === "new-login") {
         return response;
       }
 
-      router.push("/");
-      return
+      router.push(baseRoute);
+      return;
     } catch (error: any) {
-      if(type === "new-login"){
+      if (type === "new-login") {
         return Promise.reject(error);
       }
 
@@ -740,120 +938,176 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ children, apiUrl })
     } finally {
       setIsLoading(false);
     }
-  }
+  };
 
-  //@ts-ignore
-  const checkToken : any = async () => {
+  const checkToken: any = async () => {
     setIsLoading(true);
     try {
-      const token = localStorage.getItem("access-token")
+      const token = localStorage.getItem("access-token");
       const resp = await authService.validateTokenWithParam(token as string);
       setIsLoading(false);
       return Promise.resolve(resp);
-    } catch (error:any){
-      if([401].includes(error?.response?.data?.code || error?.response?.status || error.status)){
+    } catch (error: any) {
+      if (
+        [401].includes(
+          error?.response?.data?.code || error?.response?.status || error.status
+        )
+      ) {
         return refreshToken();
       }
-      if([504].includes(error?.response?.data?.code || error?.response?.status || error.status)){
+      if (
+        [504].includes(
+          error?.response?.data?.code || error?.response?.status || error.status
+        )
+      ) {
         return checkToken();
       }
-      return router.push("/main-page?logout=true")
+      return router.push(`${loginRoute}?logout=true`);
     }
-  }
-  //@ts-ignore
+  };
+
   const refreshToken = async () => {
     try {
-      const refreshToken = localStorage.getItem("refresh-token")
+      const refreshToken = localStorage.getItem("refresh-token");
       const resp = await authService.refreshToken(refreshToken as string);
       localStorage.setItem("access-token", resp.data.data.accessToken);
       localStorage.setItem("refresh-token", resp.data.data.refreshToken);
       return Promise.resolve(resp);
-    } catch (error:any){
-      if([504].includes(error?.response?.data?.code || error?.response?.status || error.status)){
+    } catch (error: any) {
+      if (
+        [504].includes(
+          error?.response?.data?.code || error?.response?.status || error.status
+        )
+      ) {
         return refreshToken();
       }
       localStorage.removeItem("access-token");
       localStorage.removeItem("refresh-token");
       Promise.reject(error);
-      return router.push("/main-page?logout=true")
+      return router.push(`${loginRoute}?logout=true`);
     } finally {
-      return setIsLoading(false);
+      setIsLoading(false);
     }
-  }
+  };
 
   useEffect(() => {
-    if (router.basePath.includes("v2")) {
-      prevPathnameRef.current = `${router.basePath}${router.asPath}`;
-    } else {
-      prevPathnameRef.current = router.asPath;
-    }
-
+    prevPathnameRef.current = router.asPath || "";
     const handleRouteChangeStart = (url: any) => {
-      const newPath = url.split("?")[0]; // Remove query parameters
+      const newPath = url.split("?")[0];
       const currentPath = prevPathnameRef.current.split("?")[0];
-
       if (newPath !== currentPath) {
-        setIsAuthoritiesReady(false);
         prevPathnameRef.current = url;
       }
     };
-
-    router.events.on("routeChangeStart", handleRouteChangeStart);
-
+    router.events?.on?.("routeChangeStart", handleRouteChangeStart);
     return () => {
-      router.events.off("routeChangeStart", handleRouteChangeStart);
+      router.events?.off?.("routeChangeStart", handleRouteChangeStart);
     };
   }, [router]);
 
+  const valueMemoized = useMemo(
+    () => ({
+      token,
+      alertMenuError,
+      authorities,
+      isAuthoritiesReady,
+      productAuthorities,
+      username,
+      userType,
+      menus,
+      loggedIn,
+      companyID,
+      companyName,
+      userMode,
+      companyLevel,
+      roleID,
+      holdingID,
+      isLoading,
+      isIntraday,
+      onboardingTourStatus,
+      userID,
+      guard,
+      passwordLogin,
+      ssoLogin,
+      logout,
+      canIApprove,
+      roleIDs,
+      menuData,
+      ssoQlolaLogin,
+      login,
+      forgotPassword,
+      verifyUserQuestion,
+      verifyChangePasswordToken,
+      checkToChangePassword,
+      passwordLoginWithCheck,
+      requestChangePassword,
+      canIDelete,
+      canIEdit,
+      action,
+      onLeaveAction,
+      setOnLeaveAction,
+      countryCode,
+      setIsLoading,
+      setUserType,
+      setToken,
+      companyCode,
+      region,
+      checkToken,
+    }),
+    [
+      token,
+      alertMenuError,
+      authorities,
+      isAuthoritiesReady,
+      productAuthorities,
+      username,
+      userType,
+      menus,
+      loggedIn,
+      companyID,
+      companyName,
+      userMode,
+      companyLevel,
+      roleID,
+      holdingID,
+      isLoading,
+      userID,
+      guard,
+      passwordLogin,
+      ssoLogin,
+      logout,
+      canIApprove,
+      roleIDs,
+      menuData,
+      ssoQlolaLogin,
+      login,
+      forgotPassword,
+      verifyUserQuestion,
+      verifyChangePasswordToken,
+      checkToChangePassword,
+      passwordLoginWithCheck,
+      requestChangePassword,
+      canIDelete,
+      canIEdit,
+      action,
+      onLeaveAction,
+      setOnLeaveAction,
+      countryCode,
+      setIsLoading,
+      setUserType,
+      setToken,
+      companyCode,
+      region,
+      checkToken,
+      onboardingTourStatus,
+    ]
+  );
+
   return (
-    <IdleTimerProvider {...{ onPrompt, onIdle, onActive, onAction, timeout: isMinutes }}>
-      <AuthContext.Provider
-        value={{
-          token,
-          alertMenuError,
-          authorities,
-          isAuthoritiesReady,
-          productAuthorities,
-          username,
-          userType,
-          menus,
-          loggedIn,
-          companyID,
-          companyName,
-          userMode,
-          companyLevel,
-          roleID,
-          holdingID,
-          isLoading,
-          userID,
-          guard,
-          passwordLogin,
-          ssoLogin,
-          logout,
-          canIApprove,
-          roleIDs,
-          menuData,
-          ssoQlolaLogin,
-          login,
-          forgotPassword,
-          verifyUserQuestion,
-          verifyChangePasswordToken,
-          checkToChangePassword,
-          passwordLoginWithCheck,
-          requestChangePassword,
-          canIDelete,
-          canIEdit,
-          action,
-          onLeaveAction,
-          setOnLeaveAction,
-          countryCode,
-          setIsLoading,
-          setToken,
-          companyCode,
-          region,
-          checkToken
-        }}
-      >
+    <IdleTimerProvider
+      {...{ onPrompt, onIdle, onActive, onAction, timeout: isMinutes }}
+    >
+      <AuthContext.Provider value={valueMemoized}>
         {children}
       </AuthContext.Provider>
     </IdleTimerProvider>