Rule cookbook: by data type, by place, by severity

Customer create | data: {"fullName": "   "}
=> deny  ONB-STR-001 error blocking /fullName "Enter your full name."
Customer create | data: {"email": "maya(at)example.com", "backupEmail": "Maya@Example.com"}
=> deny
   ONB-TYP-001 error blocking /email "Enter a valid e-mail address."
   ONB-TYP-002 info not blocking /backupEmail "We will store this address as maya@example.com."

{ "id": "c-1", "fullName": "Maya Okafor", "email": "maya@example.com", "phone": "+14155550100",
  "accountType": "personal", "country": "US", "postalCode": "27502", "dateOfBirth": "1990-04-12",
  "annualIncome": 80000, "creditLimit": 10000, "dependents": 2, "termsAccepted": true,
  "interests": ["travel", "cooking"],
  "addresses": [{ "kind": "home", "line1": "1 Main St", "city": "Apex", "primary": true }] }

{ "id": "t-1", "type": "domestic", "amount": 120.5, "currency": "USD", "memo": "rent",
  "beneficiary": { "name": "Jo Lee", "country": "US" } }

$ rule-cascade evaluate --bundle conformance/bundles/acme.onboarding.customer.bundle.json \
    --conformance-operators request.json

- id: customer.full-name.family-name-hint   # permanent: it appears in findings, logs and overrides
  kind: validation                          # validation, state, compute or action
  title: Suggest adding a family name       # for the people who read the ruleset
  target:                                   # what the rule is about, and where the UI shows it
    entity: Customer
    page: onboarding
    screen: profile
    section: identity
    component: name-input
    field: /fullName                        # JSON Pointer; the finding points at it
  operations: [create, update]              # the operations the rule takes part in
  triggers: [blur, submit]                  # client moments; the default is [submit]
  enforcement: client                       # client, server or both (the default)
  when:                                     # guard: the rule applies only when this is true
    op: not
    args: [ { fn: isBlank, args: [ { var: data.fullName } ] } ]
  assert:                                   # must be true; when it is false the finding is produced
    op: contains
    args: [ { op: trim, args: [ { var: data.fullName } ] }, " " ]
  severity: info                            # info, warning or error
  finding:
    code: ONB-STR-004                       # stable code for support, tests and analytics
    message: fullName.familyNameHint        # key into messages.<locale>

Customer create | data: {"fullName": "Maya"} | channel: client | trigger: blur
=> allow
   ONB-STR-004 info not blocking /fullName "Add your family name so we can address you properly."
Customer create | data: {"fullName": "Maya"}
=> allow

messages:
  en:
    fullName.required: "Enter your full name."
    fullName.length: "Your name must have 2 to 80 characters; it has {length}."
  es:
    fullName.required: "Introduce tu nombre completo."

Customer create | data: {"fullName": "   "} | locale: es-MX
=> deny  ONB-STR-001 error blocking /fullName "Introduce tu nombre completo."
Customer create | data: {"fullName": " M "} | locale: es-MX
=> deny  ONB-STR-002 error blocking /fullName "Your name must have 2 to 80 characters; it has 1."

scope:
  - { level: enterprise, id: acme-group }
  - { level: organization, id: acme }
  - { level: businessUnit, id: retail-banking }
  - { level: application, id: payments-hub }
  - { level: feature, id: transfers }

extends:
  - { ruleset: acme.org.base, version: ^1.2.0 }

overrides:
  params:
    maxTransferAmount: 25000        # retail tightens the org limit of 50000
  rules:
    - rule: org.transfer.memo-recommended
      set: { severity: warning }
      reason: Retail operations needs memos for dispute handling.

Transfer create | data: {"amount": 30000, "memo": ""} | ruleset: org
=> allow
   ORG-TRF-003 info not blocking /memo "Adding a memo makes this transfer easier to reconcile."
Transfer create | data: {"amount": 30000, "memo": ""}
=> deny
   ORG-TRF-002 error blocking /amount (may accept-risk by risk-officer)
      "Amount exceeds the single-transfer limit of 25000."
   ORG-TRF-003 warning not blocking /memo "Adding a memo makes this transfer easier to reconcile."
   PAY-TRF-003 warning blocking /amount,/beneficiary/name (may acknowledge)
      "This is a large transfer to Jo Lee. Please confirm the details."

Customer create | channel: client | view: {"page": "onboarding", "screen": "finance"}
  | data: {"fullName": "", "annualIncome": 500000, "creditLimit": 70000, "discountPercent": 40}
