dauth-context-react 2.2.0 → 2.4.0

package/src/reducer/dauth.actions.ts

@@ -6,21 +6,31 @@ import {
   sendEmailVerificationAPI,
   updateUserAPI,
 } from '../api/dauth.api';
-import { TOKEN_LS, REFRESH_TOKEN_LS } from '../constants';
-import { IDauthDomainState, IDauthUser } from '../interfaces';
+import {
+  IDauthDomainState,
+  IDauthStorageKeys,
+  IDauthUser,
+} from '../interfaces';
 import * as DauthTypes from './dauth.types';
 
-type TSetDauthStateAction = {
+export interface ActionContext {
   dispatch: React.Dispatch<any>;
+  domainName: string;
+  storageKeys: IDauthStorageKeys;
+  onError: (error: Error) => void;
+}
+
+type TSetDauthStateAction = ActionContext & {
   token: string;
   refreshToken: string;
-  domainName: string;
 };
 export async function setDauthStateAction({
   dispatch,
   token,
   refreshToken,
   domainName,
+  storageKeys,
+  onError,
 }: TSetDauthStateAction) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
   try {
@@ -35,15 +45,15 @@ export async function setDauthStateAction({
         },
       });
       window.history.replaceState({}, document.title, window.location.pathname);
-      localStorage.setItem(TOKEN_LS, token);
-      localStorage.setItem(REFRESH_TOKEN_LS, refreshToken);
+      localStorage.setItem(storageKeys.accessToken, token);
+      localStorage.setItem(storageKeys.refreshToken, refreshToken);
       return;
     } else {
-      return resetUser(dispatch);
+      return resetUser(dispatch, storageKeys);
     }
   } catch (error) {
-    console.error(error);
-    return resetUser(dispatch);
+    onError(error instanceof Error ? error : new Error(String(error)));
+    return resetUser(dispatch, storageKeys);
   } finally {
     dispatch({
       type: DauthTypes.SET_IS_LOADING,
@@ -52,30 +62,28 @@ export async function setDauthStateAction({
   }
 }
 
-type TSetAutoLoginAction = {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
-};
 export async function setAutoLoginAction({
   dispatch,
   domainName,
-}: TSetAutoLoginAction) {
+  storageKeys,
+  onError,
+}: ActionContext) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
-  const storedRefreshToken = localStorage.getItem(REFRESH_TOKEN_LS);
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
   if (!storedRefreshToken) {
     dispatch({
       type: DauthTypes.SET_IS_LOADING,
       payload: { isLoading: false },
     });
-    return resetUser(dispatch);
+    return resetUser(dispatch, storageKeys);
   }
   try {
     const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
     if (refreshResult.response.status === 200) {
       const newAccessToken = refreshResult.data.accessToken;
       const newRefreshToken = refreshResult.data.refreshToken;
-      localStorage.setItem(TOKEN_LS, newAccessToken);
-      localStorage.setItem(REFRESH_TOKEN_LS, newRefreshToken);
+      localStorage.setItem(storageKeys.accessToken, newAccessToken);
+      localStorage.setItem(storageKeys.refreshToken, newRefreshToken);
       const getUserFetch = await getUserAPI(domainName, newAccessToken);
       if (getUserFetch.response.status === 200) {
         dispatch({
@@ -90,10 +98,10 @@ export async function setAutoLoginAction({
       }
     }
     // Refresh failed — session expired
-    resetUser(dispatch);
+    resetUser(dispatch, storageKeys);
   } catch (error) {
-    console.error(error);
-    resetUser(dispatch);
+    onError(error instanceof Error ? error : new Error(String(error)));
+    resetUser(dispatch, storageKeys);
   } finally {
     dispatch({
       type: DauthTypes.SET_IS_LOADING,
@@ -105,11 +113,9 @@ export async function setAutoLoginAction({
 export async function setLogoutAction({
   dispatch,
   domainName,
-}: {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
-}) {
-  const storedRefreshToken = localStorage.getItem(REFRESH_TOKEN_LS);
+  storageKeys,
+}: Omit<ActionContext, 'onError'>) {
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
   if (storedRefreshToken && domainName) {
     try {
       await logoutAPI(domainName, storedRefreshToken);
@@ -128,8 +134,8 @@ export async function setLogoutAction({
       isAuthenticated: false,
     },
   });
-  localStorage.removeItem(TOKEN_LS);
-  localStorage.removeItem(REFRESH_TOKEN_LS);
+  localStorage.removeItem(storageKeys.accessToken);
+  localStorage.removeItem(storageKeys.refreshToken);
   return dispatch({
     type: DauthTypes.SET_IS_LOADING,
     payload: { isLoading: false },
@@ -139,32 +145,35 @@ export async function setLogoutAction({
 export async function refreshSessionAction({
   dispatch,
   domainName,
-}: {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
-}) {
-  const storedRefreshToken = localStorage.getItem(REFRESH_TOKEN_LS);
+  storageKeys,
+  onError,
+}: ActionContext) {
+  const storedRefreshToken = localStorage.getItem(storageKeys.refreshToken);
   if (!storedRefreshToken) {
-    return resetUser(dispatch);
+    return resetUser(dispatch, storageKeys);
   }
   try {
     const refreshResult = await refreshTokenAPI(domainName, storedRefreshToken);
     if (refreshResult.response.status === 200) {
-      localStorage.setItem(TOKEN_LS, refreshResult.data.accessToken);
-      localStorage.setItem(REFRESH_TOKEN_LS, refreshResult.data.refreshToken);
+      localStorage.setItem(
+        storageKeys.accessToken,
+        refreshResult.data.accessToken
+      );
+      localStorage.setItem(
+        storageKeys.refreshToken,
+        refreshResult.data.refreshToken
+      );
       return;
     }
     // Refresh failed — revoked or expired
-    resetUser(dispatch);
+    resetUser(dispatch, storageKeys);
   } catch (error) {
-    console.error(error);
-    resetUser(dispatch);
+    onError(error instanceof Error ? error : new Error(String(error)));
+    resetUser(dispatch, storageKeys);
   }
 }
 
-type TSetUpdateAction = {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
+type TSetUpdateAction = ActionContext & {
   user: Partial<IDauthUser>;
   token: string | null;
 };
@@ -173,6 +182,7 @@ export async function setUpdateUserAction({
   domainName,
   user,
   token,
+  onError,
 }: TSetUpdateAction) {
   if (user.language) {
     window.document.documentElement.setAttribute('lang', user.language);
@@ -193,18 +203,18 @@ export async function setUpdateUserAction({
       });
       return true;
     } else {
-      console.error('Update user error', getUserFetch.data.message);
+      onError(new Error('Update user error: ' + getUserFetch.data.message));
       return false;
     }
   } catch (error) {
-    console.error('Update user error', error);
+    onError(
+      error instanceof Error ? error : new Error('Update user error')
+    );
     return false;
   }
 }
 
-type TSetSendEmailVerificationAction = {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
+type TSetSendEmailVerificationAction = ActionContext & {
   token: string;
 };
 export async function sendEmailVerificationAction({
@@ -243,7 +253,7 @@ export async function sendEmailVerificationAction({
       });
       return false;
     }
-  } catch (error) {
+  } catch (_) {
     dispatch({
       type: DauthTypes.SET_SEND_EMAIL_VERIFICATION_STATUS,
       payload: {
@@ -262,11 +272,10 @@ export async function sendEmailVerificationAction({
 export async function getAccessTokenAction({
   dispatch,
   domainName,
-}: {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
-}) {
-  const token_ls = localStorage.getItem(TOKEN_LS);
+  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 {
@@ -276,8 +285,13 @@ export async function getAccessTokenAction({
       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 });
-        const refreshedToken = localStorage.getItem(TOKEN_LS);
+        await refreshSessionAction({
+          dispatch,
+          domainName,
+          storageKeys,
+          onError,
+        });
+        const refreshedToken = localStorage.getItem(storageKeys.accessToken);
         return refreshedToken || 'token-not-found';
       }
     }
@@ -290,30 +304,33 @@ export async function getAccessTokenAction({
 export async function deleteAccountAction({
   dispatch,
   domainName,
+  storageKeys,
+  onError,
   token,
-}: {
-  dispatch: React.Dispatch<any>;
-  domainName: string;
-  token: string;
-}) {
+}: ActionContext & { token: string }) {
   try {
     const result = await deleteAccountAPI(domainName, token);
     if (result.response.status === 200) {
-      resetUser(dispatch);
+      resetUser(dispatch, storageKeys);
       return true;
     }
     return false;
   } catch (error) {
-    console.error('Delete account error', error);
+    onError(
+      error instanceof Error ? error : new Error('Delete account error')
+    );
     return false;
   }
 }
 
 ///////////////////////////////////////////
 //////////////////////////////////////////
-export const resetUser = (dispatch: React.Dispatch<any>) => {
-  localStorage.removeItem(TOKEN_LS);
-  localStorage.removeItem(REFRESH_TOKEN_LS);
+export const resetUser = (
+  dispatch: React.Dispatch<any>,
+  storageKeys: IDauthStorageKeys
+) => {
+  localStorage.removeItem(storageKeys.accessToken);
+  localStorage.removeItem(storageKeys.refreshToken);
   return dispatch({
     type: DauthTypes.LOGIN,
     payload: {

package/dist/api/dauth.api.d.ts

@@ -1,11 +0,0 @@
-import { IDauthUser } from '../interfaces';
-import { IdeleteAccountAPIResponse, IgetUserAPIResponse, IrefreshAccessTokenAPIResponse, IrefreshTokenAPIResponse, IsendEmailVerificationAPIResponse, IupdateUserAPIResponse } from './interfaces/dauth.api.responses';
-export declare const getUserAPI: (domainName: string, token: string) => Promise<IgetUserAPIResponse>;
-export declare const updateUserAPI: (domainName: string, user: Partial<IDauthUser>, token: string) => Promise<IupdateUserAPIResponse>;
-export declare const sendEmailVerificationAPI: (domainName: string, token: string) => Promise<IsendEmailVerificationAPIResponse>;
-export declare const refreshAccessTokenAPI: (domainName: string, token: string) => Promise<IrefreshAccessTokenAPIResponse>;
-export declare const refreshTokenAPI: (domainName: string, refreshToken: string) => Promise<IrefreshTokenAPIResponse>;
-export declare const deleteAccountAPI: (domainName: string, token: string) => Promise<IdeleteAccountAPIResponse>;
-export declare const logoutAPI: (domainName: string, refreshToken: string) => Promise<{
-    response: Response;
-}>;

package/dist/api/interfaces/dauth.api.responses.d.ts

@@ -1,45 +0,0 @@
-import { IDauthDomainState, IDauthUser } from '../../interfaces';
-export interface IdeleteAccountAPIResponse {
-    response: Response;
-    data: {
-        status: string;
-        message: string;
-    };
-}
-export interface IgetUserAPIResponse {
-    response: Response;
-    data: {
-        status: string;
-        user: IDauthUser;
-        domain: IDauthDomainState;
-    };
-}
-export interface IupdateUserAPIResponse {
-    response: Response;
-    data: {
-        status: string;
-        user: IDauthUser;
-        message: string;
-    };
-}
-export interface IsendEmailVerificationAPIResponse {
-    response: Response;
-    data: {
-        status: string;
-        message: string;
-        emailStatus: string;
-    };
-}
-export interface IrefreshAccessTokenAPIResponse {
-    response: Response;
-    data: {
-        accessToken: string;
-    };
-}
-export interface IrefreshTokenAPIResponse {
-    response: Response;
-    data: {
-        accessToken: string;
-        refreshToken: string;
-    };
-}

package/dist/api/utils/config.d.ts

@@ -1,4 +0,0 @@
-export declare const apiVersion = "v1";
-export declare const serverDomain = "dauth.ovh";
-export declare function getServerBasePath(): string;
-export declare function getClientBasePath(): string;

package/dist/api/utils/routes.d.ts

@@ -1,4 +0,0 @@
-export declare const routes: {
-    signin: string;
-    updateUser: string;
-};

package/dist/constants.d.ts

@@ -1,2 +0,0 @@
-export declare const TOKEN_LS = "dauth_state";
-export declare const REFRESH_TOKEN_LS = "dauth_refresh_token";