dauth-context-react 0.2.104 → 0.2.106

package/dist/initialDauthState.d.ts

@@ -1,23 +1,21 @@
 export interface IDauthUser {
     _id: string;
-    dauthLicense?: string;
-    sid: string;
     name: string;
     lastname: string;
     nickname: string;
     email: string;
-    is_verified: boolean;
+    isVerified: boolean;
     language: string;
     avatar: {
         id: string;
         url: string;
     };
     role: string;
-    tel_prefix: string;
-    tel_suffix: string;
+    telPrefix: string;
+    telSuffix: string;
     createdAt: Date;
     updatedAt: Date;
-    last_login: Date;
+    lastLogin: Date;
 }
 export interface IDauthDomainState {
     name: string;
@@ -32,7 +30,7 @@ export interface IDauthState {
     loginWithRedirect: () => void;
     logout: () => void;
     getAccessToken: () => Promise<string>;
-    updateUser: ({ name, lastname, nickname, tel_prefix, tel_suffix, language, avatar, }: Partial<IDauthUser>) => Promise<boolean>;
+    updateUser: ({ name, lastname, nickname, telPrefix, telSuffix, language, avatar, }: Partial<IDauthUser>) => Promise<boolean>;
     updateUserWithRedirect: () => void;
     sendEmailVerificationStatus: {
         status: IActionStatus;

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

@@ -10,9 +10,8 @@ declare type TSetAutoLoginAction = {
     dispatch: React.Dispatch<any>;
     dauth_state_ls: string;
     domainName: string;
-    sid: string;
 };
-export declare function setAutoLoginAction({ dispatch, dauth_state_ls, domainName, sid, }: TSetAutoLoginAction): Promise<void>;
+export declare function setAutoLoginAction({ dispatch, dauth_state_ls, domainName, }: TSetAutoLoginAction): Promise<void>;
 export declare function setLogoutAction({ dispatch, }: {
     dispatch: React.Dispatch<any>;
 }): void;
@@ -29,10 +28,9 @@ declare type TSetSendEmailVerificationAction = {
     token: string;
 };
 export declare function sendEmailVerificationAction({ dispatch, domainName, token, }: TSetSendEmailVerificationAction): Promise<boolean>;
-export declare function checkTokenAction({ dispatch, domainName, sid, token, }: {
+export declare function checkTokenAction({ dispatch, domainName, token, }: {
     dispatch: React.Dispatch<any>;
     domainName: string;
-    sid: string;
     token: string;
 }): Promise<void>;
 export declare function getAccessTokenAction({ dispatch, domainName, }: {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.104",
+  "version": "0.2.106",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -48,6 +48,7 @@
   ],
   "devDependencies": {
     "@size-limit/preset-small-lib": "^11.0.2",
+    "@types/jsonwebtoken": "^9.0.7",
     "@types/react": "^18.2.55",
     "@types/react-dom": "^18.2.19",
     "husky": "^9.0.10",
@@ -62,5 +63,8 @@
     "react",
     "context",
     "authentication"
-  ]
+  ],
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2"
+  }
 }

package/src/index.tsx

@@ -12,30 +12,65 @@ import * as action from './reducer/dauth.actions';
 import { getClientBasePath } from './api/utils/config';
 import { TOKEN_LS } from './constants';
 import { routes } from './routes';
+import jwt from 'jsonwebtoken';
 
 interface DauthProviderProps {
   domainName: string;
-  sid: string;
+  ask: string;
   children: React.ReactNode;
 }
 
 export const DauthProvider: React.FC<DauthProviderProps> = (
   props: DauthProviderProps
 ) => {
-  const { domainName, sid, children } = props;
+  const { domainName, ask, children } = props;
   const [dauthState, dispatch] = useReducer(userReducer, initialDauthState);
 
+  // useEffect(() => {
+  //   const verifyToken = async () => {
+  //     const token = localStorage.getItem(TOKEN_LS);
+  //     if (!token) return;
+
+  //     try {
+  //       const response = await fetch('/api/verifyToken', {
+  //         method: 'POST',
+  //         headers: {
+  //           'Content-Type': 'application/json',
+  //           Authorization: `Bearer ${token}`,
+  //         },
+  //         body: JSON.stringify({ token }),
+  //       });
+
+  //       if (response.ok) {
+  //         const data = await response.json();
+  //         if (data.valid) {
+  //           dispatch({ type: 'SET_AUTHENTICATED', payload: true });
+  //         } else {
+  //           dispatch({ type: 'SET_AUTHENTICATED', payload: false });
+  //         }
+  //       } else {
+  //         dispatch({ type: 'SET_AUTHENTICATED', payload: false });
+  //       }
+  //     } catch (error) {
+  //       console.error('Error verifying token:', error);
+  //       dispatch({ type: 'SET_AUTHENTICATED', payload: false });
+  //     }
+  //   };
+
+  //   verifyToken();
+  // }, [dispatch]);
+
   // Check token periodically
   useEffect(() => {
     if (!dauthState.isAuthenticated) return;
     let interval = setInterval(() => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (!token_ls) return;
-      action.checkTokenAction({ dispatch, domainName, sid, token: token_ls });
-    }, 1000 * 60 * 2);
+      action.checkTokenAction({ dispatch, domainName, token: token_ls });
+    }, 1000 * 60 * 1);
     return () => clearInterval(interval);
   }, []);
-
+  
   // Catch login redirect
   useEffect(() => {
     const queryString = window.location.search;
@@ -46,20 +81,24 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
       action.setDauthStateAction({ dispatch, token: token_url, domainName });
     }
   }, []);