=> deny
   ONB-NUM-002 error blocking /creditLimit (may accept-risk by credit-manager)
      "The credit limit cannot exceed 50000."
   ONB-NUM-004 info not blocking /discountPercent "Discounts above 30% are reviewed monthly."
Customer create | channel: client
  | data: {"fullName": "", "annualIncome": 500000, "creditLimit": 70000, "discountPercent": 40}
=> deny
   ONB-STR-001 error blocking /fullName "Enter your full name."
   ONB-NUM-002 error blocking /creditLimit (may accept-risk by credit-manager)
      "The credit limit cannot exceed 50000."
   ONB-NUM-004 info not blocking /discountPercent "Discounts above 30% are reviewed monthly."

- id: customer.discount.high
  title: High discounts are reviewed
  when: { op: exists, args: [ { var: data.discountPercent } ] }
  assert: { op: lte, args: [ { var: data.discountPercent }, { var: params.highDiscountPercent } ] }
  severity: info
  finding:
    code: ONB-NUM-004
    message: discount.high                  # "Discounts above {threshold}% are reviewed monthly."
    args: { threshold: { var: params.highDiscountPercent } }

- id: customer.full-name.no-digits
  title: Names rarely contain digits
  when: { op: not, args: [ { fn: isBlank, args: [ { var: data.fullName } ] } ] }
  assert: { op: not, args: [ { op: matches, args: [ { var: data.fullName }, "[0-9]" ] } ] }
  severity: warning

Customer create | data: {"discountPercent": 40}
=> allow  ONB-NUM-004 info not blocking /discountPercent "Discounts above 30% are reviewed monthly."
Customer create | data: {"fullName": "R2 Dee2"}
=> allow
   ONB-STR-003 warning not blocking /fullName
      "Your name contains digits. Check that it is spelled correctly."

- id: customer.credit-limit.income-ratio
  title: Credit limit compared with income (cross-field, must be acknowledged)
  target: { entity: Customer, fields: [/creditLimit, /annualIncome] }
  when:
    op: and
    args:
      - { op: exists, args: [ { var: data.creditLimit } ] }
      - { op: exists, args: [ { var: data.annualIncome } ] }
      - { op: gte, args: [ { var: data.annualIncome }, 0 ] }
  assert:
    op: lte
    args:
      - { var: data.creditLimit }
      - { op: mul, args: [ { var: data.annualIncome }, { var: params.maxCreditToIncomeRatio } ] }
  severity: warning
  acknowledgement: required

Customer create | data: {"annualIncome": 30000, "creditLimit": 18000}
=> deny
   ONB-NUM-003 warning blocking /creditLimit,/annualIncome (may acknowledge)
      "This credit limit is high for the stated income. A limit up to 15000 needs no confirmation."
Customer create | data: {"annualIncome": 30000, "creditLimit": 18000}
  | resolutions: [{"rule": "customer.credit-limit.income-ratio", "type": "acknowledge"}]
=> allow
   ONB-NUM-003 warning not blocking acknowledged /creditLimit,/annualIncome
      "This credit limit is high for the stated income. A limit up to 15000 needs no confirmation."

- id: customer.terms.accepted
  title: Terms must be accepted
  assert: { op: eq, args: [ { var: data.termsAccepted }, true ] }
  severity: error

- id: customer.credit-limit.ceiling
  title: Credit limit ceiling, with accept-with-risk
  when: { op: exists, args: [ { var: data.creditLimit } ] }
  assert: { op: lte, args: [ { var: data.creditLimit }, { var: params.maxCreditLimit } ] }
  severity: error
  acceptance:
    allowed: true
    roles: [credit-manager]
    justification: required
    expiresAfter: P30D

Customer create | data: {"termsAccepted": false}
=> deny  ONB-BOO-001 error blocking /termsAccepted "Accept the terms to continue."
Customer create | data: {"annualIncome": 200000, "creditLimit": 60000}
=> deny
   ONB-NUM-002 error blocking /creditLimit (may accept-risk by credit-manager)
      "The credit limit cannot exceed 50000."
Customer create | data: {"annualIncome": 200000, "creditLimit": 60000}
  | actor: {"id": "u-7", "roles": ["credit-manager"]}
  | resolutions: [{"rule": "customer.credit-limit.ceiling", "type": "accept-risk",
      "justification": "long-standing client"}]
=> allow
   ONB-NUM-002 error not blocking accepted /creditLimit "The credit limit cannot exceed 50000."
Customer create | data: {"annualIncome": 200000, "creditLimit": 60000}
  | actor: {"id": "u-2", "roles": ["agent"]}
  | resolutions: [{"rule": "customer.credit-limit.ceiling", "type": "accept-risk",
      "justification": "please"}]
