Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

15.8 KB
Raw Blame
import type { RegistrationResponseJSON } from "@simplewebauthn/browser";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { AxiosError } from "axios";

import { apiRequest } from "@app/config/request";
import { SessionStorageKeys } from "@app/const";
import { getMfaStepUpChallenge } from "@app/helpers/mfaSession";
import { adminQueryKeys } from "@app/hooks/api/admin/queries";
import { getAuthToken, queryClient as qc } from "@app/hooks/api/reactQuery";

import { authKeys } from "../auth/queries";
import { MfaMethod } from "../auth/types";
import { TGroupWithProjectMemberships } from "../groups/types";
import { setAuthToken } from "../reactQuery";
import { subscriptionQueryKeys } from "../subscriptions/queries";
import { webAuthnKeys } from "../webauthn/queries";
import { userKeys } from "./query-keys";
import {
  AddUserToOrgDTO,
  AuthMethod,
  DeleteOrgMembershipBatchDTO,
  DeleteOrgMembershipDTO,
  OrgUser,
  RenameUserDTO,
  TokenVersion,
  TOrgUserAccess,
  TWorkspaceUser,
  UpdateOrgMembershipDTO,
  User,
  UserEnc
} from "./types";

export const fetchUserDetails = async () => {
  // prioritize auth token
  const authToken = getAuthToken();

  const { data } = await apiRequest.get<{ user: User & UserEnc }>("/api/v1/user", {
    headers: authToken ? { Authorization: `Bearer ${authToken}` } : undefined
  });
  return data.user;
};

export const useGetUser = () =>
  useQuery({
    queryKey: userKeys.getUser,
    queryFn: fetchUserDetails
  });

export const fetchUserDuplicateAccounts = async () => {
  const { data } = await apiRequest.get<{
    users: Array<
      User & {
        isMyAccount: boolean;
        organizations: { name: string; slug: string }[];
        devices: {
          ip: string;
          userAgent: string;
        }[];
      }
    >;
  }>("/api/v1/user/duplicate-accounts");
  return data.users;
};

export const useGetMyDuplicateAccount = () =>
  useQuery({
    queryKey: userKeys.getMyDuplicateAccount,
    staleTime: 60 * 1000, // 1 min in ms
    queryFn: fetchUserDuplicateAccounts,
    select: (users) => ({
      duplicateAccounts: users.filter((el) => !el.isMyAccount),
      myAccount: users?.find((el) => el.isMyAccount)
    })
  });

export const useDeleteMe = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async () => {
      const {
        data: { user }
      } = await apiRequest.delete<{ user: User }>("/api/v2/users/me");
      return user;
    },
    onSuccess: () => {
      localStorage.removeItem("protectedKey");
      localStorage.removeItem("protectedKeyIV");
      localStorage.removeItem("protectedKeyTag");
      localStorage.removeItem("publicKey");
      localStorage.removeItem("encryptedPrivateKey");
      localStorage.removeItem("iv");
      localStorage.removeItem("tag");
      localStorage.removeItem("PRIVATE_KEY");
      localStorage.removeItem("orgData.id");

      setAuthToken("");

      queryClient.clear();
    }
  });
};

export const fetchUserAction = async (action: string) => {
  const { data } = await apiRequest.get<{ userAction: string }>("/api/v1/user-action", {
    params: {
      action
    }
  });
  return data.userAction || "";
};

export const fetchUserProjectFavorites = async (orgId: string) => {
  const { data } = await apiRequest.get<{ projectFavorites: string[] }>(
    `/api/v1/user/me/project-favorites?orgId=${orgId}`
  );

  return data.projectFavorites;
};

export const useRenameUser = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, RenameUserDTO>({
    mutationFn: ({ newName }) =>
      apiRequest.patch("/api/v2/users/me/name", {
        firstName: newName?.split(" ")[0],
        lastName: newName?.split(" ").slice(1).join(" ")
      }),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: userKeys.getUser });
    }
  });
};

