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 { useQuery } from "@tanstack/react-query";
import { apiRequest } from "@app/config/request";
import { useOrganization } from "@app/context";
import { OrderByDirection } from "../generic/types";
import {
FilterMemberType,
FilterReturnedMachineIdentities,
FilterReturnedProjects,
FilterReturnedUsers,
GroupMembersOrderBy,
TGroup,
TGroupMachineIdentity,
TGroupMember,
TGroupProject,
TGroupUser
} from "./types";
export const groupKeys = {
getGroupById: (groupId: string) => [{ groupId }, "group"] as const,
getGroupByIdForOrg: (orgId: string, groupId: string) =>
[...groupKeys.getGroupById(groupId), orgId] as const,
allGroupUserMemberships: () => ["group-user-memberships"] as const,
forGroupUserMemberships: (slug: string) =>
[...groupKeys.allGroupUserMemberships(), slug] as const,
specificGroupUserMemberships: ({
slug,
offset,
limit,
search,
filter
}: {
slug: string;
offset: number;
limit: number;
search: string;
filter?: FilterReturnedUsers;
}) => [...groupKeys.forGroupUserMemberships(slug), { offset, limit, search, filter }] as const,
allGroupIdentitiesMemberships: () => ["group-identities-memberships"] as const,
forGroupIdentitiesMemberships: (slug: string) =>
[...groupKeys.allGroupIdentitiesMemberships(), slug] as const,
specificGroupIdentitiesMemberships: ({
slug,
offset,
limit,
search,
filter
}: {
slug: string;
offset: number;
limit: number;
search: string;
filter?: FilterReturnedMachineIdentities;
}) =>
[...groupKeys.forGroupIdentitiesMemberships(slug), { offset, limit, search, filter }] as const,
allGroupMembers: () => ["group-members"] as const,
forGroupMembers: (slug: string) => [...groupKeys.allGroupMembers(), slug] as const,
specificGroupMembers: ({
slug,
offset,
limit,
search,
orderBy,
orderDirection,
memberTypeFilter
}: {
slug: string;
offset: number;
limit: number;
search: string;
orderBy?: GroupMembersOrderBy;
orderDirection?: OrderByDirection;
memberTypeFilter?: FilterMemberType[];
}) =>
[
...groupKeys.forGroupMembers(slug),
{ offset, limit, search, orderBy, orderDirection, memberTypeFilter }
] as const,
allGroupProjects: () => ["group-projects"] as const,
forGroupProjects: (groupId: string) => [...groupKeys.allGroupProjects(), groupId] as const,
specificGroupProjects: ({
orgId,
groupId,
offset,
limit,
search,
filter,
orderBy,
orderDirection
}: {
orgId: string;
groupId: string;
offset: number;
limit: number;
search: string;
filter?: FilterReturnedProjects;
orderBy?: string;
orderDirection?: OrderByDirection;
}) =>
[
...groupKeys.forGroupProjects(groupId),
orgId,
{ offset, limit, search, filter, orderBy, orderDirection }
] as const
};
export const useGetGroupById = (groupId: string) => {
const { currentOrg } = useOrganization();
const orgId = currentOrg?.id || "";
return useQuery({
enabled: Boolean(groupId),
queryKey: groupKeys.getGroupByIdForOrg(orgId, groupId),
queryFn: async () => {
const { data } = await apiRequest.get<TGroup>(`/api/v1/groups/${groupId}`);
return { group: data };
}
});
};
export const useListGroupUsers = ({
id,
groupSlug,
offset = 0,
limit = 10,
search,
filter
}: {
id: string;
groupSlug: string;
offset: number;
limit: number;
search: string;
filter?: FilterReturnedUsers;
}) => {
return useQuery({
queryKey: groupKeys.specificGroupUserMemberships({
slug: groupSlug,
offset,
limit,
search,
filter
}),
enabled: Boolean(groupSlug),
placeholderData: (previousData) => previousData,
queryFn: async () => {
const params = new URLSearchParams({
offset: String(offset),
limit: String(limit),
...(search && { search }),
...(filter && { filter })
});
const { data } = await apiRequest.get<{ users: TGroupUser[]; totalCount: number }>(
`/api/v1/groups/${id}/users`,
{
params
}
);
return data;
}
});
};
export const useListGroupMembers = ({
id,
groupSlug,
offset = 0,
limit = 10,
search,
orderBy,
orderDirection,
memberTypeFilter
}: {
id: string;
groupSlug: string;
offset: number;
limit: number;
search: string;
orderBy?: GroupMembersOrderBy;
orderDirection?: OrderByDirection;
memberTypeFilter?: FilterMemberType[];
}) => {
return useQuery({
queryKey: groupKeys.specificGroupMembers({
slug: groupSlug,
offset,
limit,
search,
orderBy,
orderDirection,
memberTypeFilter
}),
enabled: Boolean(groupSlug),
placeholderData: (previousData) => previousData,
queryFn: async () => {
const params = new URLSearchParams({
offset: String(offset),
limit: String(limit),
...(search && { search }),
...(orderBy && { orderBy: orderBy.toString() }),
...(orderDirection && { orderDirection })
});
if (memberTypeFilter && memberTypeFilter.length > 0) {
memberTypeFilter.forEach((filter) => {
params.append("memberTypeFilter", filter);
});
}
const { data } = await apiRequest.get<{ members: TGroupMember[]; totalCount: number }>(
`/api/v1/groups/${id}/members`,
{
params
}
);
return data;
}
});
};
export const useListGroupMachineIdentities = ({
id,
groupSlug,
offset = 0,
limit = 10,
search,
filter
}: {
id: string;
groupSlug: string;
offset: number;
limit: number;
search: string;
filter?: FilterReturnedMachineIdentities;
}) => {
return useQuery({
queryKey: groupKeys.specificGroupIdentitiesMemberships({
slug: groupSlug,
offset,
limit,
search,
filter
}),
enabled: Boolean(groupSlug),
placeholderData: (previousData) => previousData,
queryFn: async () => {
const params = new URLSearchParams({
offset: String(offset),
limit: String(limit),
...(search && { search }),
...(filter && { filter })
});
const { data } = await apiRequest.get<{
machineIdentities: TGroupMachineIdentity[];
totalCount: number;
}>(`/api/v1/groups/${id}/machine-identities`, {
params
});
return data;
}
});
};
export const useListGroupProjects = ({
id,
offset = 0,
limit = 10,
search,
filter,
orderBy,
orderDirection
}: {
id: string;
offset: number;
limit: number;
search: string;
orderBy?: string;
orderDirection?: OrderByDirection;
filter?: FilterReturnedProjects;
}) => {
const { currentOrg } = useOrganization();
const orgId = currentOrg?.id || "";
return useQuery({
queryKey: groupKeys.specificGroupProjects({
orgId,
groupId: id,
offset,
limit,
search,
filter,
orderBy,
orderDirection
}),
enabled: Boolean(id),
placeholderData: (previousData) => previousData,
queryFn: async () => {
const params = new URLSearchParams({
offset: String(offset),
limit: String(limit),
...(search && { search }),
...(filter && { filter }),
...(orderBy && { orderBy }),
...(orderDirection && { orderDirection })
});
const { data } = await apiRequest.get<{ projects: TGroupProject[]; totalCount: number }>(
`/api/v1/groups/${id}/projects`,
{
params
}
);
return data;
}
});
};