=> deny
   ONB-NUM-002 error blocking /creditLimit (may accept-risk by credit-manager)
      "The credit limit cannot exceed 50000."

- id: customer.full-name.required
  title: Full name is required
  assert: { op: not, args: [ { fn: isBlank, args: [ { var: data.fullName } ] } ] }
  severity: error

- id: customer.full-name.length
  title: Full name has 2 to 80 characters
  when: { op: not, args: [ { fn: isBlank, args: [ { var: data.fullName } ] } ] }
  assert:
    op: between
    args: [ { op: len, args: [ { op: trim, args: [ { var: data.fullName } ] } ] }, 2, 80 ]
  severity: error
  finding:
    code: ONB-STR-002
    message: fullName.length                # "... it has {length}."
    args: { length: { op: len, args: [ { op: trim, args: [ { var: data.fullName } ] } ] } }

Customer create | data: {"fullName": "   "}
=> deny  ONB-STR-001 error blocking /fullName "Enter your full name."
Customer create | data: {"fullName": " M "}
=> deny  ONB-STR-002 error blocking /fullName "Your name must have 2 to 80 characters; it has 1."

- id: type.email.format
  title: E-mail addresses are well formed
  target: { type: Email }
  when: { op: exists, args: [ { var: value } ] }
  assert: { op: matches, args: [ { var: value }, "^[^@ ]+@[^@ ]+\\.[A-Za-z]{2,}$" ] }
  severity: error

- id: type.email.lower-case
  title: E-mail addresses are stored in lower case
  target: { type: Email }
  when: { op: eq, args: [ { op: typeOf, args: [ { var: value } ] }, string ] }
  assert: { op: eq, args: [ { var: value }, { op: lower, args: [ { var: value } ] } ] }
  severity: info

- id: type.phone.e164
  title: Phone numbers use the international format
  target: { type: PhoneNumber }
  when: { op: exists, args: [ { var: value } ] }
  assert: { op: matches, args: [ { var: value }, "^\\+[1-9][0-9]{7,14}$" ] }
  severity: error

Customer create | data: {"email": "maya(at)example.com", "backupEmail": "Maya@Example.com"}
=> deny
   ONB-TYP-001 error blocking /email "Enter a valid e-mail address."
   ONB-TYP-002 info not blocking /backupEmail "We will store this address as maya@example.com."
Customer create | data: {"phone": "4155550100"}
=> deny
   ONB-TYP-003 error blocking /phone
      "Enter the phone number with its country code, for example +14155550100."

Customer create | data: {"backupEmail": ""}
=> deny  ONB-TYP-001 error blocking /backupEmail "Enter a valid e-mail address."
Customer create | data: {"backupEmail": null}
=> allow

- id: customer.company-name.required-for-business
  title: Business accounts name their company
  when: { op: eq, args: [ { var: data.accountType }, business ] }
  assert: { op: not, args: [ { fn: isBlank, args: [ { var: data.companyName } ] } ] }
  severity: error

- id: customer.postal-code.format
  title: Postal code format depends on the country
  target: { entity: Customer, fields: [/postalCode, /country] }
  when: { op: not, args: [ { fn: isBlank, args: [ { var: data.postalCode } ] } ] }
  assert:
    op: if
    args:
      - { op: eq, args: [ { var: data.country }, US ] }
      - { op: matches, args: [ { var: data.postalCode }, "^[0-9]{5}(-[0-9]{4})?$" ] }
      - op: if
        args:
          - { op: eq, args: [ { var: data.country }, CA ] }
          - op: matches
            args: [ { var: data.postalCode }, "^[A-Z][0-9][A-Z] ?[0-9][A-Z][0-9]$" ]
          - op: if
            args:
              - { op: eq, args: [ { var: data.country }, IN ] }
              - { op: matches, args: [ { var: data.postalCode }, "^[1-9][0-9]{5}$" ] }
              - true
  severity: error

Customer create | data: {"accountType": "business"}
=> deny
   ONB-ENM-001 error blocking /companyName "Enter the company name for a business account."
   ONB-OBJ-003 info not blocking /addresses "Business accounts usually add a work address."
Customer create | data: {"country": "IN", "postalCode": "27502-1"}
=> deny  ONB-ENM-002 error blocking /postalCode,/country "This is not a valid postal code for IN."
Customer create | data: {"country": "GB", "postalCode": "SW1A 1AA"}
=> allow

