dauth-context-react 4.0.4 → 6.0.0

package/src/reducer/dauth.actions.ts

@@ -1,33 +1,21 @@
 import {
-  deleteAccountAPI,
   exchangeCodeAPI,
-  getUserAPI,
+  getSessionAPI,
   logoutAPI,
-  refreshTokenAPI,
   updateUserAPI,
+  deleteAccountAPI,
 } from '../api/dauth.api';
-import {
-  IDauthDomainState,
-  IDauthStorageKeys,
-  IDauthUser,
-} from '../interfaces';
+import { IDauthDomainState, IDauthUser } from '../interfaces';
 import * as DauthTypes from './dauth.types';
 
 export interface ActionContext {
   dispatch: React.Dispatch<any>;
-  domainName: string;
-  storageKeys: IDauthStorageKeys;
+  authProxyPath: string;
   onError: (error: Error) => void;
 }
 
-type TExchangeCodeAction = ActionContext & { code: string };
-export async function exchangeCodeAction({
-  dispatch,
-  code,
-  domainName,
-  storageKeys,
-  onError,
-}: TExchangeCodeAction) {
+export async function exchangeCodeAction(ctx: ActionContext, code: string) {
+  const { dispatch, authProxyPath, onError } = ctx;
   dispatch({
     type: DauthTypes.SET_IS_LOADING,
     payload: { isLoading: true },
@@ -35,29 +23,22 @@ export async function exchangeCodeAction({
   try {
     // Clean URL immediately (before any fetch)
     window.history.replaceState({}, document.title, window.location.pathname);
-    const exchangeResult = await exchangeCodeAPI(domainName, code);
-    if (exchangeResult.response.status !== 200) {
-      return resetUser(dispatch, storageKeys);
-    }
-    const { accessToken, refreshToken } = exchangeResult.data;
-    localStorage.setItem(storageKeys.accessToken, accessToken);
-    localStorage.setItem(storageKeys.refreshToken, refreshToken);
-    const getUserFetch = await getUserAPI(domainName, accessToken);
-    if (getUserFetch.response.status === 200) {
+    const result = await exchangeCodeAPI(authProxyPath, code);
+    if (result.response.status === 200) {
       dispatch({
         type: DauthTypes.LOGIN,
         payload: {
-          user: getUserFetch.data.user,
-          domain: getUserFetch.data.domain,
+          user: result.data.user,
+          domain: result.data.domain,
           isAuthenticated: true,
         },
       });
       return;
     }
-    return resetUser(dispatch, storageKeys);
+    resetUser(dispatch);
   } catch (error) {
     onError(error instanceof Error ? error : new Error(String(error)));
-    return resetUser(dispatch, storageKeys);
+    resetUser(dispatch);
   } finally {
     dispatch({
       type: DauthTypes.SET_IS_LOADING,
@@ -66,46 +47,30 @@ export async function exchangeCodeAction({
   }
 }
 
-export async function setAutoLoginAction({
-  dispatch,
-  domainName,
-  storageKeys,
-  onError,
-}: ActionContext) {
-  dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
-  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
-  if (!storedRefreshToken) {
-    dispatch({
-      type: DauthTypes.SET_IS_LOADING,
-      payload: { isLoading: false },
-    });
-    return resetUser(dispatch, storageKeys);
-  }
+export async function autoLoginAction(ctx: ActionContext) {
+  const { dispatch, authProxyPath, onError } = ctx;
+  dispatch({
+    type: DauthTypes.SET_IS_LOADING,
+    payload: { isLoading: true },
+  });
   try {
-    const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
-    if (refreshResult.response.status === 200) {
-      const newAccessToken = refreshResult.data.accessToken;
-      const newRefreshToken = refreshResult.data.refreshToken;
-      localStorage.setItem(storageKeys.accessToken, newAccessToken);
-      localStorage.setItem(storageKeys.refreshToken, newRefreshToken);
-      const getUserFetch = await getUserAPI(domainName, newAccessToken);
-      if (getUserFetch.response.status === 200) {
-        dispatch({
-          type: DauthTypes.LOGIN,
-          payload: {
-            user: getUserFetch.data.user,
-            domain: getUserFetch.data.domain,
-            isAuthenticated: true,
-          },
-        });
-        return;
-      }
+    const result = await getSessionAPI(authProxyPath);
+    if (result.response.status === 200) {
+      dispatch({
+        type: DauthTypes.LOGIN,
+        payload: {
+          user: result.data.user,
+          domain: result.data.domain,
+          isAuthenticated: true,
+        },
+      });
+      return;
     }
-    // Refresh failed — session expired
-    resetUser(dispatch, storageKeys);
+    // No session — not authenticated (not an error)
+    resetUser(dispatch);
   } catch (error) {
     onError(error instanceof Error ? error : new Error(String(error)));
-    resetUser(dispatch, storageKeys);
+    resetUser(dispatch);
   } finally {
     dispatch({
       type: DauthTypes.SET_IS_LOADING,
@@ -114,20 +79,17 @@ export async function setAutoLoginAction({
   }
 }
 
-export async function setLogoutAction({
-  dispatch,
-  domainName,
-  storageKeys,
-}: Omit<ActionContext, 'onError'>) {
-  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
-  if (storedRefreshToken && domainName) {
-    try {
-      await logoutAPI(domainName, storedRefreshToken);
-    } catch (_) {
-      // Best-effort server-side logout
-    }
+export async function logoutAction(ctx: ActionContext) {
+  const { dispatch, authProxyPath } = ctx;
+  try {
+    await logoutAPI(authProxyPath);
+  } catch {
+    // Best-effort server-side logout
   }
-  dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
+  dispatch({
+    type: DauthTypes.SET_IS_LOADING,
+    payload: { isLoading: true },
+  });
   dispatch({
     type: DauthTypes.LOGIN,
     payload: {
@@ -138,127 +100,45 @@ export async function setLogoutAction({
       isAuthenticated: false,
     },
   });
-  localStorage.removeItem(storageKeys.accessToken);
-  localStorage.removeItem(storageKeys.refreshToken);
-  return dispatch({
+  dispatch({
     type: DauthTypes.SET_IS_LOADING,
     payload: { isLoading: false },
   });
 }
 
-export async function refreshSessionAction({
-  dispatch,
-  domainName,
-  storageKeys,
-  onError,
-}: ActionContext) {
-  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
-  if (!storedRefreshToken) {
-    return resetUser(dispatch, storageKeys);
-  }
-  try {
-    const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
-    if (refreshResult.response.status === 200) {
-      localStorage.setItem(
-        storageKeys.accessToken,
-        refreshResult.data.accessToken
-      );
-      localStorage.setItem(
-        storageKeys.refreshToken,
-        refreshResult.data.refreshToken
-      );
-      return;
-    }
-    // Refresh failed — revoked or expired
-    resetUser(dispatch, storageKeys);
-  } catch (error) {
-    onError(error instanceof Error ? error : new Error(String(error)));
-    resetUser(dispatch, storageKeys);
-  }
-}
-
-type TSetUpdateAction = ActionContext & {
-  user: Partial<IDauthUser>;
-  token: string | null;
-};
-export async function setUpdateUserAction({
-  dispatch,
-  domainName,
-  user,
-  token,
-  onError,
-}: TSetUpdateAction) {
+export async function updateUserAction(
+  ctx: ActionContext,
+  user: Partial<IDauthUser>
+): Promise<boolean> {
+  const { dispatch, authProxyPath, onError } = ctx;
   if (user.language) {
     window.document.documentElement.setAttribute('lang', user.language);
   }
-  if (!token) {
-    dispatch({
-      type: DauthTypes.UPDATE_USER,
-      payload: user,
-    });
-    return false;
-  }
   try {
-    const getUserFetch = await updateUserAPI(domainName, user, token);
-    if (getUserFetch.response.status === 200) {
+    const result = await updateUserAPI(authProxyPath, user);
+    if (result.response.status === 200) {
       dispatch({
         type: DauthTypes.UPDATE_USER,
-        payload: getUserFetch.data.user,
+        payload: result.data.user,
       });
       return true;
-    } else {
-      onError(new Error('Update user error: ' + getUserFetch.data.message));
-      return false;
     }
+    onError(new Error('Update user error: ' + result.data.message));
+    return false;
   } catch (error) {
     onError(error instanceof Error ? error : new Error('Update user error'));
     return false;
   }
 }
 
-export async function getAccessTokenAction({
-  dispatch,
-  domainName,
-  storageKeys,
-  onError,
-}: ActionContext) {
-  const token_ls = localStorage.getItem(storageKeys.accessToken);
-  if (!token_ls) return 'token-not-found';
-  // Decode JWT to check expiry (without verification — that's the server's job)
-  try {
-    const payloadB64 = token_ls.split('.')[1];
-    if (payloadB64) {
-      const payload = JSON.parse(atob(payloadB64));
-      const expiresIn = (payload.exp || 0) * 1000 - Date.now();
-      // If token expires in less than 5 minutes, refresh proactively
-      if (expiresIn < 5 * 60 * 1000) {
-        await refreshSessionAction({
-          dispatch,
-          domainName,
-          storageKeys,
-          onError,
-        });
-        const refreshedToken = localStorage.getItem(storageKeys.accessToken);
-        return refreshedToken || 'token-not-found';
-      }
-    }
-  } catch (_) {
-    // If decode fails, return stored token and let server validate
-  }
-  return token_ls;
-}
-
-export async function deleteAccountAction({
-  dispatch,
-  domainName,
-  storageKeys,
-  onError,
-  token,
-}: ActionContext & { token: string }) {
+export async function deleteAccountAction(
+  ctx: ActionContext
+): Promise<boolean> {
+  const { dispatch, authProxyPath, onError } = ctx;
   try {
-    const result = await deleteAccountAPI(domainName, token);
+    const result = await deleteAccountAPI(authProxyPath);
     if (result.response.status === 200) {
-      resetUser(dispatch, storageKeys);
+      resetUser(dispatch);
       return true;
     }
     return false;
@@ -268,14 +148,7 @@ export async function deleteAccountAction({
   }
 }
 
-///////////////////////////////////////////
-//////////////////////////////////////////
-export const resetUser = (
-  dispatch: React.Dispatch<any>,
-  storageKeys: IDauthStorageKeys
-) => {
-  localStorage.removeItem(storageKeys.accessToken);
-  localStorage.removeItem(storageKeys.refreshToken);
+export const resetUser = (dispatch: React.Dispatch<any>) => {
   return dispatch({
     type: DauthTypes.LOGIN,
     payload: {