dauth-context-react 0.2.110 → 0.2.112

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 interface DauthProviderProps {
     domainName: string;
-    ask: string;
+    tsk: string;
     children: React.ReactNode;
 }
 export declare const DauthProvider: React.FC<DauthProviderProps>;

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.110",
+  "version": "0.2.112",
   "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: {
@@ -90,20 +97,20 @@ export const refreshAccessTokenAPI = async (
 
 export const verifyTokenAPI = async ({
   domainName,
-  ask,
+  tsk,
   token,
 }: {
   domainName: string;
-  ask: string;
+  tsk: string;
   token: string;
-}): Promise<any> => {
+}): Promise<IverifyTokenAPIResponse> => {
   const params = {
     method: 'POST',
     headers: {
       Authorization: token,
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify({ ask }),
+    body: JSON.stringify({ tsk }),
   };
   const response = await fetch(
     `${getServerBasePath({ domainName })}/${

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

@@ -17,29 +17,29 @@ import { IDauthUser } from './interfaces';
 
 interface DauthProviderProps {
   domainName: string;
-  ask: string;
+  tsk: string;
   children: React.ReactNode;
 }
 
 export const DauthProvider: React.FC<DauthProviderProps> = (
   props: DauthProviderProps
 ) => {
-  const { domainName, ask, children } = props;
+  const { domainName, tsk, children } = props;
   const [dauthState, dispatch] = useReducer(userReducer, initialDauthState);
 
-  const isValidAsk = useCallback(
+  const isValidTsk = useCallback(
     async (token: string) => {
       const verifyToken = await verifyTokenAPI({
         domainName,
         token,
-        ask,
+        tsk,
       });
       if (verifyToken.response.status !== 200) {
         return false;
       }
       return true;
     },
-    [domainName, ask]
+    [domainName, tsk]
   );
 
   // Check token periodically
@@ -48,7 +48,7 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
     let interval = setInterval(async () => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (!token_ls) return;
-      const isValid = await isValidAsk(token_ls);
+      const isValid = await isValidTsk(token_ls);
       if (isValid) {
         return action.checkTokenAction({
           dispatch,
@@ -56,11 +56,12 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
           token: token_ls,
         });
       } else {
-        return action.setLogoutAction({ dispatch });
+        action.setLogoutAction({ dispatch });
+        throw new Error('Ask value in DauthProvider is not valid');
       }
-    }, 1000 * 60 * 1);
+    }, 1000 * 60 * 5);
     return () => clearInterval(interval);
-  }, [dauthState.isAuthenticated, isValidAsk]);
+  }, [dauthState.isAuthenticated, isValidTsk]);
 
   // Catch login redirect
   useEffect(() => {
@@ -70,7 +71,7 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
       const urlParams = new URLSearchParams(queryString);
       const token_url = urlParams.get(TOKEN_LS);
       if (token_url && !dauthState.isAuthenticated) {
-        const isValid = await isValidAsk(token_url);
+        const isValid = await isValidTsk(token_url);
         if (isValid) {
           return action.setDauthStateAction({
             dispatch,
@@ -78,7 +79,8 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
             domainName,
           });
         } else {
-          return action.setLogoutAction({ dispatch });
+          action.setLogoutAction({ dispatch });
+          throw new Error('Ask value in DauthProvider is not valid');
         }
       }
     })();
@@ -89,15 +91,16 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
     (async () => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (token_ls && !dauthState.isAuthenticated) {
-        const isValid = await isValidAsk(token_ls);
+        const isValid = await isValidTsk(token_ls);
         if (isValid) {
           return action.setAutoLoginAction({
             dispatch,
-            dauth_state_ls: token_ls,
+            token_ls,
             domainName,
           });
         } else {
-          return action.setLogoutAction({ dispatch });
+          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,
@@ -86,13 +86,17 @@ export async function setAutoLoginAction({
         return;
       } else {
         window.location.replace(
-          `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
+          `${getClientBasePath({ domainName })}/${
+            routes.tenantSignin
+          }/${domainName}`
         );
         return resetUser(dispatch);
       }
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
+        `${getClientBasePath({ domainName })}/${
+          routes.tenantSignin
+        }/${domainName}`
       );
       return resetUser(dispatch);
     }
@@ -245,7 +249,9 @@ export async function checkTokenAction({
       return;
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
+        `${getClientBasePath({ domainName })}/${
+          routes.tenantSignin
+        }/${domainName}`
       );
       return resetUser(dispatch);
     }