chore(frontend): changed source code to src folder from root

frontend/src/pages/api/auth/ChangePassword2.ts

@@ -0,0 +1,47 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  encryptedPrivateKey: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+  clientProof: string;
+}
+
+/**
+ * This is the second step of the change password process (pake)
+ * @param {*} clientPublicKey
+ * @returns
+ */
+const changePassword2 = ({
+  encryptedPrivateKey,
+  iv,
+  tag,
+  salt,
+  verifier,
+  clientProof
+}: Props) => {
+  return SecurityClient.fetchCall('/api/v1/password/change-password', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      clientProof: clientProof,
+      encryptedPrivateKey: encryptedPrivateKey,
+      iv: iv,
+      tag: tag,
+      salt: salt,
+      verifier: verifier
+    })
+  }).then(async (res) => {
+    if (res && res.status == 200) {
+      return res;
+    } else {
+      console.log('Failed to change the password');
+    }
+  });
+};
+
+export default changePassword2;

frontend/src/pages/api/auth/CheckAuth.ts

@@ -0,0 +1,16 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+/**
+ * This function is used to check if the user is authenticated.
+ * To do that, we get their tokens from cookies, and verify if they are good.
+ */
+const checkAuth = async () => {
+  return SecurityClient.fetchCall('/api/v1/auth/checkAuth', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  }).then((res) => res);
+};
+
+export default checkAuth;

frontend/src/pages/api/auth/CheckEmailVerificationCode.ts

@@ -0,0 +1,26 @@
+interface Props {
+  email: string;
+  code: string;
+}
+
+/**
+ * This route check the verification code from the email that user just recieved
+ * @param {object} obj
+ * @param {string} obj.email
+ * @param {string} obj.code
+ * @returns
+ */
+const checkEmailVerificationCode = ({ email, code }: Props) => {
+  return fetch('/api/v1/signup/email/verify', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      email: email,
+      code: code
+    })
+  });
+};
+
+export default checkEmailVerificationCode;

frontend/src/pages/api/auth/CompleteAccountInformationSignup.ts

@@ -0,0 +1,66 @@
+interface Props {
+  email: string;
+  firstName: string;
+  lastName: string;
+  publicKey: string;
+  ciphertext: string;
+  organizationName: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+  token: string;
+}
+
+/**
+ * This function is called in the end of the signup process.
+ * It sends all the necessary nformation to the server.
+ * @param {object} obj
+ * @param {string} obj.email - email of the user completing signup
+ * @param {string} obj.firstName - first name of the user completing signup
+ * @param {string} obj.lastName - last name of the user completing sign up
+ * @param {string} obj.organizationName - organization name for this user (usually, [FIRST_NAME]'s organization)
+ * @param {string} obj.publicKey - public key of the user completing signup
+ * @param {string} obj.ciphertext
+ * @param {string} obj.iv
+ * @param {string} obj.tag
+ * @param {string} obj.salt
+ * @param {string} obj.verifier
+ * @param {string} obj.token - token that confirms a user's identity
+ * @returns
+ */
+const completeAccountInformationSignup = ({
+  email,
+  firstName,
+  lastName,
+  organizationName,
+  publicKey,
+  ciphertext,
+  iv,
+  tag,
+  salt,
+  verifier,
+  token
+}: Props) => {
+  return fetch('/api/v1/signup/complete-account/signup', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: 'Bearer ' + token
+    },
+    body: JSON.stringify({
+      email,
+      firstName,
+      lastName,
+      publicKey,
+      encryptedPrivateKey: ciphertext,
+      organizationName,
+      iv,
+      tag,
+      salt,
+      verifier
+    })
+  });
+};
+
+export default completeAccountInformationSignup;

frontend/src/pages/api/auth/CompleteAccountInformationSignupInvite.ts

