Skip to content

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

10.3 KB
Raw Blame
import { useMutation, useQueryClient } from "@tanstack/react-query";

import { apiRequest } from "@app/config/request";
import { Organization } from "@app/hooks/api/organization/types";

import { organizationKeys } from "../organization/queries";
import { User } from "../users/types";
import { adminQueryKeys, adminStandaloneKeys } from "./queries";
import {
  AdminEmailDomain,
  RootKeyEncryptionStrategy,
  TAdminCreateEmailDomainDTO,
  TCreateAdminUserDTO,
  TCreatedEncryptionKeyRotation,
  TCreateOrganizationDTO,
  TDeleteExpiringEncryptionKeyDTO,
  TDeleteStagedEncryptionKeyDTO,
  TInvalidateCacheDTO,
  TResendOrgInviteDTO,
  TServerConfig,
  TUpdateServerConfigDTO,
  TUsageReportResponse
} from "./types";

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

  return useMutation<
    { user: User; token: string; organization: { id: string } },
    object,
    TCreateAdminUserDTO
  >({
    mutationFn: async (opt) => {
      const { data } = await apiRequest.post("/api/v1/admin/signup", opt);
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.serverConfig() });
    }
  });
};

export const useUpdateServerConfig = ({
  handledErrorCodes
}: { handledErrorCodes?: string[] } = {}) => {
  const queryClient = useQueryClient();

  return useMutation<TServerConfig, object, TUpdateServerConfigDTO>({
    meta: handledErrorCodes?.length ? { handledErrorCodes } : undefined,
    mutationFn: async (opt) => {
      const { data } = await apiRequest.patch<{ config: TServerConfig }>(
        "/api/v1/admin/config",
        opt
      );
      return data.config;
    },
    onSuccess: (data) => {
      queryClient.setQueryData(adminQueryKeys.serverConfig(), data);
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getAdminIntegrationsConfig() });
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.serverConfig() });
      queryClient.invalidateQueries({ queryKey: organizationKeys.getUserOrganizations });
    }
  });
};

export const useAdminDeleteUser = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (userId: string) => {
      await apiRequest.delete(`/api/v1/admin/user-management/users/${userId}`);

      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getUsers]
      });
      queryClient.invalidateQueries({ queryKey: adminStandaloneKeys.getOrganizations });
    }
  });
};

export const useAdminBulkDeleteUsers = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (userIds: string[]) => {
      await apiRequest.delete("/api/v1/admin/user-management/users", {
        data: { userIds }
      });

      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getUsers]
      });
      queryClient.invalidateQueries({ queryKey: adminStandaloneKeys.getOrganizations });
    }
  });
};

export const useAdminDeleteOrganizationMembership = () => {
  const queryClient = useQueryClient();
  return useMutation<object, object, { organizationId: string; membershipId: string }>({
    mutationFn: async ({ organizationId, membershipId }) => {
      await apiRequest.delete(
        `/api/v1/admin/organization-management/organizations/${organizationId}/memberships/${membershipId}`
      );

      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getOrganizations]
      });
    }
  });
};

export const useAdminDeleteOrganization = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (organizationId: string) => {
      await apiRequest.delete(
        `/api/v1/admin/organization-management/organizations/${organizationId}`
      );
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getOrganizations]
      });
    }
  });
};

export const useAdminRemoveIdentitySuperAdminAccess = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (identityId: string) => {
      await apiRequest.delete(
        `/api/v1/admin/identity-management/identities/${identityId}/super-admin-access`
      );

      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getIdentities]
      });
    }
  });
};

export const useRemoveUserServerAdminAccess = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (userId: string) => {
      await apiRequest.delete(`/api/v1/admin/user-management/users/${userId}/admin-access`);

      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getUsers]
      });
    }
  });
};

export const useAdminGrantServerAdminAccess = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (userId: string) => {
      await apiRequest.patch(`/api/v1/admin/user-management/users/${userId}/admin-access`);
      return {};
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getUsers]
      });
    }
  });
};