export const useUpdateUserAuthMethods = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async ({ authMethods }: { authMethods: AuthMethod[] }) => {
      const {
        data: { user }
      } = await apiRequest.put("/api/v2/users/me/auth-methods", {
        authMethods
      });

      return user;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: userKeys.getUser });
    }
  });
};

export const useGetUserAction = (action: string) =>
  useQuery({
    queryKey: userKeys.userAction,
    queryFn: () => fetchUserAction(action)
  });

export const fetchOrgUsers = async (orgId: string) => {
  const { data } = await apiRequest.get<{ users: OrgUser[] }>(
    `/api/v1/organization/${orgId}/users`
  );

  return data.users;
};

export const useGetUserProjectFavorites = (orgId: string) =>
  useQuery({
    queryKey: userKeys.userProjectFavorites(orgId),
    queryFn: () => fetchUserProjectFavorites(orgId)
  });

export const useGetOrgUsers = (orgId: string, options?: { enabled?: boolean }) =>
  useQuery({
    queryKey: userKeys.getOrgUsers(orgId),
    queryFn: () => fetchOrgUsers(orgId),
    enabled: Boolean(orgId) && (options?.enabled ?? true)
  });

export const useGetOrgUserAccess = (orgId: string) =>
  useQuery({
    queryKey: userKeys.getOrgUserAccess(orgId),
    queryFn: async () => {
      const { data } = await apiRequest.get<{ users: TOrgUserAccess[] }>(
        `/api/v1/organization/${orgId}/user-access`
      );
      return data.users;
    },
    enabled: Boolean(orgId)
  });

// mutation
// TODO(akhilmhdh): move all mutation to mutation file
export const useAddUsersToOrg = () => {
  const queryClient = useQueryClient();
  type Response = {
    data: {
      message: string;
      completeInviteLinks?: {
        email: string;
        link: string;
      }[];
      /** Product-access grants are best-effort; present only when at least one grant failed. */
      grantFailures?: {
        projectIds: string[];
        pamAccess: boolean;
        agentVaultAccess: boolean;
      };
    };
  };

  return useMutation<Response, object, AddUserToOrgDTO>({
    mutationFn: (dto) => {
      return apiRequest.post("/api/v1/invite-org/signup", dto);
    },
    onSuccess: (_, { organizationId }) => {
      queryClient.invalidateQueries({ queryKey: userKeys.getOrgUsers(organizationId) });
      queryClient.invalidateQueries({
        queryKey: subscriptionQueryKeys.getOrgSubsription(organizationId)
      });
      queryClient.invalidateQueries({ queryKey: ["available-users"] });
    }
  });
};

export const useGetOrgMembership = (organizationId: string, orgMembershipId: string) => {
  return useQuery({
    queryKey: userKeys.getOrgMembership(organizationId, orgMembershipId),
    queryFn: async () => {
      const {
        data: { membership }
      } = await apiRequest.get<{ membership: OrgUser }>(
        `/api/v2/organizations/${organizationId}/memberships/${orgMembershipId}`
      );

      return membership;
    },
    enabled: Boolean(organizationId) && Boolean(orgMembershipId)
  });
};

export const useGetOrgMembershipProjectMemberships = (
  organizationId: string,
  orgMembershipId: string
) => {
  return useQuery({
    queryKey: userKeys.forOrgMembershipProjectMemberships(organizationId, orgMembershipId),
    queryFn: async () => {
      const {
        data: { memberships }
      } = await apiRequest.get<{ memberships: TWorkspaceUser[] }>(
        `/api/v2/organizations/${organizationId}/memberships/${orgMembershipId}/project-memberships`
      );

      return memberships;
    },
    enabled: Boolean(organizationId) && Boolean(orgMembershipId)
  });
};

export const useDeleteOrgMembership = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, DeleteOrgMembershipDTO>({
    mutationFn: ({ membershipId, orgId }) => {
      return apiRequest.delete(`/api/v2/organizations/${orgId}/memberships/${membershipId}`);
    },
    onSuccess: (_, { orgId }) => {
      queryClient.invalidateQueries({ queryKey: userKeys.getOrgUsers(orgId) });
    }
  });
};

