Flow Settings Model

The FlowSettings model stores global configuration for flow execution timing, delays, and orchestration. This replaces the legacy flow-level hook system with a centralized settings approach.

Schema Definition

model FlowSettings {
  id                        String   @id @default(uuid())
  betweenFlowsDelaySeconds  Int      @default(5)
  createdAt                 DateTime @default(now())
  updatedAt                 DateTime @updatedAt
  timeAfterSubflows         Int      @default(0)
  timeBeforeSubflows        Int      @default(0)
  postSubflowDelay          Int?     @default(1000)
  preSubflowDelay           Int?     @default(1000)
  setupSubflowReferences    String?  @default("[]")
  teardownSubflowReferences String?  @default("[]")
  testCaseExecutionInterval Int?     @default(2000)

  @@map("flow_settings")
}

Field Descriptions

Timing Controls

Field	Type	Description
id	String	UUID primary key
betweenFlowsDelaySeconds	Int	Delay between consecutive flow executions (default: 5)
timeBeforeSubflows	Int	Delay before executing setup subflows (default: 0)
timeAfterSubflows	Int	Delay after executing teardown subflows (default: 0)

Subflow Timing

Field	Type	Description
preSubflowDelay	Int?	Default delay before each subflow execution (default: 1000ms)
postSubflowDelay	Int?	Default delay after each subflow execution (default: 1000ms)

Subflow References

Field	Type	Description
setupSubflowReferences	String?	JSON string of setup subflow configurations
teardownSubflowReferences	String?	JSON string of teardown subflow configurations

Test Execution

Field	Type	Description
testCaseExecutionInterval	Int?	Interval between test case executions (default: 2000ms)

Metadata

Field	Type	Description
createdAt	DateTime	Creation timestamp
updatedAt	DateTime	Last update timestamp

Subflow Reference Structure

Setup Subflow References

[
  {
    "flowId": "setup-environment-flow",
    "preSubflowDelay": 2000,
    "postSubflowDelay": 1000
  },
  {
    "flowId": "data-preparation-flow",
    "preSubflowDelay": 500,
    "postSubflowDelay": 500
  }
]

Teardown Subflow References

[
  {
    "flowId": "cleanup-data-flow",
    "preSubflowDelay": 1000,
    "postSubflowDelay": 0
  },
  {
    "flowId": "logout-flow",
    "preSubflowDelay": 500,
    "postSubflowDelay": 2000
  }
]

Usage Examples

Basic Flow Settings

const settings = await prisma.flowSettings.create({
  data: {
    betweenFlowsDelaySeconds: 3,
    timeBeforeSubflows: 1000,
    timeAfterSubflows: 500,
    preSubflowDelay: 1500,
    postSubflowDelay: 800
  }
});

Advanced Configuration with Subflows

const advancedSettings = await prisma.flowSettings.create({
  data: {
    betweenFlowsDelaySeconds: 5,
    timeBeforeSubflows: 2000,
    timeAfterSubflows: 1000,
    preSubflowDelay: 1000,
    postSubflowDelay: 1000,
    setupSubflowReferences: JSON.stringify([
      {
        flowId: "initialize-app",
        preSubflowDelay: 2000,
        postSubflowDelay: 1000
      },
      {
        flowId: "prepare-test-data",
        preSubflowDelay: 500,
        postSubflowDelay: 0
      }
    ]),
    teardownSubflowReferences: JSON.stringify([
      {
        flowId: "cleanup-test-data",
        preSubflowDelay: 0,
        postSubflowDelay: 500
      },
      {
        flowId: "close-app",
        preSubflowDelay: 1000,
        postSubflowDelay: 2000
      }
    ]),
    testCaseExecutionInterval: 3000
  }
});

Update Timing Settings

await prisma.flowSettings.update({
  where: { id: "settings-123" },
  data: {
    betweenFlowsDelaySeconds: 10,
    preSubflowDelay: 2000,
    postSubflowDelay: 1500
  }
});

Get Current Settings

const settings = await prisma.flowSettings.findFirst({
  orderBy: { updatedAt: "desc" }
});

// Parse subflow references
const setupFlows = JSON.parse(settings?.setupSubflowReferences || "[]");
const teardownFlows = JSON.parse(settings?.teardownSubflowReferences || "[]");

Execution Flow Logic

Complete Flow Execution Sequence

1. Global Setup Phase

   • Wait timeBeforeSubflows milliseconds
   • Execute each setup subflow:
     • Wait preSubflowDelay (global or per-subflow)
     • Execute the subflow
     • Wait postSubflowDelay (global or per-subflow)

2. Main Flow Execution

   • Execute the main flow steps
   • If executing multiple flows: wait betweenFlowsDelaySeconds between each

3. Test Case Intervals (if applicable)

   • Wait testCaseExecutionInterval between test case executions

4. Global Teardown Phase

   • Wait timeAfterSubflows milliseconds
   • Execute each teardown subflow:
     • Wait preSubflowDelay (global or per-subflow)
     • Execute the subflow
     • Wait postSubflowDelay (global or per-subflow)

Performance Considerations

Timing Optimization

• Minimal Delays: Use 0-500ms for fast operations
• UI Transitions: Use 1000-2000ms for UI element waits
• App Loading: Use 2000-5000ms for app initialization
• Network Operations: Use 3000-10000ms for network-dependent actions

Subflow Design

• Keep subflows focused and fast
• Avoid long-running operations in subflows
• Use appropriate delays between subflow steps
• Monitor subflow execution times

Database Queries

• Cache settings to avoid frequent database queries
• Use appropriate indexes on frequently accessed fields
• Consider Redis caching for high-throughput scenarios

Validation Rules

Timing Constraints

• All delay values must be ≥ 0
• Maximum delay: 300000ms (5 minutes)
• Test case intervals: 0-300000ms

Subflow References

• Referenced flows must exist and be marked as subflows
• Circular references are not allowed
• JSON structure must be valid array of objects

Schema Validation

interface SubflowReference {
  flowId: string;
  preSubflowDelay?: number;
  postSubflowDelay?: number;
}

interface FlowSettingsData {
  betweenFlowsDelaySeconds: number;
  timeBeforeSubflows: number;
  timeAfterSubflows: number;
  preSubflowDelay?: number;
  postSubflowDelay?: number;
  setupSubflowReferences?: SubflowReference[];
  teardownSubflowReferences?: SubflowReference[];
  testCaseExecutionInterval?: number;
}

Best Practices

Timing Configuration

• Start with conservative delays and optimize based on testing
• Consider device performance when setting delays
• Use different settings for different environments (dev/staging/prod)
• Monitor execution times and adjust accordingly

Subflow Organization

• Create reusable subflows for common operations
• Use descriptive names for subflow references
• Group related subflows logically
• Document subflow purposes and requirements

Error Handling

• Implement timeout handling for long-running subflows
• Provide fallback behavior when subflows fail
• Log subflow execution results for debugging
• Implement circuit breakers for failing subflows

Testing

• Test timing configurations on target devices
• Validate subflow execution in different scenarios
• Monitor for race conditions between subflows
• Use realistic delays in test environments