- id: customer.dependents.whole-number
  title: Dependents is a whole number from 0 to 20
  when: { op: exists, args: [ { var: data.dependents } ] }
  assert:
    op: and
    args:
      - { op: eq, args: [ { op: mod, args: [ { var: data.dependents }, 1 ] }, 0 ] }
      - { op: between, args: [ { var: data.dependents }, 0, 20 ] }
  severity: error

Customer create | data: {"dependents": 1.5}
=> deny  ONB-NUM-001 error blocking /dependents "Dependents must be a whole number from 0 to 20."
Customer create | data: {"dependents": 21}
=> deny  ONB-NUM-001 error blocking /dependents "Dependents must be a whole number from 0 to 20."
Customer create | data: {"dependents": "2"}
=> deny
   RULE-EVALUATION-ERROR error blocking (rule customer.dependents.whole-number)
      "This rule could not be evaluated."

- id: type.money.not-negative
  title: Amounts are never negative
  target: { type: Money }
  when: { op: exists, args: [ { var: value } ] }
  assert: { op: gte, args: [ { var: value }, 0 ] }
  severity: error

- id: type.money.two-decimals
  title: Amounts have at most two decimals
  target: { type: Money }
  when: { op: eq, args: [ { op: typeOf, args: [ { var: value } ] }, number ] }
  assert: { op: eq, args: [ { op: round, args: [ { var: value }, 2 ] }, { var: value } ] }
  severity: error

- id: type.percentage.range
  title: Percentages lie between 0 and 100
  target: { type: Percentage }
  when: { op: exists, args: [ { var: value } ] }
  assert: { op: between, args: [ { var: value }, 0, 100 ] }
  severity: error

Customer create | data: {"creditLimit": -50}
=> deny  ONB-TYP-004 error blocking /creditLimit "Amounts cannot be negative."
Customer create | data: {"creditLimit": 10.005}
=> deny  ONB-TYP-005 error blocking /creditLimit "Amounts can have at most two decimals."
Customer create | data: {"discountPercent": 101}
=> deny
   ONB-TYP-006 error blocking /discountPercent "Enter a percentage from 0 to 100."
   ONB-NUM-004 info not blocking /discountPercent "Discounts above 30% are reviewed monthly."

- id: customer.marketing.needs-phone
  title: Marketing messages go to the phone number
  target: { entity: Customer, fields: [/marketingOptIn, /phone] }
  when: { op: eq, args: [ { var: data.marketingOptIn }, true ] }
  assert: { op: not, args: [ { fn: isBlank, args: [ { var: data.phone } ] } ] }
  severity: warning

Customer create | data: {"marketingOptIn": true, "phone": null}
=> allow
   ONB-BOO-002 warning not blocking /marketingOptIn,/phone
      "Add a phone number to receive offers, or switch offers off."

- id: customer.date-of-birth.format
  title: Date of birth is a calendar date
  when: { op: exists, args: [ { var: data.dateOfBirth } ] }
  assert: { fn: isIsoDate, args: [ { var: data.dateOfBirth } ] }
  severity: error

- id: customer.date-of-birth.minimum-age
  title: Customers are adults
  when: { fn: isIsoDate, args: [ { var: data.dateOfBirth } ] }
  assert:
    op: gte
    args:
      - { fn: ageOn, args: [ { var: data.dateOfBirth }, { var: ctx.now } ] }
      - { var: params.minimumAge }
  severity: error

- id: customer.date-of-birth.plausible
  title: Very old birth dates are usually typing mistakes
  when: { fn: isIsoDate, args: [ { var: data.dateOfBirth } ] }
  assert:
    op: lte
    args:
      - { fn: ageOn, args: [ { var: data.dateOfBirth }, { var: ctx.now } ] }
      - { var: params.maximumAge }
  severity: warning

Customer create | data: {"dateOfBirth": "12/04/1990"}
=> deny  ONB-DAT-001 error blocking /dateOfBirth "Enter the date of birth as YYYY-MM-DD."
Customer create | data: {"dateOfBirth": "2008-10-04"}
=> deny  ONB-DAT-002 error blocking /dateOfBirth "You must be at least 18 years old to register."
Customer create | data: {"dateOfBirth": "2008-10-03"}
=> allow
Customer create | data: {"dateOfBirth": "1900-01-01"}
=> allow  ONB-DAT-003 warning not blocking /dateOfBirth "Check the year of birth."
Customer create | data: {"dateOfBirth": "1990-02-30"}
=> deny
   RULE-EVALUATION-ERROR error blocking (rule customer.date-of-birth.minimum-age)
      "This rule could not be evaluated."
   RULE-EVALUATION-ERROR error blocking (rule customer.date-of-birth.plausible)
      "This rule could not be evaluated."

