i2y/ritsu/dandori

workflow review v1
description "Jev scores an application and says how sure it is, and a rule decides whether the verdict is acted on at once or goes to a person for approval, due by 17:00 on the third business day after it comes in: approving at once asks more certainty than rejecting at once. Written for Temporal: the scoring is an activity dandori writes, which calls Jev with TypeSafe's key (TYPESAFE_API_KEY) on the workers of its own task queue, which may be written in another language, and so does the notice, an activity you write; the rule and the date of the approval run in the worker of the workflow; the approver's tool answers the callback by the update the generated client sends"
 
use rule policy from "../rules/review_policy.rule"
use dates approvals from "../dates/approval_terms.cal"
 
record Application
  id      : string
  amount  : int
  purpose : string
 
record Score
  verdict : policy.verdict
  sure    : rate[step 1%]  range >=0 <=100
 
record Approval
  approver : string
 
inputs
  application : Application
 
outputs
  verdict : policy.verdict
 
# Jev places what the applicant wrote on the scale of verdicts, from the lowest level, and how
# sure it is of the verdict comes as a rate, for the rule to weigh.
task score(purpose: string) -> Score
  jev
    verdict score "How clearly is the money for running the business?"
      reject "It is for something personal or speculative, or against the law"
      hold "It is for the business, but the statement leaves unclear what it pays for"
      approve "It pays for a named part of running the business, such as stock, equipment, staff or premises"
    sure confidence of verdict
  model "jev-1.13.0"
  queue "scoring"
  errors busy = 429, overloaded = 529
  retry 2 times every 10 seconds on busy, overloaded
  timeout 10 seconds
 
# Someone approves in a tool of their own, and the answer comes back with the callback's id. The
# approver is told when the approval is due, and the wait ends then.
task ask_for_approval(application_id: string, amount: int, sure: rate[step 1%], by: timestamp) -> Approval
  callback
  timeout until by
 
task notify(application_id: string, text: string)
  queue "notify"
  idempotent
 
flow
  let r = score(purpose: application.purpose)
    on failure => fail Unscorable "Could not score application {application.id}"
  let d = policy(verdict: r.verdict, sure: r.sure)
  match d.decision
    approve, reject => pass
    ask =>
      let due = approvals.due(received: now)
      let a = ask_for_approval(application_id: application.id, amount: application.amount, sure: r.sure, by: due.at)
        on timeout => fail NoAnswer "No approval by 17:00 on the third business day"
      notify(application_id: application.id, text: "{a.approver} approved application {application.id}")
      succeed verdict = approve
  notify(application_id: application.id, text: "Application {application.id} was reviewed: {r.verdict}")
  succeed verdict = r.verdict

workflow <name> v<N> [implements <api>.<Service>]
                                          the name and version (on Temporal, both are in the
                                          workflow type and the task queue: review_v1); with
                                          implements, the workflow is the service of a .proto
                                          read by use proto (services.md)
description "<text>"
kind standard | express                   Step Functions; an Express workflow has limits (E031)
use rule <name> from "<file.rule>"        a rulec rule, read by rulec; under it,
                                          lambda "<function>" (Step Functions, durable functions)
                                          or connect "<url>" (the rule's Connect service, which
                                          every platform calls; Step Functions also needs
                                          connection "<EventBridge connection>"),
                                          and local (a local activity on Temporal). A rule that
                                          walks a list cannot be used (E005), nor one with an
                                          input or an output that may be none (T?). An enums
                                          file has no outputs: its enums are types
                                          (<name>.<enum>), and a call of it is E005
use openapi|smithy|proto <name> from "<file>"   an API description; under it, url "<base>"
                                          (a proto needs one to `connect` to it)
use dates <name> from "<file.cal>"        a dates file of koyomi's; each date is called like a
                                          rule, <name>.<date>(<input>: …), and answers {day, at};
                                          under it, lambda "<function>" and local, as for a rule
use book <name> from "<file.book>"        a book of chobo's, whose transfers tasks run operations
                                          on; under it, lambda "<function>" (Step Functions)
enum <Name> = <value> | <value> | …
record <Name>                             then one field a line, <name> : <type>
inputs, outputs                           the same, for what a run takes and gives back
task <name>(<param>: <type>, …) [-> <type>]
case <name> : <Record> follows <rule>.<machine>
case <name> : <book>.<transfer> follows <book>.<transfer>    a hold of a book, as a case
flow                                      the steps
on failure                                runs when a task fails and nothing handled it, then the
                                          run fails with the same error
on cancel                                 runs when the workflow is cancelled (Temporal only)