dauth-context-react 0.2.0 → 0.2.100

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 import React from 'react';
-import { IDauthState } from './initialDauthState';
 interface DauthProviderProps {
     domainName: string;
     sid: string;
     children: React.ReactNode;
 }
 export declare const DauthProvider: React.FC<DauthProviderProps>;
-export declare const useDauth: () => IDauthState;
+export declare const useDauth: () => import("./initialDauthState").IDauthState;
 export {};

package/dist/initialDauthState.d.ts

@@ -31,10 +31,10 @@ export interface IDauthState {
     isAuthenticated: boolean;
     loginWithRedirect: () => void;
     logout: () => void;
-    getAccessToken: () => any;
-    updateUser: ({ name, lastname, nickname, tel_prefix, tel_suffix, language, avatar, }: Partial<IDauthUser>) => void;
+    getAccessToken: () => Promise<string>;
+    updateUser: ({ name, lastname, nickname, tel_prefix, tel_suffix, language, avatar, }: Partial<IDauthUser>) => Promise<boolean>;
     updateUserWithRedirect: () => void;
-    sev: {
+    sendEmailVerificationStatus: {
         status: IActionStatus;
         isLoading: boolean;
     };

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

@@ -1,42 +1,43 @@
+/// <reference types="react" />
 import { IDauthUser } from '../initialDauthState';
 declare type TSetDauthStateAction = {
-    dispatch: any;
-    dauth_state: string;
+    dispatch: React.Dispatch<any>;
+    token: string;
     domainName: string;
 };
-export declare function setDauthStateAction({ dispatch, dauth_state, domainName, }: TSetDauthStateAction): Promise<any>;
+export declare function setDauthStateAction({ dispatch, token, domainName, }: TSetDauthStateAction): Promise<void>;
 declare type TSetAutoLoginAction = {
-    dispatch: any;
+    dispatch: React.Dispatch<any>;
     dauth_state_ls: string;
     domainName: string;
     sid: string;
 };
-export declare function setAutoLoginAction({ dispatch, dauth_state_ls, domainName, sid, }: TSetAutoLoginAction): Promise<any>;
-export declare function setLogoutAction({ dispatch }: {
-    dispatch: any;
-}): Promise<any>;
+export declare function setAutoLoginAction({ dispatch, dauth_state_ls, domainName, sid, }: TSetAutoLoginAction): Promise<void>;
+export declare function setLogoutAction({ dispatch, }: {
+    dispatch: React.Dispatch<any>;
+}): Promise<void>;
 declare type TSetUpdateAction = {
-    dispatch: any;
+    dispatch: React.Dispatch<any>;
     domainName: string;
     user: Partial<IDauthUser>;
     token: string | null;
 };
-export declare function setUpdateUserAction({ dispatch, domainName, user, token, }: TSetUpdateAction): Promise<any>;
+export declare function setUpdateUserAction({ dispatch, domainName, user, token, }: TSetUpdateAction): Promise<boolean>;
 declare type TSetSendEmailVerificationAction = {
-    dispatch: any;
+    dispatch: React.Dispatch<any>;
     domainName: string;
     token: string;
 };
-export declare function sendEmailVerificationAction({ dispatch, domainName, token, }: TSetSendEmailVerificationAction): Promise<any>;
+export declare function sendEmailVerificationAction({ dispatch, domainName, token, }: TSetSendEmailVerificationAction): Promise<void>;
 export declare function checkTokenAction({ dispatch, domainName, sid, token, }: {
-    dispatch: any;
+    dispatch: React.Dispatch<any>;
     domainName: string;
     sid: string;
     token: string;
-}): Promise<any>;
+}): Promise<void>;
 export declare function getAccessTokenAction({ dispatch, domainName, }: {
-    dispatch: any;
+    dispatch: React.Dispatch<any>;
     domainName: string;
 }): Promise<any>;
-export declare const resetUser: (dispatch: any) => any;
+export declare const resetUser: (dispatch: React.Dispatch<any>) => void;
 export {};

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

