Refacto workflow folders (#9302)

- Create separated folders for sections
- Add components
- Add utils and clean old ones
- Add constants
- Rename search variables folder and components

Next steps:
- clean hooks
- clean states

packages/twenty-front/src/modules/workflow/workflow-trigger/utils/__tests__/getManualTriggerDefaultSettings.test.ts

@@ -0,0 +1,26 @@
+import { generatedMockObjectMetadataItems } from '~/testing/mock-data/generatedMockObjectMetadataItems';
+import { getManualTriggerDefaultSettings } from '../getManualTriggerDefaultSettings';
+
+it('returns settings for a manual trigger that can be activated from any where', () => {
+  expect(
+    getManualTriggerDefaultSettings({
+      availability: 'EVERYWHERE',
+      activeObjectMetadataItems: generatedMockObjectMetadataItems,
+    }),
+  ).toStrictEqual({
+    objectType: undefined,
+    outputSchema: {},
+  });
+});
+
+it('returns settings for a manual trigger that can be activated from any where', () => {
+  expect(
+    getManualTriggerDefaultSettings({
+      availability: 'WHEN_RECORD_SELECTED',
+      activeObjectMetadataItems: generatedMockObjectMetadataItems,
+    }),
+  ).toStrictEqual({
+    objectType: generatedMockObjectMetadataItems[0].nameSingular,
+    outputSchema: {},
+  });
+});

packages/twenty-front/src/modules/workflow/workflow-trigger/utils/__tests__/getTriggerDefaultDefinition.test.ts

@@ -0,0 +1,50 @@
+import { generatedMockObjectMetadataItems } from '~/testing/mock-data/generatedMockObjectMetadataItems';
+import { getTriggerDefaultDefinition } from '../getTriggerDefaultDefinition';
+
+it('throws if the activeObjectMetadataItems list is empty', () => {
+  expect(() => {
+    getTriggerDefaultDefinition({
+      type: 'DATABASE_EVENT',
+      activeObjectMetadataItems: [],
+    });
+  }).toThrow();
+});
+
+it('returns a valid configuration for DATABASE_EVENT trigger type', () => {
+  expect(
+    getTriggerDefaultDefinition({
+      type: 'DATABASE_EVENT',
+      activeObjectMetadataItems: generatedMockObjectMetadataItems,
+    }),
+  ).toStrictEqual({
+    type: 'DATABASE_EVENT',
+    settings: {
+      eventName: `${generatedMockObjectMetadataItems[0].nameSingular}.created`,
+      outputSchema: {},
+    },
+  });
+});
+
+it('returns a valid configuration for MANUAL trigger type', () => {
+  expect(
+    getTriggerDefaultDefinition({
+      type: 'MANUAL',
+      activeObjectMetadataItems: generatedMockObjectMetadataItems,
+    }),
+  ).toStrictEqual({
+    type: 'MANUAL',
+    settings: {
+      objectType: generatedMockObjectMetadataItems[0].nameSingular,
+      outputSchema: {},
+    },
+  });
+});
+
+it('throws when providing an unknown trigger type', () => {
+  expect(() => {
+    getTriggerDefaultDefinition({
+      type: 'unknown' as any,
+      activeObjectMetadataItems: generatedMockObjectMetadataItems,
+    });
+  }).toThrow('Unknown type: unknown');
+});

packages/twenty-front/src/modules/workflow/workflow-trigger/utils/getManualTriggerDefaultSettings.ts

@@ -0,0 +1,31 @@
+import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import {
+  WorkflowManualTriggerAvailability,
+  WorkflowManualTriggerSettings,
+} from '@/workflow/types/Workflow';
+import { assertUnreachable } from '@/workflow/utils/assertUnreachable';
+
+export const getManualTriggerDefaultSettings = ({
+  availability,
+  activeObjectMetadataItems,
+}: {
+  availability: WorkflowManualTriggerAvailability;
+  activeObjectMetadataItems: ObjectMetadataItem[];
+}): WorkflowManualTriggerSettings => {
+  switch (availability) {
+    case 'EVERYWHERE': {
+      return {
+        objectType: undefined,
+        outputSchema: {},
+      };
+    }
+    case 'WHEN_RECORD_SELECTED': {
+      return {
+        objectType: activeObjectMetadataItems[0].nameSingular,
+        outputSchema: {},
+      };
+    }
+  }
+
+  return assertUnreachable(availability);
+};

packages/twenty-front/src/modules/workflow/workflow-trigger/utils/getTriggerDefaultDefinition.ts

@@ -0,0 +1,46 @@
+import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import {
+  WorkflowTrigger,
+  WorkflowTriggerType,
+} from '@/workflow/types/Workflow';
+import { assertUnreachable } from '@/workflow/utils/assertUnreachable';
+import { OBJECT_EVENT_TRIGGERS } from '@/workflow/workflow-trigger/constants/ObjectEventTriggers';
+import { getManualTriggerDefaultSettings } from '@/workflow/workflow-trigger/utils/getManualTriggerDefaultSettings';
+
+export const getTriggerDefaultDefinition = ({
+  type,
+  activeObjectMetadataItems,
+}: {
+  type: WorkflowTriggerType;
+  activeObjectMetadataItems: ObjectMetadataItem[];
+}): WorkflowTrigger => {
+  if (activeObjectMetadataItems.length === 0) {
+    throw new Error(
+      'This function need to receive at least one object metadata item to run.',
+    );
+  }
+
+  switch (type) {
+    case 'DATABASE_EVENT': {
+      return {
+        type,
+        settings: {
+          eventName: `${activeObjectMetadataItems[0].nameSingular}.${OBJECT_EVENT_TRIGGERS[0].value}`,
+          outputSchema: {},
+        },
+      };
+    }
+    case 'MANUAL': {
+      return {
+        type,
+        settings: getManualTriggerDefaultSettings({
+          availability: 'WHEN_RECORD_SELECTED',
+          activeObjectMetadataItems,
+        }),
+      };
+    }
+    default: {
+      return assertUnreachable(type, `Unknown type: ${type}`);
+    }
+  }
+};