- id: customer.interests.limit
  title: A limited number of interests
  assert:
    op: lte
    args:
      - op: len
        args: [ { op: coalesce, args: [ { var: data.interests }, { op: list, args: [] } ] } ]
      - { var: params.maxInterests }
  severity: error

- id: customer.interests.no-blanks
  title: Interests are not blank
  assert: { op: none, args: [ { var: data.interests }, { fn: isBlank, args: [ { var: item } ] } ] }
  severity: error

Customer create | data: {"interests": ["a", "b", "c", " ", "e", "f"]}
=> deny
   ONB-LST-001 error blocking /interests "Choose at most 5 interests."
   ONB-LST-002 error blocking /interests "Remove the empty interest."
Customer create | data: {"interests": null}
=> allow

- id: customer.interests.known
  kind: validation
  title: Interests come from the known list
  target: { entity: Customer, page: onboarding, screen: profile, section: interests,
            component: interest-chips, field: /interests }
  operations: [create, update]
  triggers: [change, submit]
  assert:
    op: all
    args:
      - { var: data.interests }
      - { op: in, args: [ { var: item }, { var: params.knownInterests } ] }
  severity: warning
  finding:
    code: ONB-VAR-001
    message: interests.known
    args:
      unknown:
        op: filter
        args:
          - { var: data.interests }
          - op: not
            args: [ { op: in, args: [ { var: item }, { var: params.knownInterests } ] } ]

Customer create | data: {"interests": ["travel", "chess", "golf"]} | ruleset: variants
=> allow
   ONB-VAR-001 warning not blocking /interests "We do not know these interests yet: chess, golf."

- id: customer.addresses.one-primary
  title: Exactly one primary address
  when: { op: not, args: [ { op: empty, args: [ { var: data.addresses } ] } ] }
  assert:
    op: eq
    args:
      - op: len
        args:
          - op: filter
            args: [ { var: data.addresses }, { op: eq, args: [ { var: item.primary }, true ] } ]
      - 1
  severity: error

- id: customer.address.city-required
  title: Every address names a city (evaluated per element)
  target: { entity: Customer, field: /city }
  forEach: /addresses
  assert: { op: not, args: [ { fn: isBlank, args: [ { var: item.city } ] } ] }
  severity: error

- id: customer.addresses.work-address-hint
  title: Business accounts usually have a work address
  when: { op: eq, args: [ { var: data.accountType }, business ] }
  assert:
    op: some
    args: [ { var: data.addresses }, { op: eq, args: [ { var: item.kind }, work ] } ]
  severity: info

Customer create
  | data: {"addresses": [{"city": "Leeds", "primary": true}, {"city": "", "primary": true}]}
=> deny
   ONB-OBJ-001 error blocking /addresses "Mark exactly one address as primary."
   ONB-OBJ-002 error blocking /addresses/1/city "Enter the city."
Customer create | data: {"accountType": "business", "companyName": "Okafor Ltd"}
=> allow  ONB-OBJ-003 info not blocking /addresses "Business accounts usually add a work address."

- id: transfer.swift.required-international
  title: SWIFT/BIC is required for international transfers
  target: { entity: Transfer, field: /beneficiary/swiftCode }
  when: { op: eq, args: [ { var: data.type }, international ] }
  assert:
    op: and
    args:
      - { op: not, args: [ { op: empty, args: [ { var: data.beneficiary.swiftCode } ] } ] }
      - op: matches
        args: [ { var: data.beneficiary.swiftCode }, "^[A-Z]{6}[A-Z0-9]{2}([A-Z0-9]{3})?$" ]
  severity: error

- id: org.transfer.blocked-country
  title: No transfers to blocked countries
  target: { entity: Transfer, field: /beneficiary/country }
  enforcement: server
  overridePolicy: locked
  assert:
    op: not
    args:
      - { op: in, args: [ { var: data.beneficiary.country }, { var: params.blockedCountries } ] }
  severity: error

Transfer create | data: {"type": "international", "beneficiary": {"country": "ES"}}
=> deny
   PAY-TRF-002 error blocking /beneficiary/swiftCode
      "A valid SWIFT/BIC code is required for international transfers."
Transfer create | data: {"beneficiary": {"country": "KP"}}
=> deny  ORG-TRF-001 error blocking /beneficiary/country "Transfers to KP are not permitted."
Transfer create | data: {"beneficiary": {"country": "KP"}} | channel: client
=> allow

Customer create | data: {"loyaltyNumber": 79927398713}
=> deny
   RULE-EVALUATION-ERROR error blocking (rule customer.loyalty-number.check-digit)
      "This rule could not be evaluated."