@@ -1 +1,2 @@
-export default function userReducer(state: any, action: any): any;
+import { IDauthState } from '../initialDauthState';
+export default function userReducer(state: IDauthState, action: any): IDauthState;

package/dist/routes.d.ts

@@ -0,0 +1,7 @@
+export declare const routes: {
+    tenantSignin: string;
+    tenantUpdateUser: string;
+    tenantGetUser: string;
+    tenantResendEmailVerification: string;
+    tenantRefreshAccessToken: string;
+};

package/package.json

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

package/src/api/dauth.api.ts

@@ -1,4 +1,5 @@
 import { IDauthUser } from '../initialDauthState';
+import { routes } from '../routes';
 import { getServerBasePath } from './utils/config';
 
 export const getUserAPI = async (
@@ -13,7 +14,9 @@ export const getUserAPI = async (
     },
   };
   const response = await fetch(
-    `${getServerBasePath({ domainName })}/t-get-user/${domainName}`,
+    `${getServerBasePath({ domainName })}/${
+      routes.tenantGetUser
+    }/${domainName}`,
     params
   );
   const data = await response.json();
@@ -34,7 +37,9 @@ export const updateUserAPI = async (
     body: JSON.stringify(user),
   };
   const response = await fetch(
-    `${getServerBasePath({ domainName })}/t-update-user/${domainName}`,
+    `${getServerBasePath({ domainName })}
+    /${routes.tenantUpdateUser}
+    /${domainName}`,
     params
   );
   const data = await response.json();
@@ -55,7 +60,7 @@ export const sendEmailVerificationAPI = async (
   const response = await fetch(
     `${getServerBasePath({
       domainName,
-    })}/t-resend-email-verification/${domainName}`,
+    })}/${routes.tenantResendEmailVerification}/${domainName}`,
     params
   );
   const data = await response.json();
@@ -76,7 +81,7 @@ export const refreshAccessTokenAPI = async (
   const response = await fetch(
     `${getServerBasePath({
       domainName,
-    })}/t-refresh-access-token/${domainName}`,
+    })}/${routes.tenantRefreshAccessToken}/${domainName}`,
     params
   );
   const data = await response.json();

package/src/constants.ts

@@ -1 +1 @@
-export const DAUTH_STATE = 'dauth_state';
+export const TOKEN_LS = 'dauth_state';

package/src/index.tsx

@@ -6,14 +6,12 @@ import React, {
   createContext,
   useContext,
 } from 'react';
-import initialDauthState, {
-  IDauthState,
-  IDauthUser,
-} from './initialDauthState';
+import initialDauthState, { IDauthUser } from './initialDauthState';
 import userReducer from './reducer/dauth.reducer';
 import * as action from './reducer/dauth.actions';
 import { getClientBasePath } from './api/utils/config';