@@ -0,0 +1,62 @@
+interface Props {
+  email: string;
+  firstName: string;
+  lastName: string;
+  publicKey: string;
+  ciphertext: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+  token: string;
+}
+
+/**
+ * This function is called in the end of the signup process.
+ * It sends all the necessary nformation to the server.
+ * @param {object} obj
+ * @param {string} obj.email - email of the user completing signupinvite flow
+ * @param {string} obj.firstName - first name of the user completing signupinvite flow
+ * @param {string} obj.lastName - last name of the user completing signupinvite flow
+ * @param {string} obj.publicKey - public key of the user completing signupinvite flow
+ * @param {string} obj.ciphertext
+ * @param {string} obj.iv
+ * @param {string} obj.tag
+ * @param {string} obj.salt
+ * @param {string} obj.verifier
+ * @param {string} obj.token - token that confirms a user's identity
+ * @returns
+ */
+const completeAccountInformationSignupInvite = ({
+  email,
+  firstName,
+  lastName,
+  publicKey,
+  ciphertext,
+  iv,
+  tag,
+  salt,
+  verifier,
+  token
+}: Props) => {
+  return fetch('/api/v1/signup/complete-account/invite', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: 'Bearer ' + token
+    },
+    body: JSON.stringify({
+      email: email,
+      firstName: firstName,
+      lastName: lastName,
+      publicKey: publicKey,
+      encryptedPrivateKey: ciphertext,
+      iv: iv,
+      tag: tag,
+      salt: salt,
+      verifier: verifier
+    })
+  });
+};
+
+export default completeAccountInformationSignupInvite;

frontend/src/pages/api/auth/EmailVerifyOnPasswordReset.ts

@@ -0,0 +1,34 @@
+interface Props {
+  email: string;
+  code: string;
+}
+
+/**
+ * This is the second part of the account recovery step (a user needs to verify their email).
+ * A user need to click on a button in a magic link page
+ * @param {object} obj
+ * @param {object} obj.email - email of a user that is trying to recover access to their account
+ * @param {object} obj.code - token that a use received via the magic link
+ * @returns
+ */
+const EmailVerifyOnPasswordReset = async ({ email, code }: Props) => {
+  const response = await fetch('/api/v1/password/email/password-reset-verify', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      email: email,
+      code: code
+    })
+  });
+  if (response?.status === 200) {
+    return response;
+  }
+
+  throw new Error(
+    'Something went wrong during email verification on password reset.'
+  );
+};
+
+export default EmailVerifyOnPasswordReset;

frontend/src/pages/api/auth/IssueBackupPrivateKey.ts

@@ -0,0 +1,52 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  encryptedPrivateKey: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+  clientProof: string;
+}
+
+/**
+ * This is the route that issues a backup private key that will afterwards be added into a pdf
+ * @param {object} obj
+ * @param {string} obj.encryptedPrivateKey
+ * @param {string} obj.iv
+ * @param {string} obj.tag
+ * @param {string} obj.salt
+ * @param {string} obj.verifier
+ * @param {string} obj.clientProof
+ * @returns
+ */
+const issueBackupPrivateKey = ({
+  encryptedPrivateKey,
+  iv,
+  tag,
+  salt,
+  verifier,
+  clientProof
+}: Props) => {
+  return SecurityClient.fetchCall('/api/v1/password/backup-private-key', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      clientProof: clientProof,
+      encryptedPrivateKey: encryptedPrivateKey,
+      iv: iv,
+      tag: tag,
+      salt: salt,
+      verifier: verifier
+    })
+  }).then((res) => {
+    if (res?.status !== 200) {
+      console.log('Failed to issue the backup key');
+    }
+    return res;
+  });
+};
+
+export default issueBackupPrivateKey;

frontend/src/pages/api/auth/Login1.ts

