fix(workflow): Throw if patches are used at Workflow top level (temporalio#369)

bergundy · web-flow · commit 81eb0fb0d8fa · 2021-11-10T16:14:40.000-06:00
diff --git a/packages/test/src/test-workflows.ts b/packages/test/src/test-workflows.ts
@@ -74,19 +74,20 @@ async function createWorkflow(
   startTime: number,
   workflowCreator: IsolatedVMWorkflowCreator
 ) {
-  const workflow = (await workflowCreator.createWorkflow(
-    {
+  const workflow = (await workflowCreator.createWorkflow({
+    info: {
       workflowType,
       runId,
       workflowId: 'test-workflowId',
       namespace: 'default',
       taskQueue: 'test',
       isReplaying: false,
     },
-    [],
-    Long.fromInt(1337).toBytes(),
-    startTime
-  )) as IsolatedVMWorkflow;
+    interceptorModules: [],
+    randomnessSeed: Long.fromInt(1337).toBytes(),
+    now: startTime,
+    patches: [],
+  })) as IsolatedVMWorkflow;
   return workflow;
 }
 
@@ -1634,6 +1635,13 @@ test('deprecatePatchWorkflow', async (t) => {
   t.deepEqual(logs, [['has change']]);
 });
 
+test('patchedTopLevel', async (t) => {
+  const { workflowType, logs } = t.context;
+  const completion = await activate(t, makeStartWorkflow(workflowType));
+  compareCompletion(t, completion, makeSuccess());
+  t.deepEqual(logs, [[['Patches cannot be used before Workflow starts']]]);
+});
+
 test('tryToContinueAfterCompletion', async (t) => {
   const { workflowType } = t.context;
   {
diff --git a/packages/test/src/workflows/index.ts b/packages/test/src/workflows/index.ts
@@ -47,6 +47,7 @@ export * from './http';
 export * from './dependencies';
 export * from './interrupt-signal';
 export * from './patched';
+export * from './patched-top-level';
 export * from './deprecate-patch';
 export * from './fail-signal';
 export * from './async-fail-signal';
diff --git a/packages/test/src/workflows/patched-top-level.ts b/packages/test/src/workflows/patched-top-level.ts
@@ -0,0 +1,13 @@
+import { patched } from '@temporalio/workflow';
+
+const startupErrors: string[] = [];
+
+try {
+  patched('should-sleep');
+} catch (err: any) {
+  startupErrors.push(err.message);
+}
+
+export async function patchedTopLevel(): Promise<void> {
+  console.log(startupErrors);
+}
diff --git a/packages/worker/src/worker.ts b/packages/worker/src/worker.ts
@@ -598,13 +598,29 @@ export class Worker {
                         isReplaying: activation.isReplaying,
                       };
 
+                      const patchJobs = activation.jobs.filter(
+                        (
+                          j
+                        ): j is NonNullableObject<
+                          Pick<coresdk.workflow_activation.IWFActivationJob, 'notifyHasPatch'>
+                        > => j.notifyHasPatch != null
+                      );
+                      const patches = patchJobs.map(({ notifyHasPatch }) => {
+                        const { patchId } = notifyHasPatch;
+                        if (!patchId) {
+                          throw new TypeError('Got a patch without a patchId');
+                        }
+                        return patchId;
+                      });
+
                       const workflow = await instrument(this.tracer, span, 'workflow.create', async () => {
-                        return await workflowCreator.createWorkflow(
-                          workflowInfo,
-                          this.options.interceptors?.workflowModules ?? [],
-                          randomnessSeed.toBytes(),
-                          tsToMs(activation.timestamp)
-                        );
+                        return await workflowCreator.createWorkflow({
+                          info: workflowInfo,
+                          interceptorModules: this.options.interceptors?.workflowModules ?? [],
+                          randomnessSeed: randomnessSeed.toBytes(),
+                          now: tsToMs(activation.timestamp),
+                          patches,
+                        });
                       });
                       state = { workflow, info: workflowInfo };
                     } else {
diff --git a/packages/worker/src/workflow/interface.ts b/packages/worker/src/workflow/interface.ts
@@ -1,6 +1,7 @@
 import { coresdk } from '@temporalio/proto';
-import { WorkflowInfo } from '@temporalio/workflow';
 import { ExternalCall } from '@temporalio/workflow/lib/dependencies';
+import { WorkflowCreateOptions } from '@temporalio/workflow/lib/worker-interface';
+export { WorkflowCreateOptions };
 
 export interface Workflow {
   /**
@@ -32,12 +33,7 @@ export interface WorkflowCreator {
   /**
    * Create a Workflow for the Worker to activate
    */
-  createWorkflow(
-    info: WorkflowInfo,
-    interceptorModules: string[],
-    randomnessSeed: number[],
-    now: number
-  ): Promise<Workflow>;
+  createWorkflow(options: WorkflowCreateOptions): Promise<Workflow>;
 
   /**
    * Destroy and cleanup any resources
diff --git a/packages/worker/src/workflow/isolated-vm.ts b/packages/worker/src/workflow/isolated-vm.ts
@@ -4,7 +4,7 @@ import { coresdk } from '@temporalio/proto';
 import * as internals from '@temporalio/workflow/lib/worker-interface';
 import { ExternalDependencyFunction, WorkflowInfo, ExternalCall } from '@temporalio/workflow';
 import { partition } from '../utils';
-import { Workflow, WorkflowCreator } from './interface';
+import { Workflow, WorkflowCreateOptions, WorkflowCreator } from './interface';
 
 /**
  * Controls how an external dependency function is executed.
@@ -153,22 +153,10 @@ export class IsolatedVMWorkflowCreator implements WorkflowCreator {
     );
   }
 
-  async createWorkflow(
-    info: WorkflowInfo,
-    interceptorModules: string[],
-    randomnessSeed: number[],
-    now: number
-  ): Promise<Workflow> {
+  async createWorkflow(options: WorkflowCreateOptions): Promise<Workflow> {
     const context = await this.getContext();
-    await this.injectConsole(context, info);
-    return await IsolatedVMWorkflow.create(
-      context,
-      info,
-      interceptorModules,
-      randomnessSeed,
-      now,
-      this.isolateExecutionTimeoutMs
-    );
+    await this.injectConsole(context, options.info);
+    return await IsolatedVMWorkflow.create(context, options, this.isolateExecutionTimeoutMs);
   }
 
   async destroy(): Promise<void> {
@@ -192,10 +180,7 @@ export class IsolatedVMWorkflow implements Workflow {
 
   public static async create(
     context: ivm.Context,
-    info: WorkflowInfo,
-    interceptorModules: string[],
-    randomnessSeed: number[],
-    now: number,
+    options: WorkflowCreateOptions,
     isolateExecutionTimeoutMs: number
   ): Promise<IsolatedVMWorkflow> {
     const [activate, concludeActivation, getAndResetExternalCalls, tryUnblockConditions, isolateExtension] =
@@ -210,14 +195,13 @@ export class IsolatedVMWorkflow implements Workflow {
           .concat(isolateExtensionModule.create(context))
       );
 
-    await context.evalClosure(
-      'lib.initRuntime($0, $1, $2, $3, $4)',
-      [info, interceptorModules, randomnessSeed, now, isolateExtension.derefInto()],
-      { arguments: { copy: true }, timeout: isolateExecutionTimeoutMs }
-    );
+    await context.evalClosure('lib.initRuntime($0, $1)', [options, isolateExtension.derefInto()], {
+      arguments: { copy: true },
+      timeout: isolateExecutionTimeoutMs,
+    });
 
     return new this(
-      info,
+      options.info,
       context,
       {
         activate,
diff --git a/packages/workflow/src/worker-interface.ts b/packages/workflow/src/worker-interface.ts
@@ -21,6 +21,14 @@ import { ExternalCall } from './dependencies';
 import { WorkflowInterceptorsFactory } from './interceptors';
 import { HookManager, IsolateExtension } from './promise-hooks';
 
+export interface WorkflowCreateOptions {
+  info: WorkflowInfo;
+  interceptorModules: string[];
+  randomnessSeed: number[];
+  now: number;
+  patches: string[];
+}
+
 export function setRequireFunc(fn: Exclude<typeof state['require'], undefined>): void {
   state.require = fn;
 }
@@ -99,10 +107,7 @@ export function overrideGlobals(): void {
  * Sets required internal state and instantiates the workflow and interceptors.
  */
 export async function initRuntime(
-  info: WorkflowInfo,
-  interceptorModules: string[],
-  randomnessSeed: number[],
-  now: number,
+  { info, interceptorModules, randomnessSeed, now, patches }: WorkflowCreateOptions,
   isolateExtension: IsolateExtension
 ): Promise<void> {
   // Globals are overridden while building the isolate before loading user code.
@@ -114,6 +119,11 @@ export async function initRuntime(
   state.now = now;
   state.random = alea(randomnessSeed);
   HookManager.instance.setIsolateExtension(isolateExtension);
+  if (info.isReplaying) {
+    for (const patch of patches) {
+      state.knownPresentPatches.add(patch);
+    }
+  }
 
   const { require: req } = state;
   if (req === undefined) {
diff --git a/packages/workflow/src/workflow.ts b/packages/workflow/src/workflow.ts
@@ -814,13 +814,13 @@ export function deprecatePatch(patchId: string): void {
 }
 
 function patchInternal(patchId: string, deprecated: boolean): boolean {
-  if (state.info === undefined) {
-    throw new IllegalStateError('Workflow info must be set when calling patch functions');
-  }
   // Patch operation does not support interception at the moment, if it did,
   // this would be the place to start the interception chain
 
-  const { isReplaying } = state.info;
+  const { isReplaying } = workflowInfo();
+  if (state.workflow === undefined) {
+    throw new IllegalStateError('Patches cannot be used before Workflow starts');
+  }
   const usePatch = !isReplaying || state.knownPresentPatches.has(patchId);
   // Avoid sending commands for patches core already knows about.
   // This optimization enables development of automatic patching tools.
