feat(schedule-actions): add resume form with catch-up policy (SLICE-2c)

Replace confirmation-only resume with optional reason and catch-up policy
radios. Stacks on mount; default submission omits unset fields.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: Assem-Uber

src/views/schedule-actions/__fixtures__/schedule-actions-config.tsx

@@ -5,6 +5,7 @@ import {
 } from 'react-icons/md';
 import { z } from 'zod';
 
+import { ScheduleCatchUpPolicy } from '@/__generated__/proto-ts/uber/cadence/api/v1/ScheduleCatchUpPolicy';
 import { type PauseScheduleResponse } from '@/route-handlers/pause-schedule/pause-schedule.types';
 import { type UnpauseScheduleResponse } from '@/route-handlers/unpause-schedule/unpause-schedule.types';
 
@@ -58,12 +59,36 @@ export const mockPauseActionConfig: ScheduleAction<
   renderSuccessMessage: () => 'Mock pause notification',
 };
 
-export const mockResumeActionConfig: ScheduleAction<UnpauseScheduleResponse> = {
+export const mockResumeActionConfig: ScheduleAction<
+  UnpauseScheduleResponse,
+  { reason?: string; catchUpPolicy?: ScheduleCatchUpPolicy },
+  { reason?: string; catchUpPolicy?: ScheduleCatchUpPolicy }
+> = {
   id: 'resume',
   label: 'Mock resume',
   subtitle: 'Mock resume a schedule',
   modal: {
-    withForm: false,
+    withForm: true,
+    form: ({ control, fieldErrors }) => (
+      <div data-testid="mock-resume-form">
+        <input
+          data-testid="mock-resume-reason"
+          aria-label="Reason (optional)"
+          aria-invalid={!!fieldErrors.reason}
+          {...control.register('reason')}
+        />
+      </div>
+    ),
+    formSchema: z.object({
+      reason: z.string().optional(),
+      catchUpPolicy: z.nativeEnum(ScheduleCatchUpPolicy).optional(),
+    }),
+    transformFormDataToSubmission: (formData) => ({
+      ...(formData.reason?.trim() ? { reason: formData.reason.trim() } : {}),
+      ...(formData.catchUpPolicy
+        ? { catchUpPolicy: formData.catchUpPolicy }
+        : {}),
+    }),
   },
   icon: MdPlayCircleOutline,
   getRunnableStatus: (schedule) =>

src/views/schedule-actions/config/schedule-actions.config.ts

@@ -6,6 +6,13 @@ import { type UnpauseScheduleResponse } from '@/route-handlers/unpause-schedule/
 import ScheduleActionPauseForm from '../schedule-action-pause-form/schedule-action-pause-form';
 import { type PauseScheduleFormData } from '../schedule-action-pause-form/schedule-action-pause-form.types';
 import { pauseScheduleFormSchema } from '../schedule-action-pause-form/schemas/pause-schedule-form-schema';
+import transformResumeScheduleFormToSubmission from '../schedule-action-resume-form/helpers/transform-resume-schedule-form-to-submission';
+import ScheduleActionResumeForm from '../schedule-action-resume-form/schedule-action-resume-form';
+import {
+  type ResumeScheduleFormData,
+  type ResumeScheduleSubmissionData,
+} from '../schedule-action-resume-form/schedule-action-resume-form.types';
+import { resumeScheduleFormSchema } from '../schedule-action-resume-form/schemas/resume-schedule-form-schema';
 import {
   type PauseScheduleSubmissionData,
   type ScheduleAction,
@@ -43,12 +50,19 @@ const pauseScheduleActionConfig: ScheduleAction<
   renderSuccessMessage: () => 'Schedule has been paused.',
 };
 
-const resumeScheduleActionConfig: ScheduleAction<UnpauseScheduleResponse> = {
+const resumeScheduleActionConfig: ScheduleAction<
+  UnpauseScheduleResponse,
+  ResumeScheduleFormData,
+  ResumeScheduleSubmissionData
+> = {
   id: 'resume',
   label: 'Resume',
   subtitle: 'Resume a paused schedule',
   modal: {
-    withForm: false,
+    withForm: true,
+    form: ScheduleActionResumeForm,
+    formSchema: resumeScheduleFormSchema,
+    transformFormDataToSubmission: transformResumeScheduleFormToSubmission,
   },
   icon: MdPlayCircleOutline,
   getRunnableStatus: (schedule) =>

src/views/schedule-actions/config/schedule-actions.constants.ts

@@ -0,0 +1,5 @@
+export const RESUME_SCHEDULE_FORM_FIELD_DESCRIPTIONS = {
+  reason: 'Optional note explaining why the schedule is being resumed.',
+  catchUpPolicy:
+    'Catch-up policy determines how to handle missed runs when unpausing a schedule.',
+} as const;

src/views/schedule-actions/schedule-action-resume-form/helpers/__tests__/transform-resume-schedule-form-to-submission.node.ts

@@ -0,0 +1,30 @@
+import { ScheduleCatchUpPolicy } from '@/__generated__/proto-ts/uber/cadence/api/v1/ScheduleCatchUpPolicy';
+
+import { USE_SCHEDULE_CATCH_UP_POLICY } from '../../schedule-action-resume-form.constants';
+import transformResumeScheduleFormToSubmission from '../transform-resume-schedule-form-to-submission';
+
+describe(transformResumeScheduleFormToSubmission.name, () => {
+  it('omits empty reason and schedule-policy default', () => {
+    expect(transformResumeScheduleFormToSubmission({})).toEqual({});
+    expect(transformResumeScheduleFormToSubmission({ reason: '   ' })).toEqual(
+      {}
+    );
+    expect(
+      transformResumeScheduleFormToSubmission({
+        catchUpPolicy: USE_SCHEDULE_CATCH_UP_POLICY,
+      })
+    ).toEqual({});
+  });
+
+  it('includes trimmed reason and explicit catchUpPolicy when provided', () => {
+    expect(
+      transformResumeScheduleFormToSubmission({
+        reason: '  Resuming after maintenance  ',
+        catchUpPolicy: ScheduleCatchUpPolicy.SCHEDULE_CATCH_UP_POLICY_ONE,
+      })
+    ).toEqual({
+      reason: 'Resuming after maintenance',
+      catchUpPolicy: ScheduleCatchUpPolicy.SCHEDULE_CATCH_UP_POLICY_ONE,
+    });
+  });
+});

src/views/schedule-actions/schedule-action-resume-form/helpers/transform-resume-schedule-form-to-submission.ts

@@ -0,0 +1,18 @@
+import { isExplicitCatchUpPolicy } from '../schedule-action-resume-form.constants';
+import {
+  type ResumeScheduleFormData,
+  type ResumeScheduleSubmissionData,
+} from '../schedule-action-resume-form.types';
+
+export default function transformResumeScheduleFormToSubmission(
+  formData: ResumeScheduleFormData
+): ResumeScheduleSubmissionData {
+  const reason = formData.reason?.trim();
+
+  return {
+    ...(reason ? { reason } : {}),
+    ...(isExplicitCatchUpPolicy(formData.catchUpPolicy)
+      ? { catchUpPolicy: formData.catchUpPolicy }
+      : {}),
+  };
+}

src/views/schedule-actions/schedule-action-resume-form/schedule-action-resume-form.constants.ts

@@ -0,0 +1,32 @@
+import { SCHEDULE_CATCH_UP_POLICIES } from '@/route-handlers/create-schedule/create-schedule.constants';
+import { SCHEDULE_CATCH_UP_POLICY_LABELS } from '@/views/shared/constants/schedule-policy-labels.constants';
+
+export const USE_SCHEDULE_CATCH_UP_POLICY = 'USE_SCHEDULE_POLICY' as const;
+
+export const DEFAULT_RESUME_CATCH_UP_POLICY = USE_SCHEDULE_CATCH_UP_POLICY;
+
+export const SCHEDULE_ACTION_RESUME_FORM_FIELD_IDS = {
+  reason: 'schedule-action-resume-reason',
+} as const;
+
+export const RESUME_CATCH_UP_POLICY_OPTIONS = [
+  {
+    id: USE_SCHEDULE_CATCH_UP_POLICY,
+    label: 'Schedule default policy',
+  },
+  ...SCHEDULE_CATCH_UP_POLICIES.map((policy) => ({
+    id: policy,
+    label: SCHEDULE_CATCH_UP_POLICY_LABELS[policy],
+  })),
+] as const;
+
+export type ResumeCatchUpPolicyOptionId =
+  (typeof RESUME_CATCH_UP_POLICY_OPTIONS)[number]['id'];
+
+export type ExplicitResumeCatchUpPolicy =
+  (typeof SCHEDULE_CATCH_UP_POLICIES)[number];
+
+export const isExplicitCatchUpPolicy = (
+  value: ResumeCatchUpPolicyOptionId | undefined
+): value is ExplicitResumeCatchUpPolicy =>
+  value !== undefined && value !== USE_SCHEDULE_CATCH_UP_POLICY;

src/views/schedule-actions/schedule-action-resume-form/schedule-action-resume-form.tsx

@@ -0,0 +1,82 @@
+import { Radio, RadioGroup } from 'baseui/radio';
+import { Textarea } from 'baseui/textarea';
+import { Controller } from 'react-hook-form';
+
+import DomainSchedulesHorizontalField from '@/views/domain-schedules/domain-schedules-horizontal-field/domain-schedules-horizontal-field';
+import { RESUME_SCHEDULE_FORM_FIELD_DESCRIPTIONS } from '@/views/schedule-actions/config/schedule-actions.constants';
+import getFieldErrorMessage from '@/views/workflow-actions/workflow-action-start-form/helpers/get-field-error-message';
+
+import {
+  DEFAULT_RESUME_CATCH_UP_POLICY,
+  RESUME_CATCH_UP_POLICY_OPTIONS,
+  SCHEDULE_ACTION_RESUME_FORM_FIELD_IDS,
+} from './schedule-action-resume-form.constants';
+import { type Props } from './schedule-action-resume-form.types';
+
+export default function ScheduleActionResumeForm({
+  fieldErrors,
+  control,
+}: Props) {
+  return (
+    <>
+      <DomainSchedulesHorizontalField
+        label="Catch-up policy"
+        description={RESUME_SCHEDULE_FORM_FIELD_DESCRIPTIONS.catchUpPolicy}
+        error={getFieldErrorMessage(fieldErrors, 'catchUpPolicy')}
+      >
+        <Controller
+          name="catchUpPolicy"
+          control={control}
+          defaultValue={DEFAULT_RESUME_CATCH_UP_POLICY}
+          render={({ field: { value, onChange, ref, ...field } }) => (
+            <RadioGroup
+              {...field}
+              // @ts-expect-error - inputRef expects ref object while ref is a callback. It should support both.
+              inputRef={ref}
+              aria-label="Catch-up policy"
+              value={value}
+              onChange={(e) => onChange(e.currentTarget.value)}
+              error={Boolean(
+                getFieldErrorMessage(fieldErrors, 'catchUpPolicy')
+              )}
+            >
+              {RESUME_CATCH_UP_POLICY_OPTIONS.map((option) => (
+                <Radio key={option.id} value={option.id}>
+                  {option.label}
+                </Radio>
+              ))}
+            </RadioGroup>
+          )}
+        />
+      </DomainSchedulesHorizontalField>
+
+      <DomainSchedulesHorizontalField
+        label="Reason for resuming (optional)"
+        description={RESUME_SCHEDULE_FORM_FIELD_DESCRIPTIONS.reason}
+        htmlFor={SCHEDULE_ACTION_RESUME_FORM_FIELD_IDS.reason}
+        error={getFieldErrorMessage(fieldErrors, 'reason')}
+      >
+        <Controller
+          name="reason"
+          control={control}
+          defaultValue=""
+          render={({ field: { ref, ...field } }) => (
+            <Textarea
+              {...field}
+              id={SCHEDULE_ACTION_RESUME_FORM_FIELD_IDS.reason}
+              // @ts-expect-error - inputRef expects ref object while ref is a callback. It should support both.
+              inputRef={ref}
+              size="compact"
+              onChange={(e) => {
+                field.onChange(e.target.value);
+              }}
+              onBlur={field.onBlur}
+              error={Boolean(getFieldErrorMessage(fieldErrors, 'reason'))}
+              placeholder="Add reason"
+            />
+          )}
+        />
+      </DomainSchedulesHorizontalField>
+    </>
+  );
+}

src/views/schedule-actions/schedule-action-resume-form/schedule-action-resume-form.types.ts

@@ -0,0 +1,19 @@
+import { type z } from 'zod';
+
+import { type ScheduleCatchUpPolicy } from '@/__generated__/proto-ts/uber/cadence/api/v1/ScheduleCatchUpPolicy';
+
+import { type ScheduleActionFormProps } from '../schedule-actions.types';
+
+import { type resumeScheduleFormSchema } from './schemas/resume-schedule-form-schema';
+
+export type ResumeScheduleFormData = z.infer<typeof resumeScheduleFormSchema>;
+
+export type ResumeScheduleSubmissionData = {
+  reason?: string;
+  catchUpPolicy?: ScheduleCatchUpPolicy;
+};
+
+export type Props = Pick<
+  ScheduleActionFormProps<ResumeScheduleFormData>,
+  'fieldErrors' | 'control'
+>;

src/views/schedule-actions/schedule-action-resume-form/schemas/resume-schedule-form-schema.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+import { SCHEDULE_CATCH_UP_POLICIES } from '@/route-handlers/create-schedule/create-schedule.constants';
+
+import { USE_SCHEDULE_CATCH_UP_POLICY } from '../schedule-action-resume-form.constants';
+
+export const resumeScheduleFormSchema = z.object({
+  reason: z.string().trim().optional(),
+  catchUpPolicy: z
+    .union([
+      z.literal(USE_SCHEDULE_CATCH_UP_POLICY),
+      z.enum(SCHEDULE_CATCH_UP_POLICIES),
+    ])
+    .optional(),
+});

src/views/schedule-actions/schedule-actions-modal-content/__tests__/schedule-actions-modal-content.test.tsx

@@ -142,6 +142,28 @@ describe(ScheduleActionsModalContent.name, () => {
       );
     });
   });
+
+  it('calls resume API with default submission when confirmed', async () => {
+    const { user, mockOnClose, getLatestRequestBody, waitForRequest } = setup({
+      actionConfig: mockScheduleActionsConfig[1],
+    });
+
+    await user.click(
+      await screen.findByRole('button', { name: 'Mock resume schedule' })
+    );
+
+    await waitForRequest();
+    expect(getLatestRequestBody()).toEqual({});
+
+    await waitFor(() => {
+      expect(mockEnqueue).toHaveBeenCalledWith(
+        expect.objectContaining({
+          message: 'Mock resume notification',
+        })
+      );
+    });
+    expect(mockOnClose).toHaveBeenCalled();
+  });
 });
 
 function setup({