Complex State Management

Workflows often involve managing complex states, conditional logic, and waiting for various external events or timeouts. IdentityFlow provides patterns to handle these scenarios effectively.

Approval Process with Timeout

This example demonstrates an approval process that waits for an external response but also includes a timeout mechanism using Promise.race.

export default defineWorkflow('approval-process', async (flow) => {
  const request = await flow.do('submit request', async () => {
    return createRequest(flow.params); // Your function to create/submit the request
  });

  // Use Promise.race to wait for either an approval response or a timeout
  const result = await Promise.race([
    flow.request('approval response', async ({ token }) => {
      // This step pauses the workflow, providing a token.
      // An external system uses this token to send a response and resume the workflow.
      return { requestId: request.id, token };
    }),
    flow.sleep('escalation timeout', '48 hours', { timedOut: true }), // If sleep resolves first, it's a timeout
  ]);

  if (result.timedOut) {
    // Check if the timeout occurred
    return flow.do('handle timeout', async () => {
      return handleEscalation(request.id); // Your escalation logic
    });
  }

  // If not a timeout, 'result' will be the data sent from the external system
  // (assuming the external system sends an object with a 'status' field)
  if (result.status === 'approved') {
    return flow.do('process approval', async () => {
      return processApproval(request.id); // Your approval logic
    });
  }

  return flow.do('handle rejection', async () => {
    return handleRejection(request.id, result.reason); // Your rejection logic
  });
});

Multi-Stage Process

This example illustrates a workflow with multiple distinct stages, including parallel processing within a stage.

export default defineWorkflow('multi-stage-process', async (flow) => {
  // Stage 1: Initial Processing
  const initialData = await flow.do('initial processing', async () => {
    return processInitialData(flow.params);
  });

  // Stage 2: Parallel Data Validation and Enrichment
  const [validationResult, enrichedData] = await Promise.all([
    flow.do('validate data', async () => validateData(initialData)),
    flow.do('enrich data', async () => enrichData(initialData)),
  ]);

  // Stage 3: Conditional Processing Based on Validation
  if (validationResult.status === 'valid') {
    await flow.do('process valid data', async () => {
      return processValidData(enrichedData);
    });
    return { finalStatus: 'Processed Successfully' };
  } else {
    await flow.do('handle invalid data', async () => {
      return handleInvalidData(validationResult.errors);
    });
    return { finalStatus: 'Failed - Invalid Data', errors: validationResult.errors };
  }
});

Key Techniques:

• flow.request(): Pause a workflow to wait for external input, providing a token for correlation.
• flow.sleep(): Introduce delays or implement timeouts.
• Promise.race(): Manage competing events, such as an external response versus a timeout.
• Promise.all() / Promise.allSettled(): Handle parallel execution of steps within a stage. See Parallel Processing.
• Conditional Logic**: Standard JavaScript if/else or switch statements to direct flow based on data or step outcomes.

By combining these patterns, you can model sophisticated stateful interactions within your IdentityFlow workflows.

Explore Custom Step Types for more reusable logic.