Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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;
}
}
});
};