@@ -0,0 +1,32 @@
+interface Login1 {
+  serverPublicKey: string;
+  salt: string;
+}
+
+/**
+ * This is the first step of the login process (pake)
+ * @param {*} email
+ * @param {*} clientPublicKey
+ * @returns
+ */
+const login1 = async (email: string, clientPublicKey: string) => {
+  const response = await fetch("/api/v1/auth/login1", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      email: email,
+      clientPublicKey,
+    }),
+  });
+  // need precise error handling about the status code
+  if (response?.status === 200) {
+    const data = (await response.json()) as unknown as Login1;
+    return data;
+  }
+
+  throw new Error("Wrong password");
+};
+
+export default login1;

frontend/src/pages/api/auth/Login2.ts

@@ -0,0 +1,36 @@
+interface Login2Response {
+  encryptedPrivateKey: string;
+  iv: string;
+  publicKey: string;
+  tag: string;
+  token: string;
+}
+
+/**
+ * This is the second step of the login process
+ * @param {*} email
+ * @param {*} clientPublicKey
+ * @returns
+ */
+const login2 = async (email: string, clientProof: string) => {
+  const response = await fetch("/api/v1/auth/login2", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      email: email,
+      clientProof,
+    }),
+    credentials: "include",
+  });
+  // need precise error handling about the status code
+  if (response.status == 200) {
+    const data = (await response.json()) as unknown as Login2Response;
+    return data;
+  }
+
+  throw new Error("Password verification failed");
+};
+
+export default login2;

frontend/src/pages/api/auth/Logout.ts

@@ -0,0 +1,31 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+/**
+ * This route logs the user out. Note: the user should authorized to do this.
+ * We first try to log out - if the authorization fails (response.status = 401), we refetch the new token, and then retry
+ */
+const logout = async () => {
+  return SecurityClient.fetchCall('/api/v1/auth/logout', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    credentials: 'include'
+  }).then((res) => {
+    if (res?.status == 200) {
+      SecurityClient.setToken('');
+      // Delete the cookie by not setting a value; Alternatively clear the local storage
+      localStorage.setItem('publicKey', '');
+      localStorage.setItem('encryptedPrivateKey', '');
+      localStorage.setItem('iv', '');
+      localStorage.setItem('tag', '');
+      localStorage.setItem('PRIVATE_KEY', '');
+      console.log('User logged out', res);
+      return res;
+    } else {
+      console.log('Failed to log out');
+    }
+  });
+};
+
+export default logout;

frontend/src/pages/api/auth/SRP1.ts

@@ -0,0 +1,30 @@
+import SecurityClient from '~/utilities/SecurityClient';
+
+interface Props {
+  clientPublicKey: string;
+}
+
+/**
+ * This is the first step of the change password process (pake)
+ * @param {string} clientPublicKey
+ * @returns
+ */
+const SRP1 = ({ clientPublicKey }: Props) => {
+  return SecurityClient.fetchCall('/api/v1/password/srp1', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      clientPublicKey
+    })
+  }).then(async (res) => {
+    if (res && res.status == 200) {
+      return await res.json();
+    } else {
+      console.log('Failed to do the first step of SRP');
+    }
+  });
+};
+
+export default SRP1;

frontend/src/pages/api/auth/SendEmailOnPasswordReset.ts

@@ -0,0 +1,33 @@
+interface Props {
+  email: string;
+}
+
+/**
+ * This is the first of the account recovery step (a user needs to verify their email).
+ * It will send an email containing a magic link to start the account recovery flow.
+ * @param {object} obj
+ * @param {object} obj.email - email of a user that is trying to recover access to their account
+ * @returns
+ */
+const SendEmailOnPasswordReset = async ({ email }: Props) => {
+  const response = await fetch('/api/v1/password/email/password-reset', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      email: email
+    })
+  });
+  // need precise error handling about the status code
+  if (response?.status === 200) {
+    const data = await response.json();
+    return data;
+  }
+
+  throw new Error(
+    'Something went wrong while sending the email verification for password reset.'
+  );
+};
+
+export default SendEmailOnPasswordReset;

frontend/src/pages/api/auth/SendVerificationEmail.ts

