Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

12.8 KB
Raw Blame
/* eslint-disable @repo/no-style-props, @repo/no-abstracted-overlay-trigger, @repo/component-file-structure */
import { useMemo, useState } from "react";
import { useRouter } from "next/router";
import {
  Popover,
  PopoverAnchor,
  PopoverContent,
  PopoverTrigger,
} from "@/src/components/ui/popover";
import { Button, type ButtonProps } from "@/src/components/ui/button";
import { LockIcon, TrashIcon } from "@langfuse/icons";
import { IconOnlyButton } from "@/src/components/IconOnlyButton";
import { useHasProjectAccess } from "@/src/features/rbac/utils/checkProjectAccess";
import { type ProjectScope } from "@langfuse/shared";
import { api } from "@/src/utils/api";
import { usePostHogClientCapture } from "@/src/features/posthog-analytics/usePostHogClientCapture";
import { showSuccessToast } from "@/src/features/notifications/showSuccessToast";
import { ConfirmationDialogController } from "@/src/components/design-system/ConfirmationDialogController/ConfirmationDialogController";

export type DeleteButtonProps = {
  itemId: string;
  projectId: string;
  isTableAction?: boolean;
  scope?: ProjectScope;
  invalidateFunc?: () => void;
  redirectUrl?: string;
  deleteConfirmation?: string;
  icon?: boolean;
  enabled?: boolean;
  variant?: ButtonProps["variant"];
  size?: ButtonProps["size"];
  title?: string;
  className?: string;
  // forwarded explicitly because the base component does not spread unknown
  // props onto the rendered button
  "aria-label"?: string;
};

type BaseDeleteButtonProps = Omit<DeleteButtonProps, "itemId"> & {
  variant?: ButtonProps["variant"];
  scope: NonNullable<DeleteButtonProps["scope"]>;
  invalidateFunc: NonNullable<DeleteButtonProps["invalidateFunc"]>;
  captureDeleteOpen: (
    capture: ReturnType<typeof usePostHogClientCapture>,
    isTableAction: boolean,
  ) => void;
  captureDeleteSuccess: (
    capture: ReturnType<typeof usePostHogClientCapture>,
    isTableAction: boolean,
  ) => void;
  entityToDeleteName: string;
  customDeletePrompt?: string;
  executeDeleteMutation: (onSuccess: () => void) => Promise<void>;
  isDeleteMutationLoading: boolean;
  itemId?: string;
  // when set, the popover explains why deletion is blocked instead of asking for confirmation
  deleteBlocker?: React.ReactNode;
  onPopoverOpenChange?: (open: boolean) => void;
};

