Skip to content

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

8.3 KB
Raw Blame
import { packRules } from "@casl/ability/extra";
import { useMutation, useQueryClient } from "@tanstack/react-query";

import { apiRequest } from "@app/config/request";

import { DelegatedApprovalRequestStatus } from "../delegatedApprovals/enums";
import { ApiErrorTypes } from "../types";
import { accessApprovalKeys } from "./queries";
import { markDelegatedDispatchRetry } from "./retrying-delegated-dispatch";
import {
  TAccessApproval,
  TAccessApprovalRequest,
  TCreateAccessPolicyDTO,
  TCreateAccessRequestDTO,
  TDeleteSecretPolicyDTO,
  TUpdateAccessPolicyDTO
} from "./types";

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

  return useMutation<object, object, TCreateAccessPolicyDTO>({
    meta: { handledErrorCodes: [ApiErrorTypes.BadRequestError] },
    mutationFn: async ({
      environments,
      projectSlug,
      approvals,
      approvers,
      bypassers,
      name,
      secretPath,
      enforcementLevel,
      allowedSelfApprovals,
      approvalsRequired,
      maxTimePeriod,
      requestExpirationTime,
      delegatedApproval
    }) => {
      const { data } = await apiRequest.post("/api/v1/access-approvals/policies", {
        environments,
        projectSlug,
        approvals,
        bypassers,
        approvers,
        secretPath,
        name,
        enforcementLevel,
        allowedSelfApprovals,
        approvalsRequired,
        maxTimePeriod,
        requestExpirationTime,
        delegatedApproval
      });
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalPolicies(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};

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

  return useMutation<object, object, TUpdateAccessPolicyDTO>({
    meta: { handledErrorCodes: [ApiErrorTypes.BadRequestError] },
    mutationFn: async ({
      id,
      approvers,
      bypassers,
      approvals,
      name,
      secretPath,
      enforcementLevel,
      allowedSelfApprovals,
      approvalsRequired,
      environments,
      maxTimePeriod,
      requestExpirationTime,
      delegatedApproval
    }) => {
      const { data } = await apiRequest.patch(`/api/v1/access-approvals/policies/${id}`, {
        approvals,
        approvers,
        bypassers,
        secretPath,
        name,
        enforcementLevel,
        allowedSelfApprovals,
        approvalsRequired,
        environments,
        maxTimePeriod,
        requestExpirationTime,
        delegatedApproval
      });
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalPolicies(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};

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

  return useMutation<object, object, TDeleteSecretPolicyDTO>({
    mutationFn: async ({ id }) => {
      const { data } = await apiRequest.delete(`/api/v1/access-approvals/policies/${id}`);
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalPolicies(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};

export const useCreateAccessRequest = () => {
  const queryClient = useQueryClient();
  return useMutation<object, object, TCreateAccessRequestDTO>({
    mutationFn: async ({ projectSlug, ...request }) => {
      const { data } = await apiRequest.post<TAccessApproval>(
        "/api/v1/access-approvals/requests",
        {
          ...request,
          permissions: request.permissions ? packRules(request.permissions) : undefined
        },
        {
          params: {
            projectSlug
          }
        }
      );

      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
    }
  });
};

export const useRevokeAccessRequest = () => {
  const queryClient = useQueryClient();
  return useMutation<
    object,
    object,
    {
      requestId: string;
      projectSlug: string;
    }
  >({
    mutationFn: async ({ requestId }) => {
      const { data } = await apiRequest.post(
        `/api/v1/access-approvals/requests/${requestId}/revoke`
      );
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};

export const useRetryDelegatedApprovalDispatch = () => {
  const queryClient = useQueryClient();
  return useMutation<
    object,
    object,
    {
      requestId: string;
      projectSlug: string;
    }
  >({
    mutationFn: async ({ requestId }) => {
      const { data } = await apiRequest.post(
        `/api/v1/access-approvals/requests/${requestId}/retry-delegated-dispatch`
      );
      return data;
    },
    onSuccess: (_, { requestId, projectSlug }) => {
      markDelegatedDispatchRetry(requestId);
      queryClient.setQueriesData<TAccessApprovalRequest[]>(
        { queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug) },
        (requests) =>
          requests?.map((request) =>
            request.id === requestId && request.delegatedApproval
              ? {
                  ...request,
                  delegatedApproval: {
                    status: DelegatedApprovalRequestStatus.PendingDispatch,
                    statusReason: null,
                    provider: request.delegatedApproval.provider ?? null
                  }
                }
              : request
          )
      );
    }
  });
};

export const useCancelAccessRequest = () => {
  const queryClient = useQueryClient();
  return useMutation<
    object,
    object,
    {
      requestId: string;
      projectSlug: string;
    }
  >({
    mutationFn: async ({ requestId }) => {
      const { data } = await apiRequest.post(
        `/api/v1/access-approvals/requests/${requestId}/cancel-delegated-dispatch`
      );
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};

export const useReviewAccessRequest = () => {
  const queryClient = useQueryClient();
  return useMutation<
    object,
    object,
    {
      requestId: string;
      status: "approved" | "rejected";
      projectSlug: string;
      bypassReason?: string;
    }
  >({
    mutationFn: async ({ requestId, status, bypassReason }) => {
      const { data } = await apiRequest.post(
        `/api/v1/access-approvals/requests/${requestId}/review`,
        {
          status,
          bypassReason
        }
      );
      return data;
    },
    onSuccess: (_, { projectSlug }) => {
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestsAllForProject(projectSlug)
      });
      queryClient.invalidateQueries({
        queryKey: accessApprovalKeys.getAccessApprovalRequestCount(projectSlug)
      });
    }
  });
};