Allow WorkerDeploymentOptions without defaultVersioningBehavior when useWorkerVersioning is false (#1963)

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: mjameswh

packages/core-bridge/src/worker.rs

@@ -550,7 +550,7 @@ mod config {
     pub struct WorkerDeploymentOptions {
         version: WorkerDeploymentVersion,
         use_worker_versioning: bool,
-        default_versioning_behavior: VersioningBehavior,
+        default_versioning_behavior: Option<VersioningBehavior>,
     }
 
     #[derive(TryFromJs)]
@@ -659,7 +659,7 @@ mod config {
             Self {
                 version: val.version.into(),
                 use_worker_versioning: val.use_worker_versioning,
-                default_versioning_behavior: Some(val.default_versioning_behavior.into()),
+                default_versioning_behavior: val.default_versioning_behavior.map(Into::into),
             }
         }
     }

packages/core-bridge/ts/native.ts

@@ -257,7 +257,7 @@ export type PollerBehavior =
 export type WorkerDeploymentOptions = {
   version: WorkerDeploymentVersion;
   useWorkerVersioning: boolean;
-  defaultVersioningBehavior: VersioningBehavior;
+  defaultVersioningBehavior: Option<VersioningBehavior>;
 };
 
 export type WorkerDeploymentVersion = {

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

@@ -3,17 +3,19 @@
  *
  * @module
  */
-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 { WorkerOptions } from '@temporalio/worker';
 import { Worker } from './helpers';
 import { Context, helpers, makeTestFunction } from './helpers-integration';
 import { unblockSignal, versionQuery } from './workflows';
 
+type WorkerDeploymentOptions = NonNullable<WorkerOptions['workerDeploymentOptions']>;
+
 const test = makeTestFunction({ workflowsPath: __filename });
 
 test('Worker deployment based versioning', async (t) => {
@@ -94,7 +96,7 @@ test('Worker deployment based versioning', async (t) => {
     workflowId: 'deployment-versioning-v1-' + randomUUID(),
   });
   const state1 = await wf1.query(versionQuery);
-  assert.equal(state1, 'v1');
+  t.is(state1, 'v1');
 
   // Wait for worker 2 to be visible and set as current version
   const describeResp2 = await waitUntilWorkerDeploymentVisible(client, w2DeploymentVersion);
@@ -106,7 +108,7 @@ test('Worker deployment based versioning', async (t) => {
     workflowId: 'deployment-versioning-v2-' + randomUUID(),
   });
   const state2 = await wf2.query(versionQuery);
-  assert.equal(state2, 'v2');
+  t.is(state2, 'v2');
 
   // Wait for worker 3 to be visible and set as current version
   const describeResp3 = await waitUntilWorkerDeploymentVisible(client, w3DeploymentVersion);
@@ -118,7 +120,7 @@ test('Worker deployment based versioning', async (t) => {
     workflowId: 'deployment-versioning-v3-' + randomUUID(),
   });
   const state3 = await wf3.query(versionQuery);
-  assert.equal(state3, 'v3');
+  t.is(state3, 'v3');
 
   // Signal all workflows to finish
   await wf1.signal(unblockSignal);
@@ -129,17 +131,16 @@ test('Worker deployment based versioning', async (t) => {
   const res2 = await wf2.result();
   const res3 = await wf3.result();
 
-  assert.equal(res1, 'version-v3');
-  assert.equal(res2, 'version-v2');
-  assert.equal(res3, 'version-v3');
+  t.is(res1, 'version-v3');
+  t.is(res2, 'version-v2');
+  t.is(res3, 'version-v3');
 
   worker1.shutdown();
   worker2.shutdown();
   worker3.shutdown();
   await worker1Promise;
   await worker2Promise;
   await worker3Promise;
-  t.pass();
 });
 
 test('Worker deployment based versioning with ramping', async (t) => {
@@ -205,7 +206,7 @@ test('Worker deployment based versioning with ramping', async (t) => {
     });
     await wf.signal(unblockSignal);
     const res = await wf.result();
-    assert.equal(res, 'version-v2');
+    t.is(res, 'version-v2');
   }
 
   // Set ramp to 0, expecting workflows to run on v1
@@ -217,7 +218,7 @@ test('Worker deployment based versioning with ramping', async (t) => {
     });
     await wf.signal(unblockSignal);
     const res = await wf.result();
-    assert.equal(res, 'version-v1');
+    t.is(res, 'version-v1');
   }
 
   // Set ramp to 50 and eventually verify workflows run on both versions
@@ -257,7 +258,7 @@ async function testWorkerDeploymentWithDynamicBehavior(
   expectedResult: string
 ) {
   if (t.context.env.supportsTimeSkipping) {
-    t.pass("Test Server doesn't support worker deployments");
+    t.fail("Test Server doesn't support worker deployments");
     return;
   }
 
@@ -295,7 +296,7 @@ async function testWorkerDeploymentWithDynamicBehavior(
   });
 
   const result = await wf.result();
-  assert.equal(result, expectedResult);
+  t.is(result, expectedResult);
 
   const history = await wf.fetchHistory();
   const hasPinnedVersioningBehavior = history.events!.some(
@@ -304,11 +305,10 @@ async function testWorkerDeploymentWithDynamicBehavior(
       event.workflowTaskCompletedEventAttributes.versioningBehavior ===
         temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_PINNED
   );
-  assert.ok(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
+  t.true(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
 
   worker.shutdown();
   await workerPromise;
-  t.pass();
 }
 
 test('Worker deployment with dynamic workflow static behavior', async (t) => {
@@ -362,11 +362,10 @@ test('Workflows can use default versioning behavior', async (t) => {
       event.workflowTaskCompletedEventAttributes.versioningBehavior ===
         temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_PINNED
   );
-  assert.ok(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
+  t.true(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
 
   worker.shutdown();
   await workerPromise;
-  t.pass();
 });
 
 test('Workflow versioningOverride overrides default versioning behavior', async (t) => {
@@ -406,7 +405,7 @@ test('Workflow versioningOverride overrides default versioning behavior', async
     },
   });
   const statePinned = await wfPinned.query(versionQuery);
-  assert.equal(statePinned, 'v1');
+  t.is(statePinned, 'v1');
 
   await wfPinned.signal(unblockSignal);
 
@@ -418,14 +417,13 @@ test('Workflow versioningOverride overrides default versioning behavior', async
         temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_PINNED ||
       event.workflowExecutionStartedEventAttributes?.versioningOverride?.pinned != null
   );
-  assert.ok(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
+  t.true(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
 
   const resPinned = await wfPinned.result();
-  assert.equal(resPinned, 'version-v1');
+  t.is(resPinned, 'version-v1');
 
   worker1.shutdown();
   await worker1Promise;
-  t.pass();
 });
 
 async function setRampingVersion(
@@ -474,3 +472,85 @@ async function setCurrentDeploymentVersion(
     conflictToken,
   });
 }
+
+///////////////////////////////
+
+/**
+ * Type-level tests for WorkerDeploymentOptions.
+ *
+ * Ensures that:
+ * - When useWorkerVersioning is true, defaultVersioningBehavior is required
+ * - When useWorkerVersioning is false, defaultVersioningBehavior must be absent
+ * - version is always required
+ */
+
+test('Worker with deployment options and useWorkerVersioning false can run workflows', async (t) => {
+  const taskQueue = 'versioning-off-with-build-id-' + randomUUID();
+  const buildId = 'my-custom-build-id-1.0';
+  const { client, nativeConnection } = t.context.env;
+
+  const worker = await Worker.create({
+    workflowsPath: require.resolve('./workflows'),
+    taskQueue,
+    workerDeploymentOptions: {
+      useWorkerVersioning: false,
+      version: {
+        buildId,
+        deploymentName: 'deployment-' + randomUUID(),
+      },
+    },
+    connection: nativeConnection,
+  });
+
+  const handle = await client.workflow.start('successString', {
+    taskQueue,
+    workflowId: 'versioning-off-build-id-' + randomUUID(),
+  });
+
+  await worker.runUntil(handle.result());
+  t.is(await handle.result(), 'success');
+
+  const history = await handle.fetchHistory();
+  const buildIdInHistory = history.events!.some(
+    (event) => event.workflowTaskCompletedEventAttributes?.workerVersion?.buildId === buildId
+  );
+  t.true(buildIdInHistory, 'Expected build ID to appear in workflow history');
+});
+
+test('WorkerDeploymentOptions with useWorkerVersioning true requires defaultVersioningBehavior', (t) => {
+  const valid: WorkerDeploymentOptions = {
+    version: { buildId: '1.0', deploymentName: 'my-deployment' },
+    useWorkerVersioning: true,
+    defaultVersioningBehavior: 'AUTO_UPGRADE',
+  };
+
+  const validPinned: WorkerDeploymentOptions = {
+    version: { buildId: '1.0', deploymentName: 'my-deployment' },
+    useWorkerVersioning: true,
+    defaultVersioningBehavior: 'PINNED',
+  };
+
+  // @ts-expect-error defaultVersioningBehavior is required when useWorkerVersioning is true
+  const missingBehavior: WorkerDeploymentOptions = {
+    version: { buildId: '1.0', deploymentName: 'my-deployment' },
+    useWorkerVersioning: true,
+  };
+
+  t.pass();
+});
+
+test('WorkerDeploymentOptions with useWorkerVersioning false does not allow defaultVersioningBehavior', (t) => {
+  const _validNoVersioning: WorkerDeploymentOptions = {
+    version: { buildId: '1.0', deploymentName: 'my-deployment' },
+    useWorkerVersioning: false,
+  };
+
+  const invalidWithBehavior: WorkerDeploymentOptions = {
+    version: { buildId: '1.0', deploymentName: 'my-deployment' },
+    useWorkerVersioning: false,
+    // @ts-expect-error defaultVersioningBehavior must not be specified when useWorkerVersioning is false
+    defaultVersioningBehavior: 'AUTO_UPGRADE',
+  };
+
+  t.pass();
+});

packages/worker/src/index.ts

@@ -39,6 +39,7 @@ export { DataConverter, defaultPayloadConverter, State, Worker, WorkerStatus } f
 export {
   CompiledWorkerOptions,
   ReplayWorkerOptions,
+  WorkerDeploymentOptions,
   WorkerOptions,
   WorkerPlugin,
   WorkflowBundle,

packages/worker/src/worker-options.ts

@@ -641,11 +641,21 @@ export type WorkerDeploymentOptions = {
   useWorkerVersioning: boolean;
 
   /**
-   * The default versioning behavior to use for all workflows on this worker. Specifying a default
-   * behavior is required.
+   * The default versioning behavior to use for all workflows on this worker.
+   *
+   * Required if {@link useWorkerVersioning} is `true`; should be left unset otherwise.
    */
-  defaultVersioningBehavior: VersioningBehavior;
-};
+  defaultVersioningBehavior?: VersioningBehavior | undefined;
+} & (
+  | {
+      useWorkerVersioning: true;
+      defaultVersioningBehavior: VersioningBehavior;
+    }
+  | {
+      useWorkerVersioning: false;
+      defaultVersioningBehavior?: never;
+    }
+);
 
 // Replay Worker ///////////////////////////////////////////////////////////////////////////////////
 
@@ -1126,21 +1136,29 @@ function toNativeDeploymentOptions(options?: WorkerDeploymentOptions): native.Wo
   if (options === undefined) {
     return null;
   }
+  if (!options.useWorkerVersioning) {
+    return {
+      version: options.version,
+      useWorkerVersioning: false,
+      defaultVersioningBehavior: null,
+    };
+  }
+  const { defaultVersioningBehavior } = options;
   let vb: native.VersioningBehavior;
-  switch (options.defaultVersioningBehavior) {
+  switch (defaultVersioningBehavior) {
     case 'PINNED':
       vb = { type: 'pinned' };
       break;
     case 'AUTO_UPGRADE':
       vb = { type: 'auto-upgrade' };
       break;
     default:
-      options.defaultVersioningBehavior satisfies never;
-      throw new Error(`Unknown versioning behavior: ${options.defaultVersioningBehavior}`);
+      defaultVersioningBehavior satisfies never;
+      throw new Error(`Unknown versioning behavior: ${defaultVersioningBehavior}`);
   }
   return {
     version: options.version,
-    useWorkerVersioning: options.useWorkerVersioning,
+    useWorkerVersioning: true,
     defaultVersioningBehavior: vb,
   };
 }