entities:
  Customer:
    schema: { $ref: "./onboarding.openapi.yaml#/components/schemas/Customer" }
    fieldTypes:
      /email: Email
      /backupEmail: Email
      /phone: PhoneNumber
      /annualIncome: Money
      /creditLimit: Money
      /discountPercent: Percentage

types:
  Email: { base: string, description: An internet e-mail address. }
  PhoneNumber: { base: string, description: A phone number in E.164 format. }
  Money: { base: number, description: An amount in the account currency with at most two decimals. }
  Percentage: { base: number, description: A number from 0 to 100. }

Customer create | data: {"annualIncome": 80000.005, "creditLimit": 10.005}
=> deny
   ONB-TYP-005 error blocking /annualIncome "Amounts can have at most two decimals."
   ONB-TYP-005 error blocking /creditLimit "Amounts can have at most two decimals."

functions:
  isBlank:
    description: True for null and for strings that are empty or only spaces.
    params: [text]
    body:
      op: or
      args:
        - { op: not, args: [ { op: exists, args: [ { var: arg.text } ] } ] }
        - { op: eq, args: [ { op: trim, args: [ { var: arg.text } ] }, "" ] }
  isIsoDate:
    description: True for strings shaped like 2026-10-03.
    params: [text]
    body:
      op: and
      args:
        - { op: eq, args: [ { op: typeOf, args: [ { var: arg.text } ] }, string ] }
        - { op: matches, args: [ { var: arg.text }, "^[0-9]{4}-[0-9]{2}-[0-9]{2}$" ] }
  ageOn:
    description: Completed years between a birth date and a moment.
    params: [birthDate, moment]
    body: { op: yearsBetween, args: [ { var: arg.birthDate }, { var: arg.moment } ] }

fn isBlank ["   "]
=> true
fn isBlank [null]
=> true
fn isIsoDate ["12/04/1990"]
=> false
fn ageOn ["2008-10-04", "2026-10-03T12:00:00Z"]
=> 17
fn ageOn ["2008-10-03", "2026-10-03T12:00:00Z"]
=> 18

params:
  minimumAge:
    type: integer
    default: 18
    description: Youngest age at which a customer may register.
    overridePolicy: tighten-only
    tightenDirection: higher
  maxInterests:
    type: integer
    default: 5

params:
  maxTransferAmount:
    type: number
    default: 50000
    description: Largest single transfer without a risk acceptance.
    overridePolicy: tighten-only
    tightenDirection: lower

overrides:
  params:
    maxTransferAmount: 25000        # retail tightens the org limit of 50000

operators:
  x-luhn:
    description: True when a string of digits ends in a valid Luhn check digit.
    args: 1

- id: customer.loyalty-number.check-digit
  title: Loyalty number check digit
  when: { op: not, args: [ { fn: isBlank, args: [ { var: data.loyaltyNumber } ] } ] }
  assert: { op: x-luhn, args: [ { var: data.loyaltyNumber } ] }
  severity: error

Customer create | data: {"loyaltyNumber": "79927398713"}
=> allow
Customer create | data: {"loyaltyNumber": "79927398710"}
=> deny
   ONB-CUS-001 error blocking /loyaltyNumber "This loyalty number is not valid. Check the digits."
Customer create | data: {"loyaltyNumber": "79927398710"} | operators: none | show: detail
=> deny
   RULE-EVALUATION-ERROR error blocking (rule customer.loyalty-number.check-digit)
      "This rule could not be evaluated."
      detail: custom operator x-luhn is not registered

import { evaluate, type Operators } from '@yarlisaisolutions/rule-cascade';

const operators: Operators = {
  'x-luhn': (text) => {
    if (typeof text !== 'string' || !/^[0-9]{2,}$/.test(text)) return false;
    const digits = [...text].reverse().map(Number);
    const sum = digits.reduce(
      (total, d, i) => total + (i % 2 === 0 ? d : d * 2 > 9 ? d * 2 - 9 : d * 2), 0);
    return sum % 10 === 0;
  },
};

rules.missingOperators(operators);                        // []: check this when the host starts
rules.evaluate(request, 'server', operators);             // on the server
evaluate(rules.manifest('client'), request, operators);   // in a browser, and in the React hook

Map<String, CustomOperator> operators = Map.of(
        "x-luhn", args -> args.get(0) instanceof String digits && luhn(digits));
RuleSet rules = RuleSet.fromBundle(bundle).withOperators(operators);
List<String> missing = rules.missingOperators();   // empty: check this when the host starts
EvaluationResult result = rules.evaluate(request);

