dauth-context-react 0.2.109 → 0.2.111

package/dist/reducer/dauth.actions.d.ts

@@ -8,10 +8,10 @@ declare type TSetDauthStateAction = {
 export declare function setDauthStateAction({ dispatch, token, domainName, }: TSetDauthStateAction): Promise<void>;
 declare type TSetAutoLoginAction = {
     dispatch: React.Dispatch<any>;
-    dauth_state_ls: string;
+    token_ls: string;
     domainName: string;
 };
-export declare function setAutoLoginAction({ dispatch, dauth_state_ls, domainName, }: TSetAutoLoginAction): Promise<void>;
+export declare function setAutoLoginAction({ dispatch, token_ls, domainName, }: TSetAutoLoginAction): Promise<void>;
 export declare function setLogoutAction({ dispatch, }: {
     dispatch: React.Dispatch<any>;
 }): void;
@@ -36,6 +36,6 @@ export declare function checkTokenAction({ dispatch, domainName, token, }: {
 export declare function getAccessTokenAction({ dispatch, domainName, }: {
     dispatch: React.Dispatch<any>;
     domainName: string;
-}): Promise<any>;
+}): Promise<string | undefined>;
 export declare const resetUser: (dispatch: React.Dispatch<any>) => void;
 export {};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.109",
+  "version": "0.2.111",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",

package/src/api/dauth.api.ts

@@ -1,11 +1,18 @@
 import { routes } from './utils/routes';
 import { getServerBasePath } from './utils/config';
 import { IDauthUser } from '../interfaces';
+import {
+  IgetUserAPIResponse,
+  IrefreshAccessTokenAPIResponse,
+  IsendEmailVerificationAPIResponse,
+  IupdateUserAPIResponse,
+  IverifyTokenAPIResponse,
+} from './interfaces/dauth.api.responses';
 
 export const getUserAPI = async (
   domainName: string,
   token: string
-): Promise<any> => {
+): Promise<IgetUserAPIResponse> => {
   const params = {
     method: 'GET',
     headers: {
@@ -27,7 +34,7 @@ export const updateUserAPI = async (
   domainName: string,
   user: Partial<IDauthUser>,
   token: string
-): Promise<any> => {
+): Promise<IupdateUserAPIResponse> => {
   const params = {
     method: 'PATCH',
     headers: {
@@ -49,7 +56,7 @@ export const updateUserAPI = async (
 export const sendEmailVerificationAPI = async (
   domainName: string,
   token: string
-): Promise<any> => {
+): Promise<IsendEmailVerificationAPIResponse> => {
   const params = {
     method: 'GET',
     headers: {
@@ -70,7 +77,7 @@ export const sendEmailVerificationAPI = async (
 export const refreshAccessTokenAPI = async (
   domainName: string,
   token: string
-): Promise<any> => {
+): Promise<IrefreshAccessTokenAPIResponse> => {
   const params = {
     method: 'GET',
     headers: {
@@ -96,7 +103,7 @@ export const verifyTokenAPI = async ({
   domainName: string;
   ask: string;
   token: string;
-}): Promise<any> => {
+}): Promise<IverifyTokenAPIResponse> => {
   const params = {
     method: 'POST',
     headers: {

package/src/api/interfaces/dauth.api.responses.ts

@@ -0,0 +1,43 @@
+import { IDauthDomainState, IDauthUser } from '../../interfaces';
+
+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 IverifyTokenAPIResponse {
+  response: Response;
+  data: {
+    status: string;
+    message: string;
+  };
+}

package/src/index.tsx

@@ -26,8 +26,8 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
 ) => {
   const { domainName, ask, children } = props;
   const [dauthState, dispatch] = useReducer(userReducer, initialDauthState);
-  
-  const verifyToken = useCallback(
+
+  const isValidAsk = useCallback(
     async (token: string) => {
       const verifyToken = await verifyTokenAPI({
         domainName,
@@ -35,23 +35,33 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
         ask,
       });
       if (verifyToken.response.status !== 200) {
-        return action.setLogoutAction({ dispatch });
+        return false;
       }
+      return true;
     },
-    [domainName, ask],
-  )
-  
+    [domainName, ask]
+  );
+
   // Check token periodically
   useEffect(() => {
     if (!dauthState.isAuthenticated) return;
     let interval = setInterval(async () => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (!token_ls) return;
-      await verifyToken(token_ls);
-      return action.checkTokenAction({ dispatch, domainName, token: token_ls });
-    }, 1000 * 60 * 1);
+      const isValid = await isValidAsk(token_ls);
+      if (isValid) {
+        return action.checkTokenAction({
+          dispatch,
+          domainName,
+          token: token_ls,
+        });
+      } else {
+        action.setLogoutAction({ dispatch });
+        throw new Error('Ask value in DauthProvider is not valid');
+      }
+    }, 1000 * 60 * 5);
     return () => clearInterval(interval);
-  }, []);
+  }, [dauthState.isAuthenticated, isValidAsk]);
 
   // Catch login redirect
   useEffect(() => {
@@ -61,8 +71,17 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
       const urlParams = new URLSearchParams(queryString);
       const token_url = urlParams.get(TOKEN_LS);
       if (token_url && !dauthState.isAuthenticated) {
-        await verifyToken(token_url);
-        action.setDauthStateAction({ dispatch, token: token_url, domainName });
+        const isValid = await isValidAsk(token_url);
+        if (isValid) {
+          return action.setDauthStateAction({
+            dispatch,
+            token: token_url,
+            domainName,
+          });
+        } else {
+          action.setLogoutAction({ dispatch });
+          throw new Error('Ask value in DauthProvider is not valid');
+        }
       }
     })();
   }, []);
@@ -72,12 +91,17 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
     (async () => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (token_ls && !dauthState.isAuthenticated) {
-        await verifyToken(token_ls);
-        action.setAutoLoginAction({
-          dispatch,
-          dauth_state_ls: token_ls,
-          domainName,
-        });
+        const isValid = await isValidAsk(token_ls);
+        if (isValid) {
+          return action.setAutoLoginAction({
+            dispatch,
+            token_ls,
+            domainName,
+          });
+        } else {
+          action.setLogoutAction({ dispatch });
+          throw new Error('Ask value in DauthProvider is not valid');
+        }
       }
     })();
   }, []);

package/src/reducer/dauth.actions.ts

@@ -54,22 +54,22 @@ export async function setDauthStateAction({
 
 type TSetAutoLoginAction = {
   dispatch: React.Dispatch<any>;
-  dauth_state_ls: string;
+  token_ls: string;
   domainName: string;
 };
 export async function setAutoLoginAction({
   dispatch,
-  dauth_state_ls,
+  token_ls,
   domainName,
 }: TSetAutoLoginAction) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
   try {
     const refreshAccessTokenFetch = await refreshAccessTokenAPI(
       domainName,
-      dauth_state_ls
+      token_ls
     );    
     if (refreshAccessTokenFetch.response.status === 200) {
-      const getUserFetch = await getUserAPI(domainName, dauth_state_ls);
+      const getUserFetch = await getUserAPI(domainName, token_ls);
       if (getUserFetch.response.status === 200) {
         dispatch({
           type: DauthTypes.LOGIN,