fix(workflow): Fix error when timer is cancelled and immediately fired in the same activation

packages/test/src/test-workflows.ts

@@ -1706,3 +1706,28 @@ test('conditionWaiter', async (t) => {
     compareCompletion(t, completion, makeSuccess([makeCompleteWorkflowExecution()]));
   }
 });
+
+test('conditionRacer', async (t) => {
+  const { workflowType } = t.context;
+  {
+    const completion = await activate(t, makeStartWorkflow(workflowType));
+    compareCompletion(
+      t,
+      completion,
+      makeSuccess([makeStartTimerCommand({ seq: 1, startToFireTimeout: msToTs('1s') })])
+    );
+  }
+  {
+    const completion = await activate(
+      t,
+      makeActivation(
+        Date.now(),
+        {
+          signalWorkflow: { signalName: 'unblock', input: [] },
+        },
+        makeFireTimerJob(1)
+      )
+    );
+    compareCompletion(t, completion, makeSuccess([{ cancelTimer: { seq: 1 } }]));
+  }
+});

packages/test/src/workflows/condition-completion-race.ts

@@ -0,0 +1,14 @@
+/**
+ * Tests that the workflow doesn't throw if condition resolves and expires in the same activation
+ *
+ * @module
+ */
+import { condition, setHandler } from '@temporalio/workflow';
+import { unblockSignal } from './definitions';
+
+export async function conditionRacer(): Promise<void> {
+  let blocked = true;
+  setHandler(unblockSignal, () => void (blocked = false));
+  await condition(() => !blocked, '1s');
+  await condition(() => blocked);
+}

packages/test/src/workflows/index.ts

@@ -70,6 +70,7 @@ export * from './try-to-continue-after-completion';
 export * from './fail-unless-signaled-before-start';
 export * from './smorgasbord';
 export * from './condition';
+export * from './condition-completion-race';
 export * from './sleep-invalid-duration';
 export * from './signals-are-always-processed';
 export * from './async-activity-completion-tester';

packages/workflow/src/internals.ts

@@ -104,8 +104,10 @@ export class Activator implements ActivationHandler {
   }
 
   public fireTimer(activation: coresdk.workflow_activation.IFireTimer): void {
-    const { resolve } = consumeCompletion('timer', getSeq(activation));
-    resolve(undefined);
+    // Timers are a special case where their completion might not be in Workflow state,
+    // this is due to immediate timer cancellation that doesn't go wait for Core.
+    const completion = maybeConsumeCompletion('timer', getSeq(activation));
+    completion?.resolve(undefined);
   }
 
   public async resolveActivity(activation: coresdk.workflow_activation.IResolveActivity): Promise<void> {
@@ -525,12 +527,21 @@ async function failQuery(queryId: string, error: any) {
   });
 }
 
-export function consumeCompletion(type: keyof State['completions'], taskSeq: number): Completion {
+/** Consume a completion if it exists in Workflow state */
+export function maybeConsumeCompletion(type: keyof State['completions'], taskSeq: number): Completion | undefined {
   const completion = state.completions[type].get(taskSeq);
+  if (completion !== undefined) {
+    state.completions[type].delete(taskSeq);
+  }
+  return completion;
+}
+
+/** Consume a completion if it exists in Workflow state, throws if it doesn't */
+export function consumeCompletion(type: keyof State['completions'], taskSeq: number): Completion {
+  const completion = maybeConsumeCompletion(type, taskSeq);
   if (completion === undefined) {
     throw new IllegalStateError(`No completion for taskSeq ${taskSeq}`);
   }
-  state.completions[type].delete(taskSeq);
   return completion;
 }