export function DeleteButton({
  variant,
  itemId,
  projectId,
  isTableAction = false,
  scope,
  invalidateFunc,
  redirectUrl,
  deleteConfirmation,
  icon = false,
  enabled = true,
  title,
  className,
  size,
  captureDeleteOpen,
  captureDeleteSuccess,
  entityToDeleteName,
  executeDeleteMutation,
  isDeleteMutationLoading,
  customDeletePrompt,
  deleteBlocker,
  onPopoverOpenChange,
  "aria-label": ariaLabel,
}: BaseDeleteButtonProps) {
  const [isDeleted, setIsDeleted] = useState(false);
  const [open, setOpen] = useState(false);
  const router = useRouter();
  const capture = usePostHogClientCapture();

  const hasAccess = useHasProjectAccess({ projectId, scope: scope });

  const onDeleteSuccess = useMemo(() => {
    return () => {
      setIsDeleted(true);
      captureDeleteSuccess(capture, isTableAction);
      !isTableAction && redirectUrl
        ? router.push(redirectUrl)
        : invalidateFunc();
    };
  }, [
    isTableAction,
    redirectUrl,
    invalidateFunc,
    router,
    captureDeleteSuccess,
    capture,
  ]);

  if (!deleteBlocker) {
    return (
      <ConfirmationDialogController
        title={`Delete ${entityToDeleteName}?`}
        text={
          customDeletePrompt ??
          `This action cannot be undone. It removes all the data associated with this ${entityToDeleteName}. If this is the project default, it will be deleted for all users.`
        }
        confirmationText={deleteConfirmation}
        confirmLabel={`Delete ${entityToDeleteName}`}
        variant="destructive"
        loading={isDeleteMutationLoading || isDeleted}
        onConfirm={() => executeDeleteMutation(onDeleteSuccess)}
      >
        {({ openDialog }) =>
          icon ? (
            <IconOnlyButton
              icon={<TrashIcon size="base" />}
              label={title ?? "Delete"}
              aria-label={ariaLabel ?? "delete"}
              disabledReason={
                hasAccess
                  ? undefined
                  : `You don't have permission to delete this ${entityToDeleteName}.`
              }
              variant={variant ?? "outline"}
              size={size ?? "icon"}
              className={className}
              disabled={!enabled}
              onClick={(event) => {
                event.stopPropagation();
                captureDeleteOpen(capture, isTableAction);
                onPopoverOpenChange?.(true);
                openDialog();
              }}
            />
          ) : (
            <Button
              variant={variant ?? "ghost"}
              size={size ?? "default"}
              title={title}
              aria-label={ariaLabel}
              className={className}
              disabled={!hasAccess || !enabled}
              onClick={(event) => {
                event.stopPropagation();
                captureDeleteOpen(capture, isTableAction);
                onPopoverOpenChange?.(true);
                openDialog();
              }}
            >
              {hasAccess ? (
                <TrashIcon size="base" color="default" __rawClassName="mr-2" />
              ) : (
                <LockIcon size="base" color="default" __rawClassName="mr-2" />
              )}
              Delete
            </Button>
          )
        }
      </ConfirmationDialogController>
    );
  }

  return (
    <Popover
      key={itemId ?? "delete-action"}
      open={open}
      onOpenChange={(o) => {
        setOpen(o);
        onPopoverOpenChange?.(o);
      }}
    >
      {icon ? (
        // Icon-only: a compact button with a built-in tooltip; the popover is
        // opened from onClick since the tooltip wrapper can't be a trigger.
        <PopoverAnchor asChild>
          <span className="inline-flex">
            <IconOnlyButton
              icon={<TrashIcon size="base" />}
              label={title ?? "Delete"}
              aria-label={ariaLabel ?? "delete"}
              disabledReason={
                hasAccess
                  ? undefined
                  : `You don't have permission to delete this ${entityToDeleteName}.`
              }
              variant={variant ?? "outline"}
              size={size ?? "icon"}
              className={className}
              disabled={!enabled}
              onClick={(e) => {
                e.stopPropagation();
                captureDeleteOpen(capture, isTableAction);
                // Opening via controlled state (PopoverAnchor, not
                // PopoverTrigger) means Radix never echoes onOpenChange, so
                // notify consumers explicitly.
                setOpen(true);
                onPopoverOpenChange?.(true);
              }}
            />
          </span>
        </PopoverAnchor>
      ) : (
        <PopoverTrigger asChild>
          <Button
            variant={variant ?? "ghost"}
            size={size ?? "default"}
            title={title}
            aria-label={ariaLabel}
            className={className}
            disabled={!hasAccess || !enabled}
            onClick={(e) => {
              e.stopPropagation();
              captureDeleteOpen(capture, isTableAction);
            }}
          >
            {hasAccess ? (
              <TrashIcon size="base" color="default" __rawClassName="mr-2" />
            ) : (
              <LockIcon size="base" color="default" __rawClassName="mr-2" />
            )}
            Delete
          </Button>
        </PopoverTrigger>
      )}
      <PopoverContent onClick={(e) => e.stopPropagation()}>
        {deleteBlocker}
      </PopoverContent>
    </Popover>
  );
}

/** DeleteMonitorButton deletes a monitor through the shared confirm-then-delete pattern. */
export function DeleteMonitorButton(props: DeleteButtonProps) {
  const utils = api.useUtils();
  const {
    itemId,
    projectId,
    scope = "alerts:CUD",
    invalidateFunc = () => utils.monitors.invalidate(),
  } = props;
  const monitorMutation = api.monitors.delete.useMutation({
    onSuccess: () => {
      showSuccessToast({
        operation: "monitor.delete",
        title: "Alert deleted",
        description: "The alert has been deleted successfully",
      });
      utils.monitors.invalidate();
    },
  });

  const executeDeleteMutation = async (onSuccess: () => void) => {
    try {
      await monitorMutation.mutateAsync({ id: itemId, projectId });
    } catch (error) {
      return Promise.reject(error);
    }
    onSuccess();
  };

  return (
    <DeleteButton
      {...props}
      scope={scope}
      invalidateFunc={invalidateFunc}
      captureDeleteOpen={(capture, isTableAction) =>
        capture("monitors:delete_form_open", {
          source: isTableAction ? "table-single-row" : "monitor",
        })
      }
      captureDeleteSuccess={(capture, isTableAction) =>
        capture("monitors:delete_monitor_button_click", {
          source: isTableAction ? "table-single-row" : "monitor",
        })
      }
      entityToDeleteName="alert"
      customDeletePrompt="This action cannot be undone. It stops all evaluations and removes its alert history."
      executeDeleteMutation={executeDeleteMutation}
      isDeleteMutationLoading={monitorMutation.isPending}
    />
  );
}

