Use compute auth service and fix static code analyzer warnings (#15)

* Clean up formatting

* Use new compute_auth service
Implment SSO
Implement token refresh
Clean up unit tests

* Fix unit tests

* Fix auth test
Fix warnings

* Update default settings for compute_auth

src/components/Contexts/UserContext.jsx

@@ -17,98 +17,86 @@ export const UserProvider = ({ children }) => {
     if (!t.idToken.payload || !t.idToken.payload.exp) return;
     setToken(t);
   }, []);
- 
+
   useEffect(() => {
     if (!token) return;
-    const { idToken: { jwtToken }} = token;
+    const {
+      idToken: { jwtToken },
+    } = token;
     verifyToken(jwtToken);
     return () => {
       if (timer) timer.terminate();
     };
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [token])
+  }, [token]);
 
-  const verifyToken = async (accessToken) => {
-    const result = await auth.verify(accessToken);
+  const refreshTokens = async () => {
+    if (!token || !token.refreshToken || !token.refreshToken.token) return null;
+    const result = await refresh(token.refreshToken.token);
+    return result;
+  }
 
-    if (!result.authenticated || !token.idToken.payload || !token.idToken.payload.exp) {
-      signOut();
-      return;
-    }
+  const isError = (resp) => {
+    if (resp === null) return true;
+    if (resp && resp.error) return true;
+    return false;
+  }
 
-    const duration = (1000 * token.idToken.payload.exp) - (new Date()).getTime();
+  const startSessionTimer = () => {
+    const duration = 1000 * token.idToken.payload.exp - new Date().getTime();
     if (!timer) {
-       timer = getTimerWorker();
-       timer.onMessage((e) => {
+      timer = getTimerWorker();
+      timer.onMessage(async (e) => {
         if (e.data === "timeout") {
+          const t = await refreshTokens();
+          if (!isError(t)) return;
           signOut();
         }
-      })  
+      });
     }
     timer.start(duration);
   };
 
-  const signIn = async (username, password) => {
+  const verifyToken = async (idToken) => {
+    try {
+      const result = await auth.verify(idToken);
+
+      if (
+        !result.authenticated ||
+        !token.idToken.payload ||
+        !token.idToken.payload.exp
+      ) {
+        const t = await refreshTokens();
+        if (!isError(t)) return;
+        signOut();
+        return;
+      }
+  
+      startSessionTimer();  
+    }
+    catch (e) {
+      setError(e.message);
+    }
+  };
+
+  const signIn = async (code) => {
     let result = null;
 
     try {
-      if (!username) throw new Error('Email is required');
-      if (!password) throw new Error('Password is required');
-  
+      if (!code) return;
+
       setFetching(true);
       setError(null);
-  
-      result = await auth.signIn(username, password);
 
-      if (result.message) throw new Error(result.message);
+      result = await auth.signIn(code);
+      if (result.message) {
+        throw new Error(result.message);
+      }
+
       signedIn(result);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
-      setFetching(false);
-    }
-
-    return result;
-  };
-
-  const signUp = async (username, password, confirmPassword) => {
-    let result = null;
-
-    try {
-      if (!username) throw new Error('Email is required');
-      if (!password) throw new Error('Password is required');
-      if (password !== confirmPassword) throw new Error('Passwords do not match');
-
-      setFetching(true);
-      setError(null);
-
-      result = await auth.signUp(username, password);
-      if (result.message) throw new Error(result.message);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
-      setFetching(false);
-    }
-
-    return result;
-  };
-
-  const signUpAndIn =  async (username, password, confirmPassword) => {
-    let result = null;
-
-    try {
-      result = await signUp(username, password, confirmPassword);
-      if (result.message) throw new Error(result.message);
-      result = await signIn(username, password);
-    }
-    catch (error) {
-      setError(error.message);
-    }
-    finally {
+    } catch (err) {
+      setError(`Sign in error. ${err.message}`);
+    } finally {
       setFetching(false);
     }
 
@@ -117,27 +105,61 @@ export const UserProvider = ({ children }) => {
 
   const signOut = () => {
     setToken(null);
-    if (!localStorage) return;
-    localStorage.removeItem("token");
+    if (localStorage) {
+      localStorage.removeItem("token");
+    }
+    return getLogoutURL();
   };
 
-  const signedIn = (token) => {
-    setToken(token);
-    if (!localStorage || !token || !token.idToken) return;
-    localStorage.setItem("token", JSON.stringify(token));
-  }
+  const signedIn = (value) => {
+    setToken(value);
+    if (!localStorage || !value || !value.idToken) return;
+    localStorage.setItem("token", JSON.stringify(value));
+  };
+
+  const refresh = async (value) => {
+    let result = null;
+
+    try {
+      if (!value) {
+        throw new Error("Token required");
+      }
+      setFetching(true);
+      setError(null);
+
+      // eslint-disable-next-line
+      result = await auth.refresh(value);
+
+      if (result.message) {
+        throw new Error(result.message);
+      }
+      signedIn(result);
+    } catch (err) {
+      setError(`Refresh error. ${err.message}`);
+    } finally {
+      setFetching(false);
+    }
+
+    return result;
+  };
+
+  const getAuthorizeURL = () => auth.ssoAuthorize();
+  const getLogoutURL = () => auth.ssoLogout();
 
   return (
-    <UserContext.Provider value={{
-      fetching,
-      token,
-      error,
-      setError,
-      signIn,
-      signUp,
-      signUpAndIn,
-      signOut,
-    }}>
+    <UserContext.Provider
+      value={{
+        fetching,
+        token,
+        error,
+        setError,
+        signIn,
+        signOut,
+        refresh,
+        getAuthorizeURL,
+        getLogoutURL,
+      }}
+    >
       {children}
     </UserContext.Provider>
   );