Remove remaining SecurityClient auth calls in favor of hooks, keep RouteGuard

frontend/src/hooks/api/auth/index.tsx

@@ -1,6 +1,10 @@
 export {
   useGetAuthToken,
   useGetCommonPasswords,
+  useResetPassword,
   useSendMfaToken, 
-  useVerifyMfaToken
-} from "./queries"
+  useSendPasswordResetEmail,
+  useSendVerificationEmail,
+  useVerifyEmailVerificationCode,
+  useVerifyMfaToken,
+  useVerifyPasswordResetCode} from "./queries"

frontend/src/hooks/api/auth/queries.tsx

@@ -4,16 +4,86 @@ import { apiRequest } from "@app/config/request";
 import { setAuthToken } from "@app/reactQuery";
 
 import {
+  ChangePasswordDTO,
+  CompleteAccountDTO,
+  CompleteAccountSignupDTO,
   GetAuthTokenAPI,
+  GetBackupEncryptedPrivateKeyDTO,
+  IssueBackupPrivateKeyDTO,
+  Login1DTO,
+  Login1Res,
+  Login2DTO,
+  Login2Res,
+  ResetPasswordDTO,
   SendMfaTokenDTO,
+  SRP1DTO,
+  SRPR1Res,
   VerifyMfaTokenDTO,
-  VerifyMfaTokenRes} from "./types";
+  VerifyMfaTokenRes,
+  VerifySignupInviteDTO} from "./types";
 
 const authKeys = {
   getAuthToken: ["token"] as const,
   commonPasswords: ["common-passwords"] as const
 };
 