-import { DAUTH_STATE } from './constants';
+import { TOKEN_LS } from './constants';
+import { routes } from './routes';
 
 interface DauthProviderProps {
   domainName: string;
@@ -25,14 +23,13 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
   props: DauthProviderProps
 ) => {
   const { domainName, sid, children } = props;
-  const [ds, dispatch] = useReducer(userReducer, initialDauthState);
-  const dauthState = ds as IDauthState;
+  const [dauthState, dispatch] = useReducer(userReducer, initialDauthState);
 
   // Check token periodically
   useEffect(() => {
     if (!dauthState.isAuthenticated) return;
     let interval = setInterval(() => {
-      const token_ls = localStorage.getItem(DAUTH_STATE);
+      const token_ls = localStorage.getItem(TOKEN_LS);
       if (!token_ls) return;
       action.checkTokenAction({ dispatch, domainName, sid, token: token_ls });
     }, 1000 * 60 * 2);
@@ -44,15 +41,15 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
     const queryString = window.location.search;
     if (!queryString) return;
     const urlParams = new URLSearchParams(queryString);
-    const dauth_state = urlParams.get(DAUTH_STATE);
-    if (dauth_state && !dauthState.isAuthenticated) {
-      action.setDauthStateAction({ dispatch, dauth_state, domainName });
+    const token_url = urlParams.get(TOKEN_LS);
+    if (token_url && !dauthState.isAuthenticated) {
+      action.setDauthStateAction({ dispatch, token: token_url, domainName });
     }
   }, []);
 
   // Auto Login
   useEffect(() => {
-    const dauth_state_ls = localStorage.getItem(DAUTH_STATE);
+    const dauth_state_ls = localStorage.getItem(TOKEN_LS);
     if (dauth_state_ls && !dauthState.isAuthenticated) {
       action.setAutoLoginAction({ dispatch, dauth_state_ls, domainName, sid });
     }
@@ -60,7 +57,7 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
 
   const loginWithRedirect = useCallback(() => {
     return window.location.replace(
-      `${getClientBasePath({ domainName })}/t-signin/${sid}`
+      `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
     );
   }, [domainName, sid]);
 
@@ -70,11 +67,11 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
 
   const getAccessToken = useCallback(async () => {
     const token = await action.getAccessTokenAction({ dispatch, domainName });
-    return token;
+    return token as string;
   }, []);
 
   const updateUser = useCallback(
-    ({
+    async ({
       name,
       lastname,
       nickname,
@@ -83,7 +80,7 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
       language,
       avatar,
     }: Partial<IDauthUser>) => {
-      const token_ls = localStorage.getItem(DAUTH_STATE);
+      const token_ls = localStorage.getItem(TOKEN_LS);
       const user = {
         name,
         lastname,
@@ -93,26 +90,29 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
         language,
         avatar,
       } as Partial<IDauthUser>;
-      return action.setUpdateUserAction({
+      return (await action.setUpdateUserAction({
         dispatch,
         domainName,
         user,
         token: token_ls,
-      });
+      })) as boolean;
     },
     [domainName]
   );
 
   const updateUserWithRedirect = useCallback(() => {
-    const token_ls = localStorage.getItem(DAUTH_STATE);
+    const token_ls = localStorage.getItem(TOKEN_LS);
     if (!token_ls) return;
     return window.location.replace(
-      `${getClientBasePath({ domainName })}/t-update-user/${sid}/${token_ls}`
+      `${getClientBasePath({ domainName })}
+      /${routes.tenantUpdateUser}
+      /${sid}
+      /${token_ls}`
     );
   }, [domainName, sid]);
 
   const sendEmailVerification = useCallback(() => {
-    const token_ls = localStorage.getItem(DAUTH_STATE);
+    const token_ls = localStorage.getItem(TOKEN_LS);
     if (!token_ls) return;
     return action.sendEmailVerificationAction({
       dispatch,

package/src/initialDauthState.ts

@@ -33,7 +33,7 @@ export interface IDauthState {
   isAuthenticated: boolean;
   loginWithRedirect: () => void;
   logout: () => void;
-  getAccessToken: () => any;
+  getAccessToken: () => Promise<string>;
   updateUser: ({
     name,
     lastname,
@@ -42,10 +42,10 @@ export interface IDauthState {
     tel_suffix,
     language,
     avatar,
-  }: Partial<IDauthUser>) => void;
+  }: Partial<IDauthUser>) => Promise<boolean>;
   updateUserWithRedirect: () => void;
   // Send email verification
-  sev: {
+  sendEmailVerificationStatus: {
     status: IActionStatus;
     isLoading: boolean;
   };
@@ -67,11 +67,11 @@ const initialDauthState: IDauthState = {
   isAuthenticated: false,
   loginWithRedirect: () => {},
   logout: () => {},
-  getAccessToken: () => initialDauthState.getAccessToken() || '',
-  updateUser: () => {},
+  getAccessToken: () => Promise.resolve(''),
+  updateUser: () => Promise.resolve(false),
   updateUserWithRedirect: () => {},
   // Send email verification
-  sev: {
+  sendEmailVerificationStatus: {
     status: {
       type: 'info',
       message: 'Sending email verification...',

package/src/reducer/dauth.actions.ts

@@ -5,23 +5,24 @@ import {
   updateUserAPI,
 } from '../api/dauth.api';
 import { getClientBasePath } from '../api/utils/config';
-import { DAUTH_STATE } from '../constants';
+import { TOKEN_LS } from '../constants';
 import { IDauthDomainState, IDauthUser } from '../initialDauthState';
+import { routes } from '../routes';
 import * as DauthTypes from './dauth.types';
 
 type TSetDauthStateAction = {
-  dispatch: any;
-  dauth_state: string;
+  dispatch: React.Dispatch<any>;
+  token: string;
   domainName: string;
 };
 export async function setDauthStateAction({
   dispatch,
-  dauth_state,
+  token,
   domainName,
 }: TSetDauthStateAction) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
   try {
-    const getUserFetch = await getUserAPI(domainName, dauth_state);
+    const getUserFetch = await getUserAPI(domainName, token);
     if (getUserFetch.response.status === 200) {
       dispatch({
         type: DauthTypes.LOGIN,
@@ -36,7 +37,7 @@ export async function setDauthStateAction({
         document.title,
         getUserFetch.data.domain.loginRedirect
       );
-      return localStorage.setItem(DAUTH_STATE, dauth_state);
+      return localStorage.setItem(TOKEN_LS, token);
     } else {
       return resetUser(dispatch);
     }
@@ -52,7 +53,7 @@ export async function setDauthStateAction({
 }
 
 type TSetAutoLoginAction = {
-  dispatch: any;
+  dispatch: React.Dispatch<any>;
   dauth_state_ls: string;
   domainName: string;
   sid: string;
@@ -81,19 +82,19 @@ export async function setAutoLoginAction({
           },
         });
         localStorage.setItem(
-          DAUTH_STATE,
+          TOKEN_LS,
           refreshAccessTokenFetch.data.accessToken
         );
         return;
       } else {
         window.location.replace(
-          `${getClientBasePath({ domainName })}/t-signin/${sid}`
+          `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
         );
         return resetUser(dispatch);
       }
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/t-signin/${sid}`
+        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
       );
       return resetUser(dispatch);
     }
@@ -108,7 +109,11 @@ export async function setAutoLoginAction({
   }
 }
 
-export async function setLogoutAction({ dispatch }: { dispatch: any }) {
+export async function setLogoutAction({
+  dispatch,
+}: {
+  dispatch: React.Dispatch<any>;
+}) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
   dispatch({
     type: DauthTypes.LOGIN,
@@ -120,7 +125,7 @@ export async function setLogoutAction({ dispatch }: { dispatch: any }) {
       isAuthenticated: false,
     },
   });
-  localStorage.removeItem(DAUTH_STATE);
+  localStorage.removeItem(TOKEN_LS);
   return dispatch({
     type: DauthTypes.SET_IS_LOADING,
     payload: { isLoading: false },
@@ -128,7 +133,7 @@ export async function setLogoutAction({ dispatch }: { dispatch: any }) {
 }
 
 type TSetUpdateAction = {
-  dispatch: any;
+  dispatch: React.Dispatch<any>;
   domainName: string;
   user: Partial<IDauthUser>;
   token: string | null;
@@ -143,29 +148,32 @@ export async function setUpdateUserAction({
     window.document.documentElement.setAttribute('lang', user.language);
   }
   if (!token) {
-    return dispatch({
+    dispatch({
       type: DauthTypes.UPDATE_USER,
       payload: user,
     });
+    return false;
   }
   try {
     const getUserFetch = await updateUserAPI(domainName, user, token);
     if (getUserFetch.response.status === 200) {
-      return dispatch({
+      dispatch({
         type: DauthTypes.UPDATE_USER,
         payload: getUserFetch.data.user,
       });
+      return true;
     } else {
       console.log('Update user error', getUserFetch.data.message);
-      return;
+      return false;
     }
   } catch (error) {
     console.log('Update user error', error);
+    return false;
   }
 }
 
 type TSetSendEmailVerificationAction = {
-  dispatch: any;
+  dispatch: React.Dispatch<any>;
   domainName: string;
   token: string;
 };
@@ -224,7 +232,7 @@ export async function checkTokenAction({
   sid,
   token,
 }: {
-  dispatch: any;
+  dispatch: React.Dispatch<any>;
   domainName: string;
   sid: string;
   token: string;
@@ -238,7 +246,7 @@ export async function checkTokenAction({
       return;
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/t-signin/${sid}`
+        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
       );
       return resetUser(dispatch);
     }
@@ -252,10 +260,10 @@ export async function getAccessTokenAction({
   dispatch,
   domainName,
 }: {
-  dispatch: any;
+  dispatch: React.Dispatch<any>;
   domainName: string;
 }) {
-  const token_ls = localStorage.getItem(DAUTH_STATE);
+  const token_ls = localStorage.getItem(TOKEN_LS);
   if (!token_ls) return;
   try {
     const refreshAccessTokenFetch = await refreshAccessTokenAPI(
@@ -276,8 +284,8 @@ export async function getAccessTokenAction({
 
 ///////////////////////////////////////////
 //////////////////////////////////////////
-export const resetUser = (dispatch: any) => {
-  localStorage.removeItem(DAUTH_STATE);
+export const resetUser = (dispatch: React.Dispatch<any>) => {
+  localStorage.removeItem(TOKEN_LS);
   return dispatch({
     type: DauthTypes.LOGIN,
     payload: {

package/src/reducer/dauth.reducer.ts

@@ -1,52 +1,63 @@
+import { IDauthState } from '../initialDauthState';
 import * as DauthTypes from './dauth.types';
 
-export default function userReducer(state: any, action: any) {
+export default function userReducer(state: IDauthState, action: any) {
   const { type, payload } = action;
 
   switch (type) {
-    case DauthTypes.LOGIN:
-      return {
+    case DauthTypes.LOGIN: {
+      const login: IDauthState = {
         ...state,
         user: payload.user,
         domain: payload.domain,
         isAuthenticated: payload.isAuthenticated,
       };
+      return login;
+    }
 
-    case DauthTypes.SET_IS_LOADING:
-      return {
+    case DauthTypes.SET_IS_LOADING: {
+      const isLoading: IDauthState = {
         ...state,
         isLoading: payload.isLoading,
       };
+      return isLoading;
+    }
 
-    case DauthTypes.UPDATE_USER:
-      return {
+    case DauthTypes.UPDATE_USER: {
+      const updateUser: IDauthState = {
         ...state,
         user: {
           ...state.user,
           ...payload,
         },
       };
+      return updateUser;
+    }
 
-    case DauthTypes.SET_SEND_EMAIL_VERIFICATION_STATUS:
-      return {
+    case DauthTypes.SET_SEND_EMAIL_VERIFICATION_STATUS: {
+      const setSendEmailVerificationStatus: IDauthState = {
         ...state,
-        sev: {
-          ...state.sev,
+        sendEmailVerificationStatus: {
+          ...state.sendEmailVerificationStatus,
           status: {
             type: payload.type,
             message: payload.message,
           },
         },
       };
+      return setSendEmailVerificationStatus;
+    }
 
-    case DauthTypes.SET_SEND_EMAIL_VERIFICATION_IS_LOADING:
-      return {
+    case DauthTypes.SET_SEND_EMAIL_VERIFICATION_IS_LOADING: {
+      const setSendEmailVerificationIsLoading: IDauthState = {
         ...state,
-        sev: {
-          ...state.sev,
+        sendEmailVerificationStatus: {
+          ...state.sendEmailVerificationStatus,
           isLoading: payload,
         },
       };
+      return setSendEmailVerificationIsLoading;
+    }
 
     default:
       return state;

package/src/routes.ts

@@ -0,0 +1,7 @@
+export const routes = {
+  tenantSignin: 't-signin',
+  tenantUpdateUser: 't-update-user',
+  tenantGetUser: 't-get-user',
+  tenantResendEmailVerification: 't-resend-email-verification',
+  tenantRefreshAccessToken: 't-refresh-access-token',
+};