Skip to content

LLM-Driven Extraction of Unstructured Data — Built for API Deployments & ETL Pipeline Workflows

8.7 KB
Raw Blame
import PropTypes from "prop-types";
import { useEffect, useState } from "react";
import { Form } from "@/components/ui/shims/antd-form";
import { Input, Select } from "@/components/ui/shims/antd-inputs";
import { Modal } from "@/components/ui/shims/antd-overlays";

import { getBackendErrorDetail } from "../../../helpers/GetStaticData.js";
import { useExceptionHandler } from "../../../hooks/useExceptionHandler.jsx";
import usePostHogEvents from "../../../hooks/usePostHogEvents.js";
import { useAlertStore } from "../../../store/alert-store";
import { useWorkflowStore } from "../../../store/workflow-store.js";
import { apiDeploymentsService } from "../../deployments/api-deployment/api-deployments-service.js";

const defaultFromDetails = {
  display_name: "",
  description: "",
  api_name: "",
  workflow: "",
};

const CreateApiDeploymentModal = ({
  open,
  setOpen,
  setTableData,
  isEdit,
  selectedRow = {},
  openCodeModal,
  setSelectedRow,
  workflowId,
  workflowEndpointList = [],
  setDeploymentName,
  onDeploymentCreated,
  refreshList,
}) => {
  const workflowStore = useWorkflowStore();
  const { updateWorkflow } = workflowStore;
  const apiDeploymentsApiService = apiDeploymentsService();
  const { setAlertDetails } = useAlertStore();
  const handleException = useExceptionHandler();
  const { Option } = Select;
  const [formDetails, setFormDetails] = useState(
    isEdit ? { ...selectedRow } : { ...defaultFromDetails },
  );
  const [isLoading, setIsLoading] = useState(false);
  const [form] = Form.useForm();
  const [backendErrors, setBackendErrors] = useState(null);
  const [isFormChanged, setIsFormChanged] = useState(false);
  const { setPostHogCustomEvent } = usePostHogEvents();

  const handleInputChange = (changedValues, allValues) => {
    setIsFormChanged(true);
    setFormDetails({ ...formDetails, ...allValues });
    const changedFieldName = Object.keys(changedValues)[0];
    form.setFields([
      {
        name: changedFieldName,
        errors: [],
      },
    ]);
    setBackendErrors((prevErrors) => {
      if (prevErrors) {
        const updatedErrors = prevErrors.errors.filter(
          (error) => error.attr !== changedFieldName,
        );
        return { ...prevErrors, errors: updatedErrors };
      }
      return null;
    });
  };

  useEffect(() => {
    if (workflowId) {
      setFormDetails((prevState) => ({
        ...prevState,
        workflow: workflowId,
      }));
    }
  }, [workflowId]);

  const clearFormDetails = () => {
    setFormDetails({ ...defaultFromDetails });
  };

  const handleCancel = () => {
    setOpen(false);
  };

  const createApiDeployment = () => {
    const wf = workflowEndpointList?.find(
      (item) => item?.workflow === formDetails?.workflow,
    );
    setPostHogCustomEvent("intent_success_api_deployment", {
      info: "Clicked on 'Save' button",
      deployment_name: formDetails?.api_name,
      workflow_name: wf?.workflow_name,
    });

    setIsLoading(true);
    const body = formDetails;
    apiDeploymentsApiService
      .createApiDeployment(body)
      .then((res) => {
        if (workflowId) {
          // Update - can update workflow endpoint status in store
          updateWorkflow({ allowChangeEndpoint: false });
          setDeploymentName(body.display_name);

          // Call the callback to refresh deployment info
          if (onDeploymentCreated) {
            onDeploymentCreated();
          }
        } else {
          // Refetch: the create response is a summary without the owner
          // fields the list renders.
          refreshList?.();
          setSelectedRow(res?.data);
          openCodeModal(true);
        }
        setOpen(false);
        clearFormDetails();
        setAlertDetails({
          type: "success",
          content: "New API created successfully",
        });
      })
      .catch((err) => {
        if (err.response?.data) {
          setBackendErrors(err.response.data);

          // Show error notification
          const errorData = err.response.data;
          if (errorData.errors && errorData.errors.length > 0) {
            setAlertDetails({
              type: "error",
              content: errorData.errors[0].detail || "Validation failed",
            });
          }
        } else {
          setAlertDetails(
            handleException(err, "Failed to create API deployment"),
          );
        }
      })
      .finally(() => {
        setIsLoading(false);
      });
  };

  const mergeUpdatedRow = (updatedData) => {
    setTableData((prev) => {
      const index = prev.findIndex((item) => item?.id === updatedData?.id);
      if (index !== -1) {
        const newData = [...prev];
        newData[index] = { ...newData[index], ...updatedData };
        return newData;
      }
      return prev;
    });
  };

  const updateApiDeployment = () => {
    setIsLoading(true);
    const body = formDetails;

    apiDeploymentsApiService
      .updateApiDeployment(body)
      .then((res) => {
        mergeUpdatedRow(res?.data);
        setOpen(false);
        clearFormDetails();
        setAlertDetails({
          type: "success",
          content: "API deployment updated successfully",
        });
      })
      .catch((err) => {
        if (err.response?.data) {
          setBackendErrors(err.response.data);
        } else {
          setAlertDetails(
            handleException(err, "Failed to update API deployment"),
          );
        }
      })
      .finally(() => {
        setIsLoading(false);
      });
  };

  return (
    <Modal
      title={isEdit ? "Update API deployment " : "Add API deployment"}
      centered
      maskClosable={false}
      open={open}
      onOk={isEdit ? updateApiDeployment : createApiDeployment}
      onCancel={handleCancel}
      okText={isEdit ? "Update" : "Save"}
      okButtonProps={{
        loading: isLoading,
        disabled: !isFormChanged,
      }}
      width={450}
    >
      <Form
        form={form}
        name="myForm"
        layout="vertical"
        initialValues={formDetails}
        onValuesChange={handleInputChange}
      >
        <Form.Item
          label="Display Name (for humans)"
          name="display_name"
          rules={[{ required: true, message: "Please enter a display name" }]}
          validateStatus={
            getBackendErrorDetail("display_name", backendErrors) ? "error" : ""
          }
          help={getBackendErrorDetail("display_name", backendErrors)}
        >
          <Input />
        </Form.Item>

        <Form.Item
          label="Description"
          name="description"
          validateStatus={
            getBackendErrorDetail("description", backendErrors) ? "error" : ""
          }
          help={getBackendErrorDetail("description", backendErrors)}
        >
          <Input />
        </Form.Item>

        <Form.Item
          label="API Name (forms part of the API signature)"
          name="api_name"
          rules={[
            { required: true, message: "Please enter an API Name" },
            {
              pattern: /^[a-zA-Z0-9_-]+$/,
              message:
                "Only letters, numbers, hyphen and underscores are allowed",
            },
            {
              pattern: /^.{1,30}$/,
              message: "Maximum 30 characters only allowed",
            },
          ]}
          validateStatus={
            getBackendErrorDetail("api_name", backendErrors) ? "error" : ""
          }
          help={getBackendErrorDetail("api_name", backendErrors)}
        >
          <Input />
        </Form.Item>

        {!workflowId && (
          <Form.Item
            label="Workflow"
            name="workflow"
            rules={[{ required: true, message: "Please select a workflow" }]}
            validateStatus={
              getBackendErrorDetail("workflow", backendErrors) ? "error" : ""
            }
            help={getBackendErrorDetail("workflow", backendErrors)}
          >
            <Select showSearch>
              {workflowEndpointList?.map((endpoint) => {
                return (
                  <Option
                    value={endpoint.workflow}
                    key={endpoint.workflow_name}
                  >
                    {endpoint.workflow_name}
                  </Option>
                );
              })}
            </Select>
          </Form.Item>
        )}
      </Form>
    </Modal>
  );
};

CreateApiDeploymentModal.propTypes = {
  open: PropTypes.bool.isRequired,
  setOpen: PropTypes.func.isRequired,
  setTableData: PropTypes.func,
  isEdit: PropTypes.bool,
  selectedRow: PropTypes.object,
  openCodeModal: PropTypes.func,
  setSelectedRow: PropTypes.func,
  workflowId: PropTypes.string,
  workflowEndpointList: PropTypes.object,
  setDeploymentName: PropTypes.func,
  onDeploymentCreated: PropTypes.func,
  refreshList: PropTypes.func,
};

export { CreateApiDeploymentModal };