+export const login1 = async (loginDetails: Login1DTO) => {
+  const { data } = await apiRequest.post<Login1Res>("/api/v3/auth/login1", loginDetails);
+  return data;
+}
+
+export const login2 = async (loginDetails: Login2DTO) => {
+  const { data } = await apiRequest.post<Login2Res>("/api/v3/auth/login2", loginDetails);
+  return data;
+}
+
+export const useLogin1 = () => {
+  return useMutation({
+    mutationFn: async (details: {
+      email: string;
+      clientPublicKey: string;
+      providerAuthToken?: string;
+    }) => {
+      return login1(details);
+    }
+  });
+}
+
+export const useLogin2 = () => {
+  return useMutation({
+    mutationFn: async (details: {
+      email: string;
+      clientProof: string;
+      providerAuthToken?: string;
+    }) => {
+      return login2(details);
+    }
+  });
+}
+
+export const srp1 = async (details: SRP1DTO) => {
+  const { data } = await apiRequest.post<SRPR1Res>("/api/v1/password/srp1", details);
+  return data; 
+}
+
+export const completeAccountSignup = async (details: CompleteAccountSignupDTO) => {
+  const { data } = await apiRequest.post("/api/v3/signup/complete-account/signup", details);
+  return data; 
+}
+
+export const completeAccountSignupInvite = async (details: CompleteAccountDTO) => {
+  const { data } = await apiRequest.post("/api/v2/signup/complete-account/invite", details);
+  return data; 
+}
+
+export const useCompleteAccountSignup = () => {
+  return useMutation({
+    mutationFn: async (details: CompleteAccountSignupDTO) => {
+      return completeAccountSignup(details);
+    }
+  });
+}
+
 export const useSendMfaToken = () => {
   return useMutation<{}, {}, SendMfaTokenDTO>({
     mutationFn: async ({ email }) => {
@@ -23,18 +93,161 @@ export const useSendMfaToken = () => {
   });
 }
 
+export const verifyMfaToken = async ({
+  email,
+  mfaCode
+}: {
+  email: string;
+  mfaCode: string;
+}) => {
+  const { data } = await apiRequest.post("/api/v2/auth/mfa/verify", {
+    email,
+    mfaToken: mfaCode
+  });
+
+  return data;
+}
+
 export const useVerifyMfaToken = () => {
   return useMutation<VerifyMfaTokenRes, {}, VerifyMfaTokenDTO>({
     mutationFn: async ({ email, mfaCode }) => {
-      const { data } = await apiRequest.post("/api/v2/auth/mfa/verify", {
+      return verifyMfaToken({
         email,
-        mfaToken: mfaCode
+        mfaCode
       });
+    }
+  });
+}
+
+export const verifySignupInvite = async (details: VerifySignupInviteDTO) => {
+  const { data } = await apiRequest.post("/api/v1/invite-org/verify", details);
+  return data;
+}
+
+export const useSendVerificationEmail = () => {
+  return useMutation({
+    mutationFn: async ({ 
+      email 
+    }: { 
+      email: string; 
+    }) => {
+      const { data } = await apiRequest.post("/api/v1/signup/email/signup", {
+        email
+      });
+      
       return data;
     }
   });
 }
 
+export const useVerifyEmailVerificationCode = () => {
+  return useMutation({
+    mutationFn: async ({ 
+      email,
+      code
+    }: { 
+      email: string; 
+      code: string; 
+    }) => {
+      const { data } = await apiRequest.post("/api/v1/signup/email/verify", {
+        email,
+        code
+      });
+      
+      return data;
+    }
+  });
+}
+
+export const useSendPasswordResetEmail = () => {
+  return useMutation({
+    mutationFn: async ({ 
+      email 
+    }: { 
+      email: string; 
+    }) => {
+      const { data } = await apiRequest.post("/api/v1/password/email/password-reset", {
+        email
+      });
+      
+      return data;
+    }
+  });
+}
+
+export const useVerifyPasswordResetCode = () => {
+  return useMutation({
+    mutationFn: async ({ 
+      email,
+      code
+    }: { 
+      email: string; 
+      code: string; 
+    }) => {
+      const { data } = await apiRequest.post("/api/v1/password/email/password-reset-verify", {
+        email,
+        code
+      });
+      
+      return data;
+    }
+  });
+}
+
+export const issueBackupPrivateKey = async (details: IssueBackupPrivateKeyDTO) => {
+  const { data } = await apiRequest.post("/api/v1/password/backup-private-key", details);
+  return data;
+}
+
+export const getBackupEncryptedPrivateKey = async ({
+  verificationToken
+}: GetBackupEncryptedPrivateKeyDTO) => {
+  const { data } = await apiRequest.get("/api/v1/password/backup-private-key", {
+    headers: {
+      Authorization: `Bearer ${verificationToken}`
+    }
+  });
+  
+  return data.backupPrivateKey;
+}
+
+export const useResetPassword = () => {
+  return useMutation({
+    mutationFn: async (details: ResetPasswordDTO) => {
+      const { data } = await apiRequest.post("/api/v1/password/password-reset", {
+        protectedKey: details.protectedKey,
+        protectedKeyIV: details.protectedKeyIV,
+        protectedKeyTag: details.protectedKeyTag,
+        encryptedPrivateKey: details.encryptedPrivateKey,
+        encryptedPrivateKeyIV: details.encryptedPrivateKeyIV,
+        encryptedPrivateKeyTag: details.encryptedPrivateKeyTag,
+        salt: details.salt,
+        verifier: details.verifier
+      }, {
+        headers: {
+          Authorization: `Bearer ${details.verificationToken}`
+        }
+      });
+      
+      return data;
+    }
+  });
+}
+
+export const changePassword = async (details: ChangePasswordDTO) => {
+  const { data } = await apiRequest.post("/api/v1/password/change-password", details);
+  return data;
+}
+
+export const useChangePassword = () => {
+  // note: use after srp1
+  return useMutation({
+    mutationFn: async (details: ChangePasswordDTO) => {
+      return changePassword(details);
+    }
+  });
+}
+
 // Refresh token is set as cookie when logged in
 // Using that we fetch the auth bearer token needed for auth calls
 const fetchAuthToken = async () => {

frontend/src/hooks/api/auth/types.ts

@@ -21,4 +21,107 @@ export type VerifyMfaTokenRes = {
   encryptedPrivateKey: string;
   iv: string;
   tag: string;
+}
+
+export type Login1DTO = {
+  email: string;
+  clientPublicKey: string;
+  providerAuthToken?: string;
+}
+
+export type Login2DTO = {
+  email: string;
+  clientProof: string;
+  providerAuthToken?: string;
+}
+
+export type Login1Res = {
+  serverPublicKey: string;
+  salt: string;
+}
+
+export type Login2Res = {
+  mfaEnabled: boolean;
+  token: string;
+  encryptionVersion?: number;
+  protectedKey?: string;
+  protectedKeyIV?: string;
+  protectedKeyTag?: string;
+  publicKey?: string;
+  encryptedPrivateKey?: string;
+  iv?: string;
+  tag?: string;
+}
+
+export type SRP1DTO = {
+  clientPublicKey: string;
+}
+
+export type SRPR1Res = {
+  serverPublicKey: string;
+  salt: string;
+}
+
+export type CompleteAccountDTO = {
+  email: string;
+  firstName: string;
+  lastName: string;
+  protectedKey: string;
+  protectedKeyIV: string;
+  protectedKeyTag: string;
+  publicKey: string;
+  encryptedPrivateKey: string;
+  encryptedPrivateKeyIV: string;
+  encryptedPrivateKeyTag: string;
+  salt: string;
+  verifier: string;
+}
+
+export type CompleteAccountSignupDTO = CompleteAccountDTO & {
+  providerAuthToken?: string;
+  attributionSource?: string;
+  organizationName: string;
+}
+
+export type VerifySignupInviteDTO = {
+  email: string;
+  code: string;
+  organizationId: string;
+}
+
+export type ChangePasswordDTO = {
+  clientProof: string;
+  protectedKey: string;
+  protectedKeyIV: string;
+  protectedKeyTag: string;
+  encryptedPrivateKey: string;
+  encryptedPrivateKeyIV: string;
+  encryptedPrivateKeyTag: string;
+  salt: string;
+  verifier: string;
+}
+
+export type ResetPasswordDTO = {
+  protectedKey: string;
+  protectedKeyIV: string;
+  protectedKeyTag: string;
+  encryptedPrivateKey: string;
+  encryptedPrivateKeyIV: string;
+  encryptedPrivateKeyTag: string;
+  salt: string;
+  verifier: string;
+  verificationToken: string;
+}
+
+export type IssueBackupPrivateKeyDTO = {
+  encryptedPrivateKey: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+  clientProof: string;
+}
+
+export type GetBackupEncryptedPrivateKeyDTO = {
+  verificationToken: string;
 }

frontend/src/hooks/api/users/queries.tsx

@@ -201,7 +201,9 @@ export const useRegisterUserAction = () => {
 
 export const useLogoutUser = () =>
   useMutation({
-    mutationFn: () => apiRequest.post("/api/v1/auth/logout"),
+    mutationFn: async () => {
+      await apiRequest.post("/api/v1/auth/logout");
+    },
     onSuccess: () => {
       setAuthToken("");
       // Delete the cookie by not setting a value; Alternatively clear the local storage