operators := rulecascade.Operators{
	"x-luhn": func(args []any) (any, error) {
		digits, ok := args[0].(string)
		return ok && luhn(digits), nil // func luhn(digits string) bool
	},
}
missing := rules.MissingOperators(operators) // empty: check this when the host starts
result, err := rules.Evaluate(request, "server", operators)

def luhn(text):
    if not isinstance(text, str) or len(text) < 2 or not all("0" <= c <= "9" for c in text):
        return False
    total = 0
    for i, c in enumerate(reversed(text)):
        d = int(c) * (2 if i % 2 else 1)
        total += d - 9 if d > 9 else d
    return total % 10 == 0


operators = {"x-luhn": luhn}                          # the arguments arrive as positional arguments
rules.missing_operators(operators)                    # []: check this when the host starts
result = rules.evaluate(request, "server", operators)

- id: customer.retention.seven-years
  kind: x-acme-retention
  title: Customer records are kept for seven years after closure
  target: { entity: Customer }
  operations: [delete]
  enforcement: server
  x-acme-keep: P7Y
  x-acme-jira: RISK-1432

- id: customer.company-name.show-for-business
  kind: state
  triggers: [load, change]
  when: { op: eq, args: [ { var: data.accountType }, business ] }
  effects:
    - field: /companyName
      set: { visible: true, required: true }

- id: customer.credit-limit.read-only-for-agents
  kind: state
  triggers: [load]
  when:
    op: not
    args:
      - op: in
        args:
          - credit-manager
          - { op: coalesce, args: [ { var: actor.roles }, { op: list, args: [] } ] }
  effects:
    - field: /creditLimit
      set: { readOnly: true }

Customer create | data: {"accountType": "business"} | channel: client | trigger: change
  | show: effects
=> allow
   effect state /companyName {"visible": true, "required": true} (customer.company-name.show-for-business)
Customer update | actor: {"id": "u-2", "roles": ["agent"]} | channel: client | trigger: load
  | show: effects
=> allow  effect state /creditLimit {"readOnly": true} (customer.credit-limit.read-only-for-agents)
Customer update | actor: {"id": "u-7", "roles": ["credit-manager"]} | channel: client
  | trigger: load | show: effects
=> allow

- id: customer.credit-limit.needs-income
  kind: state
  title: The credit limit input is disabled until the income is entered
  target: { entity: Customer, page: onboarding, screen: finance, section: credit,
            component: credit-limit-input, field: /creditLimit }
  operations: [create, update]
  triggers: [load, change]
  when: { op: not, args: [ { op: exists, args: [ { var: data.annualIncome } ] } ] }
  effects:
    - field: /creditLimit
      set: { enabled: false }

Customer create | data: {"annualIncome": null, "creditLimit": null} | ruleset: variants
  | channel: client | trigger: load | show: effects
=> allow  effect state /creditLimit {"enabled": false} (customer.credit-limit.needs-income)

- id: customer.credit-limit.change-needs-manager
  title: Only credit managers change the credit limit
  operations: [update]
  enforcement: server
  when: { op: ne, args: [ { var: data.creditLimit }, { var: original.creditLimit } ] }
  assert:
    op: in
    args:
      - credit-manager
      - { op: coalesce, args: [ { var: actor.roles }, { op: list, args: [] } ] }
  severity: error

Customer update | data: {"creditLimit": 12000} | actor: {"id": "u-2", "roles": ["agent"]}
  | channel: client | show: effects
=> allow
   effect value /displayName = "Maya Okafor" (customer.display-name.default)
   effect state /creditLimit {"readOnly": true} (customer.credit-limit.read-only-for-agents)
Customer update | data: {"creditLimit": 12000} | actor: {"id": "u-2", "roles": ["agent"]}
  | show: effects
=> deny
   ONB-UPD-003 error blocking /creditLimit "Only a credit manager can change the credit limit."
   effect value /displayName = "Maya Okafor" (customer.display-name.default)
   effect value /riskTier = "standard" (customer.risk-tier.derive)
   effect state /creditLimit {"readOnly": true} (customer.credit-limit.read-only-for-agents)

- id: customer.display-name.default
  kind: compute
  when: { op: eq, args: [ { op: typeOf, args: [ { var: data.fullName } ] }, string ] }
  assign:
    - field: /displayName
      mode: default
      value: { op: trim, args: [ { var: data.fullName } ] }

- id: transfer.fee.international
  kind: compute
  triggers: [change, submit]
  when:
    op: and
    args:
      - { op: eq, args: [ { var: data.type }, international ] }
      - { op: exists, args: [ { var: data.amount } ] }
  assign:
    - field: /fee
      mode: always
      value: { op: mul, args: [ { var: data.amount }, { var: params.internationalFeeRate } ] }

