temporalio-workflow 0.5.0

Temporal Rust workflow authoring surface
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

package temporal:workflow-runtime@0.1.0;

interface types {
type payload = list<u8>;

type workflow-command = list<u8>;

type failure = list<u8>;

type workflow-task-failed-cause = u32;

record workflow-init {
  namespace: string,
  task-queue: string,
  run-id: string,
  initialize-workflow: list<u8>,
}

record workflow-definition {
  workflow-type: string,
  has-init: bool,
  init-takes-input: bool,
  signals: list<string>,
  queries: list<string>,
  updates: list<update-definition>,
}

record update-definition {
  name: string,
  has-validator: bool,
}

record query-response {
  response: result<payload, failure>,
}

type routine-id = u64;

type workflow-activation = list<u8>;

variant routine-kind {
  main,
  signal(string),
  update(update-routine-kind),
}

record update-routine-kind {
  name: string,
  update-id: string,
  protocol-instance-id: string,
}

record started-routine {
  routine-id: routine-id,
  kind: routine-kind,
}

variant activation-job-result {
  none,
  started-routine(started-routine),
  query-response(query-response),
  update-rejected(failure),
}

record activation-result {
  job-results: list<activation-job-result>,
}

type continue-as-new-request = list<u8>;

record task-failure {
  failure: failure,
  force-cause: option<workflow-task-failed-cause>,
}

variant terminal-outcome {
  completed(payload),
  failed(failure),
  cancelled,
  continue-as-new(continue-as-new-request),
}

variant main-routine-completion {
  blocked,
  task-failed(task-failure),
  terminal(terminal-outcome),
}

variant update-routine-completion {
  completed(update-routine-success),
  rejected(update-routine-rejection),
}

record update-routine-success {
  protocol-instance-id: string,
  value: payload,
}

record update-routine-rejection {
  protocol-instance-id: string,
  failure: failure,
}

variant signal-routine-completion {
  succeeded,
  failed(failure),
}

variant routine-completion {
  main(main-routine-completion),
  signal(signal-routine-completion),
  update(update-routine-completion),
}

record routine-poll-result {
  completion: option<routine-completion>,
  made-progress: bool,
}
}