Versioning override updates

Author: Sushisource

packages/client/src/workflow-client.ts

@@ -1227,6 +1227,7 @@ export class WorkflowClient extends BaseClient {
       cronSchedule: options.cronSchedule,
       header: { fields: headers },
       priority: options.priority ? compilePriority(options.priority) : undefined,
+      versioningOverride: options.versioningOverride ? options.versioningOverride : undefined,
     };
     try {
       return (await this.workflowService.signalWithStartWorkflowExecution(req)).runId;
@@ -1296,6 +1297,7 @@ export class WorkflowClient extends BaseClient {
       cronSchedule: opts.cronSchedule,
       header: { fields: headers },
       priority: opts.priority ? compilePriority(opts.priority) : undefined,
+      versioningOverride: opts.versioningOverride ? opts.versioningOverride : undefined,
     };
   }
 

packages/client/src/workflow-options.ts

@@ -130,14 +130,20 @@ function versioningOverrideToProto(
   vo: VersioningOverride | undefined
 ): temporal.api.workflow.v1.IVersioningOverride | undefined {
   if (!vo) return undefined;
+
   // TODO: Remove deprecated field assignments when versioning is non-experimental
   if (vo === 'AUTO_UPGRADE') {
     return {
+      autoUpgrade: true,
       behavior: temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_AUTO_UPGRADE,
     };
   }
+
   return {
+    pinned: {
+      version: vo.pinnedTo,
+    },
     behavior: temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_PINNED,
-    pinnedVersion: toCanonicalString(vo.version),
+    pinnedVersion: toCanonicalString(vo.pinnedTo),
   };
 }

packages/common/src/worker-deployments.ts

@@ -51,9 +51,20 @@ export const [encodeVersioningBehavior, decodeVersioningBehavior] = makeProtoEnu
 
 /**
  * Represents versioning overrides. For example, when starting workflows.
- *
- * If set to 'AUTO_UPGRADE', the Workflow will run as if it is using {@link VersioningBehavior.AUTO_UPGRADE}.
- * Otherwise, you select a pinned behavior, and a specific version to pin to. Currently only one
- * such behavior exists, but more will be added in the future.
  */
-export type VersioningOverride = { pinned_behavior: 'PINNED'; version: WorkerDeploymentVersion } | 'AUTO_UPGRADE';
+export type VersioningOverride = PinnedVersioningOverride | 'AUTO_UPGRADE';
+
+/**
+ * Workflow will be pinned to a specific deployment version.
+ */
+export interface PinnedVersioningOverride {
+  /**
+   * The worker deployment version to pin the workflow to.
+   */
+  pinnedTo: WorkerDeploymentVersion;
+}
+
+/**
+ * The workflow will auto-upgrade to the current deployment version on the next workflow task.
+ */
+export type AutoUpgradeVersioningOverride = 'AUTO_UPGRADE';

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

@@ -361,6 +361,65 @@ test('Workflows can use default versioning behavior', async (t) => {
   t.pass();
 });
 
+test('Workflow versioningOverride overrides default versioning behavior', async (t) => {
+  const taskQueue = 'task-queue-versioning-override-' + randomUUID();
+  const { client, nativeConnection } = t.context.env;
+
+  const workerV1 = {
+    buildId: '1.0',
+    deploymentName: 'deployment-versioning-override-' + randomUUID(),
+  };
+
+  const worker1 = await Worker.create({
+    workflowsPath: require.resolve('./deployment-versioning-v1'),
+    taskQueue,
+    workerDeploymentOptions: {
+      useWorkerVersioning: true,
+      version: workerV1,
+      defaultVersioningBehavior: 'AUTO_UPGRADE',
+    },
+    connection: nativeConnection,
+  });
+  const worker1Promise = worker1.run();
+  worker1Promise.catch((err) => {
+    t.fail('Worker 1.0 run error: ' + err);
+  });
+
+  // Wait for workers to be visible and set current version to v1
+  const describeResp = await waitUntilWorkerDeploymentVisible(client, workerV1);
+  await setCurrentDeploymentVersion(client, describeResp.conflictToken, workerV1);
+
+  // Start workflow with PINNED to v1 versioningOverride - should use v1 despite AUTO_UPGRADE default
+  const wfPinned = await client.workflow.start('deploymentVersioning', {
+    taskQueue,
+    workflowId: 'versioning-override-pinned-v1-' + randomUUID(),
+    versioningOverride: {
+      pinnedTo: workerV1,
+    },
+  });
+  const statePinned = await wfPinned.query(versionQuery);
+  assert.equal(statePinned, 'v1');
+
+  await wfPinned.signal(unblockSignal);
+
+  // Get results and check versioning behavior
+  const historyPinned = await wfPinned.fetchHistory();
+  const hasPinnedVersioningBehavior = historyPinned.events!.some(
+    (event) =>
+      event.workflowExecutionStartedEventAttributes?.versioningOverride?.behavior ===
+        temporal.api.enums.v1.VersioningBehavior.VERSIONING_BEHAVIOR_PINNED ||
+      event.workflowExecutionStartedEventAttributes?.versioningOverride?.pinned != null
+  );
+  assert.ok(hasPinnedVersioningBehavior, 'Expected workflow to use pinned versioning behavior');
+
+  const resPinned = await wfPinned.result();
+  assert.equal(resPinned, 'version-v1');
+
+  worker1.shutdown();
+  await worker1Promise;
+  t.pass();
+});
+
 async function setRampingVersion(
   client: Client,
   conflictToken: Uint8Array,