dauth-context-react 0.2.108 → 0.2.110

package/dist/initialDauthState.d.ts

@@ -1,47 +1,3 @@
-export interface IDauthUser {
-    _id: string;
-    name: string;
-    lastname: string;
-    nickname: string;
-    email: string;
-    isVerified: boolean;
-    language: string;
-    avatar: {
-        id: string;
-        url: string;
-    };
-    role: string;
-    telPrefix: string;
-    telSuffix: string;
-    createdAt: Date;
-    updatedAt: Date;
-    lastLogin: Date;
-}
-export interface IDauthDomainState {
-    name: string;
-    loginRedirect: string;
-    allowedOrigins: string[];
-}
-export interface IDauthState {
-    user: IDauthUser;
-    domain: IDauthDomainState;
-    isLoading: boolean;
-    isAuthenticated: boolean;
-    loginWithRedirect: () => void;
-    logout: () => void;
-    getAccessToken: () => Promise<string>;
-    updateUser: ({ name, lastname, nickname, telPrefix, telSuffix, language, avatar, }: Partial<IDauthUser>) => Promise<boolean>;
-    updateUserWithRedirect: () => void;
-    sendEmailVerificationStatus: {
-        status: IActionStatus;
-        isLoading: boolean;
-    };
-    sendEmailVerification: () => Promise<boolean>;
-}
-export interface IActionStatus {
-    type: TStatusTypes;
-    message: string;
-}
-export declare type TStatusTypes = 'success' | 'error' | 'info' | 'warning';
+import { IDauthState } from "./interfaces";
 declare const initialDauthState: IDauthState;
 export default initialDauthState;

package/dist/interfaces.d.ts

@@ -0,0 +1,45 @@
+export interface IDauthUser {
+    _id: string;
+    name: string;
+    lastname: string;
+    nickname: string;
+    email: string;
+    isVerified: boolean;
+    language: string;
+    avatar: {
+        id: string;
+        url: string;
+    };
+    role: string;
+    telPrefix: string;
+    telSuffix: string;
+    createdAt: Date;
+    updatedAt: Date;
+    lastLogin: Date;
+}
+export interface IDauthDomainState {
+    name: string;
+    loginRedirect: string;
+    allowedOrigins: string[];
+}
+export interface IDauthState {
+    user: IDauthUser;
+    domain: IDauthDomainState;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    loginWithRedirect: () => void;
+    logout: () => void;
+    getAccessToken: () => Promise<string>;
+    updateUser: ({ name, lastname, nickname, telPrefix, telSuffix, language, avatar, }: Partial<IDauthUser>) => Promise<boolean>;
+    updateUserWithRedirect: () => void;
+    sendEmailVerificationStatus: {
+        status: IActionStatus;
+        isLoading: boolean;
+    };
+    sendEmailVerification: () => Promise<boolean>;
+}
+export interface IActionStatus {
+    type: TStatusTypes;
+    message: string;
+}
+export declare type TStatusTypes = 'success' | 'error' | 'info' | 'warning';

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

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { IDauthUser } from '../initialDauthState';
+import { IDauthUser } from '../interfaces';
 declare type TSetDauthStateAction = {
     dispatch: React.Dispatch<any>;
     token: string;

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

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

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.108",
+  "version": "0.2.110",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -62,8 +62,5 @@
     "react",
     "context",
     "authentication"
-  ],
-  "dependencies": {
-    "expo-jwt": "^1.8.0"
-  }
+  ]
 }

package/src/api/dauth.api.ts

@@ -1,6 +1,6 @@
-import { IDauthUser } from '../initialDauthState';
-import { routes } from '../routes';
+import { routes } from './utils/routes';
 import { getServerBasePath } from './utils/config';
+import { IDauthUser } from '../interfaces';
 
 export const getUserAPI = async (
   domainName: string,
@@ -87,3 +87,30 @@ export const refreshAccessTokenAPI = async (
   const data = await response.json();
   return { response, data };
 };
+
+export const verifyTokenAPI = async ({
+  domainName,
+  ask,
+  token,
+}: {
+  domainName: string;
+  ask: string;
+  token: string;
+}): Promise<any> => {
+  const params = {
+    method: 'POST',
+    headers: {
+      Authorization: token,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ ask }),
+  };
+  const response = await fetch(
+    `${getServerBasePath({ domainName })}/${
+      routes.tenantVerifyToken
+    }/${domainName}`,
+    params
+  );
+  const data = await response.json();
+  return { response, data };
+};

