Workflow language reference

// a line comment            /* a block comment */

record Traveller { ... }                 // a named row shape
formuladef "travel-age-factor" { ... }   // a reusable formula, by key
blockdef "my-ncd" { ... }                // a reusable sub-workflow, by key
workflow "travel-pricing" { ... }        // the workflow itself (at most one)

record RateRow {
    field rateValue : NUMBER
    field rowCode : STRING
    field loadable : BOOLEAN          // fields are scalar: NUMBER, STRING, BOOLEAN, ENUM(...)
}

formuladef "ks-age-factor" {
    in driverAge : NUMBER
    expression: """
        let senior = if(driverAge > 70, 1.10, 1.0);
        if(driverAge < 25, 1.15, senior)
        """
}

blockdef "ks-param-block" {
    input amount                      // public input port
    param surcharge : NUMBER          // set by the caller, not a port
    param label : STRING

    aggregate pbSum {
        sign: ADD
    }
    output pbOut {                    // exactly one output: its ports are the block's outputs
    }

    connect amount -> pbSum.currentTotal
    connect surcharge -> pbSum.contribution
    connect pbSum -> pbOut.total
    connect label -> pbOut.label
}

input sumInsured                          // NUMBER, output port "value"
input usage : ENUM("PRIVATE", "COMMERCIAL", "PSV")
input travellers : LIST<RECORD:Traveller>
input riskScore : NUMBER out score         // rename the output port

formula F_ageLoad {                        // inputs inferred from what is connected
    expression: runningTotal * (factor - 1)
}
formula F_over {
    in oldest : NUMBER                      // or declared
    out flag : BOOLEAN                      // NUMBER (default), BOOLEAN or STRING
    expression: oldest > 70
}
formula F_ageFactor {
    in driverAge : NUMBER
    binding: formula "ks-age-factor"        // run a formula saved under a key
}
formula F_ncd {
    in runningTotal : NUMBER                // no binding: wired through $binding instead
}

decision D_windscreen {
    in hasWindscreen : BOOLEAN
    expression: hasWindscreen
    otherwise -> F_windscreenNil            // runs on false
}
decision D_young {
    in driverAge : NUMBER
    binding: formula "ks-is-young"
    true -> F_youngLevy                     // runs on true
}
formula F_windscreenCharge {
    expression: 30 * usdKes
    guard: D_windscreen.true                // or D_windscreen.false
}

lookup L_vat {
    kind: NODE_BINDING
    key: "ks-vat"                           // one fixed key
}
lookup L_ncd {
    kind: NODE_BINDING
    key: "ks:ncd:" from ncdTier             // prefix + the value of the wired port
}
connect ncdTier -> L_ncd
connect L_ncd -> F_ncd.$binding

grouplookup levyTables {                   // group mode: every table whose code starts "levy:"
    kind: RATE_TABLE
    keyPrefix: "levy:"
    row: TableName
    project code from key                    // the setting's own key, prefix removed
    project name from "name" default "-"
    out tables
}
grouplookup rows {                           // array mode: one table, its rows; keys by position
    kind: RATE_TABLE
    key: from tableCode
    array: "rows"
    row: TableRateRow
    project k1 from "keys" index 0 default "-"
    project rate from "rate"
    out rows
}

transform T_eligible {
    op: FILTER
    elements: age : LIST<NUMBER>             // several lists, zipped item by item
    elements: name : LIST<STRING>
    context: minAge : NUMBER                 // the same value for every item
    expression: age >= minAge and name != "SPAM"
}
transform T_rowContribs {
    op: MAP
    elements: row : LIST<RECORD:RateRow>
    context: sumInsured : NUMBER
    binding: block "ks-row-contribution"     // a block per item: one NUMBER output
}
connect T_eligible.age -> T_eligibleCount.age

recordfield RF_loadCode {
    in row : RECORD:RateRow
    field: rowCode
    out code
}
recordfields PR from primaryRate : RECORD:RateRow   // one step per field: PR_rateValue, PR_rowCode, ...

aggregate A_ncd {
    sign: SUBTRACT                           // or ADD
}
connect A_rowLoad -> A_ncd.currentTotal      // the total so far
connect F_ncd -> A_ncd.contribution          // this step's amount
connect A_ncd -> F_vat.runningTotal          // newTotal, onward

fetch Fe_fxRate {
    in quoteDate : DATE                      // parameters, substituted into the operation
    out usdKes : NUMBER                      // the typed result
    connection: "ks-http-conn"
    operation: "ks-fx-op"
    guard: D_windscreen.true
}
fetch Fe_classFactor {
    in vehicleClass : STRING
    out classFactor : NUMBER
}
connect L_dbConn -> Fe_classFactor.$connection
connect L_dbOp -> Fe_classFactor.$operation

block B_rate {
    in key1 : STRING
    in x : NUMBER
    out rate : NUMBER                        // must match the block's own ports exactly
    param tableCode = "motor-base-rate"      // literal: NUMBER, STRING or BOOLEAN
    binding: block "protected:table-rate:1d-band"
}
block B_period {                             // bound at run time instead
    in amount : NUMBER
    out adjustment : NUMBER
}
connect L_period -> B_period.$binding

output O_quote {
    in premium : NUMBER                      // optional: ports are also made by connect
}
connect A_vat -> O_quote.premium
connect B_period.days -> O_quote.coverDays

curl -s -X POST https://<your-address>/api/workflow/dsl/simulate \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "$(jq -n --rawfile src motor-premium.wf '{
    source: $src,
    scope: {organizationId: "<organisation>"},
    asOfDate: "2026-10-09",
    inputs: {
      vehicleValue: {type: "NUMBER", value: "2000000"},
      driverAge:    {type: "NUMBER", value: "23"}
    }
  }')"