Options getter function

Author: Sushisource

packages/common/src/workflow-definition-options.ts

@@ -8,11 +8,12 @@ export interface WorkflowDefinitionOptions {
 }
 
 type AsyncFunction<Args extends any[], ReturnType> = (...args: Args) => Promise<ReturnType>;
+export type WorkflowDefinitionOptionsOrGetter = WorkflowDefinitionOptions | (() => WorkflowDefinitionOptions);
 
 /**
  * A workflow function that has been defined with options from {@link WorkflowDefinitionOptions}.
  */
 export interface WorkflowFunctionWithOptions<Args extends any[], ReturnType> extends AsyncFunction<Args, ReturnType> {
   __temporal_is_workflow_function_with_options: true;
-  options: WorkflowDefinitionOptions;
+  options: WorkflowDefinitionOptionsOrGetter;
 }

packages/test/src/deployment-versioning-v1/index.ts

@@ -1,4 +1,4 @@
-import { setHandler, condition, defineWorkflowWithOptions } from '@temporalio/workflow';
+import { setHandler, condition, defineWorkflowWithOptions, workflowInfo } from '@temporalio/workflow';
 import { unblockSignal, versionQuery } from '../workflows';
 
 defineWorkflowWithOptions({ versioningBehavior: 'AUTO_UPGRADE' }, deploymentVersioning);