export const useDeleteOrgMembershipBatch = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, DeleteOrgMembershipBatchDTO>({
    mutationFn: ({ membershipIds, orgId }) => {
      return apiRequest.delete(`/api/v2/organizations/${orgId}/memberships`, {
        data: {
          membershipIds
        }
      });
    },
    onSuccess: (_, { orgId }) => {
      queryClient.invalidateQueries({ queryKey: userKeys.getOrgUsers(orgId) });
    }
  });
};

export const useUpdateOrgMembership = () => {
  const queryClient = useQueryClient();

  return useMutation<object, object, UpdateOrgMembershipDTO>({
    mutationFn: ({ organizationId, membershipId, role, isActive, metadata }) => {
      return apiRequest.patch(
        `/api/v2/organizations/${organizationId}/memberships/${membershipId}`,
        {
          role,
          isActive,
          metadata
        }
      );
    },
    onSuccess: (_, { organizationId, membershipId }) => {
      queryClient.invalidateQueries({ queryKey: userKeys.getOrgUsers(organizationId) });
      queryClient.invalidateQueries({
        queryKey: userKeys.getOrgMembership(organizationId, membershipId)
      });
    },
    // to remove old states
    onError: (_, { organizationId, membershipId }) => {
      queryClient.invalidateQueries({ queryKey: userKeys.getOrgUsers(organizationId) });
      queryClient.invalidateQueries({
        queryKey: userKeys.getOrgMembership(organizationId, membershipId)
      });
    }
  });
};

export const useRegisterUserAction = () => {
  const queryClient = useQueryClient();
  return useMutation<object, object, string>({
    mutationFn: (action) => apiRequest.post("/api/v1/user-action", { action }),
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: userKeys.userAction });
    }
  });
};

export const logoutUser = async () => {
  await apiRequest.post("/api/v1/auth/logout");
};

// Utility function to clear session storage and query cache
export const clearSession = () => {
  const serverConfig = qc.getQueryData(adminQueryKeys.serverConfig());

  setAuthToken(""); // Clear authentication token
  localStorage.removeItem("protectedKey");
  localStorage.removeItem("protectedKeyIV");
  localStorage.removeItem("protectedKeyTag");
  localStorage.removeItem("publicKey");
  localStorage.removeItem("encryptedPrivateKey");
  localStorage.removeItem("iv");
  localStorage.removeItem("tag");
  localStorage.removeItem("PRIVATE_KEY");
  localStorage.removeItem("orgData.id");
  sessionStorage.removeItem(SessionStorageKeys.CLI_TERMINAL_TOKEN);

  qc.clear();

  // Server configuration is public and required to render authentication routes.
  // Preserve it so delayed logout cleanup cannot suspend and remount the login page.
  if (serverConfig !== undefined) {
    qc.setQueryData(adminQueryKeys.serverConfig(), serverConfig);
  }
};

let logoutTimer: ReturnType<typeof setTimeout> | null = null;

export const useLogoutUser = () => {
  return useMutation({
    mutationFn: async () => {
      if (logoutTimer) {
        clearTimeout(logoutTimer);
        logoutTimer = null;
      }
      setAuthToken("");
      // Remove the login check cache immediately so the restrict-login-signup
      // middleware doesn't find stale auth data and redirect to select-organization.
      qc.removeQueries({ queryKey: authKeys.getAuthToken });
      await logoutUser();
    },
    onSuccess: () => {
      // Delay cache clear so the route transition completes first and
      // useSuspenseQuery components unmount before their cache is removed.
      logoutTimer = setTimeout(() => {
        clearSession();
        logoutTimer = null;
      }, 1000);
    }
  });
};

export const useGetMyIp = () => {
  return useQuery({
    queryKey: userKeys.myIp,
    queryFn: async () => {
      const { data } = await apiRequest.get<{ ip: string }>("/api/v1/users/me/ip");
      return data.ip;
    },
    enabled: true
  });
};

export const useGetMySessions = () => {
  return useQuery({
    queryKey: userKeys.mySessions,
    queryFn: async () => {
      const { data } = await apiRequest.get<TokenVersion[]>("/api/v2/users/me/sessions");

      return data;
    },
    enabled: true
  });
};