export function DeleteEvalConfigButton(props: DeleteButtonProps) {
  const utils = api.useUtils();
  const {
    itemId,
    projectId,
    scope = "evaluationRule:CUD",
    invalidateFunc = () => utils.evals.invalidate(),
  } = props;

  const evaluatorMutation = api.evals.deleteEvalJob.useMutation({
    onSuccess: () => {
      showSuccessToast({
        operation: "evaluator.delete",
        title: "Running evaluator deleted",
        description: "The running evaluator has been deleted successfully",
      });
      utils.evals.invalidate();
    },
  });

  const executeDeleteMutation = async (onSuccess: () => void) => {
    try {
      await evaluatorMutation.mutateAsync({
        evalConfigId: itemId,
        projectId,
      });
      onSuccess();
    } catch (error) {
      return Promise.reject(error);
    }
  };

  return (
    <DeleteButton
      {...props}
      scope={scope}
      invalidateFunc={invalidateFunc}
      captureDeleteOpen={(capture, isTableAction) =>
        capture("eval_config:delete_form_open", {
          source: isTableAction ? "table-single-row" : "eval config detail",
        })
      }
      captureDeleteSuccess={(capture, isTableAction) =>
        capture("eval_config:delete_evaluator_button_click", {
          source: isTableAction ? "table-single-row" : "eval config detail",
        })
      }
      customDeletePrompt="This action cannot be undone and removes all logs associated with this running evaluator. Scores produced by this evaluator will not be deleted."
      entityToDeleteName="running evaluator"
      executeDeleteMutation={executeDeleteMutation}
      isDeleteMutationLoading={evaluatorMutation.isPending}
    />
  );
}

export function DeleteEvaluationModelButton(
  props: Omit<DeleteButtonProps, "itemId">,
) {
  const utils = api.useUtils();
  const {
    projectId,
    scope = "evalDefaultModel:CUD",
    invalidateFunc = () => utils.defaultLlmModel.invalidate(),
  } = props;

  const { mutateAsync: deleteDefaultModel, isPending } =
    api.defaultLlmModel.deleteDefaultModel.useMutation({
      onSuccess: () => {
        showSuccessToast({
          operation: "evaluation_model.delete",
          title: "Default evaluation model deleted",
          description:
            "The default evaluation model has been deleted. Any running evaluations relying on the default model will be inactivated. Queued jobs will fail.",
        });
        utils.defaultLlmModel.fetchDefaultModel.invalidate({ projectId });
      },
    });

  const executeDeleteMutation = async (onSuccess: () => void) => {
    try {
      await deleteDefaultModel({
        projectId,
      });
    } catch (error) {
      return Promise.reject(error);
    }
    onSuccess();
  };

  return (
    <DeleteButton
      {...props}
      variant="outline"
      scope={scope}
      invalidateFunc={invalidateFunc}
      captureDeleteOpen={(capture, isTableAction) =>
        capture("eval_config:delete_form_open", {
          source: isTableAction ? "table-single-row" : "evaluator",
        })
      }
      captureDeleteSuccess={(capture, isTableAction) =>
        capture("eval_config:delete_evaluator_button_click", {
          source: isTableAction ? "table-single-row" : "evaluator",
        })
      }
      entityToDeleteName="default evaluation model"
      customDeletePrompt="Deleting this model might cause running evaluators to fail. Please make sure you have no running evaluators relying on this model."
      deleteConfirmation="delete"
      executeDeleteMutation={executeDeleteMutation}
      isDeleteMutationLoading={isPending}
    />
  );
}