-
+  
   // Auto Login
   useEffect(() => {
-    const dauth_state_ls = localStorage.getItem(TOKEN_LS);
-    if (dauth_state_ls && !dauthState.isAuthenticated) {
-      action.setAutoLoginAction({ dispatch, dauth_state_ls, domainName, sid });
+    if (dauthState.isAuthenticated) return;
+    const token_ls = localStorage.getItem(TOKEN_LS);
+    if (!token_ls) return;
+    const verify = jwt.verify(token_ls, ask as string);
+    console.log({ verify });
+    if (token_ls && !dauthState.isAuthenticated) {
+      action.setAutoLoginAction({ dispatch, dauth_state_ls: token_ls, domainName });
     }
   }, []);
 
   const loginWithRedirect = useCallback(() => {
     return window.location.replace(
-      `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
+      `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
     );
-  }, [domainName, sid]);
+  }, [domainName, domainName]);
 
   const logout = useCallback(() => {
     return action.setLogoutAction({ dispatch });
@@ -75,8 +114,8 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
       name,
       lastname,
       nickname,
-      tel_prefix,
-      tel_suffix,
+      telPrefix,
+      telSuffix,
       language,
       avatar,
     }: Partial<IDauthUser>) => {
@@ -85,8 +124,8 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
         name,
         lastname,
         nickname,
-        tel_prefix,
-        tel_suffix,
+        telPrefix,
+        telSuffix,
         language,
         avatar,
       } as Partial<IDauthUser>;
@@ -106,9 +145,9 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
     return window.location.replace(
       `${getClientBasePath({ domainName })}/${
         routes.tenantUpdateUser
-      }/${sid}/${token_ls}`
+      }/${domainName}/${token_ls}`
     );
-  }, [domainName, sid]);
+  }, [domainName, domainName]);
 
   const sendEmailVerification = useCallback(async () => {
     const token_ls = localStorage.getItem(TOKEN_LS);

package/src/initialDauthState.ts

@@ -1,23 +1,21 @@
 export interface IDauthUser {
   _id: string;
-  dauthLicense?: string;
-  sid: string;
   name: string;
   lastname: string;
   nickname: string;
   email: string;
-  is_verified: boolean;
+  isVerified: boolean;
   language: string;
   avatar: {
     id: string;
     url: string;
   };
   role: string;
-  tel_prefix: string;
-  tel_suffix: string;
+  telPrefix: string;
+  telSuffix: string;
   createdAt: Date;
   updatedAt: Date;
-  last_login: Date;
+  lastLogin: Date;
 }
 
 export interface IDauthDomainState {
@@ -38,8 +36,8 @@ export interface IDauthState {
     name,
     lastname,
     nickname,
-    tel_prefix,
-    tel_suffix,
+    telPrefix,
+    telSuffix,
     language,
     avatar,
   }: Partial<IDauthUser>) => Promise<boolean>;

package/src/reducer/dauth.actions.ts

@@ -56,20 +56,18 @@ type TSetAutoLoginAction = {
   dispatch: React.Dispatch<any>;
   dauth_state_ls: string;
   domainName: string;
-  sid: string;
 };
 export async function setAutoLoginAction({
   dispatch,
   dauth_state_ls,
   domainName,
-  sid,
 }: TSetAutoLoginAction) {
   dispatch({ type: DauthTypes.SET_IS_LOADING, payload: { isLoading: true } });
   try {
     const refreshAccessTokenFetch = await refreshAccessTokenAPI(
       domainName,
       dauth_state_ls
-    );
+    );    
     if (refreshAccessTokenFetch.response.status === 200) {
       const getUserFetch = await getUserAPI(domainName, dauth_state_ls);
       if (getUserFetch.response.status === 200) {
@@ -88,13 +86,13 @@ export async function setAutoLoginAction({
         return;
       } else {
         window.location.replace(
-          `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
+          `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
         );
         return resetUser(dispatch);
       }
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
+        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
       );
       return resetUser(dispatch);
     }
@@ -232,12 +230,10 @@ export async function sendEmailVerificationAction({
 export async function checkTokenAction({
   dispatch,
   domainName,
-  sid,
   token,
 }: {
   dispatch: React.Dispatch<any>;
   domainName: string;
-  sid: string;
   token: string;
 }) {
   try {
@@ -249,7 +245,7 @@ export async function checkTokenAction({
       return;
     } else {
       window.location.replace(
-        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${sid}`
+        `${getClientBasePath({ domainName })}/${routes.tenantSignin}/${domainName}`
       );
       return resetUser(dispatch);
     }