Temporal 클러스터 없이 엣지에서 내결함성 워크플로를 — Cloudflare Workflows의 재시도·인간 승인·타임아웃 처리 방식

export class MyWorkflow extends WorkflowEntrypoint {
  async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
    // step 이름이 고유하면 재시도 시 중복 실행되지 않습니다
    const result = await step.do('fetch-user-data', async () => {
      return await fetchUser(event.payload.userId);
    });
 
    // 재시도 옵션을 세밀하게 구성할 수 있습니다
    const processed = await step.do(
      'process-data',
      {
        retries: {
          limit: 5,               // 최대 재시도 횟수 (스텝 개수 한도와 별개)
          delay: '1 second',      // 초기 지연
          backoff: 'exponential', // constant | linear | exponential
        },
        timeout: '10 minutes',
      },
      async () => {
        return await heavyProcessing(result);
      }
    );
  }
}

// 1시간 후에 재개 — 이 시간 동안 비용 없음
await step.sleep('wait-before-retry', '1 hour');
 
// 외부 이벤트를 최대 72시간 대기
// 타임아웃 처리 방식(예외 발생 vs 특수 반환값)은 공식 타입 정의 기준으로 확인하세요
const approvalEvent = await step.waitForEvent<ApprovalEvent>('approval-gate', {
  timeout: '72 hours',
});

export class DocumentPipeline extends WorkflowEntrypoint {
  async run(
    event: WorkflowEvent<{ fileUrl: string; userId: string }>,
    step: WorkflowStep
  ) {
    const parsed = await step.do('parse-document', async () => {
      return await parseWithOCR(event.payload.fileUrl);
    });
 
    const summary = await step.do(
      'summarize',
      {
        retries: {
          limit: 3,
          delay: '2 seconds',
          backoff: 'exponential',
        },
      },
      async () => {
        return await callLLM(parsed.text);
      }
    );
 
    await step.do('notify-user', async () => {
      return await sendEmail(event.payload.userId, summary);
    });
  }
}

export class PaymentApprovalWorkflow extends WorkflowEntrypoint {
  async run(event: WorkflowEvent<PaymentRequest>, step: WorkflowStep) {
    // 1단계: 사전 검증
    const validated = await step.do('validate-payment', async () => {
      return await validatePaymentRequest(event.payload);
    });
 
    // 2단계: 담당자에게 승인 요청 전송
    // workflowId는 페이로드로 전달하거나 플랫폼 컨텍스트에서 획득하세요
    await step.do('send-approval-request', async () => {
      await sendSlackApprovalRequest({
        amount: validated.amount,
        workflowId: event.payload.workflowId,
      });
    });
 
    // 3단계: 최대 72시간 승인 대기 — 이 구간은 비용 없음
    // waitForEvent 타임아웃이 예외로 처리되는지 특수값으로 처리되는지
    // 공식 타입 정의로 확인 후 핸들링 방식을 결정하세요
    let approval: { payload: { outcome: 'approved' | 'rejected' } } | null = null;
    try {
      approval = await step.waitForEvent<{ outcome: 'approved' | 'rejected' }>(
        'manager-approval',
        { timeout: '72 hours' }
      );
    } catch {
      // 타임아웃: 승인 기한 만료 처리
      await step.do('notify-timeout', async () => {
        await notifyUser(event.payload.userId, '승인 대기 시간이 초과됐습니다.');
      });
      return; // 워크플로 성공으로 완료 — 결제는 실행되지 않음
    }
 
    if (approval.payload.outcome === 'rejected') {
      await step.do('notify-rejection', async () => {
        await notifyUser(event.payload.userId, '결제 요청이 거절되었습니다.');
      });
      return; // 워크플로 성공으로 완료 — 결제는 실행되지 않음
    }
 
    // 4단계: 승인 완료 후 결제 실행
    await step.do(
      'process-payment',
      { retries: { limit: 3, backoff: 'exponential' } },
      async () => {
        return await processPayment(validated);
      }
    );
  }
}

// 슬랙 웹훅이나 관리 UI에서 호출
const instance = await env.MY_WORKFLOW.get(workflowId);
await instance.sendEvent({
  type: 'manager-approval', // waitForEvent('manager-approval')와 동일해야 합니다
  payload: { outcome: 'approved' },
});

export class OrderWorkflow extends WorkflowEntrypoint {
  async run(event: WorkflowEvent<OrderRequest>, step: WorkflowStep) {
    // try 바깥에 선언해야 catch 블록에서 참조할 수 있습니다
    // step 반환값은 SQLite에 커밋되므로 재시작 시에도 재현됩니다
    let inventoryResult: { reserved: boolean } | undefined;
    let paymentResult: { charged: boolean } | undefined;
 
    try {
      inventoryResult = await step.do('reserve-inventory', async () => {
        await reserveStock(event.payload.items);
        return { reserved: true };
      });
 
      paymentResult = await step.do('charge-payment', async () => {
        await chargeCard(event.payload.paymentMethod, event.payload.total);
        return { charged: true };
      });
 
      await step.do('confirm-order', async () => {
        await confirmOrder(event.payload.orderId);
      });
    } catch (error) {
      // step 반환값 기준으로 보상 여부 결정
      // 재시작 시 완료된 step은 건너뛰고 반환값을 재현하므로 상태가 보존됩니다
      if (paymentResult?.charged) {
        await step.do('compensate-payment', async () => {
          await refundCard(event.payload.paymentMethod, event.payload.total);
        });
      }
      if (inventoryResult?.reserved) {
        await step.do('compensate-inventory', async () => {
          await releaseStock(event.payload.items);
        });
      }
      throw error;
    }
  }
}

// wrangler.jsonc
{
  "workflows": [
    {
      "name": "my-workflow",
      "binding": "MY_WORKFLOW",
      "class_name": "MyWorkflow",
      "settings": {
        "step_limit": 25000,
        "cpu_time_limit": 300000  // 단위(ms 또는 μs)는 공식 문서 기준으로 확인하세요
      }
    }
  ]
}

// 잘못된 예시 — step 바깥의 비결정적 코드
export class BadWorkflow extends WorkflowEntrypoint {
  async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
    const timestamp = Date.now(); // 재시작 시 다른 값이 나옵니다
    const result = await step.do('do-something', async () => {
      return await doWork(timestamp); // 재현 불일치 가능
    });
  }
}
 
// 올바른 예시 — step 안에서 캡처
export class GoodWorkflow extends WorkflowEntrypoint {
  async run(event: WorkflowEvent<Params>, step: WorkflowStep) {
    const result = await step.do('do-something', async () => {
      const timestamp = Date.now(); // step 안에서 캡처, 결과로 저장됨
      return await doWork(timestamp);
    });
  }
}