@voltro/workflow 0.69.0 → 0.70.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +168 -0
- package/dist/cluster-CSycI4sz.js +329 -0
- package/dist/cluster.d.ts +101 -1
- package/dist/cluster.js +2 -2
- package/dist/clusterDiagnostics-CNtl5LX9.js +20 -0
- package/dist/clusterTestSuite.js +2 -2
- package/dist/index.d.ts +141 -5
- package/dist/index.js +3 -2
- package/dist/{src-Dj8r1Kcn.js → src-TRpoU54e.js} +337 -312
- package/package.json +4 -4
- package/dist/cluster-OUXsLZ2x.js +0 -177
|
@@ -2,15 +2,15 @@ import { E as e, F as t, I as n, M as r, N as i, P as a, T as o, w as s } from "
|
|
|
2
2
|
import { Activity as c, DurableClock as l, DurableDeferred as u, Workflow as d, WorkflowEngine as f } from "@effect/workflow";
|
|
3
3
|
import { Cause as p, Effect as m, Either as h, Exit as g, FiberRef as _, Layer as v, Schema as y } from "effect";
|
|
4
4
|
import { publishServerError as ee } from "@voltro/protocol";
|
|
5
|
-
import { and as b, boolean as te, eq as x, generateId as S, gt as C, gte as ne, id as w, inSet as re, integer as T, isNull as E, json as D, lt as O, or as ie, queryFor as k, reference as
|
|
6
|
-
import { createHash as
|
|
7
|
-
import { WorkflowInstance as
|
|
5
|
+
import { and as b, boolean as te, eq as x, generateId as S, gt as C, gte as ne, id as w, inSet as re, integer as T, isNull as E, json as D, lt as O, or as ie, queryFor as k, reference as ae, registerRetention as oe, retentionTtlMsFromEnv as se, table as A, text as j, timestamp as M } from "@voltro/database";
|
|
6
|
+
import { createHash as ce } from "node:crypto";
|
|
7
|
+
import { WorkflowInstance as le } from "@effect/workflow/WorkflowEngine";
|
|
8
8
|
//#region src/inMemoryLayer.ts
|
|
9
|
-
var
|
|
9
|
+
var ue = f.layerMemory, de = A("_voltro_workflow_runs", {
|
|
10
10
|
id: w({ prefix: "wfrun" }),
|
|
11
|
-
tag:
|
|
12
|
-
executionId:
|
|
13
|
-
status:
|
|
11
|
+
tag: j(),
|
|
12
|
+
executionId: j().unique(),
|
|
13
|
+
status: j().oneOf([
|
|
14
14
|
"running",
|
|
15
15
|
"succeeded",
|
|
16
16
|
"failed",
|
|
@@ -18,37 +18,37 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
18
18
|
"suspended"
|
|
19
19
|
]).default("running"),
|
|
20
20
|
payload: D(),
|
|
21
|
-
workflowVersion:
|
|
21
|
+
workflowVersion: j().nullable(),
|
|
22
22
|
workflowPatches: D().nullable(),
|
|
23
|
-
runnerEnteredAt:
|
|
23
|
+
runnerEnteredAt: M().nullable(),
|
|
24
24
|
reclaimCount: T().default(0),
|
|
25
25
|
output: D().nullable(),
|
|
26
26
|
subject: D().nullable(),
|
|
27
|
-
source:
|
|
28
|
-
errorTag:
|
|
29
|
-
errorMessage:
|
|
27
|
+
source: j().nullable(),
|
|
28
|
+
errorTag: j().nullable(),
|
|
29
|
+
errorMessage: j().nullable(),
|
|
30
30
|
cancelled: te().default(!1),
|
|
31
|
-
discardedAt:
|
|
32
|
-
discardedBy:
|
|
33
|
-
startedAt:
|
|
34
|
-
completedAt:
|
|
31
|
+
discardedAt: M().nullable(),
|
|
32
|
+
discardedBy: j().nullable(),
|
|
33
|
+
startedAt: M().default("now"),
|
|
34
|
+
completedAt: M().nullable(),
|
|
35
35
|
durationMs: T().nullable(),
|
|
36
|
-
traceId:
|
|
37
|
-
parentExecutionId:
|
|
38
|
-
parentClosePolicy:
|
|
36
|
+
traceId: j().nullable(),
|
|
37
|
+
parentExecutionId: j().nullable(),
|
|
38
|
+
parentClosePolicy: j().oneOf([
|
|
39
39
|
"cancel",
|
|
40
40
|
"terminate",
|
|
41
41
|
"abandon"
|
|
42
42
|
]).nullable()
|
|
43
|
-
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]),
|
|
43
|
+
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), fe = A("_voltro_workflow_run_steps", {
|
|
44
44
|
id: w({ prefix: "wfstep" }),
|
|
45
|
-
runId:
|
|
45
|
+
runId: ae(() => de, {
|
|
46
46
|
index: !1,
|
|
47
47
|
onDelete: "cascade"
|
|
48
48
|
}),
|
|
49
|
-
stepName:
|
|
49
|
+
stepName: j(),
|
|
50
50
|
attempt: T().default(1),
|
|
51
|
-
status:
|
|
51
|
+
status: j().oneOf([
|
|
52
52
|
"running",
|
|
53
53
|
"succeeded",
|
|
54
54
|
"failed"
|
|
@@ -56,43 +56,43 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
56
56
|
input: D().nullable(),
|
|
57
57
|
retryPolicy: D().nullable(),
|
|
58
58
|
output: D().nullable(),
|
|
59
|
-
errorTag:
|
|
60
|
-
errorMessage:
|
|
59
|
+
errorTag: j().nullable(),
|
|
60
|
+
errorMessage: j().nullable(),
|
|
61
61
|
errorCause: D().nullable(),
|
|
62
|
-
startedAt:
|
|
63
|
-
completedAt:
|
|
62
|
+
startedAt: M().default("now"),
|
|
63
|
+
completedAt: M().nullable(),
|
|
64
64
|
durationMs: T().nullable()
|
|
65
|
-
}).index(["runId", "stepName"]).index(["startedAt"]),
|
|
65
|
+
}).index(["runId", "stepName"]).index(["startedAt"]), pe = A("_voltro_workflow_run_events", {
|
|
66
66
|
id: w({ prefix: "wfev" }),
|
|
67
|
-
runId:
|
|
67
|
+
runId: ae(() => de, {
|
|
68
68
|
index: !1,
|
|
69
69
|
onDelete: "cascade"
|
|
70
70
|
}),
|
|
71
|
-
eventType:
|
|
71
|
+
eventType: j(),
|
|
72
72
|
payload: D().nullable(),
|
|
73
|
-
occurredAt:
|
|
74
|
-
stepName:
|
|
73
|
+
occurredAt: M().default("now"),
|
|
74
|
+
stepName: j().nullable(),
|
|
75
75
|
attempt: T().nullable()
|
|
76
|
-
}).index(["runId", "occurredAt"]).index(["eventType"]),
|
|
76
|
+
}).index(["runId", "occurredAt"]).index(["eventType"]), me = A("_voltro_workflow_start_contexts", {
|
|
77
77
|
id: w({ prefix: "wfctx" }),
|
|
78
|
-
workflowName:
|
|
79
|
-
executionId:
|
|
78
|
+
workflowName: j(),
|
|
79
|
+
executionId: j().unique(),
|
|
80
80
|
subject: D().nullable(),
|
|
81
|
-
traceId:
|
|
82
|
-
source:
|
|
83
|
-
parentExecutionId:
|
|
84
|
-
parentClosePolicy:
|
|
81
|
+
traceId: j().nullable(),
|
|
82
|
+
source: j().nullable(),
|
|
83
|
+
parentExecutionId: j().nullable(),
|
|
84
|
+
parentClosePolicy: j().oneOf([
|
|
85
85
|
"cancel",
|
|
86
86
|
"terminate",
|
|
87
87
|
"abandon"
|
|
88
88
|
]).nullable(),
|
|
89
|
-
createdAt:
|
|
90
|
-
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]),
|
|
89
|
+
createdAt: M().default("now")
|
|
90
|
+
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), he = A("_voltro_workflow_pending", {
|
|
91
91
|
id: w({ prefix: "wfp" }),
|
|
92
|
-
tenantId:
|
|
93
|
-
workflowName:
|
|
94
|
-
controlKey:
|
|
95
|
-
mode:
|
|
92
|
+
tenantId: j().nullable(),
|
|
93
|
+
workflowName: j(),
|
|
94
|
+
controlKey: j(),
|
|
95
|
+
mode: j().oneOf([
|
|
96
96
|
"debounce",
|
|
97
97
|
"batch",
|
|
98
98
|
"throttle",
|
|
@@ -102,22 +102,22 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
102
102
|
]),
|
|
103
103
|
payload: D(),
|
|
104
104
|
callerContext: D().nullable(),
|
|
105
|
-
queuedAppVersion:
|
|
106
|
-
queuedSchemaFingerprint:
|
|
105
|
+
queuedAppVersion: j().nullable(),
|
|
106
|
+
queuedSchemaFingerprint: j().nullable(),
|
|
107
107
|
priority: T().default(0),
|
|
108
|
-
dueAt:
|
|
109
|
-
deadlineAt:
|
|
108
|
+
dueAt: M(),
|
|
109
|
+
deadlineAt: M().nullable(),
|
|
110
110
|
collapsed: T().default(1),
|
|
111
|
-
firstSeenAt:
|
|
112
|
-
updatedAt:
|
|
111
|
+
firstSeenAt: M().default("now"),
|
|
112
|
+
updatedAt: M().default("now"),
|
|
113
113
|
attempts: T().default(0),
|
|
114
|
-
lastError:
|
|
115
|
-
deadLetteredAt:
|
|
116
|
-
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]),
|
|
114
|
+
lastError: j().nullable(),
|
|
115
|
+
deadLetteredAt: M().nullable()
|
|
116
|
+
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), ge = A("_voltro_workflow_admissions", {
|
|
117
117
|
id: w({ prefix: "wfadm" }),
|
|
118
|
-
tenantId:
|
|
119
|
-
workflowName:
|
|
120
|
-
outcome:
|
|
118
|
+
tenantId: j().nullable(),
|
|
119
|
+
workflowName: j(),
|
|
120
|
+
outcome: j().oneOf([
|
|
121
121
|
"admitted",
|
|
122
122
|
"dropped",
|
|
123
123
|
"skipped",
|
|
@@ -125,61 +125,61 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
125
125
|
"expired",
|
|
126
126
|
"discarded"
|
|
127
127
|
]),
|
|
128
|
-
mode:
|
|
129
|
-
reason:
|
|
128
|
+
mode: j().nullable(),
|
|
129
|
+
reason: j().nullable(),
|
|
130
130
|
collapsed: T().default(1),
|
|
131
131
|
waitedMs: T().nullable(),
|
|
132
|
-
executionId:
|
|
133
|
-
runId:
|
|
134
|
-
singletonKey:
|
|
135
|
-
concurrencyKey:
|
|
136
|
-
rateKey:
|
|
137
|
-
admittedAt:
|
|
138
|
-
expiresAt:
|
|
139
|
-
releasedAt:
|
|
140
|
-
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]),
|
|
132
|
+
executionId: j().nullable(),
|
|
133
|
+
runId: j().nullable(),
|
|
134
|
+
singletonKey: j().nullable(),
|
|
135
|
+
concurrencyKey: j().nullable(),
|
|
136
|
+
rateKey: j().nullable(),
|
|
137
|
+
admittedAt: M().default("now"),
|
|
138
|
+
expiresAt: M().nullable(),
|
|
139
|
+
releasedAt: M().nullable()
|
|
140
|
+
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), _e = A("_voltro_workflow_pauses", {
|
|
141
141
|
id: w({ prefix: "wfpause" }),
|
|
142
|
-
pausedAt:
|
|
143
|
-
pausedBy:
|
|
144
|
-
reason:
|
|
145
|
-
}),
|
|
142
|
+
pausedAt: M().default("now"),
|
|
143
|
+
pausedBy: j().nullable(),
|
|
144
|
+
reason: j().nullable()
|
|
145
|
+
}), ve = class extends Error {
|
|
146
146
|
workflowName;
|
|
147
147
|
field;
|
|
148
148
|
constructor(e, t, n) {
|
|
149
149
|
super(`workflow '${e}': ${t}(payload) threw — a flow-control key function must be total over every payload the workflow accepts, because it runs before the run exists and there is nowhere to report a partial failure to. Cause: ${n instanceof Error ? n.message : String(n)}`), this.name = "FlowControlKeyError", this.workflowName = e, this.field = t, this.cause = n;
|
|
150
150
|
}
|
|
151
|
-
},
|
|
151
|
+
}, N = (e, t, n, r) => {
|
|
152
152
|
try {
|
|
153
153
|
let e = n(r);
|
|
154
154
|
if (typeof e != "string" || e.length === 0) throw Error(`returned ${e === "" ? "an empty string" : String(e)}; expected a non-empty string`);
|
|
155
155
|
return e;
|
|
156
156
|
} catch (n) {
|
|
157
|
-
throw new
|
|
157
|
+
throw new ve(e, t, n);
|
|
158
158
|
}
|
|
159
|
-
},
|
|
159
|
+
}, ye = (e, t) => e === void 0 ? t : `pool\u0000${e}\u0000${t}`, P = (e, t) => {
|
|
160
160
|
let n = e.workflowName, r = 0;
|
|
161
161
|
if (e.priority !== void 0) try {
|
|
162
162
|
let n = e.priority(t);
|
|
163
163
|
if (!Number.isFinite(n)) throw Error(`returned ${String(n)}; expected a finite number`);
|
|
164
164
|
r = Math.trunc(n);
|
|
165
165
|
} catch (e) {
|
|
166
|
-
throw new
|
|
166
|
+
throw new ve(n, "priority", e);
|
|
167
167
|
}
|
|
168
168
|
return {
|
|
169
|
-
...e.debounce === void 0 ? {} : { debounceKey:
|
|
170
|
-
...e.singleton === void 0 ? {} : { singletonKey:
|
|
171
|
-
...e.concurrency === void 0 ? {} : { concurrencyKey:
|
|
172
|
-
...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey:
|
|
173
|
-
...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey:
|
|
174
|
-
...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey:
|
|
169
|
+
...e.debounce === void 0 ? {} : { debounceKey: N(n, "debounce.key", e.debounce.key, t) },
|
|
170
|
+
...e.singleton === void 0 ? {} : { singletonKey: N(n, "singleton.key", e.singleton.key, t) },
|
|
171
|
+
...e.concurrency === void 0 ? {} : { concurrencyKey: ye(e.concurrency.pool, e.concurrency.key === void 0 ? "" : N(n, "concurrency.key", e.concurrency.key, t)) },
|
|
172
|
+
...e.throttle?.key === void 0 ? e.throttle === void 0 ? {} : { throttleKey: "" } : { throttleKey: N(n, "throttle.key", e.throttle.key, t) },
|
|
173
|
+
...e.rateLimit?.key === void 0 ? e.rateLimit === void 0 ? {} : { rateLimitKey: "" } : { rateLimitKey: N(n, "rateLimit.key", e.rateLimit.key, t) },
|
|
174
|
+
...e.batch?.key === void 0 ? e.batch === void 0 ? {} : { batchKey: "" } : { batchKey: N(n, "batch.key", e.batch.key, t) },
|
|
175
175
|
priority: r
|
|
176
176
|
};
|
|
177
|
-
},
|
|
177
|
+
}, be = (e, t, n, r) => {
|
|
178
178
|
let i = e.filter((e) => e > r - n);
|
|
179
179
|
if (i.length < t) return;
|
|
180
180
|
let a = [...i].sort((e, t) => t - e)[t - 1];
|
|
181
181
|
if (a !== void 0) return a + n;
|
|
182
|
-
},
|
|
182
|
+
}, xe = (e) => {
|
|
183
183
|
let { control: t, keys: n, state: r, now: i, reconsidering: a } = e;
|
|
184
184
|
if (r.paused === !0) return {
|
|
185
185
|
kind: "defer",
|
|
@@ -189,7 +189,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
189
189
|
keys: n
|
|
190
190
|
};
|
|
191
191
|
if (t.rateLimit !== void 0) {
|
|
192
|
-
let e =
|
|
192
|
+
let e = be(r.recentAdmissions ?? [], t.rateLimit.limit, t.rateLimit.periodMs, i);
|
|
193
193
|
if (e !== void 0) return {
|
|
194
194
|
kind: "drop",
|
|
195
195
|
reason: "rate-limit",
|
|
@@ -208,12 +208,12 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
208
208
|
kind: "admit",
|
|
209
209
|
reason: "debounce-deadline",
|
|
210
210
|
keys: n,
|
|
211
|
-
...
|
|
211
|
+
...F(t, r)
|
|
212
212
|
} : {
|
|
213
213
|
kind: "admit",
|
|
214
214
|
reason: "debounce-elapsed",
|
|
215
215
|
keys: n,
|
|
216
|
-
...
|
|
216
|
+
...F(t, r)
|
|
217
217
|
} : {
|
|
218
218
|
kind: "defer",
|
|
219
219
|
mode: "debounce",
|
|
@@ -229,12 +229,12 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
229
229
|
kind: "admit",
|
|
230
230
|
reason: "batch-full",
|
|
231
231
|
keys: n,
|
|
232
|
-
...
|
|
232
|
+
...F(t, r)
|
|
233
233
|
} : a && i >= s ? {
|
|
234
234
|
kind: "admit",
|
|
235
235
|
reason: "batch-timeout",
|
|
236
236
|
keys: n,
|
|
237
|
-
...
|
|
237
|
+
...F(t, r)
|
|
238
238
|
} : {
|
|
239
239
|
kind: "defer",
|
|
240
240
|
mode: "batch",
|
|
@@ -244,7 +244,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
244
244
|
};
|
|
245
245
|
}
|
|
246
246
|
if (t.throttle !== void 0) {
|
|
247
|
-
let e =
|
|
247
|
+
let e = be(r.recentAdmissions ?? [], t.throttle.limit, t.throttle.periodMs, i);
|
|
248
248
|
if (e !== void 0) return {
|
|
249
249
|
kind: "defer",
|
|
250
250
|
mode: "throttle",
|
|
@@ -261,25 +261,25 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
261
261
|
keys: n
|
|
262
262
|
} : {
|
|
263
263
|
kind: "admit",
|
|
264
|
-
reason:
|
|
264
|
+
reason: Se(t) ? "under-limits" : "no-controls",
|
|
265
265
|
keys: n,
|
|
266
|
-
...
|
|
266
|
+
...F(t, r)
|
|
267
267
|
};
|
|
268
|
-
},
|
|
268
|
+
}, Se = (e) => e.debounce !== void 0 || e.singleton !== void 0 || e.concurrency !== void 0 || e.throttle !== void 0 || e.rateLimit !== void 0 || e.batch !== void 0, F = (e, t) => e.singleton?.mode === "cancel" && t.singletonHolder !== void 0 ? { evict: t.singletonHolder } : {}, Ce = (e, t, n) => {
|
|
269
269
|
let r = e.timeouts?.startMs;
|
|
270
270
|
return r !== void 0 && n - t.firstSeenAt >= r;
|
|
271
|
-
},
|
|
271
|
+
}, we = (e, t, n) => {
|
|
272
272
|
let r = e.timeouts?.finishMs;
|
|
273
273
|
return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
|
|
274
|
-
},
|
|
274
|
+
}, Te = (e, t) => e.priority === t.priority ? e.firstSeenAt === t.firstSeenAt ? e.id < t.id ? -1 : +(e.id > t.id) : e.firstSeenAt - t.firstSeenAt : t.priority - e.priority, I = "_voltro_workflow_pending", L = "_voltro_workflow_admissions", Ee = "_voltro_workflow_pauses", De = 864e5, Oe = (e, t, n) => `wfp_${ce("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, R = (e) => {
|
|
275
275
|
if (e instanceof Date) return e.getTime();
|
|
276
276
|
if (typeof e == "number") return e;
|
|
277
277
|
let t = Date.parse(String(e));
|
|
278
278
|
return Number.isNaN(t) ? 0 : t;
|
|
279
|
-
},
|
|
279
|
+
}, z = (e, t) => {
|
|
280
280
|
let n = typeof e == "number" ? e : Number(e);
|
|
281
281
|
return Number.isFinite(n) ? Math.trunc(n) : t;
|
|
282
|
-
},
|
|
282
|
+
}, ke = (e) => ({
|
|
283
283
|
id: String(e.id),
|
|
284
284
|
tenantId: e.tenantId === null || e.tenantId === void 0 ? null : String(e.tenantId),
|
|
285
285
|
workflowName: String(e.workflowName),
|
|
@@ -289,26 +289,26 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
289
289
|
callerContext: e.callerContext ?? null,
|
|
290
290
|
queuedAppVersion: e.queuedAppVersion === null || e.queuedAppVersion === void 0 ? null : String(e.queuedAppVersion),
|
|
291
291
|
queuedSchemaFingerprint: e.queuedSchemaFingerprint === null || e.queuedSchemaFingerprint === void 0 ? null : String(e.queuedSchemaFingerprint),
|
|
292
|
-
priority:
|
|
293
|
-
dueAt:
|
|
294
|
-
deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 :
|
|
295
|
-
collapsed:
|
|
296
|
-
firstSeenAt:
|
|
297
|
-
attempts:
|
|
292
|
+
priority: z(e.priority, 0),
|
|
293
|
+
dueAt: R(e.dueAt),
|
|
294
|
+
deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : R(e.deadlineAt),
|
|
295
|
+
collapsed: z(e.collapsed, 1),
|
|
296
|
+
firstSeenAt: R(e.firstSeenAt),
|
|
297
|
+
attempts: z(e.attempts, 0),
|
|
298
298
|
lastError: e.lastError === null || e.lastError === void 0 ? null : String(e.lastError),
|
|
299
|
-
deadLetteredAt: e.deadLetteredAt === null || e.deadLetteredAt === void 0 ? void 0 :
|
|
300
|
-
}),
|
|
299
|
+
deadLetteredAt: e.deadLetteredAt === null || e.deadLetteredAt === void 0 ? void 0 : R(e.deadLetteredAt)
|
|
300
|
+
}), B = (e, t, n, r) => ({
|
|
301
301
|
table: e,
|
|
302
302
|
predicate: t,
|
|
303
303
|
order: n,
|
|
304
304
|
take: r,
|
|
305
305
|
skip: void 0,
|
|
306
306
|
projection: void 0
|
|
307
|
-
}),
|
|
308
|
-
let t = await e.query(
|
|
307
|
+
}), Ae = async (e) => {
|
|
308
|
+
let t = await e.query(B(Ee, void 0, [], 1e3));
|
|
309
309
|
return new Set(t.map((e) => String(e.id)));
|
|
310
|
-
},
|
|
311
|
-
await e.upsert(
|
|
310
|
+
}, je = async (e, t, n, r) => {
|
|
311
|
+
await e.upsert(Ee, {
|
|
312
312
|
id: t,
|
|
313
313
|
pausedAt: /* @__PURE__ */ new Date(),
|
|
314
314
|
pausedBy: n,
|
|
@@ -321,43 +321,43 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
321
321
|
"reason"
|
|
322
322
|
]
|
|
323
323
|
});
|
|
324
|
-
},
|
|
324
|
+
}, Me = async (e, t) => e.delete(Ee, t), Ne = async (e) => {
|
|
325
325
|
let { store: t, control: n, keys: r, now: i } = e, a = { paused: e.paused }, o = [];
|
|
326
326
|
n.debounce !== void 0 && r.debounceKey !== void 0 && o.push((async () => {
|
|
327
|
-
let e = (await t.query(
|
|
327
|
+
let e = (await t.query(B(I, b(x("workflowName", n.workflowName), x("controlKey", r.debounceKey), x("mode", "debounce")), [], 1)))[0];
|
|
328
328
|
if (e === void 0) return;
|
|
329
|
-
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 :
|
|
329
|
+
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : R(e.deadlineAt);
|
|
330
330
|
a.debouncePending = {
|
|
331
|
-
firstSeenAt:
|
|
332
|
-
collapsed:
|
|
331
|
+
firstSeenAt: R(e.firstSeenAt),
|
|
332
|
+
collapsed: z(e.collapsed, 1),
|
|
333
333
|
...i === void 0 ? {} : { deadlineAt: i }
|
|
334
334
|
};
|
|
335
335
|
})()), n.batch !== void 0 && r.batchKey !== void 0 && o.push((async () => {
|
|
336
|
-
let e = await t.query(
|
|
336
|
+
let e = await t.query(B(I, b(x("workflowName", n.workflowName), x("controlKey", r.batchKey), x("mode", "batch")), [{
|
|
337
337
|
column: "firstSeenAt",
|
|
338
338
|
direction: "asc"
|
|
339
339
|
}], n.batch.maxSize + 1));
|
|
340
340
|
e.length !== 0 && (a.batchPending = {
|
|
341
341
|
count: e.length,
|
|
342
|
-
firstSeenAt:
|
|
342
|
+
firstSeenAt: R(e[0].firstSeenAt)
|
|
343
343
|
});
|
|
344
344
|
})()), n.singleton !== void 0 && r.singletonKey !== void 0 && o.push((async () => {
|
|
345
|
-
let e = await
|
|
345
|
+
let e = await Pe(t, n.workflowName, r.singletonKey, i);
|
|
346
346
|
e !== void 0 && (a.singletonHolder = e);
|
|
347
347
|
})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && o.push((async () => {
|
|
348
|
-
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(
|
|
348
|
+
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(B(L, b(...e, x("concurrencyKey", r.concurrencyKey), E("releasedAt"), C("expiresAt", new Date(i))), [], n.concurrency.limit));
|
|
349
349
|
a.inFlight = o.length;
|
|
350
350
|
})());
|
|
351
351
|
let s = n.rateLimit ?? n.throttle, c = r.rateLimitKey ?? r.throttleKey;
|
|
352
352
|
return s !== void 0 && c !== void 0 && o.push((async () => {
|
|
353
|
-
let e = await t.query(
|
|
353
|
+
let e = await t.query(B(L, b(x("workflowName", n.workflowName), x("rateKey", c), x("outcome", "admitted"), C("admittedAt", new Date(i - s.periodMs))), [{
|
|
354
354
|
column: "admittedAt",
|
|
355
355
|
direction: "desc"
|
|
356
356
|
}], s.limit));
|
|
357
|
-
a.recentAdmissions = e.map((e) =>
|
|
357
|
+
a.recentAdmissions = e.map((e) => R(e.admittedAt));
|
|
358
358
|
})()), await Promise.all(o), a;
|
|
359
|
-
},
|
|
360
|
-
let i = (await e.query(
|
|
359
|
+
}, Pe = async (e, t, n, r) => {
|
|
360
|
+
let i = (await e.query(B(L, b(x("workflowName", t), x("singletonKey", n), E("releasedAt"), C("expiresAt", new Date(r))), [{
|
|
361
361
|
column: "admittedAt",
|
|
362
362
|
direction: "desc"
|
|
363
363
|
}], 1)))[0];
|
|
@@ -366,20 +366,20 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
366
366
|
if (a != null) return {
|
|
367
367
|
executionId: String(a),
|
|
368
368
|
runId: i.runId === null || i.runId === void 0 ? "" : String(i.runId),
|
|
369
|
-
admittedAt:
|
|
369
|
+
admittedAt: R(i.admittedAt)
|
|
370
370
|
};
|
|
371
|
-
},
|
|
372
|
-
let { store: t, control: n, decision: r, now: i } = e, a =
|
|
371
|
+
}, Fe = async (e) => {
|
|
372
|
+
let { store: t, control: n, decision: r, now: i } = e, a = Le(r.mode, r.keys);
|
|
373
373
|
if (r.collapse === "hold") {
|
|
374
|
-
let o = e.existingId ??
|
|
375
|
-
return await t.update(
|
|
374
|
+
let o = e.existingId ?? Oe(n.workflowName, r.mode, a);
|
|
375
|
+
return await t.update(I, o, {
|
|
376
376
|
dueAt: new Date(r.dueAt),
|
|
377
377
|
updatedAt: new Date(i)
|
|
378
378
|
}), o;
|
|
379
379
|
}
|
|
380
380
|
if (r.collapse === "replace") {
|
|
381
|
-
let o =
|
|
382
|
-
return await t.upsert(
|
|
381
|
+
let o = Oe(n.workflowName, r.mode, a);
|
|
382
|
+
return await t.upsert(I, {
|
|
383
383
|
id: o,
|
|
384
384
|
tenantId: e.tenantId,
|
|
385
385
|
workflowName: n.workflowName,
|
|
@@ -408,7 +408,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
408
408
|
priority: r.keys.priority,
|
|
409
409
|
dueAt: new Date(r.dueAt),
|
|
410
410
|
deadlineAt: r.deadlineAt === void 0 ? t.deadlineAt ?? null : new Date(r.deadlineAt),
|
|
411
|
-
collapsed:
|
|
411
|
+
collapsed: z(t.collapsed, 1) + 1,
|
|
412
412
|
updatedAt: new Date(i),
|
|
413
413
|
attempts: 0,
|
|
414
414
|
lastError: null,
|
|
@@ -416,7 +416,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
416
416
|
})
|
|
417
417
|
}), o;
|
|
418
418
|
}
|
|
419
|
-
let o = await t.insert(
|
|
419
|
+
let o = await t.insert(I, {
|
|
420
420
|
tenantId: e.tenantId,
|
|
421
421
|
workflowName: n.workflowName,
|
|
422
422
|
controlKey: a,
|
|
@@ -436,8 +436,8 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
436
436
|
deadLetteredAt: null
|
|
437
437
|
});
|
|
438
438
|
return String(o.id);
|
|
439
|
-
},
|
|
440
|
-
let t = await e.store.insert(
|
|
439
|
+
}, Ie = async (e) => {
|
|
440
|
+
let t = await e.store.insert(I, {
|
|
441
441
|
tenantId: e.tenantId,
|
|
442
442
|
workflowName: e.workflowName,
|
|
443
443
|
controlKey: "",
|
|
@@ -460,7 +460,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
460
460
|
intentId: String(t.id),
|
|
461
461
|
dueAt: e.at
|
|
462
462
|
};
|
|
463
|
-
},
|
|
463
|
+
}, Le = (e, t) => {
|
|
464
464
|
switch (e) {
|
|
465
465
|
case "debounce": return t.debounceKey ?? "";
|
|
466
466
|
case "batch": return t.batchKey ?? "";
|
|
@@ -468,8 +468,8 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
468
468
|
case "concurrency": return t.concurrencyKey ?? "";
|
|
469
469
|
default: return "";
|
|
470
470
|
}
|
|
471
|
-
},
|
|
472
|
-
let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(
|
|
471
|
+
}, V = async (e) => {
|
|
472
|
+
let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(L, {
|
|
473
473
|
tenantId: e.tenantId,
|
|
474
474
|
workflowName: t.workflowName,
|
|
475
475
|
outcome: e.outcome,
|
|
@@ -487,31 +487,31 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
487
487
|
releasedAt: e.outcome === "admitted" ? null : new Date(r)
|
|
488
488
|
});
|
|
489
489
|
return String(a.id);
|
|
490
|
-
},
|
|
491
|
-
let r = await e.query(
|
|
492
|
-
return r.length !== 0 && (await Promise.all(r.map((t) => e.update(
|
|
493
|
-
},
|
|
494
|
-
let r = (await e.query(
|
|
490
|
+
}, Re = async (e, t, n) => {
|
|
491
|
+
let r = await e.query(B(L, b(x("executionId", t), x("outcome", "admitted"), E("releasedAt")), [], 10));
|
|
492
|
+
return r.length !== 0 && (await Promise.all(r.map((t) => e.update(L, String(t.id), { releasedAt: new Date(n) }))), !0);
|
|
493
|
+
}, ze = async (e, t, n) => (await Be(e, t, n)).due, Be = async (e, t, n) => {
|
|
494
|
+
let r = (await e.query(B(I, E("deadLetteredAt"), [{
|
|
495
495
|
column: "priority",
|
|
496
496
|
direction: "desc"
|
|
497
497
|
}, {
|
|
498
498
|
column: "firstSeenAt",
|
|
499
499
|
direction: "asc"
|
|
500
|
-
}], n))).map(
|
|
500
|
+
}], n))).map(ke), i;
|
|
501
501
|
for (let e of r) e.dueAt <= t || (i === void 0 || e.dueAt < i) && (i = e.dueAt);
|
|
502
502
|
return {
|
|
503
|
-
due: r.filter((e) => e.dueAt <= t).sort(
|
|
503
|
+
due: r.filter((e) => e.dueAt <= t).sort(Te),
|
|
504
504
|
nextDueAt: i
|
|
505
505
|
};
|
|
506
|
-
},
|
|
506
|
+
}, Ve = async (e, t) => (await e.query(B(I, void 0, [{
|
|
507
507
|
column: "firstSeenAt",
|
|
508
508
|
direction: "asc"
|
|
509
|
-
}], t))).map(
|
|
510
|
-
let i = (await e.query(
|
|
509
|
+
}], t))).map(ke), H = async (e, t) => e.delete(I, t), He = async (e, t, n, r) => {
|
|
510
|
+
let i = (await e.query(B(I, x("id", t), [], 1)))[0];
|
|
511
511
|
if (i === void 0) return !1;
|
|
512
|
-
let a =
|
|
512
|
+
let a = ke(i);
|
|
513
513
|
try {
|
|
514
|
-
await e.insert(
|
|
514
|
+
await e.insert(L, {
|
|
515
515
|
tenantId: a.tenantId,
|
|
516
516
|
workflowName: a.workflowName,
|
|
517
517
|
outcome: "discarded",
|
|
@@ -529,55 +529,55 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
529
529
|
releasedAt: new Date(r)
|
|
530
530
|
});
|
|
531
531
|
} catch {}
|
|
532
|
-
return e.delete(
|
|
533
|
-
},
|
|
532
|
+
return e.delete(I, t);
|
|
533
|
+
}, Ue = (e, t = Math.random) => {
|
|
534
534
|
let n = Math.min(1e3 * 2 ** Math.max(0, e - 1), 3e5);
|
|
535
535
|
return Math.round(n / 2 + t() * (n / 2));
|
|
536
|
-
},
|
|
536
|
+
}, U = async (e, t, n, r) => {
|
|
537
537
|
let i = t.attempts + 1;
|
|
538
|
-
await e.update(
|
|
538
|
+
await e.update(I, t.id, {
|
|
539
539
|
attempts: i,
|
|
540
540
|
lastError: n.slice(0, 500),
|
|
541
|
-
dueAt: new Date(r +
|
|
541
|
+
dueAt: new Date(r + Ue(i)),
|
|
542
542
|
updatedAt: new Date(r)
|
|
543
543
|
});
|
|
544
|
-
},
|
|
544
|
+
}, We = async (e, t, n, r) => await e.update(I, t.id, {
|
|
545
545
|
attempts: t.attempts + 1,
|
|
546
546
|
lastError: n.slice(0, 500),
|
|
547
547
|
deadLetteredAt: new Date(r),
|
|
548
548
|
updatedAt: new Date(r)
|
|
549
|
-
}) !== null,
|
|
550
|
-
let r = (await e.query(
|
|
551
|
-
return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(
|
|
549
|
+
}) !== null, Ge = async (e, t, n) => {
|
|
550
|
+
let r = (await e.query(B(I, x("id", t), [], 1)))[0];
|
|
551
|
+
return r === void 0 || r.deadLetteredAt === null || r.deadLetteredAt === void 0 ? !1 : await e.update(I, t, {
|
|
552
552
|
attempts: 0,
|
|
553
553
|
lastError: null,
|
|
554
554
|
deadLetteredAt: null,
|
|
555
555
|
dueAt: new Date(n),
|
|
556
556
|
updatedAt: new Date(n)
|
|
557
557
|
}) !== null;
|
|
558
|
-
},
|
|
559
|
-
let t = await
|
|
558
|
+
}, Ke = async (e) => {
|
|
559
|
+
let t = await Ne({
|
|
560
560
|
store: e.store,
|
|
561
561
|
control: e.control,
|
|
562
562
|
keys: e.keys,
|
|
563
563
|
now: e.now,
|
|
564
564
|
paused: e.paused
|
|
565
565
|
});
|
|
566
|
-
return
|
|
566
|
+
return xe({
|
|
567
567
|
control: e.control,
|
|
568
568
|
keys: e.keys,
|
|
569
569
|
state: t,
|
|
570
570
|
now: e.now,
|
|
571
571
|
reconsidering: e.reconsidering
|
|
572
572
|
});
|
|
573
|
-
},
|
|
574
|
-
let r = await e.query(
|
|
573
|
+
}, qe = async (e, t, n = 1e3) => {
|
|
574
|
+
let r = await e.query(B(L, void 0, [{
|
|
575
575
|
column: "admittedAt",
|
|
576
576
|
direction: "asc"
|
|
577
|
-
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null &&
|
|
578
|
-
return await Promise.all(a.map((t) => e.delete(
|
|
579
|
-
},
|
|
580
|
-
let { store: t, control: n, now: r } = e, i =
|
|
577
|
+
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && R(e.admittedAt) < i);
|
|
578
|
+
return await Promise.all(a.map((t) => e.delete(L, String(t.id)))), a.length;
|
|
579
|
+
}, Je = async (e) => {
|
|
580
|
+
let { store: t, control: n, now: r } = e, i = P(n, e.payload), a = await Ke({
|
|
581
581
|
store: t,
|
|
582
582
|
control: n,
|
|
583
583
|
keys: i,
|
|
@@ -585,7 +585,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
585
585
|
now: r,
|
|
586
586
|
reconsidering: !1
|
|
587
587
|
});
|
|
588
|
-
if (a.kind === "drop") return await
|
|
588
|
+
if (a.kind === "drop") return await V({
|
|
589
589
|
store: t,
|
|
590
590
|
control: n,
|
|
591
591
|
keys: i,
|
|
@@ -602,7 +602,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
602
602
|
kind: "dropped",
|
|
603
603
|
retryAfterMs: a.retryAfterMs
|
|
604
604
|
};
|
|
605
|
-
if (a.kind === "skip") return await
|
|
605
|
+
if (a.kind === "skip") return await V({
|
|
606
606
|
store: t,
|
|
607
607
|
control: n,
|
|
608
608
|
keys: i,
|
|
@@ -622,7 +622,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
622
622
|
};
|
|
623
623
|
if (a.kind === "defer") return {
|
|
624
624
|
kind: "queued",
|
|
625
|
-
intentId: await
|
|
625
|
+
intentId: await Fe({
|
|
626
626
|
store: t,
|
|
627
627
|
control: n,
|
|
628
628
|
decision: a,
|
|
@@ -638,12 +638,12 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
638
638
|
};
|
|
639
639
|
let o = e.payload, s = [], c = 1;
|
|
640
640
|
if (n.batch !== void 0 && i.batchKey !== void 0) {
|
|
641
|
-
let r = await
|
|
641
|
+
let r = await Ye(t, n.workflowName, i.batchKey, n.batch.maxSize);
|
|
642
642
|
o = { items: [...r.map((e) => e.payload), e.payload] }, s = r.map((e) => e.id), c = r.length + 1;
|
|
643
643
|
}
|
|
644
644
|
return {
|
|
645
645
|
kind: "start",
|
|
646
|
-
ledgerId: await
|
|
646
|
+
ledgerId: await V({
|
|
647
647
|
store: t,
|
|
648
648
|
control: n,
|
|
649
649
|
keys: i,
|
|
@@ -666,7 +666,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
666
666
|
runId: a.evict.runId
|
|
667
667
|
} }
|
|
668
668
|
};
|
|
669
|
-
},
|
|
669
|
+
}, Ye = async (e, t, n, r) => (await e.query({
|
|
670
670
|
table: "_voltro_workflow_pending",
|
|
671
671
|
predicate: b(x("workflowName", t), x("controlKey", n), x("mode", "batch")),
|
|
672
672
|
order: [{
|
|
@@ -679,22 +679,22 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
679
679
|
})).map((e) => ({
|
|
680
680
|
id: String(e.id),
|
|
681
681
|
payload: e.payload
|
|
682
|
-
})),
|
|
682
|
+
})), Xe = async (e, t, n, r) => {
|
|
683
683
|
await e.update("_voltro_workflow_admissions", t, {
|
|
684
684
|
executionId: n,
|
|
685
685
|
runId: r
|
|
686
686
|
});
|
|
687
|
-
},
|
|
687
|
+
}, Ze = A("_voltro_workflow_watermarks", {
|
|
688
688
|
id: w({ prefix: "wfwm" }),
|
|
689
|
-
positionAt:
|
|
690
|
-
updatedAt:
|
|
691
|
-
}),
|
|
689
|
+
positionAt: M(),
|
|
690
|
+
updatedAt: M().default("now")
|
|
691
|
+
}), Qe = (e) => {
|
|
692
692
|
let t = e instanceof Error ? e.message : String(e);
|
|
693
693
|
return t.length > 400 ? `${t.slice(0, 400)}…` : t;
|
|
694
|
-
},
|
|
694
|
+
}, $e = (e) => {
|
|
695
695
|
let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => h.right(e) : (t) => {
|
|
696
696
|
let n = y.decodeUnknownEither(e.payloadSchema)(t);
|
|
697
|
-
return h.isRight(n) ? h.right(n.right) : h.left(
|
|
697
|
+
return h.isRight(n) ? h.right(n.right) : h.left(Qe(n.left));
|
|
698
698
|
}, s = e.runs.map((e) => ({
|
|
699
699
|
run: e,
|
|
700
700
|
decoded: o(e.payload)
|
|
@@ -711,7 +711,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
711
711
|
workflowName: e.workflowName,
|
|
712
712
|
event: o.event,
|
|
713
713
|
subject: l.id,
|
|
714
|
-
detail:
|
|
714
|
+
detail: Qe(u.left)
|
|
715
715
|
});
|
|
716
716
|
continue;
|
|
717
717
|
}
|
|
@@ -731,7 +731,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
731
731
|
workflowName: e.workflowName,
|
|
732
732
|
event: o.event,
|
|
733
733
|
subject: n,
|
|
734
|
-
detail:
|
|
734
|
+
detail: Qe(t)
|
|
735
735
|
}), !1;
|
|
736
736
|
}
|
|
737
737
|
};
|
|
@@ -754,33 +754,33 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
754
754
|
discards: n,
|
|
755
755
|
problems: r
|
|
756
756
|
};
|
|
757
|
-
},
|
|
757
|
+
}, et = (e) => {
|
|
758
758
|
let t;
|
|
759
759
|
for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
|
|
760
760
|
return t;
|
|
761
|
-
},
|
|
761
|
+
}, tt = "_voltro_workflow_watermarks", nt = "_voltro_workflow_events", W = "cancelOn", rt = 36e5, it = 500, G = (e) => {
|
|
762
762
|
if (e instanceof Date) return e;
|
|
763
763
|
if (typeof e == "number") return new Date(e);
|
|
764
764
|
if (typeof e == "string") {
|
|
765
765
|
let t = new Date(e);
|
|
766
766
|
if (!Number.isNaN(t.getTime())) return t;
|
|
767
767
|
}
|
|
768
|
-
},
|
|
769
|
-
table:
|
|
768
|
+
}, K = (e) => e instanceof Error ? e.message : String(e), at = async (e, t) => G((await e.query({
|
|
769
|
+
table: tt,
|
|
770
770
|
predicate: x("id", t),
|
|
771
771
|
order: [],
|
|
772
772
|
take: 1,
|
|
773
773
|
skip: void 0,
|
|
774
774
|
projection: void 0
|
|
775
|
-
}))[0]?.positionAt),
|
|
776
|
-
await e.upsert(
|
|
775
|
+
}))[0]?.positionAt), ot = async (e, t, n) => {
|
|
776
|
+
await e.upsert(tt, {
|
|
777
777
|
id: t,
|
|
778
778
|
positionAt: n,
|
|
779
779
|
updatedAt: /* @__PURE__ */ new Date()
|
|
780
780
|
}, {
|
|
781
781
|
conflictColumns: ["id"],
|
|
782
782
|
update: (e) => {
|
|
783
|
-
let t =
|
|
783
|
+
let t = G(e.positionAt);
|
|
784
784
|
return t !== void 0 && t.getTime() >= n.getTime() ? {
|
|
785
785
|
positionAt: t,
|
|
786
786
|
updatedAt: /* @__PURE__ */ new Date()
|
|
@@ -790,7 +790,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
790
790
|
};
|
|
791
791
|
}
|
|
792
792
|
});
|
|
793
|
-
},
|
|
793
|
+
}, st = async (e, t, n) => {
|
|
794
794
|
let r = async (r) => e.query({
|
|
795
795
|
table: "_voltro_workflow_runs",
|
|
796
796
|
predicate: b(x("tag", t), x("status", r)),
|
|
@@ -803,7 +803,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
803
803
|
projection: void 0
|
|
804
804
|
});
|
|
805
805
|
return [...await r("running"), ...await r("suspended")].flatMap((e) => {
|
|
806
|
-
let t = e, n =
|
|
806
|
+
let t = e, n = G(t.startedAt);
|
|
807
807
|
return typeof t.id != "string" || typeof t.executionId != "string" || n === void 0 ? [] : [{
|
|
808
808
|
runId: t.id,
|
|
809
809
|
executionId: t.executionId,
|
|
@@ -811,7 +811,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
811
811
|
startedAt: n
|
|
812
812
|
}];
|
|
813
813
|
});
|
|
814
|
-
},
|
|
814
|
+
}, ct = async (e, t, n) => (await e.query({
|
|
815
815
|
table: "_voltro_workflow_pending",
|
|
816
816
|
predicate: x("workflowName", t),
|
|
817
817
|
order: [{
|
|
@@ -822,13 +822,13 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
822
822
|
skip: void 0,
|
|
823
823
|
projection: void 0
|
|
824
824
|
})).flatMap((e) => {
|
|
825
|
-
let t = e, n =
|
|
825
|
+
let t = e, n = G(t.firstSeenAt);
|
|
826
826
|
return typeof t.id != "string" || n === void 0 ? [] : [{
|
|
827
827
|
intentId: t.id,
|
|
828
828
|
payload: t.payload,
|
|
829
829
|
firstSeenAt: n
|
|
830
830
|
}];
|
|
831
|
-
}),
|
|
831
|
+
}), lt = async (e, t) => {
|
|
832
832
|
let n = t.workflows.filter((e) => e.entries.length > 0);
|
|
833
833
|
if (n.length === 0) return {
|
|
834
834
|
examined: !1,
|
|
@@ -843,8 +843,8 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
843
843
|
};
|
|
844
844
|
let r = e.now?.() ?? Date.now(), i = t.batch ?? 500, a = t.coldLookbackMs ?? 36e5, o = /* @__PURE__ */ new Set();
|
|
845
845
|
for (let e of n) for (let t of e.entries) o.add(t.event);
|
|
846
|
-
let s = await
|
|
847
|
-
table:
|
|
846
|
+
let s = await at(e.store, W), c = s ?? new Date(r - a), l = await e.store.query({
|
|
847
|
+
table: nt,
|
|
848
848
|
predicate: ne("occurredAt", c),
|
|
849
849
|
order: [{
|
|
850
850
|
column: "occurredAt",
|
|
@@ -855,7 +855,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
855
855
|
projection: void 0
|
|
856
856
|
}), u = [];
|
|
857
857
|
for (let e of l) {
|
|
858
|
-
let t = e, n =
|
|
858
|
+
let t = e, n = G(t.occurredAt);
|
|
859
859
|
typeof t.id == "string" && typeof t.name == "string" && n !== void 0 && o.has(t.name) && u.push({
|
|
860
860
|
id: t.id,
|
|
861
861
|
name: t.name,
|
|
@@ -869,15 +869,15 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
869
869
|
if (n.length === 0) continue;
|
|
870
870
|
let r = [], i = [];
|
|
871
871
|
try {
|
|
872
|
-
r = await
|
|
872
|
+
r = await st(e.store, t.workflowName, _), i = await ct(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
|
|
873
873
|
} catch (e) {
|
|
874
874
|
f.push({
|
|
875
875
|
subject: t.workflowName,
|
|
876
|
-
detail:
|
|
876
|
+
detail: K(e)
|
|
877
877
|
}), g = !0;
|
|
878
878
|
continue;
|
|
879
879
|
}
|
|
880
|
-
let a =
|
|
880
|
+
let a = $e({
|
|
881
881
|
workflowName: t.workflowName,
|
|
882
882
|
entries: t.entries,
|
|
883
883
|
payloadSchema: t.payloadSchema,
|
|
@@ -902,7 +902,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
902
902
|
} catch (e) {
|
|
903
903
|
f.push({
|
|
904
904
|
subject: n.runId,
|
|
905
|
-
detail:
|
|
905
|
+
detail: K(e)
|
|
906
906
|
});
|
|
907
907
|
}
|
|
908
908
|
for (let n of a.discards) try {
|
|
@@ -915,26 +915,26 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
915
915
|
} catch (e) {
|
|
916
916
|
f.push({
|
|
917
917
|
subject: n.intentId,
|
|
918
|
-
detail:
|
|
918
|
+
detail: K(e)
|
|
919
919
|
});
|
|
920
920
|
}
|
|
921
921
|
}
|
|
922
|
-
let v =
|
|
922
|
+
let v = et(u), y = s;
|
|
923
923
|
if (g) e.log?.warn("workflow.cancelOn: holding the watermark — some workflows could not be evaluated", { failures: f.length });
|
|
924
924
|
else if (v !== void 0) try {
|
|
925
|
-
await
|
|
925
|
+
await ot(e.store, W, v), y = v;
|
|
926
926
|
} catch (e) {
|
|
927
927
|
f.push({
|
|
928
|
-
subject:
|
|
929
|
-
detail:
|
|
928
|
+
subject: W,
|
|
929
|
+
detail: K(e)
|
|
930
930
|
});
|
|
931
931
|
}
|
|
932
932
|
else if (s === void 0) try {
|
|
933
|
-
await
|
|
933
|
+
await ot(e.store, W, c), y = c;
|
|
934
934
|
} catch (e) {
|
|
935
935
|
f.push({
|
|
936
|
-
subject:
|
|
937
|
-
detail:
|
|
936
|
+
subject: W,
|
|
937
|
+
detail: K(e)
|
|
938
938
|
});
|
|
939
939
|
}
|
|
940
940
|
return d.length > 0 && e.log?.warn("workflow.cancelOn: some events could not be evaluated", {
|
|
@@ -951,14 +951,14 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
951
951
|
failures: f,
|
|
952
952
|
watermark: y
|
|
953
953
|
};
|
|
954
|
-
},
|
|
954
|
+
}, ut = 18e5, dt = 200, ft = 20, q = (e) => {
|
|
955
955
|
if (e instanceof Date) return e;
|
|
956
956
|
if (typeof e == "number") return new Date(e);
|
|
957
957
|
if (typeof e == "string") {
|
|
958
958
|
let t = new Date(e);
|
|
959
959
|
if (!Number.isNaN(t.getTime())) return t;
|
|
960
960
|
}
|
|
961
|
-
},
|
|
961
|
+
}, J = (e) => e instanceof Error ? e.message : String(e), pt = async (e, t, n) => (await e.query({
|
|
962
962
|
table: "_voltro_workflow_run_events",
|
|
963
963
|
predicate: x("runId", t),
|
|
964
964
|
order: [{
|
|
@@ -969,7 +969,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
969
969
|
skip: void 0,
|
|
970
970
|
projection: void 0
|
|
971
971
|
})).flatMap((e) => {
|
|
972
|
-
let t = e, n =
|
|
972
|
+
let t = e, n = q(t.occurredAt);
|
|
973
973
|
return typeof t.eventType != "string" || n === void 0 ? [] : [{
|
|
974
974
|
eventType: t.eventType,
|
|
975
975
|
occurredAt: n,
|
|
@@ -988,13 +988,13 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
988
988
|
projection: void 0
|
|
989
989
|
}))[0];
|
|
990
990
|
if (n === void 0) return;
|
|
991
|
-
let r =
|
|
991
|
+
let r = q(n.startedAt), i = q(n.completedAt);
|
|
992
992
|
return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
|
|
993
993
|
}, ht = (e, t) => {
|
|
994
994
|
for (let n of e) {
|
|
995
995
|
if (n.eventType === "timer-fired") return !1;
|
|
996
996
|
if (n.eventType !== "timer-set") continue;
|
|
997
|
-
let e =
|
|
997
|
+
let e = q(n.payload?.scheduledWakeAt);
|
|
998
998
|
return e !== void 0 && e.getTime() > t;
|
|
999
999
|
}
|
|
1000
1000
|
return !1;
|
|
@@ -1028,12 +1028,12 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1028
1028
|
sawFullRunPage: !1,
|
|
1029
1029
|
failures: [{
|
|
1030
1030
|
subject: "_voltro_workflow_runs",
|
|
1031
|
-
detail:
|
|
1031
|
+
detail: J(e)
|
|
1032
1032
|
}]
|
|
1033
1033
|
};
|
|
1034
1034
|
}
|
|
1035
1035
|
for (let t of d) {
|
|
1036
|
-
let i = t, o =
|
|
1036
|
+
let i = t, o = q(i.startedAt);
|
|
1037
1037
|
if (typeof i.id != "string" || typeof i.tag != "string" || typeof i.executionId != "string" || typeof i.status != "string" || o === void 0) continue;
|
|
1038
1038
|
let d, f;
|
|
1039
1039
|
try {
|
|
@@ -1041,7 +1041,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1041
1041
|
} catch (e) {
|
|
1042
1042
|
s.push({
|
|
1043
1043
|
subject: i.id,
|
|
1044
|
-
detail:
|
|
1044
|
+
detail: J(e)
|
|
1045
1045
|
});
|
|
1046
1046
|
continue;
|
|
1047
1047
|
}
|
|
@@ -1066,11 +1066,22 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1066
1066
|
idleMs: h,
|
|
1067
1067
|
reason: gt(i.status, d)
|
|
1068
1068
|
};
|
|
1069
|
-
|
|
1069
|
+
c.push(g);
|
|
1070
|
+
let _ = {};
|
|
1071
|
+
if (e.describeRun !== void 0) try {
|
|
1072
|
+
_ = await e.describeRun(g) ?? {};
|
|
1073
|
+
} catch (e) {
|
|
1074
|
+
s.push({
|
|
1075
|
+
subject: `${g.runId}:describeRun`,
|
|
1076
|
+
detail: J(e)
|
|
1077
|
+
});
|
|
1078
|
+
}
|
|
1079
|
+
if (e.log?.warn("workflow.staleness: run has made no progress", {
|
|
1070
1080
|
workflow: g.tag,
|
|
1071
1081
|
runId: g.runId,
|
|
1072
1082
|
idleMs: g.idleMs,
|
|
1073
|
-
reason: g.reason
|
|
1083
|
+
reason: g.reason,
|
|
1084
|
+
..._
|
|
1074
1085
|
}), e.recordEvent !== void 0) try {
|
|
1075
1086
|
await e.recordEvent({
|
|
1076
1087
|
runId: g.runId,
|
|
@@ -1081,13 +1092,14 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1081
1092
|
lastProgressAt: g.lastProgressAt.toISOString(),
|
|
1082
1093
|
reason: g.reason,
|
|
1083
1094
|
tag: g.tag,
|
|
1084
|
-
executionId: g.executionId
|
|
1095
|
+
executionId: g.executionId,
|
|
1096
|
+
..._
|
|
1085
1097
|
}
|
|
1086
1098
|
});
|
|
1087
1099
|
} catch (e) {
|
|
1088
1100
|
s.push({
|
|
1089
1101
|
subject: g.runId,
|
|
1090
|
-
detail:
|
|
1102
|
+
detail: J(e)
|
|
1091
1103
|
});
|
|
1092
1104
|
}
|
|
1093
1105
|
if (e.onStalled !== void 0) try {
|
|
@@ -1095,7 +1107,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1095
1107
|
} catch (e) {
|
|
1096
1108
|
s.push({
|
|
1097
1109
|
subject: `${g.runId}:onStalled`,
|
|
1098
|
-
detail:
|
|
1110
|
+
detail: J(e)
|
|
1099
1111
|
});
|
|
1100
1112
|
}
|
|
1101
1113
|
}
|
|
@@ -1122,8 +1134,8 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1122
1134
|
}, yt = 200, bt = async (e, t = {}) => {
|
|
1123
1135
|
let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, a, o, s;
|
|
1124
1136
|
try {
|
|
1125
|
-
a = await
|
|
1126
|
-
let t = await
|
|
1137
|
+
a = await Ae(e.store);
|
|
1138
|
+
let t = await Be(e.store, n(), i);
|
|
1127
1139
|
o = t.due, s = t.nextDueAt;
|
|
1128
1140
|
} catch (e) {
|
|
1129
1141
|
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), vt;
|
|
@@ -1171,10 +1183,10 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1171
1183
|
intent: t.id,
|
|
1172
1184
|
cause: String(e)
|
|
1173
1185
|
}), !1))) {
|
|
1174
|
-
await
|
|
1186
|
+
await U(e.store, t, s, o).catch(() => {});
|
|
1175
1187
|
continue;
|
|
1176
1188
|
}
|
|
1177
|
-
if (await
|
|
1189
|
+
if (await We(e.store, t, s, o).catch(() => !1)) {
|
|
1178
1190
|
c.deadLettered++, r?.warn?.("workflow flow control: intent dead-lettered", {
|
|
1179
1191
|
workflow: t.workflowName,
|
|
1180
1192
|
intent: t.id,
|
|
@@ -1187,7 +1199,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1187
1199
|
workflow: t.workflowName,
|
|
1188
1200
|
intent: t.id,
|
|
1189
1201
|
cause: String(i)
|
|
1190
|
-
}), await
|
|
1202
|
+
}), await U(e.store, t, String(i), n()).catch(() => {});
|
|
1191
1203
|
}
|
|
1192
1204
|
for (let t of l.values()) try {
|
|
1193
1205
|
await Ct(e, t, a, c, n());
|
|
@@ -1209,10 +1221,10 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1209
1221
|
size: t.length,
|
|
1210
1222
|
cause: String(e)
|
|
1211
1223
|
}), !1))) {
|
|
1212
|
-
await Promise.all(t.map((t) =>
|
|
1224
|
+
await Promise.all(t.map((t) => U(e.store, t, l, s).catch(() => {})));
|
|
1213
1225
|
continue;
|
|
1214
1226
|
}
|
|
1215
|
-
if ((await Promise.all(t.map((t) =>
|
|
1227
|
+
if ((await Promise.all(t.map((t) => We(e.store, t, l, s).catch(() => !1)))).every(Boolean)) {
|
|
1216
1228
|
c.deadLettered += t.length, r?.warn?.("workflow flow control: batch dead-lettered", {
|
|
1217
1229
|
workflow: a.workflowName,
|
|
1218
1230
|
intents: t.map((e) => e.id),
|
|
@@ -1226,9 +1238,10 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1226
1238
|
workflow: a?.workflowName,
|
|
1227
1239
|
size: t.length,
|
|
1228
1240
|
cause: String(i)
|
|
1229
|
-
}), a !== void 0 && await
|
|
1241
|
+
}), a !== void 0 && await U(e.store, a, String(i), n()).catch(() => {});
|
|
1230
1242
|
}
|
|
1231
|
-
|
|
1243
|
+
let p = await Tt(e, n()).catch(() => ({ cancelled: 0 }));
|
|
1244
|
+
return c.timedOut = p.cancelled, p.nextDeadlineAt !== void 0 && (s === void 0 || p.nextDeadlineAt < s) && (s = p.nextDeadlineAt), {
|
|
1232
1245
|
...c,
|
|
1233
1246
|
examined: !0,
|
|
1234
1247
|
...s === void 0 ? {} : { nextDueAt: s }
|
|
@@ -1242,14 +1255,14 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1242
1255
|
payload: t.payload,
|
|
1243
1256
|
callerContext: t.callerContext,
|
|
1244
1257
|
reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this start was waiting in the admission queue`
|
|
1245
|
-
}), await
|
|
1258
|
+
}), await H(e.store, t.id), r.expired++;
|
|
1246
1259
|
return;
|
|
1247
1260
|
}
|
|
1248
|
-
if (
|
|
1249
|
-
await
|
|
1261
|
+
if (Ce(a, t, i)) {
|
|
1262
|
+
await V({
|
|
1250
1263
|
store: e.store,
|
|
1251
1264
|
control: a,
|
|
1252
|
-
keys:
|
|
1265
|
+
keys: P(a, t.payload),
|
|
1253
1266
|
outcome: "expired",
|
|
1254
1267
|
mode: t.mode,
|
|
1255
1268
|
reason: `timeouts.start elapsed after ${i - t.firstSeenAt}ms`,
|
|
@@ -1264,14 +1277,14 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1264
1277
|
payload: t.payload,
|
|
1265
1278
|
callerContext: t.callerContext,
|
|
1266
1279
|
reason: `timeouts.start (${a.timeouts?.startMs}ms) elapsed while this start waited in the admission queue; ${t.collapsed} start(s) had collapsed into it`
|
|
1267
|
-
}), await
|
|
1280
|
+
}), await H(e.store, t.id), r.expired++;
|
|
1268
1281
|
return;
|
|
1269
1282
|
}
|
|
1270
|
-
let o =
|
|
1283
|
+
let o = P(a, t.payload);
|
|
1271
1284
|
await wt(e, {
|
|
1272
1285
|
control: a,
|
|
1273
1286
|
intent: t,
|
|
1274
|
-
decision: await
|
|
1287
|
+
decision: await Ke({
|
|
1275
1288
|
store: e.store,
|
|
1276
1289
|
control: a,
|
|
1277
1290
|
keys: o,
|
|
@@ -1291,10 +1304,10 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1291
1304
|
payload: t.payload,
|
|
1292
1305
|
callerContext: t.callerContext,
|
|
1293
1306
|
reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this delayed start waited for its 'at' instant`
|
|
1294
|
-
}), await
|
|
1307
|
+
}), await H(e.store, t.id), r.expired++;
|
|
1295
1308
|
return;
|
|
1296
1309
|
}
|
|
1297
|
-
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await
|
|
1310
|
+
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await Je({
|
|
1298
1311
|
store: e.store,
|
|
1299
1312
|
control: a,
|
|
1300
1313
|
payload: t.payload,
|
|
@@ -1305,15 +1318,15 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1305
1318
|
waiting: !1
|
|
1306
1319
|
});
|
|
1307
1320
|
if (o.kind === "queued") {
|
|
1308
|
-
await
|
|
1321
|
+
await H(e.store, t.id), r.deferred++;
|
|
1309
1322
|
return;
|
|
1310
1323
|
}
|
|
1311
1324
|
if (o.kind === "dropped") {
|
|
1312
|
-
await
|
|
1325
|
+
await H(e.store, t.id), r.dropped++;
|
|
1313
1326
|
return;
|
|
1314
1327
|
}
|
|
1315
1328
|
if (o.kind === "skipped") {
|
|
1316
|
-
await
|
|
1329
|
+
await H(e.store, t.id), r.skipped++;
|
|
1317
1330
|
return;
|
|
1318
1331
|
}
|
|
1319
1332
|
let s = await e.startAdmitted(a.workflowName, o.payload, t.callerContext);
|
|
@@ -1326,35 +1339,35 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1326
1339
|
source: "flow-control",
|
|
1327
1340
|
mode: "singleton"
|
|
1328
1341
|
}
|
|
1329
|
-
}).catch(() => !1), await
|
|
1330
|
-
for (let t of o.consume) await
|
|
1331
|
-
o.ledgerId !== void 0 && await
|
|
1342
|
+
}).catch(() => !1), await Re(e.store, o.evict.executionId, i).catch(() => {}), r.evicted++);
|
|
1343
|
+
for (let t of o.consume) await H(e.store, t).catch(() => {});
|
|
1344
|
+
o.ledgerId !== void 0 && await Xe(e.store, o.ledgerId, s.executionId, s.runId ?? null).catch(() => {}), await H(e.store, t.id), r.admitted++;
|
|
1332
1345
|
}, Ct = async (e, t, n, r, i) => {
|
|
1333
1346
|
let a = t[0];
|
|
1334
1347
|
if (a === void 0) return;
|
|
1335
1348
|
let o = e.controls.get(a.workflowName);
|
|
1336
1349
|
if (o === void 0 || o.batch === void 0) {
|
|
1337
|
-
for (let n of t) await
|
|
1350
|
+
for (let n of t) await H(e.store, n.id);
|
|
1338
1351
|
r.expired += t.length;
|
|
1339
1352
|
return;
|
|
1340
1353
|
}
|
|
1341
1354
|
let s = [...t].sort((e, t) => e.firstSeenAt - t.firstSeenAt), c = s[0];
|
|
1342
|
-
if (
|
|
1355
|
+
if (Ce(o, c, i)) {
|
|
1343
1356
|
await e.onAbandoned({
|
|
1344
1357
|
workflowName: a.workflowName,
|
|
1345
1358
|
payload: { items: s.map((e) => e.payload) },
|
|
1346
1359
|
callerContext: c.callerContext,
|
|
1347
1360
|
reason: `timeouts.start elapsed with ${s.length} item(s) accumulated in the batch`
|
|
1348
1361
|
});
|
|
1349
|
-
for (let t of s) await
|
|
1362
|
+
for (let t of s) await H(e.store, t.id);
|
|
1350
1363
|
r.expired += s.length;
|
|
1351
1364
|
return;
|
|
1352
1365
|
}
|
|
1353
|
-
let l =
|
|
1366
|
+
let l = P(o, c.payload);
|
|
1354
1367
|
await wt(e, {
|
|
1355
1368
|
control: o,
|
|
1356
1369
|
intent: c,
|
|
1357
|
-
decision: await
|
|
1370
|
+
decision: await Ke({
|
|
1358
1371
|
store: e.store,
|
|
1359
1372
|
control: o,
|
|
1360
1373
|
keys: l,
|
|
@@ -1370,7 +1383,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1370
1383
|
}, wt = async (e, t) => {
|
|
1371
1384
|
let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c } = t;
|
|
1372
1385
|
if (i.kind === "defer") {
|
|
1373
|
-
await
|
|
1386
|
+
await Fe({
|
|
1374
1387
|
store: e.store,
|
|
1375
1388
|
control: n,
|
|
1376
1389
|
decision: i,
|
|
@@ -1383,7 +1396,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1383
1396
|
return;
|
|
1384
1397
|
}
|
|
1385
1398
|
if (i.kind === "drop") {
|
|
1386
|
-
await
|
|
1399
|
+
await V({
|
|
1387
1400
|
store: e.store,
|
|
1388
1401
|
control: n,
|
|
1389
1402
|
keys: a,
|
|
@@ -1397,12 +1410,12 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1397
1410
|
tenantId: r.tenantId,
|
|
1398
1411
|
now: s
|
|
1399
1412
|
});
|
|
1400
|
-
for (let t of c ?? [r]) await
|
|
1413
|
+
for (let t of c ?? [r]) await H(e.store, t.id);
|
|
1401
1414
|
o.dropped++;
|
|
1402
1415
|
return;
|
|
1403
1416
|
}
|
|
1404
1417
|
if (i.kind === "skip") {
|
|
1405
|
-
await
|
|
1418
|
+
await V({
|
|
1406
1419
|
store: e.store,
|
|
1407
1420
|
control: n,
|
|
1408
1421
|
keys: a,
|
|
@@ -1416,7 +1429,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1416
1429
|
tenantId: r.tenantId,
|
|
1417
1430
|
now: s
|
|
1418
1431
|
});
|
|
1419
|
-
for (let t of c ?? [r]) await
|
|
1432
|
+
for (let t of c ?? [r]) await H(e.store, t.id);
|
|
1420
1433
|
o.skipped++;
|
|
1421
1434
|
return;
|
|
1422
1435
|
}
|
|
@@ -1429,7 +1442,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1429
1442
|
source: "flow-control",
|
|
1430
1443
|
mode: "singleton"
|
|
1431
1444
|
}
|
|
1432
|
-
}), await
|
|
1445
|
+
}), await Re(e.store, i.evict.executionId, s), await V({
|
|
1433
1446
|
store: e.store,
|
|
1434
1447
|
control: n,
|
|
1435
1448
|
keys: a,
|
|
@@ -1444,7 +1457,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1444
1457
|
now: s
|
|
1445
1458
|
}), o.evicted++);
|
|
1446
1459
|
let l = c === void 0 ? r.payload : { items: c.map((e) => e.payload) }, u = c === void 0 ? r.collapsed : c.reduce((e, t) => e + t.collapsed, 0), d = await e.startAdmitted(n.workflowName, l, r.callerContext);
|
|
1447
|
-
await
|
|
1460
|
+
await V({
|
|
1448
1461
|
store: e.store,
|
|
1449
1462
|
control: n,
|
|
1450
1463
|
keys: a,
|
|
@@ -1458,40 +1471,47 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1458
1471
|
tenantId: r.tenantId,
|
|
1459
1472
|
now: s
|
|
1460
1473
|
});
|
|
1461
|
-
for (let t of c ?? [r]) await
|
|
1474
|
+
for (let t of c ?? [r]) await H(e.store, t.id);
|
|
1462
1475
|
o.admitted++;
|
|
1463
1476
|
}, Tt = async (e, t) => {
|
|
1464
|
-
if (e.listRunningRuns === void 0) return 0;
|
|
1465
|
-
let n = 0;
|
|
1466
|
-
for (let
|
|
1467
|
-
if (
|
|
1468
|
-
let
|
|
1469
|
-
for (let
|
|
1470
|
-
if (!
|
|
1471
|
-
startedAt:
|
|
1477
|
+
if (e.listRunningRuns === void 0) return { cancelled: 0 };
|
|
1478
|
+
let n = 0, r;
|
|
1479
|
+
for (let i of e.controls.values()) {
|
|
1480
|
+
if (i.timeouts?.finishMs === void 0) continue;
|
|
1481
|
+
let a = await e.listRunningRuns(i.workflowName);
|
|
1482
|
+
for (let o of a) {
|
|
1483
|
+
if (!we(i, {
|
|
1484
|
+
startedAt: o.startedAt,
|
|
1472
1485
|
terminal: !1
|
|
1473
|
-
}, t))
|
|
1474
|
-
|
|
1486
|
+
}, t)) {
|
|
1487
|
+
let e = o.startedAt + i.timeouts.finishMs;
|
|
1488
|
+
(r === void 0 || e < r) && (r = e);
|
|
1489
|
+
continue;
|
|
1490
|
+
}
|
|
1491
|
+
let a = `timeouts.finish (${i.timeouts.finishMs}ms) elapsed; the run was cancelled after ${t - o.startedAt}ms`;
|
|
1475
1492
|
await e.cancelRun({
|
|
1476
|
-
workflowName:
|
|
1477
|
-
runId:
|
|
1478
|
-
executionId:
|
|
1479
|
-
reason:
|
|
1493
|
+
workflowName: o.workflowName,
|
|
1494
|
+
runId: o.runId,
|
|
1495
|
+
executionId: o.executionId,
|
|
1496
|
+
reason: a,
|
|
1480
1497
|
detail: {
|
|
1481
1498
|
source: "flow-control",
|
|
1482
1499
|
timeout: "finish"
|
|
1483
1500
|
}
|
|
1484
|
-
}) && (await
|
|
1485
|
-
workflowName:
|
|
1486
|
-
payload:
|
|
1501
|
+
}) && (await Re(e.store, o.executionId, t), await e.onAbandoned({
|
|
1502
|
+
workflowName: o.workflowName,
|
|
1503
|
+
payload: o.payload,
|
|
1487
1504
|
callerContext: null,
|
|
1488
|
-
reason:
|
|
1489
|
-
runId:
|
|
1490
|
-
executionId:
|
|
1505
|
+
reason: a,
|
|
1506
|
+
runId: o.runId,
|
|
1507
|
+
executionId: o.executionId
|
|
1491
1508
|
}), n++);
|
|
1492
1509
|
}
|
|
1493
1510
|
}
|
|
1494
|
-
return
|
|
1511
|
+
return {
|
|
1512
|
+
cancelled: n,
|
|
1513
|
+
...r === void 0 ? {} : { nextDeadlineAt: r }
|
|
1514
|
+
};
|
|
1495
1515
|
}, Et = 3e5, Dt, Ot = (e) => {
|
|
1496
1516
|
Dt = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
|
|
1497
1517
|
}, kt = () => {
|
|
@@ -1517,7 +1537,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1517
1537
|
} catch {}
|
|
1518
1538
|
}, Pt = (e, t) => {
|
|
1519
1539
|
let r = m.gen(function* () {
|
|
1520
|
-
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 864e5, s = yield* m.serviceOption(
|
|
1540
|
+
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 864e5, s = yield* m.serviceOption(le), c;
|
|
1521
1541
|
Mt({
|
|
1522
1542
|
workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
|
|
1523
1543
|
signalName: t.name,
|
|
@@ -1768,26 +1788,26 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
1768
1788
|
table: Y,
|
|
1769
1789
|
predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
|
|
1770
1790
|
order: []
|
|
1771
|
-
})).length, tn =
|
|
1791
|
+
})).length, tn = A(Y, {
|
|
1772
1792
|
id: w({ prefix: "bhd" }),
|
|
1773
|
-
holdKey:
|
|
1774
|
-
budget:
|
|
1775
|
-
tenantId:
|
|
1776
|
-
executionId:
|
|
1777
|
-
workflowName:
|
|
1778
|
-
signalName:
|
|
1779
|
-
stepName:
|
|
1780
|
-
spentMicroUsd:
|
|
1781
|
-
limitMicroUsd:
|
|
1782
|
-
heldAt:
|
|
1783
|
-
releasedAt:
|
|
1784
|
-
outcome:
|
|
1793
|
+
holdKey: j().maxLength(191),
|
|
1794
|
+
budget: j(),
|
|
1795
|
+
tenantId: j().nullable(),
|
|
1796
|
+
executionId: j(),
|
|
1797
|
+
workflowName: j(),
|
|
1798
|
+
signalName: j(),
|
|
1799
|
+
stepName: j(),
|
|
1800
|
+
spentMicroUsd: j().nullable(),
|
|
1801
|
+
limitMicroUsd: j().nullable(),
|
|
1802
|
+
heldAt: M().default("now"),
|
|
1803
|
+
releasedAt: M().nullable(),
|
|
1804
|
+
outcome: j().nullable()
|
|
1785
1805
|
}).index(["budget", "releasedAt"]), nn = () => {
|
|
1786
|
-
|
|
1806
|
+
oe({
|
|
1787
1807
|
source: "framework",
|
|
1788
1808
|
table: Y,
|
|
1789
1809
|
timeColumn: "releasedAt",
|
|
1790
|
-
ttlMs:
|
|
1810
|
+
ttlMs: se(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
|
|
1791
1811
|
});
|
|
1792
1812
|
}, rn = class extends Error {
|
|
1793
1813
|
budget;
|
|
@@ -2159,13 +2179,14 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2159
2179
|
reason: n?.message ?? String(n)
|
|
2160
2180
|
});
|
|
2161
2181
|
}
|
|
2162
|
-
}), b = (e, t, n) => m.promise(async () => {
|
|
2182
|
+
}), b = (e, t, n, r) => m.promise(async () => {
|
|
2163
2183
|
if (o.onTerminal) try {
|
|
2164
2184
|
await o.onTerminal({
|
|
2165
2185
|
workflowName: o.name,
|
|
2166
2186
|
executionId: e,
|
|
2167
2187
|
...n === void 0 ? {} : { runId: n },
|
|
2168
|
-
status: t
|
|
2188
|
+
status: t,
|
|
2189
|
+
...r === void 0 ? {} : r
|
|
2169
2190
|
});
|
|
2170
2191
|
} catch (n) {
|
|
2171
2192
|
h("failed to release the workflow admission lease", {
|
|
@@ -2253,7 +2274,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2253
2274
|
reclaimCount: n,
|
|
2254
2275
|
maxRunReclaims: r
|
|
2255
2276
|
});
|
|
2256
|
-
let t = yield*
|
|
2277
|
+
let t = yield* le;
|
|
2257
2278
|
return yield* d.suspend(t);
|
|
2258
2279
|
}
|
|
2259
2280
|
k = yield* wn(o, T, h), yield* E("failed to record workflow re-entry", m.gen(function* () {
|
|
@@ -2322,9 +2343,9 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2322
2343
|
}));
|
|
2323
2344
|
}
|
|
2324
2345
|
}));
|
|
2325
|
-
let
|
|
2326
|
-
if (d.isResult(
|
|
2327
|
-
let e =
|
|
2346
|
+
let ae = o.subject?.tenantId, oe = c(te, S).pipe(m.locally(a, T), m.locally(r, S), m.locally(t, typeof ae == "string" ? ae : void 0), m.locally(i, ie), m.locally(s, k), m.provideService(n, f)), se = o.pluginWorkflowStepLayer ? oe.pipe(m.provide(o.pluginWorkflowStepLayer)) : oe, A = yield* d.intoResult(se);
|
|
2347
|
+
if (d.isResult(A) && A._tag === "Suspended") {
|
|
2348
|
+
let e = A.cause, t = e !== void 0 && !p.isEmpty(e), n = t ? p.squash(e) : void 0, r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = t ? n?.message ?? String(n) : null;
|
|
2328
2349
|
t && (yield* m.sync(() => ee({
|
|
2329
2350
|
error: n,
|
|
2330
2351
|
source: "workflow",
|
|
@@ -2358,10 +2379,10 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2358
2379
|
} : { reason: "workflow-suspend" }
|
|
2359
2380
|
}));
|
|
2360
2381
|
})));
|
|
2361
|
-
let a = yield*
|
|
2382
|
+
let a = yield* le;
|
|
2362
2383
|
return yield* d.suspend(a);
|
|
2363
2384
|
}
|
|
2364
|
-
let
|
|
2385
|
+
let j = A;
|
|
2365
2386
|
if (k !== void 0 && T !== void 0) {
|
|
2366
2387
|
let t = k.settle();
|
|
2367
2388
|
if (t.length > 0) {
|
|
@@ -2380,8 +2401,8 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2380
2401
|
}));
|
|
2381
2402
|
}
|
|
2382
2403
|
}
|
|
2383
|
-
if (g.isFailure(
|
|
2384
|
-
let e =
|
|
2404
|
+
if (g.isFailure(j.exit)) {
|
|
2405
|
+
let e = j.exit.cause, t = p.failureOption(e), n = t._tag === "Some" ? t.value : p.squash(e), r = n && typeof n == "object" && "_tag" in n ? String(n._tag) : null, i = n?.message ?? String(n);
|
|
2385
2406
|
return yield* m.sync(() => ee({
|
|
2386
2407
|
error: n,
|
|
2387
2408
|
source: "workflow",
|
|
@@ -2413,17 +2434,21 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2413
2434
|
durationMs: Date.now() - C
|
|
2414
2435
|
}
|
|
2415
2436
|
})), yield* y(S, "failed", T);
|
|
2416
|
-
}))), yield* b(S, "failed", T
|
|
2437
|
+
}))), yield* b(S, "failed", T, {
|
|
2438
|
+
payload: te,
|
|
2439
|
+
errorTag: r,
|
|
2440
|
+
errorMessage: i
|
|
2441
|
+
}), yield* m.sync(() => o.recordRun?.({
|
|
2417
2442
|
name: o.name,
|
|
2418
2443
|
status: "failed",
|
|
2419
2444
|
durationMs: Date.now() - C
|
|
2420
2445
|
})), yield* m.failCause(e);
|
|
2421
2446
|
}
|
|
2422
|
-
let
|
|
2447
|
+
let M = j.exit.value;
|
|
2423
2448
|
return T && (yield* E("failed to record workflow success", m.gen(function* () {
|
|
2424
2449
|
let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2425
2450
|
status: "succeeded",
|
|
2426
|
-
output: X(
|
|
2451
|
+
output: X(M, l),
|
|
2427
2452
|
completedAt: /* @__PURE__ */ new Date(),
|
|
2428
2453
|
durationMs: Date.now() - C,
|
|
2429
2454
|
runnerEnteredAt: null
|
|
@@ -2441,7 +2466,7 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2441
2466
|
status: "succeeded",
|
|
2442
2467
|
durationMs: Date.now() - C,
|
|
2443
2468
|
completedAtSec: Date.now() / 1e3
|
|
2444
|
-
})),
|
|
2469
|
+
})), M;
|
|
2445
2470
|
});
|
|
2446
2471
|
}, En = (e) => e === "cancel" || e === "terminate", Dn = (e) => e === "running" || e === "suspended", On = async (e) => {
|
|
2447
2472
|
let t = await e.store.query({
|
|
@@ -2570,9 +2595,9 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2570
2595
|
}
|
|
2571
2596
|
return typeof e == "object" ? e : null;
|
|
2572
2597
|
}, Mn = async (e, t) => {
|
|
2573
|
-
let n = k(
|
|
2598
|
+
let n = k(de), r = (await t.query(n.where(ie(x("id", e), x("executionId", e))).limit(1).descriptor))[0];
|
|
2574
2599
|
if (r === void 0) return null;
|
|
2575
|
-
let i = String(r.id), a = k(
|
|
2600
|
+
let i = String(r.id), a = k(fe), o = await t.query(a.where(x("runId", i)).descriptor);
|
|
2576
2601
|
return {
|
|
2577
2602
|
id: i,
|
|
2578
2603
|
executionId: $(r.executionId) ?? "",
|
|
@@ -2638,4 +2663,4 @@ var le = f.layerMemory, ue = j("_voltro_workflow_runs", {
|
|
|
2638
2663
|
};
|
|
2639
2664
|
};
|
|
2640
2665
|
//#endregion
|
|
2641
|
-
export {
|
|
2666
|
+
export { $e as $, Ut as A, Ce as At, ut as B, de as Bt, on as C, Re as Ct, Bt as D, Te as Dt, Kt as E, ve as Et, jt as F, _e as Ft, rt as G, dt as H, kt as I, he as It, tt as J, it as K, Ot as L, me as Lt, Pt as M, ye as Mt, Et as N, P as Nt, Vt as O, xe as Ot, Mt as P, ge as Pt, et as Q, yt as R, pe as Rt, un as S, V as St, Xt as T, Ge as Tt, _t as U, ft as V, ue as Vt, W, lt as X, at as Y, ot as Z, en as _, Be as _t, vn as a, Ee as at, fn as b, Ne as bt, yn as c, We as ct, Tn as d, ze as dt, Ze as et, hn as f, Ke as ft, tn as g, Oe as gt, an as h, je as ht, _n as i, De as it, It as j, be as jt, Ht as k, we as kt, Z as l, H as lt, rn as m, Ie as mt, Mn as n, Xe as nt, Cn as o, I as ot, Y as p, U as pt, nt as q, On as r, L as rt, bn as s, Ve as st, Nn as t, Je as tt, X as u, He as ut, $t as v, Fe as vt, Yt as w, Me as wt, dn as x, Ae as xt, Qt as y, qe as yt, bt as z, fe as zt };
|