Remove logic for WorkflowUpdate to find corresponding initial event, add Nexus operation events to failed/timedout/canceled (#2397)

Author: Alex-Tideman

src/lib/models/event-groups/create-event-group.test.ts

@@ -144,27 +144,4 @@ describe('createEventGroup', () => {
   it('should ignore an event that should not create an event group', () => {
     expect(createEventGroup(completedEvent)).toBeUndefined();
   });
-
-  it('should create a group from a WorkflowExecutionUpdateAccepted event and add WorkflowTaskScheduled event to group', () => {
-    const workflowTaskEvent = {
-      id: '120',
-    } as unknown as WorkflowEvent;
-
-    const updateEvent = {
-      id: '123',
-      eventId: '123',
-      workflowExecutionUpdateAcceptedEventAttributes: {
-        acceptedRequestSequencingEventId: 120,
-      },
-    } as unknown as WorkflowEvent;
-
-    expect(
-      createEventGroup(updateEvent, [workflowTaskEvent, updateEvent])
-        .initialEvent.id,
-    ).toBe(workflowTaskEvent.id);
-    expect(
-      createEventGroup(updateEvent, [workflowTaskEvent, updateEvent]).eventList
-        .length,
-    ).toBe(2);
-  });
 });

src/lib/models/event-groups/create-event-group.ts

@@ -50,44 +50,21 @@ type StartingEvents = {
   Nexus: NexusOperationScheduledEvent;
 };
 
-const getInitialEvent = (
-  event: CommonHistoryEvent,
-  events?: CommonHistoryEvent[],
-) => {
-  if (events?.length && isWorkflowExecutionUpdateAcceptedEvent(event)) {
-    return events.find(
-      (e) =>
-        e.id ===
-        event.workflowExecutionUpdateAcceptedEventAttributes?.acceptedRequestSequencingEventId.toString(),
-    );
-  }
-  return event;
-};
-
 const createGroupFor = <K extends keyof StartingEvents>(
   event: StartingEvents[K],
-  events?: CommonHistoryEvent[],
 ): EventGroup => {
   const id = getGroupId(event);
-  const initialEvent = getInitialEvent(event, events);
-  const name = getEventGroupName(event, initialEvent);
+  const name = getEventGroupName(event);
   const label = getEventGroupLabel(event);
-  const displayName = getEventGroupDisplayName(event, initialEvent);
+  const displayName = getEventGroupDisplayName(event);
 
   const { timestamp, category, classification } = event;
 
   const groupEvents: EventGroup['events'] = new Map();
   const groupEventIds: EventGroup['eventIds'] = new Set();
 
-  if (initialEvent && isWorkflowExecutionUpdateAcceptedEvent(event)) {
-    groupEvents.set(initialEvent.id, initialEvent);
-    groupEvents.set(event.id, event);
-    groupEventIds.add(initialEvent.id);
-    groupEventIds.add(event.id);
-  } else {
-    groupEvents.set(event.id, event);
-    groupEventIds.add(event.id);
-  }
+  groupEvents.set(event.id, event);
+  groupEventIds.add(event.id);
 
   return {
     id,
@@ -96,7 +73,7 @@ const createGroupFor = <K extends keyof StartingEvents>(
     displayName,
     events: groupEvents,
     eventIds: groupEventIds,
-    initialEvent,
+    initialEvent: event,
     timestamp,
     category: isLocalActivityMarkerEvent(event) ? 'local-activity' : category,
     classification,
@@ -140,10 +117,7 @@ const createGroupFor = <K extends keyof StartingEvents>(
   };
 };
 
-export const createEventGroup = (
-  event: CommonHistoryEvent,
-  events?: CommonHistoryEvent[],
-): EventGroup => {
+export const createEventGroup = (event: CommonHistoryEvent): EventGroup => {
   if (isActivityTaskScheduledEvent(event))
     return createGroupFor<'Activity'>(event);
 
@@ -166,16 +140,15 @@ export const createEventGroup = (
   }
 
   if (isWorkflowExecutionUpdateAcceptedEvent(event))
-    return createGroupFor<'Update'>(event, events);
+    return createGroupFor<'Update'>(event);
 
   if (isNexusOperationScheduledEvent(event))
-    return createGroupFor<'Nexus'>(event, events);
+    return createGroupFor<'Nexus'>(event);
 };
 
 export const createWorkflowTaskGroup = (
   event: CommonHistoryEvent,
-  events?: CommonHistoryEvent[],
 ): EventGroup => {
   if (isWorkflowTaskScheduledEvent(event))
-    return createGroupFor<'WorkflowTask'>(event, events);
+    return createGroupFor<'WorkflowTask'>(event);
 };

src/lib/models/event-groups/get-event-in-group.ts

@@ -9,6 +9,9 @@ import {
   isChildWorkflowExecutionTerminatedEvent,
   isChildWorkflowExecutionTimedOutEvent,
   isFailedWorkflowExecutionUpdateCompletedEvent,
+  isNexusOperationCanceledEvent,
+  isNexusOperationFailedEvent,
+  isNexusOperationTimedOutEvent,
   isSignalExternalWorkflowExecutionFailedEvent,
   isTimerCanceledEvent,
   isWorkflowExecutionCanceledEvent,
@@ -30,7 +33,9 @@ export const eventIsFailureOrTimedOut = (event: WorkflowEvent): boolean => {
     isChildWorkflowExecutionFailedEvent(event) ||
     isChildWorkflowExecutionTimedOutEvent(event) ||
     isSignalExternalWorkflowExecutionFailedEvent(event) ||
-    isFailedWorkflowExecutionUpdateCompletedEvent(event)
+    isFailedWorkflowExecutionUpdateCompletedEvent(event) ||
+    isNexusOperationFailedEvent(event) ||
+    isNexusOperationTimedOutEvent(event)
   );
 };
 
@@ -46,7 +51,8 @@ export const eventIsCanceled = (event: WorkflowEvent): boolean => {
     isActivityTaskCanceledEvent(event) ||
     isTimerCanceledEvent(event) ||
     isWorkflowExecutionCanceledEvent(event) ||
-    isChildWorkflowExecutionCanceledEvent(event)
+    isChildWorkflowExecutionCanceledEvent(event) ||
+    isNexusOperationCanceledEvent(event)
   );
 };
 

src/lib/models/event-groups/get-group-name.ts

@@ -12,13 +12,9 @@ import {
   isTimerStartedEvent,
   isWorkflowExecutionSignaledEvent,
   isWorkflowExecutionUpdateAcceptedEvent,
-  isWorkflowExecutionUpdateAdmittedEvent,
 } from '$lib/utilities/is-event-type';
 
-export const getEventGroupName = (
-  event: CommonHistoryEvent,
-  initialEvent?: CommonHistoryEvent,
-): string => {
+export const getEventGroupName = (event: CommonHistoryEvent): string => {
   if (!event) return '';
 
   if (isActivityTaskScheduledEvent(event)) {
@@ -54,13 +50,8 @@ export const getEventGroupName = (
   }
 
   if (isWorkflowExecutionUpdateAcceptedEvent(event)) {
-    if (isWorkflowExecutionUpdateAdmittedEvent(initialEvent)) {
-      return initialEvent.workflowExecutionUpdateAdmittedEventAttributes
-        ?.request?.input?.name;
-    } else {
-      return event.workflowExecutionUpdateAcceptedEventAttributes
-        ?.acceptedRequest?.input?.name;
-    }
+    return event.workflowExecutionUpdateAcceptedEventAttributes?.acceptedRequest
+      ?.input?.name;
   }
 
   if (isNexusOperationScheduledEvent(event)) {
@@ -111,15 +102,12 @@ export const getEventGroupLabel = (event: CommonHistoryEvent): string => {
   }
 };
 
-export const getEventGroupDisplayName = (
-  event: CommonHistoryEvent,
-  initialEvent?: CommonHistoryEvent,
-): string => {
+export const getEventGroupDisplayName = (event: CommonHistoryEvent): string => {
   if (!event) return '';
 
   if (isLocalActivityMarkerEvent(event)) {
     return getSummaryAttribute(event)?.value?.toString() ?? 'Local Activity';
   }
 
-  return getEventGroupName(event, initialEvent);
+  return getEventGroupName(event);
 };

src/lib/models/event-groups/index.ts

@@ -69,7 +69,7 @@ export const groupEvents = (
 
   const createGroups = (event: CommonHistoryEvent) => {
     const id = getGroupId(event);
-    const group = createEventGroup(event, events);
+    const group = createEventGroup(event);
     const pendingActivity = getPendingActivity(event, pendingActivities);
     const pendingNexusOperation = getPendingNexusOperation(
       event,
@@ -131,7 +131,7 @@ export const groupWorkflowTaskEvents = (
 
   const createGroups = (event: CommonHistoryEvent) => {
     const id = getGroupId(event);
-    const group = createWorkflowTaskGroup(event, events);
+    const group = createWorkflowTaskGroup(event);
 
     if (group) {
       groups[group.id] = group;