export const useRevokeMySessions = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async () => {
      const { data } = await apiRequest.delete("/api/v2/users/me/sessions");

      return data;
    },
    onSuccess() {
      queryClient.invalidateQueries({ queryKey: userKeys.mySessions });
    }
  });
};

// Enroll an MFA factor: proves and persists the factor. This does not mint or
// return recovery codes; those are issued only when MFA is enabled (useActivateMfa).
export const useEnrollMfa = () => {
  const queryClient = useQueryClient();
  return useMutation({
    meta: { handledErrorCodes: ["SESSION_MFA_REQUIRED"] },
    mutationFn: async (
      dto:
        | { method: MfaMethod.TOTP; totp: string }
        | {
            method: MfaMethod.WEBAUTHN;
            registrationResponse: RegistrationResponseJSON;
            name?: string;
          }
    ) => {
      await apiRequest.post("/api/v2/users/me/mfa/enroll", dto);
    },
    onSuccess() {
      queryClient.invalidateQueries({ queryKey: userKeys.getUser });
      queryClient.invalidateQueries({ queryKey: userKeys.totpConfiguration });
      // Enrollment is method-agnostic; a WEBAUTHN enroll adds a credential, so
      // keep the passkey list in sync regardless of the method used.
      queryClient.invalidateQueries({ queryKey: webAuthnKeys.credentials });
    }
  });
};

// Enable MFA. Issues a fresh recovery-code pool (invalidating any prior codes)
// and returns it once so the caller can display it to the user.
export const useActivateMfa = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ selectedMfaMethod }: { selectedMfaMethod?: MfaMethod }) => {
      const { data } = await apiRequest.post<{ user: unknown; recoveryCodes: string[] }>(
        "/api/v2/users/me/mfa/activate",
        {
          selectedMfaMethod
        }
      );

      return { user: data.user, recoveryCodes: data.recoveryCodes };
    },
    onSuccess() {
      queryClient.invalidateQueries({ queryKey: userKeys.getUser });
      queryClient.invalidateQueries({ queryKey: userKeys.mfaRecoveryCodes });
    }
  });
};

export const fetchMyOrganizationProjects = async (orgId: string) => {
  const {
    data: { workspaces }
  } = await apiRequest.get(`/api/v1/organization/${orgId}/my-workspaces`);

  return workspaces;
};

export const useGetMyOrganizationProjects = (orgId: string) => {
  return useQuery({
    queryKey: userKeys.myOrganizationProjects(orgId),
    queryFn: async () => {
      return fetchMyOrganizationProjects(orgId);
    },
    enabled: true
  });
};

export const useListUserGroupMemberships = (username: string) => {
  return useQuery({
    queryKey: userKeys.listUserGroupMemberships(username),
    queryFn: async () => {
      const { data } = await apiRequest.get<TGroupWithProjectMemberships[]>(
        `/api/v1/user/me/${username}/groups`
      );

      return data;
    }
  });
};

export const useGetUserTotpRegistration = (options?: { enabled?: boolean }) => {
  return useQuery({
    queryKey: userKeys.totpRegistration,
    queryFn: async () => {
      const { data } = await apiRequest.post<{ otpUrl: string }>("/api/v1/user/me/totp/register");

      return data;
    },
    enabled: options?.enabled ?? true,
    // Retrying a step-up error would mint a second challenge and email a second code.
    retry: (failureCount, error) => !getMfaStepUpChallenge(error) && failureCount < 1
  });
};

export const useGetUserTotpConfiguration = () => {
  return useQuery({
    queryKey: userKeys.totpConfiguration,
    queryFn: async () => {
      try {
        const { data } = await apiRequest.get<{ isVerified: boolean }>("/api/v1/user/me/totp");

        return data;
      } catch (error) {
        if (error instanceof AxiosError && [404, 400].includes(error.response?.data?.statusCode)) {
          return {
            isVerified: false
          };
        }
        throw error;
      }
    }
  });
};