export const useUpdateServerEncryptionStrategy = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async (strategy: RootKeyEncryptionStrategy) => {
      await apiRequest.patch("/api/v1/admin/encryption-strategies", { strategy });
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getServerEncryptionStrategies() });
    }
  });
};

export const useCreateEncryptionKeyRotation = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ replaceStaged }: { replaceStaged?: boolean } = {}) => {
      const { data } = await apiRequest.post<{ rotation: TCreatedEncryptionKeyRotation }>(
        "/api/v1/admin/encryption/root-key/rotations",
        { replaceStaged: Boolean(replaceStaged) }
      );

      return data.rotation;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getEncryptionRootKey() });
    }
  });
};

export const useDeleteStagedEncryptionKey = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ label }: TDeleteStagedEncryptionKeyDTO) => {
      await apiRequest.delete("/api/v1/admin/encryption/root-key/staged", { data: { label } });
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getEncryptionRootKey() });
    }
  });
};

export const useDeleteExpiringEncryptionKey = () => {
  const queryClient = useQueryClient();
  return useMutation({
    mutationFn: async ({ label, force }: TDeleteExpiringEncryptionKeyDTO) => {
      await apiRequest.delete("/api/v1/admin/encryption/root-key/expiring", {
        data: { label, force: Boolean(force) }
      });
    },
    // Removing the expiring key retires its history row, so the rotations table is stale too.
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getEncryptionRootKey() });
      queryClient.invalidateQueries({ queryKey: ["server-encryption-key-rotations"] });
    }
  });
};

export const useInvalidateCache = () => {
  const queryClient = useQueryClient();
  return useMutation<void, object, TInvalidateCacheDTO>({
    mutationFn: async (dto) => {
      await apiRequest.post("/api/v1/admin/invalidate-cache", dto);
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getInvalidateCache() });
    }
  });
};

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

  return useMutation({
    mutationFn: async (opt: TCreateOrganizationDTO) => {
      const { data } = await apiRequest.post<{ organization: Organization }>(
        "/api/v1/admin/organization-management/organizations",
        opt
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getOrganizations() });
    }
  });
};

export const useServerAdminResendOrgInvite = () => {
  return useMutation({
    mutationFn: async ({ organizationId, membershipId }: TResendOrgInviteDTO) => {
      await apiRequest.post(
        `/api/v1/admin/organization-management/organizations/${organizationId}/memberships/${membershipId}/resend-invite`
      );
    }
  });
};

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

  return useMutation({
    mutationFn: async (orgId: string) => {
      const { data } = await apiRequest.post(
        `/api/v1/admin/organization-management/organizations/${orgId}/access`
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({ queryKey: organizationKeys.getUserOrganizations });
      queryClient.invalidateQueries({ queryKey: adminQueryKeys.getOrganizations() });
    }
  });
};

export const useGenerateUsageReport = () => {
  return useMutation<TUsageReportResponse, object, void>({
    mutationFn: async () => {
      const { data } = await apiRequest.post<TUsageReportResponse>(
        "/api/v1/admin/usage-report/generate"
      );
      return data;
    }
  });
};

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

  return useMutation<{ emailDomain: AdminEmailDomain }, object, TAdminCreateEmailDomainDTO>({
    mutationFn: async (dto) => {
      const { data } = await apiRequest.post<{ emailDomain: AdminEmailDomain }>(
        "/api/v1/admin/email-domain-management/domains",
        dto
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getEmailDomains]
      });
    }
  });
};

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

  return useMutation<{ emailDomain: AdminEmailDomain }, object, string>({
    mutationFn: async (emailDomainId) => {
      const { data } = await apiRequest.delete<{ emailDomain: AdminEmailDomain }>(
        `/api/v1/admin/email-domain-management/domains/${emailDomainId}`
      );
      return data;
    },
    onSuccess: () => {
      queryClient.invalidateQueries({
        queryKey: [adminStandaloneKeys.getEmailDomains]
      });
    }
  });
};