Continue workflow folders re-ordering (#9315)

- put actions in steps - move hooks - move states
2025-01-02 13:23:07 +01:00
parent e3f7a0572e
commit 5da744ebc5
52 changed files with 86 additions and 80 deletions
@@ -0,0 +1,61 @@
+import { WorkflowWithCurrentVersion } from '@/workflow/types/Workflow';
+import { renderHook } from '@testing-library/react';
+import { useCreateStep } from '../useCreateStep';
+
+const mockOpenRightDrawer = jest.fn();
+const mockCreateNewWorkflowVersion = jest.fn();
+const mockCreateWorkflowVersionStep = jest.fn().mockResolvedValue({
+  data: { createWorkflowVersionStep: { id: '1' } },
+});
+
+jest.mock('recoil', () => ({
+  useRecoilValue: () => 'parent-step-id',
+  useSetRecoilState: () => jest.fn(),
+  atom: (params: any) => params,
+}));
+
+jest.mock('@/ui/layout/right-drawer/hooks/useRightDrawer', () => ({
+  useRightDrawer: () => ({
+    openRightDrawer: mockOpenRightDrawer,
+  }),
+}));
+
+jest.mock(
+  '@/workflow/workflow-steps/hooks/useCreateWorkflowVersionStep',
+  () => ({
+    useCreateWorkflowVersionStep: () => ({
+      createWorkflowVersionStep: mockCreateWorkflowVersionStep,
+    }),
+  }),
+);
+
+jest.mock('@/workflow/hooks/useCreateNewWorkflowVersion', () => ({
+  useCreateNewWorkflowVersion: () => ({
+    createNewWorkflowVersion: mockCreateNewWorkflowVersion,
+  }),
+}));
+
+describe('useCreateStep', () => {
+  const mockWorkflow = {
+    id: '123',
+    currentVersion: {
+      id: '456',
+      status: 'DRAFT',
+      steps: [],
+      trigger: { type: 'manual' },
+    },
+    versions: [],
+  };
+
+  it('should create step in draft version', async () => {
+    const { result } = renderHook(() =>
+      useCreateStep({
+        workflow: mockWorkflow as unknown as WorkflowWithCurrentVersion,
+      }),
+    );
+    await result.current.createStep('CODE');
+
+    expect(mockCreateWorkflowVersionStep).toHaveBeenCalled();
+    expect(mockOpenRightDrawer).toHaveBeenCalled();
+  });
+});
@@ -0,0 +1,62 @@
+import { WorkflowWithCurrentVersion } from '@/workflow/types/Workflow';
+import { useDeleteStep } from '@/workflow/workflow-steps/hooks/useDeleteStep';
+import { renderHook } from '@testing-library/react';
+
+const mockCloseRightDrawer = jest.fn();
+const mockCreateNewWorkflowVersion = jest.fn();
+const mockDeleteWorkflowVersionStep = jest.fn();
+const updateOneRecordMock = jest.fn();
+
+jest.mock('@/object-record/hooks/useUpdateOneRecord', () => ({
+  useUpdateOneRecord: () => ({
+    updateOneRecord: updateOneRecordMock,
+  }),
+}));
+
+jest.mock('recoil', () => ({
+  useRecoilValue: () => 'parent-step-id',
+  useSetRecoilState: () => jest.fn(),
+  atom: (params: any) => params,
+}));
+
+jest.mock('@/ui/layout/right-drawer/hooks/useRightDrawer', () => ({
+  useRightDrawer: () => ({
+    closeRightDrawer: mockCloseRightDrawer,
+  }),
+}));
+
+jest.mock('@/workflow/hooks/useDeleteWorkflowVersionStep', () => ({
+  useDeleteWorkflowVersionStep: () => ({
+    deleteWorkflowVersionStep: mockDeleteWorkflowVersionStep,
+  }),
+}));
+
+jest.mock('@/workflow/hooks/useCreateNewWorkflowVersion', () => ({
+  useCreateNewWorkflowVersion: () => ({
+    createNewWorkflowVersion: mockCreateNewWorkflowVersion,
+  }),
+}));
+
+describe('useDeleteStep', () => {
+  const mockWorkflow = {
+    id: '123',
+    currentVersion: {
+      id: '456',
+      status: 'DRAFT',
+      steps: [],
+      trigger: { type: 'manual' },
+    },
+    versions: [],
+  };
+
+  it('should delete step in draft version', async () => {
+    const { result } = renderHook(() =>
+      useDeleteStep({
+        workflow: mockWorkflow as unknown as WorkflowWithCurrentVersion,
+      }),
+    );
+    await result.current.deleteStep('1');
+
+    expect(mockDeleteWorkflowVersionStep).toHaveBeenCalled();
+  });
+});
@@ -0,0 +1,72 @@
+import { WorkflowWithCurrentVersion } from '@/workflow/types/Workflow';
+import { useUpdateStep } from '@/workflow/workflow-steps/hooks/useUpdateStep';
+import { renderHook } from '@testing-library/react';
+
+const mockCreateNewWorkflowVersion = jest.fn();
+const mockUpdateWorkflowVersionStep = jest.fn();
+
+jest.mock('recoil', () => ({
+  useRecoilValue: () => 'parent-step-id',
+  useSetRecoilState: () => jest.fn(),
+  atom: (params: any) => params,
+}));
+
+jest.mock(
+  '@/workflow/workflow-steps/hooks/useUpdateWorkflowVersionStep',
+  () => ({
+    useUpdateWorkflowVersionStep: () => ({
+      updateWorkflowVersionStep: mockUpdateWorkflowVersionStep,
+    }),
+  }),
+);
+
+jest.mock('@/workflow/hooks/useCreateNewWorkflowVersion', () => ({
+  useCreateNewWorkflowVersion: () => ({
+    createNewWorkflowVersion: mockCreateNewWorkflowVersion,
+  }),
+}));
+
+describe('useUpdateStep', () => {
+  const mockWorkflow = {
+    id: '123',
+    currentVersion: {
+      id: '456',
+      status: 'DRAFT',
+      steps: [],
+      trigger: { type: 'manual' },
+    },
+    versions: [],
+  };
+
+  it('should update step in draft version', async () => {
+    const { result } = renderHook(() =>
+      useUpdateStep({
+        workflow: mockWorkflow as unknown as WorkflowWithCurrentVersion,
+      }),
+    );
+    await result.current.updateStep({
+      id: '1',
+      name: 'name',
+      valid: true,
+      type: 'CODE',
+      settings: {
+        input: {
+          serverlessFunctionId: 'id',
+          serverlessFunctionVersion: '1',
+          serverlessFunctionInput: {},
+        },
+        outputSchema: {},
+        errorHandlingOptions: {
+          retryOnFailure: {
+            value: true,
+          },
+          continueOnFailure: {
+            value: true,
+          },
+        },
+      },
+    });
+
+    expect(mockUpdateWorkflowVersionStep).toHaveBeenCalled();
+  });
+});
@@ -0,0 +1,59 @@
+import { useRightDrawer } from '@/ui/layout/right-drawer/hooks/useRightDrawer';
+import { RightDrawerPages } from '@/ui/layout/right-drawer/types/RightDrawerPages';
+import { useGetUpdatableWorkflowVersion } from '@/workflow/hooks/useGetUpdatableWorkflowVersion';
+import { workflowLastCreatedStepIdState } from '@/workflow/states/workflowLastCreatedStepIdState';
+import {
+  WorkflowStepType,
+  WorkflowWithCurrentVersion,
+} from '@/workflow/types/Workflow';
+import { workflowSelectedNodeState } from '@/workflow/workflow-diagram/states/workflowSelectedNodeState';
+import { useCreateWorkflowVersionStep } from '@/workflow/workflow-steps/hooks/useCreateWorkflowVersionStep';
+import { workflowCreateStepFromParentStepIdState } from '@/workflow/workflow-steps/states/workflowCreateStepFromParentStepIdState';
+import { useRecoilValue, useSetRecoilState } from 'recoil';
+import { isDefined } from 'twenty-ui';
+
+export const useCreateStep = ({
+  workflow,
+}: {
+  workflow: WorkflowWithCurrentVersion;
+}) => {
+  const { openRightDrawer } = useRightDrawer();
+  const { createWorkflowVersionStep } = useCreateWorkflowVersionStep();
+  const setWorkflowSelectedNode = useSetRecoilState(workflowSelectedNodeState);
+  const setWorkflowLastCreatedStepId = useSetRecoilState(
+    workflowLastCreatedStepIdState,
+  );
+
+  const workflowCreateStepFromParentStepId = useRecoilValue(
+    workflowCreateStepFromParentStepIdState,
+  );
+
+  const { getUpdatableWorkflowVersion } = useGetUpdatableWorkflowVersion();
+
+  const createStep = async (newStepType: WorkflowStepType) => {
+    if (!isDefined(workflowCreateStepFromParentStepId)) {
+      throw new Error('Select a step to create a new step from first.');
+    }
+
+    const workflowVersion = await getUpdatableWorkflowVersion(workflow);
+
+    const createdStep = (
+      await createWorkflowVersionStep({
+        workflowVersionId: workflowVersion.id,
+        stepType: newStepType,
+      })
+    )?.data?.createWorkflowVersionStep;
+
+    if (!createdStep) {
+      return;
+    }
+
+    setWorkflowSelectedNode(createdStep.id);
+    setWorkflowLastCreatedStepId(createdStep.id);
+    openRightDrawer(RightDrawerPages.WorkflowStepEdit);
+  };
+
+  return {
+    createStep,
+  };
+};
@@ -0,0 +1,64 @@
+import { useApolloClient, useMutation } from '@apollo/client';
+import {
+  CreateWorkflowVersionStepMutation,
+  CreateWorkflowVersionStepMutationVariables,
+  CreateWorkflowVersionStepInput,
+} from '~/generated/graphql';
+import { CREATE_WORKFLOW_VERSION_STEP } from '@/workflow/graphql/mutations/createWorkflowVersionStep';
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { useGetRecordFromCache } from '@/object-record/cache/hooks/useGetRecordFromCache';
+import { isDefined } from 'twenty-ui';
+import { updateRecordFromCache } from '@/object-record/cache/utils/updateRecordFromCache';
+import { WorkflowVersion } from '@/workflow/types/Workflow';
+
+export const useCreateWorkflowVersionStep = () => {
+  const apolloClient = useApolloClient();
+  const { objectMetadataItems } = useObjectMetadataItems();
+  const { objectMetadataItem } = useObjectMetadataItem({
+    objectNameSingular: CoreObjectNameSingular.WorkflowVersion,
+  });
+  const getRecordFromCache = useGetRecordFromCache({
+    objectNameSingular: CoreObjectNameSingular.WorkflowVersion,
+  });
+  const [mutate] = useMutation<
+    CreateWorkflowVersionStepMutation,
+    CreateWorkflowVersionStepMutationVariables
+  >(CREATE_WORKFLOW_VERSION_STEP, {
+    client: apolloClient,
+  });
+  const createWorkflowVersionStep = async (
+    input: CreateWorkflowVersionStepInput,
+  ) => {
+    const result = await mutate({
+      variables: { input },
+    });
+    const createdStep = result?.data?.createWorkflowVersionStep;
+    if (!isDefined(createdStep)) {
+      return;
+    }
+
+    const cachedRecord = getRecordFromCache<WorkflowVersion>(
+      input.workflowVersionId,
+    );
+    if (!cachedRecord) {
+      return;
+    }
+
+    const newCachedRecord = {
+      ...cachedRecord,
+      steps: [...(cachedRecord.steps || []), createdStep],
+    };
+
+    updateRecordFromCache({
+      objectMetadataItems,
+      objectMetadataItem,
+      cache: apolloClient.cache,
+      record: newCachedRecord,
+    });
+    return result;
+  };
+
+  return { createWorkflowVersionStep };
+};
@@ -0,0 +1,47 @@
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useUpdateOneRecord } from '@/object-record/hooks/useUpdateOneRecord';
+import { useRightDrawer } from '@/ui/layout/right-drawer/hooks/useRightDrawer';
+import { useDeleteWorkflowVersionStep } from '@/workflow/hooks/useDeleteWorkflowVersionStep';
+import { useGetUpdatableWorkflowVersion } from '@/workflow/hooks/useGetUpdatableWorkflowVersion';
+import {
+  WorkflowVersion,
+  WorkflowWithCurrentVersion,
+} from '@/workflow/types/Workflow';
+import { TRIGGER_STEP_ID } from '@/workflow/workflow-trigger/constants/TriggerStepId';
+
+export const useDeleteStep = ({
+  workflow,
+}: {
+  workflow: WorkflowWithCurrentVersion;
+}) => {
+  const { deleteWorkflowVersionStep } = useDeleteWorkflowVersionStep();
+  const { updateOneRecord: updateOneWorkflowVersion } =
+    useUpdateOneRecord<WorkflowVersion>({
+      objectNameSingular: CoreObjectNameSingular.WorkflowVersion,
+    });
+
+  const { getUpdatableWorkflowVersion } = useGetUpdatableWorkflowVersion();
+  const { closeRightDrawer } = useRightDrawer();
+
+  const deleteStep = async (stepId: string) => {
+    closeRightDrawer();
+    const workflowVersion = await getUpdatableWorkflowVersion(workflow);
+    if (stepId === TRIGGER_STEP_ID) {
+      await updateOneWorkflowVersion({
+        idToUpdate: workflow.currentVersion.id,
+        updateOneRecordInput: {
+          trigger: null,
+        },
+      });
+      return;
+    }
+    await deleteWorkflowVersionStep({
+      workflowVersionId: workflowVersion.id,
+      stepId,
+    });
+  };
+
+  return {
+    deleteStep,
+  };
+};
@@ -0,0 +1,32 @@
+import { useGetUpdatableWorkflowVersion } from '@/workflow/hooks/useGetUpdatableWorkflowVersion';
+import {
+  WorkflowStep,
+  WorkflowWithCurrentVersion,
+} from '@/workflow/types/Workflow';
+import { useUpdateWorkflowVersionStep } from '@/workflow/workflow-steps/hooks/useUpdateWorkflowVersionStep';
+import { isDefined } from 'twenty-ui';
+
+export const useUpdateStep = ({
+  workflow,
+}: {
+  workflow: WorkflowWithCurrentVersion;
+}) => {
+  const { getUpdatableWorkflowVersion } = useGetUpdatableWorkflowVersion();
+  const { updateWorkflowVersionStep } = useUpdateWorkflowVersionStep();
+
+  const updateStep = async <T extends WorkflowStep>(updatedStep: T) => {
+    if (!isDefined(workflow.currentVersion)) {
+      throw new Error('Can not update an undefined workflow version.');
+    }
+
+    const workflowVersion = await getUpdatableWorkflowVersion(workflow);
+    await updateWorkflowVersionStep({
+      workflowVersionId: workflowVersion.id,
+      step: updatedStep,
+    });
+  };
+
+  return {
+    updateStep,
+  };
+};
@@ -0,0 +1,69 @@
+import { useApolloClient, useMutation } from '@apollo/client';
+import {
+  UpdateWorkflowVersionStepInput,
+  UpdateWorkflowVersionStepMutation,
+  UpdateWorkflowVersionStepMutationVariables,
+  WorkflowAction,
+} from '~/generated/graphql';
+import { UPDATE_WORKFLOW_VERSION_STEP } from '@/workflow/graphql/mutations/updateWorkflowVersionStep';
+import { updateRecordFromCache } from '@/object-record/cache/utils/updateRecordFromCache';
+import { useObjectMetadataItems } from '@/object-metadata/hooks/useObjectMetadataItems';
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useGetRecordFromCache } from '@/object-record/cache/hooks/useGetRecordFromCache';
+import { isDefined } from 'twenty-ui';
+import { WorkflowVersion } from '@/workflow/types/Workflow';
+
+export const useUpdateWorkflowVersionStep = () => {
+  const apolloClient = useApolloClient();
+  const { objectMetadataItems } = useObjectMetadataItems();
+  const { objectMetadataItem } = useObjectMetadataItem({
+    objectNameSingular: CoreObjectNameSingular.WorkflowVersion,
+  });
+  const getRecordFromCache = useGetRecordFromCache({
+    objectNameSingular: CoreObjectNameSingular.WorkflowVersion,
+  });
+  const [mutate] = useMutation<
+    UpdateWorkflowVersionStepMutation,
+    UpdateWorkflowVersionStepMutationVariables
+  >(UPDATE_WORKFLOW_VERSION_STEP, {
+    client: apolloClient,
+  });
+
+  const updateWorkflowVersionStep = async (
+    input: UpdateWorkflowVersionStepInput,
+  ) => {
+    const result = await mutate({ variables: { input } });
+    const updatedStep = result?.data?.updateWorkflowVersionStep;
+    if (!isDefined(updatedStep)) {
+      return;
+    }
+
+    const cachedRecord = getRecordFromCache<WorkflowVersion>(
+      input.workflowVersionId,
+    );
+    if (!cachedRecord) {
+      return;
+    }
+
+    const newCachedRecord = {
+      ...cachedRecord,
+      steps: (cachedRecord.steps || []).map((step: WorkflowAction) => {
+        if (step.id === updatedStep.id) {
+          return updatedStep;
+        }
+        return step;
+      }),
+    };
+
+    updateRecordFromCache({
+      objectMetadataItems,
+      objectMetadataItem,
+      cache: apolloClient.cache,
+      record: newCachedRecord,
+    });
+    return result;
+  };
+
+  return { updateWorkflowVersionStep };
+};