package/src/{routes.ts → api/utils/routes.ts}

@@ -4,4 +4,5 @@ export const routes = {
   tenantGetUser: 't-get-user',
   tenantResendEmailVerification: 't-resend-email-verification',
   tenantRefreshAccessToken: 't-refresh-access-token',
+  tenantVerifyToken: "t-verify-token",
 };

package/src/index.tsx

@@ -6,13 +6,14 @@ import React, {
   createContext,
   useContext,
 } from 'react';
-import initialDauthState, { IDauthUser } from './initialDauthState';
+import initialDauthState from './initialDauthState';
 import userReducer from './reducer/dauth.reducer';
 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 'expo-jwt';
+import { routes } from './api/utils/routes';
+import { verifyTokenAPI } from './api/dauth.api';
+import { IDauthUser } from './interfaces';
 
 interface DauthProviderProps {
   domainName: string;
@@ -26,48 +27,80 @@ export const DauthProvider: React.FC<DauthProviderProps> = (
   const { domainName, ask, children } = props;
   const [dauthState, dispatch] = useReducer(userReducer, initialDauthState);
 
+  const isValidAsk = useCallback(
+    async (token: string) => {
+      const verifyToken = await verifyTokenAPI({
+        domainName,
+        token,
+        ask,
+      });
+      if (verifyToken.response.status !== 200) {
+        return false;
+      }
+      return true;
+    },
+    [domainName, ask]
+  );
+
   // Check token periodically
   useEffect(() => {
     if (!dauthState.isAuthenticated) return;
-    let interval = setInterval(() => {
+    let interval = setInterval(async () => {
       const token_ls = localStorage.getItem(TOKEN_LS);
       if (!token_ls) return;
-      action.checkTokenAction({ dispatch, domainName, token: token_ls });
+      const isValid = await isValidAsk(token_ls);
+      if (isValid) {
+        return action.checkTokenAction({
+          dispatch,
+          domainName,
+          token: token_ls,
+        });
+      } else {
+        return action.setLogoutAction({ dispatch });
+      }
     }, 1000 * 60 * 1);
     return () => clearInterval(interval);
-  }, []);
+  }, [dauthState.isAuthenticated, isValidAsk]);
 
   // Catch login redirect
   useEffect(() => {
-    const queryString = window.location.search;
-    if (!queryString) return;
-    const urlParams = new URLSearchParams(queryString);
-    const token_url = urlParams.get(TOKEN_LS);
-    if (token_url && !dauthState.isAuthenticated) {
-      action.setDauthStateAction({ dispatch, token: token_url, domainName });
-    }
+    (async () => {
+      const queryString = window.location.search;
+      if (!queryString) return;
+      const urlParams = new URLSearchParams(queryString);
+      const token_url = urlParams.get(TOKEN_LS);
+      if (token_url && !dauthState.isAuthenticated) {
+        const isValid = await isValidAsk(token_url);
+        if (isValid) {
+          return action.setDauthStateAction({
+            dispatch,
+            token: token_url,
+            domainName,
+          });
+        } else {
+          return action.setLogoutAction({ dispatch });
+        }
+      }
+    })();
   }, []);
 
   // Auto Login
   useEffect(() => {
-    if (dauthState.isAuthenticated) return;
-    const token_ls = localStorage.getItem(TOKEN_LS);
-    if (!token_ls) return;
-    
-    try {
-      const verify = JWT.decode(token_ls, ask as string);
-      console.log({ verify });
-    } catch (error) {
-      console.log(error);
-    }
-
-    if (token_ls && !dauthState.isAuthenticated) {
-      action.setAutoLoginAction({
-        dispatch,
-        dauth_state_ls: token_ls,
-        domainName,
-      });
-    }
+    (async () => {
+      const token_ls = localStorage.getItem(TOKEN_LS);
+      if (token_ls && !dauthState.isAuthenticated) {
+        const isValid = await isValidAsk(token_ls);
+        if (isValid) {
+          return action.setAutoLoginAction({
+            dispatch,
+            dauth_state_ls: token_ls,
+            domainName,
+          });
+        } else {
+          return action.setLogoutAction({ dispatch });
+        }
+      }
+    })();
   }, []);
 
   const loginWithRedirect = useCallback(() => {

package/src/initialDauthState.ts

@@ -1,60 +1,4 @@
-export interface IDauthUser {
-  _id: string;
-  name: string;
-  lastname: string;
-  nickname: string;
-  email: string;
-  isVerified: boolean;
-  language: string;
-  avatar: {
-    id: string;
-    url: string;
-  };
-  role: string;
-  telPrefix: string;
-  telSuffix: string;
-  createdAt: Date;
-  updatedAt: Date;
-  lastLogin: Date;
-}
-
-export interface IDauthDomainState {
-  name: string;
-  loginRedirect: string;
-  allowedOrigins: string[];
-}
-
-export interface IDauthState {
-  user: IDauthUser;
-  domain: IDauthDomainState;
-  isLoading: boolean;
-  isAuthenticated: boolean;
-  loginWithRedirect: () => void;
-  logout: () => void;
-  getAccessToken: () => Promise<string>;
-  updateUser: ({
-    name,
-    lastname,
-    nickname,
-    telPrefix,
-    telSuffix,
-    language,
-    avatar,
-  }: Partial<IDauthUser>) => Promise<boolean>;
-  updateUserWithRedirect: () => void;
-  // Send email verification
-  sendEmailVerificationStatus: {
-    status: IActionStatus;
-    isLoading: boolean;
-  };
-  sendEmailVerification: () => Promise<boolean>;
-}
-
-export interface IActionStatus {
-  type: TStatusTypes;
-  message: string;
-}
-export type TStatusTypes = 'success' | 'error' | 'info' | 'warning';
+import { IActionStatus, IDauthDomainState, IDauthState, IDauthUser } from "./interfaces";
 
 const initialDauthState: IDauthState = {
   user: {

package/src/interfaces.ts

@@ -0,0 +1,57 @@
+export interface IDauthUser {
+  _id: string;
+  name: string;
+  lastname: string;
+  nickname: string;
+  email: string;
+  isVerified: boolean;
+  language: string;
+  avatar: {
+    id: string;
+    url: string;
+  };
+  role: string;
+  telPrefix: string;
+  telSuffix: string;
+  createdAt: Date;
+  updatedAt: Date;
+  lastLogin: Date;
+}
+
+export interface IDauthDomainState {
+  name: string;
+  loginRedirect: string;
+  allowedOrigins: string[];
+}
+
+export interface IDauthState {
+  user: IDauthUser;
+  domain: IDauthDomainState;
+  isLoading: boolean;
+  isAuthenticated: boolean;
+  loginWithRedirect: () => void;
+  logout: () => void;
+  getAccessToken: () => Promise<string>;
+  updateUser: ({
+    name,
+    lastname,
+    nickname,
+    telPrefix,
+    telSuffix,
+    language,
+    avatar,
+  }: Partial<IDauthUser>) => Promise<boolean>;
+  updateUserWithRedirect: () => void;
+  // Send email verification
+  sendEmailVerificationStatus: {
+    status: IActionStatus;
+    isLoading: boolean;
+  };
+  sendEmailVerification: () => Promise<boolean>;
+}
+
+export interface IActionStatus {
+  type: TStatusTypes;
+  message: string;
+}
+export type TStatusTypes = 'success' | 'error' | 'info' | 'warning';

package/src/reducer/dauth.actions.ts

@@ -6,8 +6,8 @@ import {
 } from '../api/dauth.api';
 import { getClientBasePath } from '../api/utils/config';
 import { TOKEN_LS } from '../constants';
-import { IDauthDomainState, IDauthUser } from '../initialDauthState';
-import { routes } from '../routes';
+import { IDauthDomainState, IDauthUser } from '../interfaces';
+import { routes } from '../api/utils/routes';
 import * as DauthTypes from './dauth.types';
 
 type TSetDauthStateAction = {

package/src/reducer/dauth.reducer.ts

@@ -1,4 +1,4 @@
-import { IDauthState } from '../initialDauthState';
+import { IDauthState } from '../interfaces';
 import * as DauthTypes from './dauth.types';
 
 export default function userReducer(state: IDauthState, action: any) {