@@ -0,0 +1,17 @@
+/**
+ * This route send the verification email to the user's email (contains a 6-digit verification code)
+ * @param {*} email
+ */
+const sendVerificationEmail = (email: string) => {
+  fetch('/api/v1/signup/email/signup', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      email: email
+    })
+  });
+};
+
+export default sendVerificationEmail;

frontend/src/pages/api/auth/Token.ts

@@ -0,0 +1,17 @@
+const token = async () => {
+  return fetch('/api/v1/auth/token', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    credentials: 'include'
+  }).then(async (res) => {
+    if (res.status == 200) {
+      return (await res.json()).token;
+    } else {
+      console.log('Getting a new token failed');
+    }
+  });
+};
+
+export default token;

frontend/src/pages/api/auth/VerifySignupInvite.ts

@@ -0,0 +1,26 @@
+interface Props {
+  email: string;
+  code: string;
+}
+
+/**
+ * This route verifies the signup invite link
+ * @param {object} obj
+ * @param {string} obj.email - email that a user is trying to verify
+ * @param {string} obj.code - code that a user received to the abovementioned email
+ * @returns
+ */
+const verifySignupInvite = ({ email, code }: Props) => {
+  return fetch('/api/v1/invite-org/verify', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      email,
+      code
+    })
+  });
+};
+
+export default verifySignupInvite;

frontend/src/pages/api/auth/getBackupEncryptedPrivateKey.ts

@@ -0,0 +1,26 @@
+/**
+ * This is the route that get an encrypted private key (will be decrypted with a backup key)
+ * @param {object} obj
+ * @param {object} obj.verificationToken - this is the token that confirms that a user is the right one
+ * @returns
+ */
+const getBackupEncryptedPrivateKey = ({
+  verificationToken
+}: {
+  verificationToken: string;
+}) => {
+  return fetch('/api/v1/password/backup-private-key', {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: 'Bearer ' + verificationToken
+    }
+  }).then(async (res) => {
+    if (res?.status !== 200) {
+      console.log('Failed to get the backup key');
+    }
+    return (await res?.json())?.backupPrivateKey;
+  });
+};
+
+export default getBackupEncryptedPrivateKey;

frontend/src/pages/api/auth/publicKeyInfisical.ts

@@ -0,0 +1,10 @@
+const publicKeyInfisical = () => {
+  return fetch('/api/v1/key/publicKey/infisical', {
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+};
+
+export default publicKeyInfisical;

frontend/src/pages/api/auth/resetPasswordOnAccountRecovery.ts

@@ -0,0 +1,50 @@
+interface Props {
+  verificationToken: string;
+  encryptedPrivateKey: string;
+  iv: string;
+  tag: string;
+  salt: string;
+  verifier: string;
+}
+
+/**
+ * This is the route that resets the account password if all the previus steps were passed
+ * @param {object} obj
+ * @param {object} obj.verificationToken - this is the token that confirms that a user is the right one
+ * @param {object} obj.encryptedPrivateKey - the new encrypted private key (encrypted using the new password)
+ * @param {object} obj.iv
+ * @param {object} obj.tag
+ * @param {object} obj.salt
+ * @param {object} obj.verifier
+ * @returns
+ */
+const resetPasswordOnAccountRecovery = ({
+  verificationToken,
+  encryptedPrivateKey,
+  iv,
+  tag,
+  salt,
+  verifier
+}: Props) => {
+  return fetch('/api/v1/password/password-reset', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: 'Bearer ' + verificationToken
+    },
+    body: JSON.stringify({
+      encryptedPrivateKey: encryptedPrivateKey,
+      iv: iv,
+      tag: tag,
+      salt: salt,
+      verifier: verifier
+    })
+  }).then(async (res) => {
+    if (res?.status !== 200) {
+      console.log('Failed to get the backup key');
+    }
+    return res;
+  });
+};
+
+export default resetPasswordOnAccountRecovery;