fix(client): Fix workflow arg types on create/update schedules (#1028)

Author: mjameswh

packages/client/src/schedule-client.ts

@@ -1,6 +1,6 @@
 import { status as grpcStatus } from '@grpc/grpc-js';
 import { v4 as uuid4 } from 'uuid';
-import { mapToPayloads, searchAttributePayloadConverter } from '@temporalio/common';
+import { mapToPayloads, searchAttributePayloadConverter, Workflow } from '@temporalio/common';
 import { composeInterceptors, Headers } from '@temporalio/common/lib/interceptors';
 import {
   encodeMapToPayloads,
@@ -20,6 +20,8 @@ import {
   ScheduleOptions,
   ScheduleOverlapPolicy,
   ScheduleUpdateOptions,
+  ScheduleOptionsAction,
+  ScheduleOptionsStartWorkflowAction,
 } from './schedule-types';
 import {
   compileScheduleOptions,
@@ -67,7 +69,9 @@ export interface ScheduleHandle {
    * sends the returned `UpdatedSchedule` to the Server to update the Schedule definition. Note that,
    * in the future, `updateFn` might be invoked multiple time, with identical or different input.
    */
-  update(updateFn: (previous: ScheduleDescription) => ScheduleUpdateOptions): Promise<void>;
+  update<W extends Workflow = Workflow>(
+    updateFn: (previous: ScheduleDescription) => ScheduleUpdateOptions<ScheduleOptionsStartWorkflowAction<W>>
+  ): Promise<void>;
 
   /**
    * Delete the Schedule
@@ -197,7 +201,10 @@ export class ScheduleClient extends BaseClient {
    * @throws {@link ScheduleAlreadyRunning} if there's a running (not deleted) Schedule with the given `id`
    * @returns a ScheduleHandle to the created Schedule
    */
-  public async create(options: ScheduleOptions): Promise<ScheduleHandle> {
+  public async create<W extends Workflow = Workflow>(
+    options: ScheduleOptions<ScheduleOptionsStartWorkflowAction<W>>
+  ): Promise<ScheduleHandle>;
+  public async create<A extends ScheduleOptionsAction>(options: ScheduleOptions<A>): Promise<ScheduleHandle> {
     await this._createSchedule(options);
     return this.getHandle(options.scheduleId);
   }

packages/client/src/schedule-types.ts

@@ -8,7 +8,7 @@ import { WorkflowStartOptions } from './workflow-options';
  *
  * @experimental
  */
-export interface ScheduleOptions {
+export interface ScheduleOptions<A extends ScheduleOptionsAction = ScheduleOptionsAction> {
   /**
    * Schedule Id
    *
@@ -24,7 +24,7 @@ export interface ScheduleOptions {
   /**
    * Which Action to take
    */
-  action: ScheduleOptionsAction;
+  action: A;
 
   policies?: {
     /**
@@ -132,11 +132,11 @@ export type CompiledScheduleOptions = Replace<
  *
  * @experimental
  */
-export type ScheduleUpdateOptions = Replace<
+export type ScheduleUpdateOptions<A extends ScheduleOptionsAction = ScheduleOptionsAction> = Replace<
   Omit<ScheduleOptions, 'scheduleId' | 'memo' | 'searchAttributes'>,
   {
     action: Replace<
-      ScheduleOptions['action'],
+      A,
       {
         // No default value on update
         workflowId: string;
@@ -834,8 +834,6 @@ export enum ScheduleOverlapPolicy {
   ALLOW_ALL,
 }
 
-export type ScheduleOverlapPolicy2 = keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy;
-
 checkExtends<
   keyof typeof temporal.api.enums.v1.ScheduleOverlapPolicy,
   `SCHEDULE_OVERLAP_POLICY_${keyof typeof ScheduleOverlapPolicy}`

packages/test/src/test-schedules.ts

@@ -1,10 +1,16 @@
 import { randomUUID } from 'crypto';
 import anyTest, { TestFn } from 'ava';
 import asyncRetry from 'async-retry';
-import { Client, defaultPayloadConverter } from '@temporalio/client';
+import {
+  Client,
+  defaultPayloadConverter,
+  CalendarSpec,
+  CalendarSpecDescription,
+  ScheduleHandle,
+  ScheduleSummary,
+  ScheduleUpdateOptions,
+} from '@temporalio/client';
 import { msToNumber } from '@temporalio/common/lib/time';
-import { CalendarSpec, CalendarSpecDescription, ScheduleSummary } from '@temporalio/client/lib/schedule-types';
-import { ScheduleHandle } from '@temporalio/client/lib/schedule-client';
 import { RUN_INTEGRATION_TESTS } from './helpers';
 
 export interface Context {
@@ -15,7 +21,8 @@ const taskQueue = 'async-activity-completion';
 const test = anyTest as TestFn<Context>;
 
 const dummyWorkflow = async () => undefined;
-const dummyWorkflow2 = async (_x?: string) => undefined;
+const dummyWorkflowWith1Arg = async (_s: string) => undefined;
+const dummyWorkflowWith2Args = async (_x: number, _y: number) => undefined;
 
 const calendarSpecDescriptionDefaults: CalendarSpecDescription = {
   second: [{ start: 0, end: 0, step: 1 }],
@@ -29,7 +36,7 @@ const calendarSpecDescriptionDefaults: CalendarSpecDescription = {
 };
 
 if (RUN_INTEGRATION_TESTS) {
-  test.before(async (t) => {
+  test.beforeEach(async (t) => {
     t.context = {
       client: new Client(),
     };
@@ -115,7 +122,7 @@ if (RUN_INTEGRATION_TESTS) {
     }
   });
 
-  test('Can create schedule with startWorkflow action', async (t) => {
+  test('Can create schedule with startWorkflow action (no arg)', async (t) => {
     const { client } = t.context;
     const scheduleId = `can-create-schedule-with-startWorkflow-action-${randomUUID()}`;
     const handle = await client.schedule.create({
@@ -148,6 +155,41 @@ if (RUN_INTEGRATION_TESTS) {
     }
   });
 
+  test('Can create schedule with startWorkflow action (with args)', async (t) => {
+    const { client } = t.context;
+    const scheduleId = `can-create-schedule-with-startWorkflow-action-${randomUUID()}`;
+    const handle = await client.schedule.create({
+      scheduleId,
+      spec: {
+        calendars: [{ hour: { start: 2, end: 7, step: 1 } }],
+      },
+      action: {
+        type: 'startWorkflow',
+        workflowType: dummyWorkflowWith2Args,
+        args: [3, 4],
+        taskQueue,
+        memo: {
+          'my-memo': 'foo',
+        },
+        searchAttributes: {
+          CustomKeywordField: ['test-value2'],
+        },
+      },
+    });
+
+    try {
+      const describedSchedule = await handle.describe();
+
+      t.is(describedSchedule.action.type, 'startWorkflow');
+      t.is(describedSchedule.action.workflowType, 'dummyWorkflowWith2Args');
+      t.deepEqual(describedSchedule.action.args, [3, 4]);
+      t.deepEqual(describedSchedule.action.memo, { 'my-memo': 'foo' });
+      t.deepEqual(describedSchedule.action.searchAttributes?.CustomKeywordField, ['test-value2']);
+    } finally {
+      await handle.delete();
+    }
+  });
+
   test('Interceptor is called on create schedule', async (t) => {
     const clientWithInterceptor = new Client({
       connection: t.context.client.connection,
@@ -272,9 +314,9 @@ if (RUN_INTEGRATION_TESTS) {
     }
   });
 
-  test('Can update schedule', async (t) => {
+  test('Can update schedule calendar', async (t) => {
     const { client } = t.context;
-    const scheduleId = `can-update-schedule-${randomUUID()}`;
+    const scheduleId = `can-update-schedule-calendar-${randomUUID()}`;
     const handle = await client.schedule.create({
       scheduleId,
       spec: {
@@ -315,7 +357,8 @@ if (RUN_INTEGRATION_TESTS) {
       action: {
         type: 'startWorkflow',
         workflowId: `${scheduleId}-workflow`,
-        workflowType: dummyWorkflow,
+        workflowType: dummyWorkflowWith1Arg,
+        args: ['foo'],
         taskQueue,
       },
     });
@@ -326,16 +369,48 @@ if (RUN_INTEGRATION_TESTS) {
         action: {
           type: 'startWorkflow',
           workflowId: `${scheduleId}-workflow-2`,
-          workflowType: dummyWorkflow2,
-          args: ['updated'],
+          workflowType: dummyWorkflowWith2Args,
+          args: [3, 4],
           taskQueue,
         },
       }));
 
       const describedSchedule = await handle.describe();
       t.is(describedSchedule.action.type, 'startWorkflow');
-      t.is(describedSchedule.action.workflowType, 'dummyWorkflow2');
-      t.deepEqual(describedSchedule.action.args, ['updated']);
+      t.is(describedSchedule.action.workflowType, 'dummyWorkflowWith2Args');
+      t.deepEqual(describedSchedule.action.args, [3, 4]);
+    } finally {
+      await handle.delete();
+    }
+  });
+
+  test('Can update schedule intervals', async (t) => {
+    const { client } = t.context;
+    const scheduleId = `can-update-schedule-intervals-${randomUUID()}`;
+    const handle = await client.schedule.create({
+      scheduleId,
+      spec: {
+        intervals: [{ every: '5h' }],
+      },
+      action: {
+        type: 'startWorkflow',
+        workflowId: `${scheduleId}-workflow`,
+        workflowType: dummyWorkflowWith1Arg,
+        args: ['foo'],
+        taskQueue,
+      },
+    });
+
+    try {
+      await handle.update((x: ScheduleUpdateOptions) => {
+        x.spec.intervals = [{ every: '3h' }];
+        return x;
+      });
+
+      const describedSchedule = await handle.describe();
+      t.is(describedSchedule.action.type, 'startWorkflow');
+      t.is(describedSchedule.action.workflowType, 'dummyWorkflowWith1Arg');
+      t.deepEqual(describedSchedule.action.args, ['foo']);
     } finally {
       await handle.delete();
     }

packages/test/src/workflows/condition-timeout-0.ts

@@ -3,7 +3,7 @@
  * which means that the condition would block indefinitely and would return undefined once
  * fn evaluates to true, rather than returning true or false.
  */
-import { condition, setHandler, defineSignal, sleep, ApplicationFailure } from '@temporalio/workflow';
+import { condition, setHandler, defineSignal, sleep } from '@temporalio/workflow';
 
 export const aSignal = defineSignal('a');
 export const bSignal = defineSignal('b');

packages/worker/src/index.ts

@@ -25,7 +25,7 @@ export { NativeConnectionOptions, RequiredNativeConnectionOptions, TLSConfig } f
 export { startDebugReplayer } from './debug-replayer';
 export { IllegalStateError } from '@temporalio/common';
 export { ShutdownError, TransportError, UnexpectedError } from '@temporalio/core-bridge';
-export { GracefulShutdownPeriodExpiredError, errors } from './errors';
+export { GracefulShutdownPeriodExpiredError, errors } from './errors'; // eslint-disable-line deprecation/deprecation
 export * from './interceptors';
 export * from './logger';
 export { History, Runtime, RuntimeOptions, makeTelemetryFilterString } from './runtime';