Customer create | data: {"fullName": "  Maya Okafor "} | channel: client | show: effects
=> allow  effect value /displayName = "Maya Okafor" (customer.display-name.default)
Transfer create | show: effects
  | data: {"type": "international", "amount": 500, "fee": 0,
      "beneficiary": {"swiftCode": "BSCHESMM"}}
=> allow  effect value /fee = 7.5 (transfer.fee.international)

- id: customer.country.immutable
  title: Country cannot change after registration
  operations: [update]
  enforcement: server
  assert: { op: eq, args: [ { var: data.country }, { var: original.country } ] }
  severity: error

- id: customer.email.change-notice
  title: Changing the e-mail address triggers verification
  operations: [update]
  assert: { op: eq, args: [ { var: data.email }, { var: original.email } ] }
  severity: info

- id: transfer.delete.only-draft
  title: Only draft transfers can be deleted
  operations: [delete]
  enforcement: server
  assert: { op: eq, args: [ { var: original.status }, draft ] }
  severity: error

Customer update | data: {"country": "CA", "postalCode": "K1A 0B1", "email": "new@example.com"}
=> deny
   ONB-UPD-001 error blocking /country "The country cannot be changed after registration."
   ONB-UPD-002 info not blocking /email "We will send a verification link to the new address."
Transfer delete | original: {"id": "t-1", "status": "submitted", "createdBy": "u-1"}
=> deny  PAY-TRF-006 error blocking "Only draft transfers can be deleted."
Transfer delete
=> allow

- id: transfer.approve.four-eyes
  title: The creator cannot approve their own transfer
  operations: [approve]
  enforcement: server
  assert: { op: ne, args: [ { var: actor.id }, { var: original.createdBy } ] }
  severity: error

- id: transfer.read.mask-for-non-owners
  kind: state
  title: Hide the internal risk score from non-risk staff
  operations: [read]
  when:
    op: not
    args:
      - op: in
        args:
          - risk-officer
          - { op: coalesce, args: [ { var: actor.roles }, { op: list, args: [] } ] }
  effects:
    - field: /riskScore
      set: { visible: false }

Transfer approve | actor: {"id": "u-1", "roles": ["approver"]}
=> deny  PAY-TRF-007 error blocking "You cannot approve a transfer you created."
Transfer approve | actor: {"id": "u-2", "roles": ["approver"]}
=> allow
Transfer read | data: {"riskScore": 71} | actor: {"id": "u-1", "roles": ["teller"]} | show: effects
=> allow  effect state /riskScore {"visible": false} (transfer.read.mask-for-non-owners)

Transfer aprove | actor: {"id": "u-1", "roles": ["approver"]}
=> allow

- id: transfer.created.notify-risk
  kind: action
  enforcement: server
  when:
    op: and
    args:
      - { op: exists, args: [ { var: data.amount } ] }
      - { op: gte, args: [ { var: data.amount }, { var: params.largeTransferThreshold } ] }
  commands:
    - name: risk.large-transfer-created
      type: event
      ref: com.acme.payments.transfer.large.v1
      payload:
        transferId: { var: data.id }
        amount: { var: data.amount }
      idempotencyKey: [ large-transfer, { var: data.id } ]

Transfer create | data: {"amount": 12000} | show: commands
=> deny
   PAY-TRF-003 warning blocking /amount,/beneficiary/name (may acknowledge)
      "This is a large transfer to Jo Lee. Please confirm the details."
   no commands
Transfer create | data: {"amount": 12000} | show: commands
  | resolutions: [{"rule": "transfer.large.review-warning", "type": "acknowledge"}]
=> allow
   PAY-TRF-003 warning not blocking acknowledged /amount,/beneficiary/name
      "This is a large transfer to Jo Lee. Please confirm the details."
   command risk.large-transfer-created key=large-transfer:t-1 payload={"transferId": "t-1", "amount": 12000}

- name: "number: a credit manager accepts a limit over the ceiling with a justification"
  entity: Customer
  operation: update
  given:
    data:
      fullName: Maya Okafor
      email: a@b.co
      country: GB
      annualIncome: 200000
      creditLimit: 60000
    original: { email: a@b.co, country: GB }
    actor: { id: u-7, roles: [credit-manager] }
    resolutions:
      - rule: customer.credit-limit.ceiling
        type: accept-risk
        justification: long-standing client
  expect:
    decision: allow
    findings:
      - { rule: customer.credit-limit.ceiling, severity: error, status: accepted, blocking: false }
    effects:
      - { type: value, field: /riskTier, value: review }