swf-core 1.0.0-alpha7

Serverless Workflow DSL models — data structures, serialization, and validation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use super::{ValidationResult, ValidationRule};
use crate::models::authentication::AuthenticationPolicyDefinition;
use crate::models::retry::BackoffStrategyDefinition;
use crate::models::schema::SchemaDefinition;
use crate::models::task::ProcessTypeDefinition;
use crate::models::workflow::WorkflowScheduleDefinition;

/// Validates that at most one of the given boolean flags is true.
/// Emits a MutualExclusion error if more than one is set.
fn validate_at_most_one(
    flags: &[bool],
    prefix: &str,
    message: &str,
    result: &mut ValidationResult,
) {
    let count = flags.iter().filter(|&&f| f).count();
    if count > 1 {
        result.add_error(prefix, ValidationRule::MutualExclusion, message);
    }
}

/// Validates that exactly one of the given boolean flags is true.
/// Emits a MutualExclusion error if zero or more than one is set.
fn validate_exactly_one(
    flags: &[bool],
    prefix: &str,
    message: &str,
    result: &mut ValidationResult,
) {
    let count = flags.iter().filter(|&&f| f).count();
    if count != 1 {
        result.add_error(prefix, ValidationRule::MutualExclusion, message);
    }
}

/// Validates an authentication policy for oneOf constraint
pub fn validate_auth_policy_one_of(
    policy: &AuthenticationPolicyDefinition,
    prefix: &str,
    result: &mut ValidationResult,
) {
    validate_at_most_one(
        &[
            policy.basic.is_some(),
            policy.bearer.is_some(),
            policy.certificate.is_some(),
            policy.digest.is_some(),
            policy.oauth2.is_some(),
            policy.oidc.is_some(),
        ],
        prefix,
        "authentication policy: only one authentication type must be specified",
        result,
    );
}

/// Validates a workflow schedule definition for oneOf constraint
pub fn validate_schedule_one_of(
    schedule: &WorkflowScheduleDefinition,
    prefix: &str,
    result: &mut ValidationResult,
) {
    validate_at_most_one(
        &[
            schedule.every.is_some(),
            schedule.cron.as_ref().is_some_and(|s| !s.is_empty()),
            schedule.after.is_some(),
            schedule.on.is_some(),
        ],
        prefix,
        "schedule: only one of 'every', 'cron', 'after', or 'on' must be specified",
        result,
    );
}

/// Validates a process type definition for oneOf constraint
pub fn validate_process_type_one_of(
    process: &ProcessTypeDefinition,
    prefix: &str,
    result: &mut ValidationResult,
) {
    validate_exactly_one(
        &[
            process.container.is_some(),
            process.script.is_some(),
            process.shell.is_some(),
            process.workflow.is_some(),
        ],
        &format!("{}.run", prefix),
        "run task: exactly one of 'container', 'script', 'shell', or 'workflow' must be specified",
        result,
    );
}

/// Validates a backoff strategy definition for oneOf constraint
pub fn validate_backoff_one_of(
    backoff: &BackoffStrategyDefinition,
    prefix: &str,
    result: &mut ValidationResult,
) {
    validate_at_most_one(
        &[
            backoff.constant.is_some(),
            backoff.exponential.is_some(),
            backoff.linear.is_some(),
        ],
        prefix,
        "backoff: only one of 'constant', 'exponential', or 'linear' must be specified",
        result,
    );
}

/// Validates a schema definition for oneOf constraint
pub fn validate_schema_one_of(
    schema: &SchemaDefinition,
    prefix: &str,
    result: &mut ValidationResult,
) {
    let has_document = schema.document.is_some();
    let has_resource = schema.resource.is_some();

    if has_document && has_resource {
        result.add_error(
            prefix,
            ValidationRule::MutualExclusion,
            "schema: 'document' and 'resource' are mutually exclusive",
        );
    }
    if !has_document && !has_resource {
        result.add_error(
            prefix,
            ValidationRule::Required,
            "schema: either 'document' or 'resource' must be specified",
        );
    }
}