@@ -15,3 +15,14 @@ export default defineWorkflowWithOptions({ versioningBehavior: 'PINNED' }, _defa
 async function _default(): Promise<string> {
   return 'dynamic';
 }
+
+defineWorkflowWithOptions(() => {
+  // Need to ensure accessing workflow context still works in here
+  workflowInfo();
+  return {
+    versioningBehavior: 'PINNED',
+  };
+}, usesGetter);
+export async function usesGetter(): Promise<string> {
+  return 'usesGetter';
+}

packages/test/src/test-worker-deployment-versioning.ts

@@ -6,11 +6,12 @@
 import assert from 'assert';
 import { randomUUID } from 'crypto';
 import asyncRetry from 'async-retry';
+import { ExecutionContext } from 'ava';
 import { Client } from '@temporalio/client';
 import { toCanonicalString, WorkerDeploymentVersion } from '@temporalio/common';
 import { temporal } from '@temporalio/proto';
 import { Worker } from './helpers';
-import { makeTestFunction } from './helpers-integration';
+import { Context, makeTestFunction } from './helpers-integration';
 import { unblockSignal, versionQuery } from './workflows';
 
 const test = makeTestFunction({ workflowsPath: __filename });
@@ -242,7 +243,11 @@ test('Worker deployment based versioning with ramping', async (t) => {
   t.pass();
 });
 
-test('Worker deployment with dynamic workflow on run', async (t) => {
+async function testWorkerDeploymentWithDynamicBehavior(
+  t: ExecutionContext<Context>,
+  workflowName: string,
+  expectedResult: string
+) {
   if (t.context.env.supportsTimeSkipping) {
     t.pass("Test Server doesn't support worker deployments");
     return;
@@ -276,17 +281,15 @@ test('Worker deployment with dynamic workflow on run', async (t) => {
   const describeResp = await waitUntilWorkerDeploymentVisible(client, version);
   await setCurrentDeploymentVersion(client, describeResp.conflictToken, version);
 
-  const wf = await client.workflow.start('cooldynamicworkflow', {
+  const wf = await client.workflow.start(workflowName, {
     taskQueue,
     workflowId: 'dynamic-workflow-versioning-' + randomUUID(),
   });
 
   const result = await wf.result();
-  assert.equal(result, 'dynamic');
+  assert.equal(result, expectedResult);
 
-  // Check history for versioning behavior
   const history = await wf.fetchHistory();
-
   const hasPinnedVersioningBehavior = history.events!.some(
     (event) =>
       event.workflowTaskCompletedEventAttributes &&
@@ -298,6 +301,14 @@ test('Worker deployment with dynamic workflow on run', async (t) => {
   worker.shutdown();
   await workerPromise;
   t.pass();
+}
+
+test('Worker deployment with dynamic workflow static behavior', async (t) => {
+  await testWorkerDeploymentWithDynamicBehavior(t, 'cooldynamicworkflow', 'dynamic');
+});
+
+test('Worker deployment with behavior in getter', async (t) => {
+  await testWorkerDeploymentWithDynamicBehavior(t, 'usesGetter', 'usesGetter');
 });
 
 test('Workflows can use default versioning behavior', async (t) => {

packages/workflow/src/internals.ts

@@ -22,6 +22,7 @@ import {
   fromPayloadsAtIndex,
   WorkflowFunctionWithOptions,
   VersioningBehavior,
+  WorkflowDefinitionOptions,
 } from '@temporalio/common';
 import {
   decodeSearchAttributes,
@@ -419,6 +420,7 @@ export class Activator implements ActivationHandler {
   public readonly registeredActivityNames: Set<string>;
 
   public versioningBehavior?: VersioningBehavior;
+  public workflowDefinitionOptionsGetter?: () => WorkflowDefinitionOptions;
 
   constructor({
     info,
@@ -534,6 +536,9 @@ export class Activator implements ActivationHandler {
           ? this.failureConverter.failureToError(continuedFailure, this.payloadConverter)
           : undefined,
     }));
+    if (this.workflowDefinitionOptionsGetter) {
+      this.versioningBehavior = this.workflowDefinitionOptionsGetter().versioningBehavior;
+    }
   }
 
   public cancelWorkflow(_activation: coresdk.workflow_activation.ICancelWorkflow): void {

packages/workflow/src/worker-interface.ts

@@ -3,14 +3,9 @@
  *
  * @module
  */
-import {
-  encodeVersioningBehavior,
-  IllegalStateError,
-  isWorkflowFunctionWithOptions,
-  VersioningBehavior,
-} from '@temporalio/common';
+import { encodeVersioningBehavior, IllegalStateError, isWorkflowFunctionWithOptions } from '@temporalio/common';
 import { composeInterceptors } from '@temporalio/common/lib/interceptors';
-import { coresdk, temporal } from '@temporalio/proto';
+import { coresdk } from '@temporalio/proto';
 import { disableStorage } from './cancellation-scope';
 import { disableUpdateStorage } from './update-scope';
 import { WorkflowInterceptorsFactory } from './interceptors';
@@ -86,10 +81,18 @@ export function initRuntime(options: WorkflowCreateOptionsInternal): void {
 
     if (isWorkflowFunctionWithOptions(workflowFn)) {
       activator.workflow = workflowFn;
-      activator.versioningBehavior = workflowFn.options.versioningBehavior;
+      if (typeof workflowFn.options === 'object') {
+        activator.versioningBehavior = workflowFn.options.versioningBehavior;
+      } else {
+        activator.workflowDefinitionOptionsGetter = workflowFn.options;
+      }
     } else if (isWorkflowFunctionWithOptions(defaultWorkflowFn)) {
       activator.workflow = defaultWorkflowFn;
-      activator.versioningBehavior = defaultWorkflowFn.options.versioningBehavior;
+      if (typeof defaultWorkflowFn.options === 'object') {
+        activator.versioningBehavior = defaultWorkflowFn.options.versioningBehavior;
+      } else {
+        activator.workflowDefinitionOptionsGetter = defaultWorkflowFn.options;
+      }
     } else if (typeof workflowFn === 'function') {
       activator.workflow = workflowFn;
     } else if (typeof defaultWorkflowFn === 'function') {

packages/workflow/src/workflow.ts

@@ -23,7 +23,7 @@ import {
   WorkflowUpdateValidatorType,
   SearchAttributeUpdatePair,
   compilePriority,
-  WorkflowDefinitionOptions,
+  WorkflowDefinitionOptionsOrGetter,
   WorkflowFunctionWithOptions,
 } from '@temporalio/common';
 import {
@@ -1617,13 +1617,15 @@ export function allHandlersFinished(): boolean {
  * }
  * ```
  *
- * @param options Options for the workflow defintion.
+ * @param options Options for the workflow defintion, or a function that returns options. If a
+ * function is provided, it will be called once just before the workflow function is called for the
+ * first time.
  * @param fn The workflow function.
  * @returns The same passed in workflow function, with the specified options applied. You can export
  * this function to make it available as a workflow function.
  */
 export function defineWorkflowWithOptions<A extends any[], RT>(
-  options: WorkflowDefinitionOptions,
+  options: WorkflowDefinitionOptionsOrGetter,
   fn: (...args: A) => Promise<RT>
 ): WorkflowFunctionWithOptions<A, RT> {
   const wrappedFn = Object.assign(fn, {