fix(workflow): Handle multiple from and improve layout (#15068)

Co-authored-by: Octave <octave.albert@filigran.io>

Author: delemaf

opencti-platform/opencti-front/src/private/components/settings/sub_types/workflow/hooks/useWorkflowInitialElements.test.ts

@@ -70,7 +70,7 @@ describe('useWorkflowInitialElements', () => {
     ],
     transitions: [
       {
-        from: 'status-open',
+        from: ['status-open'],
         to: 'status-closed',
         event: 'close_event',
         conditions: {},
@@ -221,7 +221,7 @@ describe('useWorkflowInitialElements', () => {
       ...mockWorkflowDefinition!,
       transitions: [
         {
-          from: 'status-open',
+          from: ['status-open'],
           to: 'status-closed',
           event: 'share_event',
           conditions: {},
@@ -260,7 +260,7 @@ describe('useWorkflowInitialElements', () => {
       ...mockWorkflowDefinition!,
       transitions: [
         {
-          from: 'status-open',
+          from: ['status-open'],
           to: 'status-closed',
           event: 'unshare_event',
           conditions: {},

opencti-platform/opencti-front/src/private/components/settings/sub_types/workflow/hooks/useWorkflowInitialElements.ts

@@ -94,29 +94,34 @@ export const useWorkflowInitialElements = (
 
     // 2. Map transitions to transition nodes
     const transitionNodes: Node[] = workflowDefinition.transitions
-      .map(({ from, to, event, conditions = {}, comment, asyncActions = [], syncActions = [] }) => ({
-        id: `${WorkflowNodeType.transition}-${from}-${to}`,
-        type: WorkflowNodeType.transition,
-        data: {
-          event,
-          conditions,
-          comment: (comment ?? CommentMode.disabled) as CommentModeType,
-          asyncActions: parseActions((asyncActions ?? []) as ReadonlyArray<ReadOnlyAction>),
-          syncActions: parseActions((syncActions ?? []) as ReadonlyArray<ReadOnlyAction>),
-        },
-        position: { x: 0, y: 0 },
-      }));
+      .map(({ from, to, event, conditions = {}, comment, asyncActions = [], syncActions = [] }) => {
+        const fromIds = (Array.isArray(from) ? from : [from]).join(',');
+        return {
+          id: `${WorkflowNodeType.transition}-${fromIds}-${to}`,
+          type: WorkflowNodeType.transition,
+          data: {
+            event,
+            conditions,
+            comment: (comment ?? CommentMode.disabled) as CommentModeType,
+            asyncActions: parseActions((asyncActions ?? []) as ReadonlyArray<ReadOnlyAction>),
+            syncActions: parseActions((syncActions ?? []) as ReadonlyArray<ReadOnlyAction>),
+          },
+          position: { x: 0, y: 0 },
+        };
+      });
 
     // 3. Map transitions to edges
     const transitionEdges: Edge[] = workflowDefinition.transitions.flatMap((transition) => {
-      const transitionId = `${WorkflowNodeType.transition}-${transition.from}-${transition.to}`;
+      const fromArray = Array.isArray(transition.from) ? transition.from : [transition.from];
+      const fromIds = fromArray.join(',');
+      const transitionId = `${WorkflowNodeType.transition}-${fromIds}-${transition.to}`;
       return [
-        {
-          id: `e-${transition.from}->${transitionId}`,
+        ...fromArray.map((fromState) => ({
+          id: `e-${fromState}->${transitionId}`,
           type: WorkflowNodeType.transition,
-          source: transition.from,
+          source: fromState,
           target: transitionId,
-        },
+        })),
         {
           id: `e-${transitionId}->${transition.to}`,
           type: WorkflowNodeType.transition,

opencti-platform/opencti-front/src/private/components/settings/sub_types/workflow/utils.test.ts

@@ -108,6 +108,28 @@ describe('Workflow utils', () => {
     expect(result.states[0].onExit).toEqual([{ type: 'validateDraft' }]);
   });
 
+  it('should fan out multiple-source transitions into one entry per source state', () => {
+    const nodes: Node[] = [
+      { id: 'state-1', type: WorkflowNodeType.status, data: { statusTemplate: { id: 'state-1' }, onEnter: [], onExit: [] }, position: { x: 0, y: 0 } },
+      { id: 'state-2', type: WorkflowNodeType.status, data: { statusTemplate: { id: 'state-2' }, onEnter: [], onExit: [] }, position: { x: 0, y: 0 } },
+      { id: 'state-reject', type: WorkflowNodeType.status, data: { statusTemplate: { id: 'state-reject' }, onEnter: [], onExit: [] }, position: { x: 0, y: 0 } },
+      { id: 'trans-reject', type: WorkflowNodeType.transition, data: { event: 'reject', conditions: {}, actions: [], asyncActions: [], syncActions: [] }, position: { x: 0, y: 0 } },
+    ];
+    const edges: Edge[] = [
+      // Both state-1 and state-2 feed into the same "reject" transition node
+      { id: 'e1', source: 'state-1', target: 'trans-reject', type: 'smoothstep' },
+      { id: 'e2', source: 'state-2', target: 'trans-reject', type: 'smoothstep' },
+      { id: 'e3', source: 'trans-reject', target: 'state-reject', type: 'smoothstep' },
+    ];
+    const result = transformToWorkflowDefinition(nodes, edges, mockWorkflowDefinition);
+    // Must produce two separate transitions rather than one with from: ['state-1', 'state-2']
+    expect(result.transitions).toHaveLength(2);
+    expect(result.transitions).toEqual(expect.arrayContaining([
+      expect.objectContaining({ from: 'state-1', to: 'state-reject', event: 'reject' }),
+      expect.objectContaining({ from: 'state-2', to: 'state-reject', event: 'reject' }),
+    ]));
+  });
+
   it('should correctly identify element types', () => {
     const statusNode: Node = { id: '1', type: WorkflowNodeType.status, data: {}, position: { x: 0, y: 0 } };
     const placeholderNode: Node = { id: '2', type: WorkflowNodeType.placeholder, data: {}, position: { x: 0, y: 0 } };

opencti-platform/opencti-front/src/private/components/settings/sub_types/workflow/utils.ts

@@ -131,31 +131,29 @@ const transformToWorkflowDefinition = (
       // Find ALL outgoing edges (This Transition -> To Status)
       const outgoingEdges = edges.filter((e) => e.source === node.id);
 
-      // Create a transition entry for every possible path through this node
-      // This handles: Multiple Sources -> 1 Transition -> Multiple Targets
-      if (outgoingEdges.length > 0) {
-        return incomingEdges.flatMap((inEdge) =>
-          outgoingEdges.map((outEdge) => ({
-            from: nodes.find((n) => n.id === inEdge.source)?.data.statusTemplate.id,
-            to: nodes.find((n) => n.id === outEdge.target)?.data.statusTemplate.id || null,
-            event,
-            conditions,
-            comment,
-            asyncActions: formatActions(asyncActions),
-            syncActions: formatActions(syncActions),
-          })),
-        );
-      }
-      // Multiple Sources -> 1 Transition -> (no target)
-      return incomingEdges.map((inEdge) => ({
-        from: nodes.find((n) => n.id === inEdge.source)?.data.statusTemplate.id,
-        to: null as string | null,
+      // Collect all source state IDs
+      const fromStates = incomingEdges
+        .map((inEdge) => nodes.find((n) => n.id === inEdge.source)?.data.statusTemplate.id)
+        .filter(Boolean) as string[];
+
+      const actionPayload = {
         event,
         conditions,
-        comment,
         asyncActions: formatActions(asyncActions),
         syncActions: formatActions(syncActions),
-      }));
+        comment,
+      };
+
+      // Fan out: one SerializedTransition per (from, to) pair.
+      // SerializedTransition.from is always a single string — never an array —
+      // so the backend's getTransitions(currentState) strict-equality check works correctly.
+      const toStates = outgoingEdges.length > 0
+        ? outgoingEdges.map((outEdge) => nodes.find((n) => n.id === outEdge.target)?.data.statusTemplate.id || null)
+        : [null as string | null];
+
+      return fromStates.flatMap((from) =>
+        toStates.map((to) => ({ ...actionPayload, from, to })),
+      );
     }
     return [];
   });

opencti-platform/opencti-front/src/schema/relay.schema.graphql

@@ -10784,7 +10784,7 @@ type WorkflowSerializedState {
 }
 
 type WorkflowSerializedTransition {
-  from: String!
+  from: [String!]!
   to: String!
   event: String!
   asyncActions: [WorkflowActionConfig!]

opencti-platform/opencti-graphql/src/generated/graphql.ts

@@ -38021,7 +38021,7 @@ export type WorkflowSerializedTransition = {
   comment?: Maybe<Scalars['String']['output']>;
   conditions?: Maybe<Scalars['JSON']['output']>;
   event: Scalars['String']['output'];
-  from: Scalars['String']['output'];
+  from: Array<Scalars['String']['output']>;
   syncActions?: Maybe<Array<WorkflowActionConfig>>;
   to: Scalars['String']['output'];
 };
@@ -52849,7 +52849,7 @@ export type WorkflowSerializedTransitionResolvers<ContextType = any, ParentType
   comment?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
   conditions?: Resolver<Maybe<ResolversTypes['JSON']>, ParentType, ContextType>;
   event?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
-  from?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  from?: Resolver<Array<ResolversTypes['String']>, ParentType, ContextType>;
   syncActions?: Resolver<Maybe<Array<ResolversTypes['WorkflowActionConfig']>>, ParentType, ContextType>;
   to?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
 }>;

opencti-platform/opencti-graphql/src/modules/workflow/api/workflow-resolvers.ts

@@ -76,6 +76,9 @@ const workflowResolvers = {
     pendingError: (instance: any) => instance.pendingError ?? null,
     pendingTransition: (instance: any) => instance.pendingTransition ?? null,
   },
+  WorkflowSerializedTransition: {
+    from: (transition: any) => (Array.isArray(transition.from) ? transition.from : [transition.from]),
+  },
   WorkflowTransition: {
     toStatus: (transition: any) => ({ id: transition.toState, template_id: transition.toState }),
     comment: (transition: any) => transition.comment ?? null,

opencti-platform/opencti-graphql/src/modules/workflow/api/workflow.graphql

@@ -16,7 +16,7 @@ type WorkflowSerializedState {
 }
 
 type WorkflowSerializedTransition {
-    from: String!
+    from: [String!]!
     to: String!
     event: String!
     asyncActions: [WorkflowActionConfig!]

opencti-platform/opencti-graphql/src/modules/workflow/workflow-validation.ts

@@ -165,7 +165,8 @@ export const validateWorkflowDefinitionData = async (
     stateIdsToCheck.add(initialState);
   }
 
-  const events = new Set<string>();
+  // Track (fromState, event) pairs to prevent duplicate transitions from the same source.
+  const fromEventPairs = new Set<string>();
   let hasValidateDraft = false;
   const statesWithIncomingTransition = new Set<string>();
 
@@ -176,13 +177,18 @@ export const validateWorkflowDefinitionData = async (
         message: `Transition ${transition.event} should be linked to at least one status`,
       });
     }
-    if (events.has(transition.event)) {
-      errors.push({
-        type: 'DUPLICATE_TRANSITION_EVENT',
-        message: `Transition '${transition.event}' referenced in multiple transitions`,
-      });
+
+    const fromStatesForCheck = Array.isArray(transition.from) ? transition.from : [transition.from];
+    for (const fromState of fromStatesForCheck) {
+      const key = `${fromState}::${transition.event}`;
+      if (fromEventPairs.has(key)) {
+        errors.push({
+          type: 'DUPLICATE_TRANSITION_EVENT',
+          message: `Transition '${transition.event}' referenced in multiple transitions`,
+        });
+      }
+      fromEventPairs.add(key);
     }
-    events.add(transition.event);
 
     const fromStates = Array.isArray(transition.from) ? transition.from : [transition.from];
     for (const fromState of fromStates) {

opencti-platform/opencti-graphql/tests/01-unit/modules/workflow-validation-test.ts

@@ -120,7 +120,7 @@ describe('Workflow Validation', () => {
       initialState: 'existing-state',
       transitions: [
         { from: 'a', to: 'b', event: 'test' },
-        { from: 'b', to: 'c', event: 'test' },
+        { from: 'a', to: 'c', event: 'test' }, // Change 'b' to 'a' to duplicate from the same source
       ],
     };
     const errors = await validateWorkflowDefinitionData(mockContext, mockUser, JSON.stringify(invalid), 'Report');
@@ -649,7 +649,7 @@ describe('Workflow Validation', () => {
       ],
     };
     await expect(validateWorkflowDefinitionData(mockContext, mockUser, JSON.stringify(invalid), 'DraftWorkspace'))
-      .rejects.toThrow("not allowed in syncActions");
+      .rejects.toThrow('not allowed in syncActions');
   });
 
   it('should detect validateDraft in syncActions for DraftWorkspace requirement', async () => {