Fix pending decisions (#852)

* Fix pending decisions

* change label to start

* fix snapshot

* Update src/views/workflow-history/helpers/pending-decision-info-to-event.ts

* Update src/utils/data-formatters/format-pending-workflow-history-event/format-pending-decision-start-event.ts

---------

Co-authored-by: Adhitya Mamallan <[email protected]>

Author: Assem-Uber

src/utils/data-formatters/format-pending-workflow-history-event/__tests__/index.test.ts

@@ -3,8 +3,9 @@ import { ZodError } from 'zod';
 import logger from '@/utils/logger';
 import {
   pendingActivityTaskStartEvent,
-  pendingActivityTaskStartEventWithScheduledState,
-  pendingDecisionTaskScheduleEvent,
+  pendingActivityTaskStartEventWithStartedState,
+  pendingDecisionTaskStartEvent,
+  pendingDecisionTaskStartEventWithStartedState,
 } from '@/views/workflow-history/__fixtures__/workflow-history-pending-events';
 
 import formatPendingWorkflowHistoryEvent from '..';
@@ -13,8 +14,9 @@ jest.mock('@/utils/logger');
 
 const pendingEvents = [
   pendingActivityTaskStartEvent,
-  pendingActivityTaskStartEventWithScheduledState,
-  pendingDecisionTaskScheduleEvent,
+  pendingActivityTaskStartEventWithStartedState,
+  pendingDecisionTaskStartEvent,
+  pendingDecisionTaskStartEventWithStartedState,
 ];
 describe('formatWorkflowHistoryEvent', () => {
   pendingEvents.forEach((event) => {

src/utils/data-formatters/format-pending-workflow-history-event/__tests__/index.test.ts.snapshot

@@ -7,7 +7,6 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
     "name": "activity.cron.Start",
   },
   "attempt": 1,
-  "eventId": null,
   "eventTime": 2024-09-07T22:16:10.599Z,
   "eventType": "PendingActivityTaskStart",
   "expirationTime": 1970-01-01T00:06:00.000Z,
@@ -24,8 +23,8 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
   "maximumAttempts": 10,
   "scheduleId": 7,
   "scheduledTime": 1970-01-01T00:03:00.000Z,
-  "startedWorkerIdentity": "",
-  "state": "started",
+  "startedWorkerIdentity": "worker-1",
+  "state": "scheduled",
 }
 `;
 
@@ -36,7 +35,6 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
     "name": "activity.cron.Start",
   },
   "attempt": 1,
-  "eventId": null,
   "eventTime": 2024-09-07T22:16:10.599Z,
   "eventType": "PendingActivityTaskStart",
   "expirationTime": 1970-01-01T00:06:00.000Z,
@@ -48,25 +46,38 @@ exports[`formatWorkflowHistoryEvent should format workflow pendingActivityTaskSt
   "lastFailureDetails": null,
   "lastFailureReason": "",
   "lastHeartbeatTime": null,
-  "lastStartedTime": null,
+  "lastStartedTime": 2024-09-07T22:16:10.599Z,
   "lastWorkerIdentity": "",
   "maximumAttempts": 10,
   "scheduleId": 7,
   "scheduledTime": 1970-01-01T00:03:00.000Z,
-  "startedWorkerIdentity": "",
-  "state": "scheduled",
+  "startedWorkerIdentity": "worker-1",
+  "state": "started",
 }
 `;
 
-exports[`formatWorkflowHistoryEvent should format workflow pendingDecisionTaskScheduleEventAttributes to match snapshot 1`] = `
+exports[`formatWorkflowHistoryEvent should format workflow pendingDecisionTaskStartEventAttributes to match snapshot 1`] = `
 {
   "attempt": 1,
-  "eventId": 2,
   "eventTime": 2024-09-07T22:16:10.599Z,
-  "eventType": "PendingDecisionTaskSchedule",
+  "eventType": "PendingDecisionTaskStart",
   "originalScheduledTime": null,
   "scheduleId": 7,
   "scheduledTime": 1970-01-01T00:03:00.000Z,
   "startedTime": null,
+  "state": "scheduled",
+}
+`;
+
+exports[`formatWorkflowHistoryEvent should format workflow pendingDecisionTaskStartEventAttributes to match snapshot 2`] = `
+{
+  "attempt": 1,
+  "eventTime": 2024-09-07T22:16:10.599Z,
+  "eventType": "PendingDecisionTaskStart",
+  "originalScheduledTime": null,
+  "scheduleId": 7,
+  "scheduledTime": 1970-01-01T00:03:00.000Z,
+  "startedTime": 2024-09-07T22:16:10.599Z,
+  "state": "started",
 }
 `;

src/utils/data-formatters/format-pending-workflow-history-event/format-pending-activity-start-event.ts

@@ -18,11 +18,9 @@ export default function formatPendingActivityTaskStartEvent({
     ...eventAttributes
   },
   eventTime,
-  eventId,
 }: PendingActivityTaskStartEvent) {
   return {
     ...eventAttributes,
-    eventId,
     eventTime: formatTimestampToDatetime(eventTime),
     eventType: 'PendingActivityTaskStart',
     state: formatEnum(state, 'PENDING_ACTIVITY_STATE', 'pascal'),

src/utils/data-formatters/format-pending-workflow-history-event/format-pending-decision-schedule-event.ts

@@ -0,0 +1,29 @@
+import { type PendingDecisionTaskStartEvent } from '@/views/workflow-history/workflow-history.types';
+
+import formatEnum from '../format-enum';
+import formatTimestampToDatetime from '../format-timestamp-to-datetime';
+
+const formatPendingDecisionTaskStartEvent = ({
+  pendingDecisionTaskStartEventAttributes: {
+    state,
+    scheduleId,
+    startedTime,
+    scheduledTime,
+    originalScheduledTime,
+    ...eventAttributes
+  },
+  eventTime,
+}: PendingDecisionTaskStartEvent) => {
+  return {
+    ...eventAttributes,
+    state: formatEnum(state, 'PENDING_DECISION_STATE', 'pascal'),
+    eventType: 'PendingDecisionTaskStart',
+    eventTime: formatTimestampToDatetime(eventTime),
+    scheduleId: parseInt(scheduleId),
+    scheduledTime: formatTimestampToDatetime(scheduledTime),
+    startedTime: formatTimestampToDatetime(startedTime),
+    originalScheduledTime: formatTimestampToDatetime(originalScheduledTime),
+  };
+};
+
+export default formatPendingDecisionTaskStartEvent;

src/utils/data-formatters/format-pending-workflow-history-event/format-pending-decision-start-event.ts

@@ -3,20 +3,18 @@ import { type z } from 'zod';
 import { type PendingHistoryEvent } from '@/views/workflow-history/workflow-history.types';
 
 import formatPendingActivityTaskStartEvent from '../format-pending-workflow-history-event/format-pending-activity-start-event';
-import formatPendingDecisionTaskScheduleEvent from '../format-pending-workflow-history-event/format-pending-decision-schedule-event';
+import formatPendingDecisionTaskStartEvent from '../format-pending-workflow-history-event/format-pending-decision-start-event';
 
 import {
   pendingActivityTaskStartSchema,
-  pendingDecisionTaskScheduleSchema,
+  pendingDecisionTaskStartSchema,
 } from './pending-history-event-schema';
 
 export const formatPendingActivityTaskStartEventSchema =
   pendingActivityTaskStartSchema.transform(formatPendingActivityTaskStartEvent);
 
-export const formatPendingDecisionTaskScheduleEventSchema =
-  pendingDecisionTaskScheduleSchema.transform(
-    formatPendingDecisionTaskScheduleEvent
-  );
+export const formatPendingDecisionTaskStartEventSchema =
+  pendingDecisionTaskStartSchema.transform(formatPendingDecisionTaskStartEvent);
 
 function unExistingEventType(_: never) {
   return null;
@@ -25,8 +23,8 @@ export const getFormatPendingEventSchema = (event: PendingHistoryEvent) => {
   switch (event.attributes) {
     case 'pendingActivityTaskStartEventAttributes':
       return formatPendingActivityTaskStartEventSchema;
-    case 'pendingDecisionTaskScheduleEventAttributes':
-      return formatPendingDecisionTaskScheduleEventSchema;
+    case 'pendingDecisionTaskStartEventAttributes':
+      return formatPendingDecisionTaskStartEventSchema;
     default:
       return unExistingEventType(event); // used to show a type error if any pending event attributes cases are not covered
   }
@@ -36,7 +34,7 @@ export type FormattedPendingActivityTaskStartEvent = z.infer<
   typeof formatPendingActivityTaskStartEventSchema
 >;
 export type FormattedPendingDecisionTaskScheduleEvent = z.infer<
-  typeof formatPendingDecisionTaskScheduleEventSchema
+  typeof formatPendingDecisionTaskStartEventSchema
 >;
 
 export type FormattedHistoryPendingEvent =

src/utils/data-formatters/schema/format-history-pending-event-schema.ts

@@ -47,12 +47,16 @@ export const pendingActivityTaskStartSchema = z.object({
   }),
 });
 
-export const pendingDecisionTaskScheduleSchema = z.object({
-  attributes: z.literal('pendingDecisionTaskScheduleEventAttributes'),
+export const pendingDecisionTaskStartSchema = z.object({
+  attributes: z.literal('pendingDecisionTaskStartEventAttributes'),
   eventTime: timestampSchema.nullable(),
-  eventId: z.string(),
-  pendingDecisionTaskScheduleEventAttributes: z.object({
-    state: z.literal(PendingDecisionState.PENDING_DECISION_STATE_SCHEDULED),
+  eventId: z.null(),
+  computedEventId: z.string(),
+  pendingDecisionTaskStartEventAttributes: z.object({
+    state: z.enum([
+      PendingDecisionState.PENDING_DECISION_STATE_SCHEDULED,
+      PendingDecisionState.PENDING_DECISION_STATE_STARTED,
+    ]),
     scheduledTime: timestampSchema.nullable(),
     startedTime: timestampSchema.nullable(),
     attempt: z.number(),

src/utils/data-formatters/schema/pending-history-event-schema.ts

@@ -66,7 +66,7 @@ const allAttrsArr = arrayOfAllAttrs([
 const allAttrsArrExtended = arrayOfAllAttrsExtended([
   ...allAttrsArr,
   'pendingActivityTaskStartEventAttributes',
-  'pendingDecisionTaskScheduleEventAttributes',
+  'pendingDecisionTaskStartEventAttributes',
 ]);
 
 export const allWorkflowEventTypesAttrs: Pick<HistoryEvent, 'attributes'>[] =

src/views/workflow-history/__fixtures__/all-workflow-event-types-attributes.ts

@@ -24,7 +24,7 @@ import {
   timeoutDecisionTaskEvent,
 } from './workflow-history-decision-events';
 import {
-  pendingDecisionTaskScheduleEvent,
+  pendingDecisionTaskStartEvent,
   pendingActivityTaskStartEvent,
 } from './workflow-history-pending-events';
 import {
@@ -106,6 +106,6 @@ export const allWorkflowEvents = [
 
 export const allWorkflowEventsExtended = [
   ...allWorkflowEvents,
-  pendingDecisionTaskScheduleEvent,
+  pendingDecisionTaskStartEvent,
   pendingActivityTaskStartEvent,
 ];

src/views/workflow-history/__fixtures__/all-workflow-event-types.ts

@@ -1,6 +1,6 @@
 import type {
   PendingActivityTaskStartEvent,
-  PendingDecisionTaskScheduleEvent,
+  PendingDecisionTaskStartEvent,
 } from '../workflow-history.types';
 
 export const pendingActivityTaskStartEvent = {
@@ -16,7 +16,6 @@ export const pendingActivityTaskStartEvent = {
     activityType: {
       name: 'activity.cron.Start',
     },
-
     heartbeatDetails: {
       data: 'MTcyNTc0NzM3MDU3NTQwOTg0MwoiZ2FkZW5jZS1jYW5hcnkteGRjIgoid29ya2Zsb3cuc2FuaXR5Igo=',
     },
@@ -38,27 +37,32 @@ export const pendingActivityTaskStartEvent = {
       nanos: 0,
     },
     scheduleId: '7',
-    startedWorkerIdentity: '',
-    state: 'PENDING_ACTIVITY_STATE_STARTED',
+    startedWorkerIdentity: 'worker-1',
+    state: 'PENDING_ACTIVITY_STATE_SCHEDULED',
   },
 } as const satisfies PendingActivityTaskStartEvent;
 
-export const pendingActivityTaskStartEventWithScheduledState = {
+export const pendingActivityTaskStartEventWithStartedState = {
   ...pendingActivityTaskStartEvent,
   pendingActivityTaskStartEventAttributes: {
     ...pendingActivityTaskStartEvent.pendingActivityTaskStartEventAttributes,
-    state: 'PENDING_ACTIVITY_STATE_SCHEDULED',
+    state: 'PENDING_ACTIVITY_STATE_STARTED',
+    lastStartedTime: {
+      seconds: '1725747370',
+      nanos: 599547391,
+    },
   },
 } as const satisfies PendingActivityTaskStartEvent;
 
-export const pendingDecisionTaskScheduleEvent = {
-  eventId: '2',
-  attributes: 'pendingDecisionTaskScheduleEventAttributes',
+export const pendingDecisionTaskStartEvent = {
+  eventId: null,
+  computedEventId: 'pending-7',
+  attributes: 'pendingDecisionTaskStartEventAttributes',
   eventTime: {
     seconds: '1725747370',
     nanos: 599547391,
   },
-  pendingDecisionTaskScheduleEventAttributes: {
+  pendingDecisionTaskStartEventAttributes: {
     originalScheduledTime: null,
     startedTime: null,
     attempt: 1,
@@ -69,4 +73,16 @@ export const pendingDecisionTaskScheduleEvent = {
     scheduleId: '7',
     state: 'PENDING_DECISION_STATE_SCHEDULED',
   },
-} as const satisfies PendingDecisionTaskScheduleEvent;
+} as const satisfies PendingDecisionTaskStartEvent;
+
+export const pendingDecisionTaskStartEventWithStartedState = {
+  ...pendingDecisionTaskStartEvent,
+  pendingDecisionTaskStartEventAttributes: {
+    ...pendingDecisionTaskStartEvent.pendingDecisionTaskStartEventAttributes,
+    state: 'PENDING_DECISION_STATE_STARTED',
+    startedTime: {
+      seconds: '1725747370',
+      nanos: 599547391,
+    },
+  },
+} as const satisfies PendingDecisionTaskStartEvent;