@voltro/workflow 0.34.0 → 0.35.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 +167 -0
- package/dist/{cluster-CyIyBO39.js → cluster-CVyPUB9X.js} +43 -34
- package/dist/cluster.js +1 -1
- package/dist/clusterTestSuite.js +4 -4
- package/dist/index.d.ts +192 -1
- package/dist/index.js +3 -3
- package/dist/{primitives-oLKOTbvJ.js → primitives-CyQZeT1t.js} +142 -98
- package/dist/primitives.d.ts +94 -0
- package/dist/primitives.js +2 -2
- package/dist/{src-BXObaqb-.js → src-DPkbBZDD.js} +535 -452
- package/package.json +3 -3
|
@@ -1,16 +1,16 @@
|
|
|
1
|
-
import {
|
|
1
|
+
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 "./primitives-CyQZeT1t.js";
|
|
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
|
-
import { and as b, boolean as ee, eq as x, generateId as S, gt as C, gte as te, id as w, inSet as ne, integer as T, isNull as E, json as D, lt as O, or as k, queryFor as A, reference as
|
|
5
|
-
import { createHash as
|
|
6
|
-
import { WorkflowInstance as
|
|
7
|
-
import { publishServerError as
|
|
4
|
+
import { and as b, boolean as ee, eq as x, generateId as S, gt as C, gte as te, id as w, inSet as ne, integer as T, isNull as E, json as D, lt as O, or as k, queryFor as A, reference as re, registerRetention as ie, retentionTtlMsFromEnv as ae, table as j, text as M, timestamp as N } from "@voltro/database";
|
|
5
|
+
import { createHash as oe } from "node:crypto";
|
|
6
|
+
import { WorkflowInstance as se } from "@effect/workflow/WorkflowEngine";
|
|
7
|
+
import { publishServerError as ce } from "@voltro/protocol";
|
|
8
8
|
//#region src/inMemoryLayer.ts
|
|
9
|
-
var
|
|
9
|
+
var le = f.layerMemory, P = j("_voltro_workflow_runs", {
|
|
10
10
|
id: w({ prefix: "wfrun" }),
|
|
11
|
-
tag:
|
|
12
|
-
executionId:
|
|
13
|
-
status:
|
|
11
|
+
tag: M(),
|
|
12
|
+
executionId: M().unique(),
|
|
13
|
+
status: M().oneOf([
|
|
14
14
|
"running",
|
|
15
15
|
"succeeded",
|
|
16
16
|
"failed",
|
|
@@ -18,37 +18,37 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
18
18
|
"suspended"
|
|
19
19
|
]).default("running"),
|
|
20
20
|
payload: D(),
|
|
21
|
-
workflowVersion:
|
|
21
|
+
workflowVersion: M().nullable(),
|
|
22
22
|
workflowPatches: D().nullable(),
|
|
23
|
-
runnerEnteredAt:
|
|
23
|
+
runnerEnteredAt: N().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: M().nullable(),
|
|
28
|
+
errorTag: M().nullable(),
|
|
29
|
+
errorMessage: M().nullable(),
|
|
30
30
|
cancelled: ee().default(!1),
|
|
31
|
-
discardedAt:
|
|
32
|
-
discardedBy:
|
|
33
|
-
startedAt:
|
|
34
|
-
completedAt:
|
|
31
|
+
discardedAt: N().nullable(),
|
|
32
|
+
discardedBy: M().nullable(),
|
|
33
|
+
startedAt: N().default("now"),
|
|
34
|
+
completedAt: N().nullable(),
|
|
35
35
|
durationMs: T().nullable(),
|
|
36
|
-
traceId:
|
|
37
|
-
parentExecutionId:
|
|
38
|
-
parentClosePolicy:
|
|
36
|
+
traceId: M().nullable(),
|
|
37
|
+
parentExecutionId: M().nullable(),
|
|
38
|
+
parentClosePolicy: M().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"]), ue =
|
|
43
|
+
}).index(["tag"]).index(["status"]).index(["source"]).index(["startedAt"]).index(["parentExecutionId"]).index(["parentClosePolicy"]), ue = j("_voltro_workflow_run_steps", {
|
|
44
44
|
id: w({ prefix: "wfstep" }),
|
|
45
|
-
runId:
|
|
45
|
+
runId: re(() => P, {
|
|
46
46
|
index: !1,
|
|
47
47
|
onDelete: "cascade"
|
|
48
48
|
}),
|
|
49
|
-
stepName:
|
|
49
|
+
stepName: M(),
|
|
50
50
|
attempt: T().default(1),
|
|
51
|
-
status:
|
|
51
|
+
status: M().oneOf([
|
|
52
52
|
"running",
|
|
53
53
|
"succeeded",
|
|
54
54
|
"failed"
|
|
@@ -56,43 +56,43 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
56
56
|
input: D().nullable(),
|
|
57
57
|
retryPolicy: D().nullable(),
|
|
58
58
|
output: D().nullable(),
|
|
59
|
-
errorTag:
|
|
60
|
-
errorMessage:
|
|
59
|
+
errorTag: M().nullable(),
|
|
60
|
+
errorMessage: M().nullable(),
|
|
61
61
|
errorCause: D().nullable(),
|
|
62
|
-
startedAt:
|
|
63
|
-
completedAt:
|
|
62
|
+
startedAt: N().default("now"),
|
|
63
|
+
completedAt: N().nullable(),
|
|
64
64
|
durationMs: T().nullable()
|
|
65
|
-
}).index(["runId", "stepName"]).index(["startedAt"]), de =
|
|
65
|
+
}).index(["runId", "stepName"]).index(["startedAt"]), de = j("_voltro_workflow_run_events", {
|
|
66
66
|
id: w({ prefix: "wfev" }),
|
|
67
|
-
runId:
|
|
67
|
+
runId: re(() => P, {
|
|
68
68
|
index: !1,
|
|
69
69
|
onDelete: "cascade"
|
|
70
70
|
}),
|
|
71
|
-
eventType:
|
|
71
|
+
eventType: M(),
|
|
72
72
|
payload: D().nullable(),
|
|
73
|
-
occurredAt:
|
|
74
|
-
stepName:
|
|
73
|
+
occurredAt: N().default("now"),
|
|
74
|
+
stepName: M().nullable(),
|
|
75
75
|
attempt: T().nullable()
|
|
76
|
-
}).index(["runId", "occurredAt"]).index(["eventType"]), fe =
|
|
76
|
+
}).index(["runId", "occurredAt"]).index(["eventType"]), fe = j("_voltro_workflow_start_contexts", {
|
|
77
77
|
id: w({ prefix: "wfctx" }),
|
|
78
|
-
workflowName:
|
|
79
|
-
executionId:
|
|
78
|
+
workflowName: M(),
|
|
79
|
+
executionId: M().unique(),
|
|
80
80
|
subject: D().nullable(),
|
|
81
|
-
traceId:
|
|
82
|
-
source:
|
|
83
|
-
parentExecutionId:
|
|
84
|
-
parentClosePolicy:
|
|
81
|
+
traceId: M().nullable(),
|
|
82
|
+
source: M().nullable(),
|
|
83
|
+
parentExecutionId: M().nullable(),
|
|
84
|
+
parentClosePolicy: M().oneOf([
|
|
85
85
|
"cancel",
|
|
86
86
|
"terminate",
|
|
87
87
|
"abandon"
|
|
88
88
|
]).nullable(),
|
|
89
|
-
createdAt:
|
|
90
|
-
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), pe =
|
|
89
|
+
createdAt: N().default("now")
|
|
90
|
+
}).index(["workflowName"]).index(["executionId"]).index(["parentExecutionId"]), pe = j("_voltro_workflow_pending", {
|
|
91
91
|
id: w({ prefix: "wfp" }),
|
|
92
|
-
tenantId:
|
|
93
|
-
workflowName:
|
|
94
|
-
controlKey:
|
|
95
|
-
mode:
|
|
92
|
+
tenantId: M().nullable(),
|
|
93
|
+
workflowName: M(),
|
|
94
|
+
controlKey: M(),
|
|
95
|
+
mode: M().oneOf([
|
|
96
96
|
"debounce",
|
|
97
97
|
"batch",
|
|
98
98
|
"throttle",
|
|
@@ -102,18 +102,18 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
102
102
|
payload: D(),
|
|
103
103
|
callerContext: D().nullable(),
|
|
104
104
|
priority: T().default(0),
|
|
105
|
-
dueAt:
|
|
106
|
-
deadlineAt:
|
|
105
|
+
dueAt: N(),
|
|
106
|
+
deadlineAt: N().nullable(),
|
|
107
107
|
collapsed: T().default(1),
|
|
108
|
-
firstSeenAt:
|
|
109
|
-
updatedAt:
|
|
108
|
+
firstSeenAt: N().default("now"),
|
|
109
|
+
updatedAt: N().default("now"),
|
|
110
110
|
attempts: T().default(0),
|
|
111
|
-
lastError:
|
|
112
|
-
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), me =
|
|
111
|
+
lastError: M().nullable()
|
|
112
|
+
}).index(["workflowName", "controlKey"]).index(["dueAt"]).index(["workflowName", "mode"]).index(["tenantId"]), me = j("_voltro_workflow_admissions", {
|
|
113
113
|
id: w({ prefix: "wfadm" }),
|
|
114
|
-
tenantId:
|
|
115
|
-
workflowName:
|
|
116
|
-
outcome:
|
|
114
|
+
tenantId: M().nullable(),
|
|
115
|
+
workflowName: M(),
|
|
116
|
+
outcome: M().oneOf([
|
|
117
117
|
"admitted",
|
|
118
118
|
"dropped",
|
|
119
119
|
"skipped",
|
|
@@ -121,23 +121,23 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
121
121
|
"expired",
|
|
122
122
|
"discarded"
|
|
123
123
|
]),
|
|
124
|
-
mode:
|
|
125
|
-
reason:
|
|
124
|
+
mode: M().nullable(),
|
|
125
|
+
reason: M().nullable(),
|
|
126
126
|
collapsed: T().default(1),
|
|
127
127
|
waitedMs: T().nullable(),
|
|
128
|
-
executionId:
|
|
129
|
-
runId:
|
|
130
|
-
singletonKey:
|
|
131
|
-
concurrencyKey:
|
|
132
|
-
rateKey:
|
|
133
|
-
admittedAt:
|
|
134
|
-
expiresAt:
|
|
135
|
-
releasedAt:
|
|
136
|
-
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), he =
|
|
128
|
+
executionId: M().nullable(),
|
|
129
|
+
runId: M().nullable(),
|
|
130
|
+
singletonKey: M().nullable(),
|
|
131
|
+
concurrencyKey: M().nullable(),
|
|
132
|
+
rateKey: M().nullable(),
|
|
133
|
+
admittedAt: N().default("now"),
|
|
134
|
+
expiresAt: N().nullable(),
|
|
135
|
+
releasedAt: N().nullable()
|
|
136
|
+
}).index(["workflowName", "admittedAt"]).index(["concurrencyKey", "releasedAt"]).index(["singletonKey", "releasedAt"]).index(["rateKey", "admittedAt"]).index(["executionId"]).index(["tenantId"]), he = j("_voltro_workflow_pauses", {
|
|
137
137
|
id: w({ prefix: "wfpause" }),
|
|
138
|
-
pausedAt:
|
|
139
|
-
pausedBy:
|
|
140
|
-
reason:
|
|
138
|
+
pausedAt: N().default("now"),
|
|
139
|
+
pausedBy: M().nullable(),
|
|
140
|
+
reason: M().nullable()
|
|
141
141
|
}), ge = class extends Error {
|
|
142
142
|
workflowName;
|
|
143
143
|
field;
|
|
@@ -267,15 +267,15 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
267
267
|
}, Se = (e, t, n) => {
|
|
268
268
|
let r = e.timeouts?.finishMs;
|
|
269
269
|
return r === void 0 || t.terminal ? !1 : n - t.startedAt >= r;
|
|
270
|
-
}, Ce = (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, R = "_voltro_workflow_pending", z = "_voltro_workflow_admissions",
|
|
270
|
+
}, Ce = (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, R = "_voltro_workflow_pending", z = "_voltro_workflow_admissions", we = "_voltro_workflow_pauses", Te = 1440 * 60 * 1e3, Ee = (e, t, n) => `wfp_${oe("sha256").update(`${e}\u0000${t}\u0000${n}`).digest("hex").slice(0, 40)}`, B = (e) => {
|
|
271
271
|
if (e instanceof Date) return e.getTime();
|
|
272
272
|
if (typeof e == "number") return e;
|
|
273
273
|
let t = Date.parse(String(e));
|
|
274
274
|
return Number.isNaN(t) ? 0 : t;
|
|
275
|
-
},
|
|
275
|
+
}, V = (e, t) => {
|
|
276
276
|
let n = typeof e == "number" ? e : Number(e);
|
|
277
277
|
return Number.isFinite(n) ? Math.trunc(n) : t;
|
|
278
|
-
},
|
|
278
|
+
}, De = (e) => ({
|
|
279
279
|
id: String(e.id),
|
|
280
280
|
tenantId: e.tenantId === null || e.tenantId === void 0 ? null : String(e.tenantId),
|
|
281
281
|
workflowName: String(e.workflowName),
|
|
@@ -283,25 +283,25 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
283
283
|
mode: String(e.mode),
|
|
284
284
|
payload: e.payload,
|
|
285
285
|
callerContext: e.callerContext ?? null,
|
|
286
|
-
priority:
|
|
287
|
-
dueAt:
|
|
288
|
-
deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 :
|
|
289
|
-
collapsed:
|
|
290
|
-
firstSeenAt:
|
|
291
|
-
attempts:
|
|
286
|
+
priority: V(e.priority, 0),
|
|
287
|
+
dueAt: B(e.dueAt),
|
|
288
|
+
deadlineAt: e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : B(e.deadlineAt),
|
|
289
|
+
collapsed: V(e.collapsed, 1),
|
|
290
|
+
firstSeenAt: B(e.firstSeenAt),
|
|
291
|
+
attempts: V(e.attempts, 0),
|
|
292
292
|
lastError: e.lastError === null || e.lastError === void 0 ? null : String(e.lastError)
|
|
293
|
-
}),
|
|
293
|
+
}), H = (e, t, n, r) => ({
|
|
294
294
|
table: e,
|
|
295
295
|
predicate: t,
|
|
296
296
|
order: n,
|
|
297
297
|
take: r,
|
|
298
298
|
skip: void 0,
|
|
299
299
|
projection: void 0
|
|
300
|
-
}),
|
|
301
|
-
let t = await e.query(
|
|
300
|
+
}), Oe = async (e) => {
|
|
301
|
+
let t = await e.query(H(we, void 0, [], 1e3));
|
|
302
302
|
return new Set(t.map((e) => String(e.id)));
|
|
303
|
-
},
|
|
304
|
-
await e.upsert(
|
|
303
|
+
}, ke = async (e, t, n, r) => {
|
|
304
|
+
await e.upsert(we, {
|
|
305
305
|
id: t,
|
|
306
306
|
pausedAt: /* @__PURE__ */ new Date(),
|
|
307
307
|
pausedBy: n,
|
|
@@ -314,43 +314,43 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
314
314
|
"reason"
|
|
315
315
|
]
|
|
316
316
|
});
|
|
317
|
-
},
|
|
317
|
+
}, Ae = async (e, t) => e.delete(we, t), je = async (e) => {
|
|
318
318
|
let { store: t, control: n, keys: r, now: i } = e, a = { paused: e.paused }, o = [];
|
|
319
319
|
n.debounce !== void 0 && r.debounceKey !== void 0 && o.push((async () => {
|
|
320
|
-
let e = (await t.query(
|
|
320
|
+
let e = (await t.query(H(R, b(x("workflowName", n.workflowName), x("controlKey", r.debounceKey), x("mode", "debounce")), [], 1)))[0];
|
|
321
321
|
if (e === void 0) return;
|
|
322
|
-
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 :
|
|
322
|
+
let i = e.deadlineAt === null || e.deadlineAt === void 0 ? void 0 : B(e.deadlineAt);
|
|
323
323
|
a.debouncePending = {
|
|
324
|
-
firstSeenAt:
|
|
325
|
-
collapsed:
|
|
324
|
+
firstSeenAt: B(e.firstSeenAt),
|
|
325
|
+
collapsed: V(e.collapsed, 1),
|
|
326
326
|
...i === void 0 ? {} : { deadlineAt: i }
|
|
327
327
|
};
|
|
328
328
|
})()), n.batch !== void 0 && r.batchKey !== void 0 && o.push((async () => {
|
|
329
|
-
let e = await t.query(
|
|
329
|
+
let e = await t.query(H(R, b(x("workflowName", n.workflowName), x("controlKey", r.batchKey), x("mode", "batch")), [{
|
|
330
330
|
column: "firstSeenAt",
|
|
331
331
|
direction: "asc"
|
|
332
332
|
}], n.batch.maxSize + 1));
|
|
333
333
|
e.length !== 0 && (a.batchPending = {
|
|
334
334
|
count: e.length,
|
|
335
|
-
firstSeenAt:
|
|
335
|
+
firstSeenAt: B(e[0].firstSeenAt)
|
|
336
336
|
});
|
|
337
337
|
})()), n.singleton !== void 0 && r.singletonKey !== void 0 && o.push((async () => {
|
|
338
|
-
let e = await
|
|
338
|
+
let e = await Me(t, n.workflowName, r.singletonKey, i);
|
|
339
339
|
e !== void 0 && (a.singletonHolder = e);
|
|
340
340
|
})()), n.concurrency !== void 0 && r.concurrencyKey !== void 0 && o.push((async () => {
|
|
341
|
-
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(
|
|
341
|
+
let e = n.concurrency.pool === void 0 ? [x("workflowName", n.workflowName)] : [], o = await t.query(H(z, b(...e, x("concurrencyKey", r.concurrencyKey), E("releasedAt"), C("expiresAt", new Date(i))), [], n.concurrency.limit));
|
|
342
342
|
a.inFlight = o.length;
|
|
343
343
|
})());
|
|
344
344
|
let s = n.rateLimit ?? n.throttle, c = r.rateLimitKey ?? r.throttleKey;
|
|
345
345
|
return s !== void 0 && c !== void 0 && o.push((async () => {
|
|
346
|
-
let e = await t.query(
|
|
346
|
+
let e = await t.query(H(z, b(x("workflowName", n.workflowName), x("rateKey", c), x("outcome", "admitted"), C("admittedAt", new Date(i - s.periodMs))), [{
|
|
347
347
|
column: "admittedAt",
|
|
348
348
|
direction: "desc"
|
|
349
349
|
}], s.limit));
|
|
350
|
-
a.recentAdmissions = e.map((e) =>
|
|
350
|
+
a.recentAdmissions = e.map((e) => B(e.admittedAt));
|
|
351
351
|
})()), await Promise.all(o), a;
|
|
352
|
-
},
|
|
353
|
-
let i = (await e.query(
|
|
352
|
+
}, Me = async (e, t, n, r) => {
|
|
353
|
+
let i = (await e.query(H(z, b(x("workflowName", t), x("singletonKey", n), E("releasedAt"), C("expiresAt", new Date(r))), [{
|
|
354
354
|
column: "admittedAt",
|
|
355
355
|
direction: "desc"
|
|
356
356
|
}], 1)))[0];
|
|
@@ -359,19 +359,19 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
359
359
|
if (a != null) return {
|
|
360
360
|
executionId: String(a),
|
|
361
361
|
runId: i.runId === null || i.runId === void 0 ? "" : String(i.runId),
|
|
362
|
-
admittedAt:
|
|
362
|
+
admittedAt: B(i.admittedAt)
|
|
363
363
|
};
|
|
364
|
-
},
|
|
365
|
-
let { store: t, control: n, decision: r, now: i } = e, a =
|
|
364
|
+
}, Ne = async (e) => {
|
|
365
|
+
let { store: t, control: n, decision: r, now: i } = e, a = Fe(r.mode, r.keys);
|
|
366
366
|
if (r.collapse === "hold") {
|
|
367
|
-
let o = e.existingId ??
|
|
367
|
+
let o = e.existingId ?? Ee(n.workflowName, r.mode, a);
|
|
368
368
|
return await t.update(R, o, {
|
|
369
369
|
dueAt: new Date(r.dueAt),
|
|
370
370
|
updatedAt: new Date(i)
|
|
371
371
|
}), o;
|
|
372
372
|
}
|
|
373
373
|
if (r.collapse === "replace") {
|
|
374
|
-
let o =
|
|
374
|
+
let o = Ee(n.workflowName, r.mode, a);
|
|
375
375
|
return await t.upsert(R, {
|
|
376
376
|
id: o,
|
|
377
377
|
tenantId: e.tenantId,
|
|
@@ -396,7 +396,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
396
396
|
priority: r.keys.priority,
|
|
397
397
|
dueAt: new Date(r.dueAt),
|
|
398
398
|
deadlineAt: r.deadlineAt === void 0 ? t.deadlineAt ?? null : new Date(r.deadlineAt),
|
|
399
|
-
collapsed:
|
|
399
|
+
collapsed: V(t.collapsed, 1) + 1,
|
|
400
400
|
updatedAt: new Date(i)
|
|
401
401
|
})
|
|
402
402
|
}), o;
|
|
@@ -418,7 +418,28 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
418
418
|
lastError: null
|
|
419
419
|
});
|
|
420
420
|
return String(o.id);
|
|
421
|
-
},
|
|
421
|
+
}, Pe = async (e) => {
|
|
422
|
+
let t = await e.store.insert(R, {
|
|
423
|
+
tenantId: e.tenantId,
|
|
424
|
+
workflowName: e.workflowName,
|
|
425
|
+
controlKey: "",
|
|
426
|
+
mode: "delayed",
|
|
427
|
+
payload: e.payload,
|
|
428
|
+
callerContext: e.callerContext ?? null,
|
|
429
|
+
priority: 0,
|
|
430
|
+
dueAt: new Date(e.at),
|
|
431
|
+
deadlineAt: null,
|
|
432
|
+
collapsed: 1,
|
|
433
|
+
firstSeenAt: new Date(e.now),
|
|
434
|
+
updatedAt: new Date(e.now),
|
|
435
|
+
attempts: 0,
|
|
436
|
+
lastError: null
|
|
437
|
+
});
|
|
438
|
+
return {
|
|
439
|
+
intentId: String(t.id),
|
|
440
|
+
dueAt: e.at
|
|
441
|
+
};
|
|
442
|
+
}, Fe = (e, t) => {
|
|
422
443
|
switch (e) {
|
|
423
444
|
case "debounce": return t.debounceKey ?? "";
|
|
424
445
|
case "batch": return t.batchKey ?? "";
|
|
@@ -426,7 +447,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
426
447
|
case "concurrency": return t.concurrencyKey ?? "";
|
|
427
448
|
default: return "";
|
|
428
449
|
}
|
|
429
|
-
},
|
|
450
|
+
}, U = async (e) => {
|
|
430
451
|
let { control: t, keys: n, now: r } = e, i = t.timeouts?.finishMs ?? 864e5, a = await e.store.insert(z, {
|
|
431
452
|
tenantId: e.tenantId,
|
|
432
453
|
workflowName: t.workflowName,
|
|
@@ -445,29 +466,29 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
445
466
|
releasedAt: e.outcome === "admitted" ? null : new Date(r)
|
|
446
467
|
});
|
|
447
468
|
return String(a.id);
|
|
448
|
-
},
|
|
449
|
-
let r = await e.query(
|
|
469
|
+
}, W = async (e, t, n) => {
|
|
470
|
+
let r = await e.query(H(z, b(x("executionId", t), x("outcome", "admitted"), E("releasedAt")), [], 10));
|
|
450
471
|
return r.length === 0 ? !1 : (await Promise.all(r.map((t) => e.update(z, String(t.id), { releasedAt: new Date(n) }))), !0);
|
|
451
|
-
},
|
|
452
|
-
let r = (await e.query(
|
|
472
|
+
}, Ie = async (e, t, n) => (await Le(e, t, n)).due, Le = async (e, t, n) => {
|
|
473
|
+
let r = (await e.query(H(R, void 0, [{
|
|
453
474
|
column: "priority",
|
|
454
475
|
direction: "desc"
|
|
455
476
|
}, {
|
|
456
477
|
column: "firstSeenAt",
|
|
457
478
|
direction: "asc"
|
|
458
|
-
}], n))).map(
|
|
479
|
+
}], n))).map(De), i;
|
|
459
480
|
for (let e of r) e.dueAt <= t || (i === void 0 || e.dueAt < i) && (i = e.dueAt);
|
|
460
481
|
return {
|
|
461
482
|
due: r.filter((e) => e.dueAt <= t).sort(Ce),
|
|
462
483
|
nextDueAt: i
|
|
463
484
|
};
|
|
464
|
-
},
|
|
485
|
+
}, Re = async (e, t) => (await e.query(H(R, void 0, [{
|
|
465
486
|
column: "firstSeenAt",
|
|
466
487
|
direction: "asc"
|
|
467
|
-
}], t))).map(
|
|
468
|
-
let i = (await e.query(
|
|
488
|
+
}], t))).map(De), G = async (e, t) => e.delete(R, t), ze = async (e, t, n, r) => {
|
|
489
|
+
let i = (await e.query(H(R, x("id", t), [], 1)))[0];
|
|
469
490
|
if (i === void 0) return !1;
|
|
470
|
-
let a =
|
|
491
|
+
let a = De(i);
|
|
471
492
|
try {
|
|
472
493
|
await e.insert(z, {
|
|
473
494
|
tenantId: a.tenantId,
|
|
@@ -488,14 +509,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
488
509
|
});
|
|
489
510
|
} catch {}
|
|
490
511
|
return e.delete(R, t);
|
|
491
|
-
},
|
|
512
|
+
}, Be = async (e, t, n, r) => {
|
|
492
513
|
await e.update(R, t.id, {
|
|
493
514
|
attempts: t.attempts + 1,
|
|
494
515
|
lastError: n.slice(0, 500),
|
|
495
516
|
updatedAt: new Date(r)
|
|
496
517
|
});
|
|
497
|
-
},
|
|
498
|
-
let t = await
|
|
518
|
+
}, Ve = async (e) => {
|
|
519
|
+
let t = await je({
|
|
499
520
|
store: e.store,
|
|
500
521
|
control: e.control,
|
|
501
522
|
keys: e.keys,
|
|
@@ -509,14 +530,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
509
530
|
now: e.now,
|
|
510
531
|
reconsidering: e.reconsidering
|
|
511
532
|
});
|
|
512
|
-
},
|
|
513
|
-
let r = await e.query(
|
|
533
|
+
}, He = async (e, t, n = 1e3) => {
|
|
534
|
+
let r = await e.query(H(z, void 0, [{
|
|
514
535
|
column: "admittedAt",
|
|
515
536
|
direction: "asc"
|
|
516
|
-
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null &&
|
|
537
|
+
}], n)), i = t.getTime(), a = r.filter((e) => e.releasedAt != null && B(e.admittedAt) < i);
|
|
517
538
|
return await Promise.all(a.map((t) => e.delete(z, String(t.id)))), a.length;
|
|
518
|
-
},
|
|
519
|
-
let { store: t, control: n, now: r } = e, i = I(n, e.payload), a = await
|
|
539
|
+
}, Ue = async (e) => {
|
|
540
|
+
let { store: t, control: n, now: r } = e, i = I(n, e.payload), a = await Ve({
|
|
520
541
|
store: t,
|
|
521
542
|
control: n,
|
|
522
543
|
keys: i,
|
|
@@ -524,7 +545,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
524
545
|
now: r,
|
|
525
546
|
reconsidering: !1
|
|
526
547
|
});
|
|
527
|
-
if (a.kind === "drop") return await
|
|
548
|
+
if (a.kind === "drop") return await U({
|
|
528
549
|
store: t,
|
|
529
550
|
control: n,
|
|
530
551
|
keys: i,
|
|
@@ -541,7 +562,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
541
562
|
kind: "dropped",
|
|
542
563
|
retryAfterMs: a.retryAfterMs
|
|
543
564
|
};
|
|
544
|
-
if (a.kind === "skip") return await
|
|
565
|
+
if (a.kind === "skip") return await U({
|
|
545
566
|
store: t,
|
|
546
567
|
control: n,
|
|
547
568
|
keys: i,
|
|
@@ -561,7 +582,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
561
582
|
};
|
|
562
583
|
if (a.kind === "defer") return {
|
|
563
584
|
kind: "queued",
|
|
564
|
-
intentId: await
|
|
585
|
+
intentId: await Ne({
|
|
565
586
|
store: t,
|
|
566
587
|
control: n,
|
|
567
588
|
decision: a,
|
|
@@ -575,12 +596,12 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
575
596
|
};
|
|
576
597
|
let o = e.payload, s = [], c = 1;
|
|
577
598
|
if (n.batch !== void 0 && i.batchKey !== void 0) {
|
|
578
|
-
let r = await
|
|
599
|
+
let r = await We(t, n.workflowName, i.batchKey, n.batch.maxSize);
|
|
579
600
|
o = { items: [...r.map((e) => e.payload), e.payload] }, s = r.map((e) => e.id), c = r.length + 1;
|
|
580
601
|
}
|
|
581
602
|
return {
|
|
582
603
|
kind: "start",
|
|
583
|
-
ledgerId: await
|
|
604
|
+
ledgerId: await U({
|
|
584
605
|
store: t,
|
|
585
606
|
control: n,
|
|
586
607
|
keys: i,
|
|
@@ -603,7 +624,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
603
624
|
runId: a.evict.runId
|
|
604
625
|
} }
|
|
605
626
|
};
|
|
606
|
-
},
|
|
627
|
+
}, We = async (e, t, n, r) => (await e.query({
|
|
607
628
|
table: "_voltro_workflow_pending",
|
|
608
629
|
predicate: b(x("workflowName", t), x("controlKey", n), x("mode", "batch")),
|
|
609
630
|
order: [{
|
|
@@ -616,22 +637,22 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
616
637
|
})).map((e) => ({
|
|
617
638
|
id: String(e.id),
|
|
618
639
|
payload: e.payload
|
|
619
|
-
})),
|
|
640
|
+
})), Ge = async (e, t, n, r) => {
|
|
620
641
|
await e.update("_voltro_workflow_admissions", t, {
|
|
621
642
|
executionId: n,
|
|
622
643
|
runId: r
|
|
623
644
|
});
|
|
624
|
-
},
|
|
645
|
+
}, Ke = j("_voltro_workflow_watermarks", {
|
|
625
646
|
id: w({ prefix: "wfwm" }),
|
|
626
|
-
positionAt:
|
|
627
|
-
updatedAt:
|
|
628
|
-
}),
|
|
647
|
+
positionAt: N(),
|
|
648
|
+
updatedAt: N().default("now")
|
|
649
|
+
}), qe = (e) => {
|
|
629
650
|
let t = e instanceof Error ? e.message : String(e);
|
|
630
651
|
return t.length > 400 ? `${t.slice(0, 400)}…` : t;
|
|
631
|
-
},
|
|
652
|
+
}, Je = (e) => {
|
|
632
653
|
let t = [], n = [], r = [], i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set(), o = e.payloadSchema === void 0 ? (e) => h.right(e) : (t) => {
|
|
633
654
|
let n = y.decodeUnknownEither(e.payloadSchema)(t);
|
|
634
|
-
return h.isRight(n) ? h.right(n.right) : h.left(
|
|
655
|
+
return h.isRight(n) ? h.right(n.right) : h.left(qe(n.left));
|
|
635
656
|
}, s = e.runs.map((e) => ({
|
|
636
657
|
run: e,
|
|
637
658
|
decoded: o(e.payload)
|
|
@@ -648,7 +669,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
648
669
|
workflowName: e.workflowName,
|
|
649
670
|
event: o.event,
|
|
650
671
|
subject: l.id,
|
|
651
|
-
detail:
|
|
672
|
+
detail: qe(u.left)
|
|
652
673
|
});
|
|
653
674
|
continue;
|
|
654
675
|
}
|
|
@@ -668,7 +689,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
668
689
|
workflowName: e.workflowName,
|
|
669
690
|
event: o.event,
|
|
670
691
|
subject: n,
|
|
671
|
-
detail:
|
|
692
|
+
detail: qe(t)
|
|
672
693
|
}), !1;
|
|
673
694
|
}
|
|
674
695
|
};
|
|
@@ -691,26 +712,26 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
691
712
|
discards: n,
|
|
692
713
|
problems: r
|
|
693
714
|
};
|
|
694
|
-
},
|
|
715
|
+
}, Ye = (e) => {
|
|
695
716
|
let t;
|
|
696
717
|
for (let n of e) (t === void 0 || n.occurredAt.getTime() > t.getTime()) && (t = n.occurredAt);
|
|
697
718
|
return t;
|
|
698
|
-
},
|
|
719
|
+
}, Xe = "_voltro_workflow_watermarks", Ze = "_voltro_workflow_events", K = "cancelOn", Qe = 3600 * 1e3, $e = 500, q = (e) => {
|
|
699
720
|
if (e instanceof Date) return e;
|
|
700
721
|
if (typeof e == "number") return new Date(e);
|
|
701
722
|
if (typeof e == "string") {
|
|
702
723
|
let t = new Date(e);
|
|
703
724
|
if (!Number.isNaN(t.getTime())) return t;
|
|
704
725
|
}
|
|
705
|
-
}, J = (e) => e instanceof Error ? e.message : String(e),
|
|
706
|
-
table:
|
|
726
|
+
}, J = (e) => e instanceof Error ? e.message : String(e), et = async (e, t) => q((await e.query({
|
|
727
|
+
table: Xe,
|
|
707
728
|
predicate: x("id", t),
|
|
708
729
|
order: [],
|
|
709
730
|
take: 1,
|
|
710
731
|
skip: void 0,
|
|
711
732
|
projection: void 0
|
|
712
|
-
}))[0]?.positionAt),
|
|
713
|
-
await e.upsert(
|
|
733
|
+
}))[0]?.positionAt), tt = async (e, t, n) => {
|
|
734
|
+
await e.upsert(Xe, {
|
|
714
735
|
id: t,
|
|
715
736
|
positionAt: n,
|
|
716
737
|
updatedAt: /* @__PURE__ */ new Date()
|
|
@@ -727,7 +748,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
727
748
|
};
|
|
728
749
|
}
|
|
729
750
|
});
|
|
730
|
-
},
|
|
751
|
+
}, nt = async (e, t, n) => {
|
|
731
752
|
let r = async (r) => e.query({
|
|
732
753
|
table: "_voltro_workflow_runs",
|
|
733
754
|
predicate: b(x("tag", t), x("status", r)),
|
|
@@ -748,7 +769,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
748
769
|
startedAt: n
|
|
749
770
|
}];
|
|
750
771
|
});
|
|
751
|
-
},
|
|
772
|
+
}, rt = async (e, t, n) => (await e.query({
|
|
752
773
|
table: "_voltro_workflow_pending",
|
|
753
774
|
predicate: x("workflowName", t),
|
|
754
775
|
order: [{
|
|
@@ -765,7 +786,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
765
786
|
payload: t.payload,
|
|
766
787
|
firstSeenAt: n
|
|
767
788
|
}];
|
|
768
|
-
}),
|
|
789
|
+
}), it = async (e, t) => {
|
|
769
790
|
let n = t.workflows.filter((e) => e.entries.length > 0);
|
|
770
791
|
if (n.length === 0) return {
|
|
771
792
|
examined: !1,
|
|
@@ -780,8 +801,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
780
801
|
};
|
|
781
802
|
let r = e.now?.() ?? Date.now(), i = t.batch ?? 500, a = t.coldLookbackMs ?? 36e5, o = /* @__PURE__ */ new Set();
|
|
782
803
|
for (let e of n) for (let t of e.entries) o.add(t.event);
|
|
783
|
-
let s = await
|
|
784
|
-
table:
|
|
804
|
+
let s = await et(e.store, K), c = s ?? new Date(r - a), l = await e.store.query({
|
|
805
|
+
table: Ze,
|
|
785
806
|
predicate: te("occurredAt", c),
|
|
786
807
|
order: [{
|
|
787
808
|
column: "occurredAt",
|
|
@@ -806,7 +827,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
806
827
|
if (n.length === 0) continue;
|
|
807
828
|
let r = [], i = [];
|
|
808
829
|
try {
|
|
809
|
-
r = await
|
|
830
|
+
r = await nt(e.store, t.workflowName, _), i = await rt(e.store, t.workflowName, _), (r.length >= _ || i.length >= _) && (h = !0);
|
|
810
831
|
} catch (e) {
|
|
811
832
|
f.push({
|
|
812
833
|
subject: t.workflowName,
|
|
@@ -814,7 +835,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
814
835
|
}), g = !0;
|
|
815
836
|
continue;
|
|
816
837
|
}
|
|
817
|
-
let a =
|
|
838
|
+
let a = Je({
|
|
818
839
|
workflowName: t.workflowName,
|
|
819
840
|
entries: t.entries,
|
|
820
841
|
payloadSchema: t.payloadSchema,
|
|
@@ -856,10 +877,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
856
877
|
});
|
|
857
878
|
}
|
|
858
879
|
}
|
|
859
|
-
let v =
|
|
880
|
+
let v = Ye(u), y = s;
|
|
860
881
|
if (g) e.log?.warn("workflow.cancelOn: holding the watermark — some workflows could not be evaluated", { failures: f.length });
|
|
861
882
|
else if (v !== void 0) try {
|
|
862
|
-
await
|
|
883
|
+
await tt(e.store, K, v), y = v;
|
|
863
884
|
} catch (e) {
|
|
864
885
|
f.push({
|
|
865
886
|
subject: K,
|
|
@@ -867,7 +888,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
867
888
|
});
|
|
868
889
|
}
|
|
869
890
|
else if (s === void 0) try {
|
|
870
|
-
await
|
|
891
|
+
await tt(e.store, K, c), y = c;
|
|
871
892
|
} catch (e) {
|
|
872
893
|
f.push({
|
|
873
894
|
subject: K,
|
|
@@ -888,14 +909,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
888
909
|
failures: f,
|
|
889
910
|
watermark: y
|
|
890
911
|
};
|
|
891
|
-
},
|
|
912
|
+
}, at = 1800 * 1e3, ot = 200, st = 20, Y = (e) => {
|
|
892
913
|
if (e instanceof Date) return e;
|
|
893
914
|
if (typeof e == "number") return new Date(e);
|
|
894
915
|
if (typeof e == "string") {
|
|
895
916
|
let t = new Date(e);
|
|
896
917
|
if (!Number.isNaN(t.getTime())) return t;
|
|
897
918
|
}
|
|
898
|
-
},
|
|
919
|
+
}, ct = (e) => e instanceof Error ? e.message : String(e), lt = async (e, t, n) => (await e.query({
|
|
899
920
|
table: "_voltro_workflow_run_events",
|
|
900
921
|
predicate: x("runId", t),
|
|
901
922
|
order: [{
|
|
@@ -912,7 +933,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
912
933
|
occurredAt: n,
|
|
913
934
|
payload: t.payload
|
|
914
935
|
}];
|
|
915
|
-
}),
|
|
936
|
+
}), ut = async (e, t) => {
|
|
916
937
|
let n = (await e.query({
|
|
917
938
|
table: "_voltro_workflow_run_steps",
|
|
918
939
|
predicate: x("runId", t),
|
|
@@ -927,7 +948,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
927
948
|
if (n === void 0) return;
|
|
928
949
|
let r = Y(n.startedAt), i = Y(n.completedAt);
|
|
929
950
|
return r === void 0 ? i : i === void 0 ? r : i.getTime() > r.getTime() ? i : r;
|
|
930
|
-
},
|
|
951
|
+
}, dt = (e, t) => {
|
|
931
952
|
for (let n of e) {
|
|
932
953
|
if (n.eventType === "timer-fired") return !1;
|
|
933
954
|
if (n.eventType !== "timer-set") continue;
|
|
@@ -935,14 +956,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
935
956
|
return e !== void 0 && e.getTime() > t;
|
|
936
957
|
}
|
|
937
958
|
return !1;
|
|
938
|
-
},
|
|
959
|
+
}, ft = (e, t) => {
|
|
939
960
|
if (e !== "suspended") return "no-progress";
|
|
940
961
|
for (let e of t) {
|
|
941
962
|
if (e.eventType === "signal-received" || e.eventType === "signal-sent") return "suspended";
|
|
942
963
|
if (e.eventType === "signal-awaited") return "awaiting-signal";
|
|
943
964
|
}
|
|
944
965
|
return "suspended";
|
|
945
|
-
},
|
|
966
|
+
}, pt = async (e, t = {}) => {
|
|
946
967
|
let n = e.now?.() ?? Date.now(), r = t.stallAfterMs ?? 18e5, i = t.runPage ?? 200, a = t.eventLookback ?? 20, o = new Date(n - r), s = [], c = [], l = 0, u = 0, d;
|
|
947
968
|
try {
|
|
948
969
|
d = await e.store.query({
|
|
@@ -965,7 +986,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
965
986
|
sawFullRunPage: !1,
|
|
966
987
|
failures: [{
|
|
967
988
|
subject: "_voltro_workflow_runs",
|
|
968
|
-
detail:
|
|
989
|
+
detail: ct(e)
|
|
969
990
|
}]
|
|
970
991
|
};
|
|
971
992
|
}
|
|
@@ -974,15 +995,15 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
974
995
|
if (typeof i.id != "string" || typeof i.tag != "string" || typeof i.executionId != "string" || typeof i.status != "string" || o === void 0) continue;
|
|
975
996
|
let d, f;
|
|
976
997
|
try {
|
|
977
|
-
d = await
|
|
998
|
+
d = await lt(e.store, i.id, a), f = await ut(e.store, i.id);
|
|
978
999
|
} catch (e) {
|
|
979
1000
|
s.push({
|
|
980
1001
|
subject: i.id,
|
|
981
|
-
detail:
|
|
1002
|
+
detail: ct(e)
|
|
982
1003
|
});
|
|
983
1004
|
continue;
|
|
984
1005
|
}
|
|
985
|
-
if (
|
|
1006
|
+
if (dt(d, n)) {
|
|
986
1007
|
u += 1;
|
|
987
1008
|
continue;
|
|
988
1009
|
}
|
|
@@ -1001,7 +1022,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1001
1022
|
status: i.status,
|
|
1002
1023
|
lastProgressAt: m,
|
|
1003
1024
|
idleMs: h,
|
|
1004
|
-
reason:
|
|
1025
|
+
reason: ft(i.status, d)
|
|
1005
1026
|
};
|
|
1006
1027
|
if (c.push(g), e.log?.warn("workflow.staleness: run has made no progress", {
|
|
1007
1028
|
workflow: g.tag,
|
|
@@ -1024,7 +1045,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1024
1045
|
} catch (e) {
|
|
1025
1046
|
s.push({
|
|
1026
1047
|
subject: g.runId,
|
|
1027
|
-
detail:
|
|
1048
|
+
detail: ct(e)
|
|
1028
1049
|
});
|
|
1029
1050
|
}
|
|
1030
1051
|
if (e.onStalled !== void 0) try {
|
|
@@ -1032,7 +1053,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1032
1053
|
} catch (e) {
|
|
1033
1054
|
s.push({
|
|
1034
1055
|
subject: `${g.runId}:onStalled`,
|
|
1035
|
-
detail:
|
|
1056
|
+
detail: ct(e)
|
|
1036
1057
|
});
|
|
1037
1058
|
}
|
|
1038
1059
|
}
|
|
@@ -1044,7 +1065,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1044
1065
|
sawFullRunPage: d.length >= i,
|
|
1045
1066
|
failures: s
|
|
1046
1067
|
};
|
|
1047
|
-
},
|
|
1068
|
+
}, mt = {
|
|
1048
1069
|
scanned: 0,
|
|
1049
1070
|
admitted: 0,
|
|
1050
1071
|
deferred: 0,
|
|
@@ -1055,14 +1076,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1055
1076
|
failed: 0,
|
|
1056
1077
|
timedOut: 0,
|
|
1057
1078
|
examined: !1
|
|
1058
|
-
},
|
|
1079
|
+
}, ht = 200, gt = async (e, t = {}) => {
|
|
1059
1080
|
let n = e.now ?? (() => Date.now()), r = e.log, i = t.batchSize ?? 200, a, o, s;
|
|
1060
1081
|
try {
|
|
1061
|
-
a = await
|
|
1062
|
-
let t = await
|
|
1082
|
+
a = await Oe(e.store);
|
|
1083
|
+
let t = await Le(e.store, n(), i);
|
|
1063
1084
|
o = t.due, s = t.nextDueAt;
|
|
1064
1085
|
} catch (e) {
|
|
1065
|
-
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }),
|
|
1086
|
+
return r?.warn?.("workflow flow control: could not read the admission queue", { cause: String(e) }), mt;
|
|
1066
1087
|
}
|
|
1067
1088
|
let c = {
|
|
1068
1089
|
scanned: o.length,
|
|
@@ -1084,16 +1105,16 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1084
1105
|
u.push(e);
|
|
1085
1106
|
}
|
|
1086
1107
|
for (let t of u) try {
|
|
1087
|
-
await
|
|
1108
|
+
await _t(e, t, a, c, n());
|
|
1088
1109
|
} catch (i) {
|
|
1089
1110
|
c.failed++, r?.warn?.("workflow flow control: an intent failed to drain", {
|
|
1090
1111
|
workflow: t.workflowName,
|
|
1091
1112
|
intent: t.id,
|
|
1092
1113
|
cause: String(i)
|
|
1093
|
-
}), await
|
|
1114
|
+
}), await Be(e.store, t, String(i), n()).catch(() => {});
|
|
1094
1115
|
}
|
|
1095
1116
|
for (let t of l.values()) try {
|
|
1096
|
-
await
|
|
1117
|
+
await yt(e, t, a, c, n());
|
|
1097
1118
|
} catch (i) {
|
|
1098
1119
|
c.failed++;
|
|
1099
1120
|
let a = t[0];
|
|
@@ -1101,14 +1122,15 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1101
1122
|
workflow: a?.workflowName,
|
|
1102
1123
|
size: t.length,
|
|
1103
1124
|
cause: String(i)
|
|
1104
|
-
}), a !== void 0 && await
|
|
1125
|
+
}), a !== void 0 && await Be(e.store, a, String(i), n()).catch(() => {});
|
|
1105
1126
|
}
|
|
1106
|
-
return c.timedOut = await
|
|
1127
|
+
return c.timedOut = await xt(e, n()).catch(() => 0), {
|
|
1107
1128
|
...c,
|
|
1108
1129
|
examined: !0,
|
|
1109
1130
|
...s === void 0 ? {} : { nextDueAt: s }
|
|
1110
1131
|
};
|
|
1111
|
-
},
|
|
1132
|
+
}, _t = async (e, t, n, r, i) => {
|
|
1133
|
+
if (t.mode === "delayed") return vt(e, t, n, r, i);
|
|
1112
1134
|
let a = e.controls.get(t.workflowName);
|
|
1113
1135
|
if (a === void 0) {
|
|
1114
1136
|
await e.onAbandoned({
|
|
@@ -1120,7 +1142,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1120
1142
|
return;
|
|
1121
1143
|
}
|
|
1122
1144
|
if (xe(a, t, i)) {
|
|
1123
|
-
await
|
|
1145
|
+
await U({
|
|
1124
1146
|
store: e.store,
|
|
1125
1147
|
control: a,
|
|
1126
1148
|
keys: I(a, t.payload),
|
|
@@ -1142,10 +1164,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1142
1164
|
return;
|
|
1143
1165
|
}
|
|
1144
1166
|
let o = I(a, t.payload);
|
|
1145
|
-
await
|
|
1167
|
+
await bt(e, {
|
|
1146
1168
|
control: a,
|
|
1147
1169
|
intent: t,
|
|
1148
|
-
decision: await
|
|
1170
|
+
decision: await Ve({
|
|
1149
1171
|
store: e.store,
|
|
1150
1172
|
control: a,
|
|
1151
1173
|
keys: o,
|
|
@@ -1158,7 +1180,43 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1158
1180
|
now: i,
|
|
1159
1181
|
items: void 0
|
|
1160
1182
|
});
|
|
1161
|
-
},
|
|
1183
|
+
}, vt = async (e, t, n, r, i) => {
|
|
1184
|
+
if (e.registeredWorkflows !== void 0 && !e.registeredWorkflows.has(t.workflowName)) {
|
|
1185
|
+
await e.onAbandoned({
|
|
1186
|
+
workflowName: t.workflowName,
|
|
1187
|
+
payload: t.payload,
|
|
1188
|
+
callerContext: t.callerContext,
|
|
1189
|
+
reason: `workflow '${t.workflowName}' is no longer registered — it was renamed or removed while this delayed start waited for its 'at' instant`
|
|
1190
|
+
}), await G(e.store, t.id), r.expired++;
|
|
1191
|
+
return;
|
|
1192
|
+
}
|
|
1193
|
+
let a = e.controls.get(t.workflowName) ?? { workflowName: t.workflowName }, o = await Ue({
|
|
1194
|
+
store: e.store,
|
|
1195
|
+
control: a,
|
|
1196
|
+
payload: t.payload,
|
|
1197
|
+
callerContext: t.callerContext,
|
|
1198
|
+
tenantId: t.tenantId,
|
|
1199
|
+
paused: n.has(t.workflowName),
|
|
1200
|
+
now: i,
|
|
1201
|
+
waiting: !1
|
|
1202
|
+
});
|
|
1203
|
+
if (o.kind === "queued") {
|
|
1204
|
+
await G(e.store, t.id), r.deferred++;
|
|
1205
|
+
return;
|
|
1206
|
+
}
|
|
1207
|
+
if (o.kind === "dropped") {
|
|
1208
|
+
await G(e.store, t.id), r.dropped++;
|
|
1209
|
+
return;
|
|
1210
|
+
}
|
|
1211
|
+
if (o.kind === "skipped") {
|
|
1212
|
+
await G(e.store, t.id), r.skipped++;
|
|
1213
|
+
return;
|
|
1214
|
+
}
|
|
1215
|
+
let s = await e.startAdmitted(a.workflowName, o.payload, t.callerContext);
|
|
1216
|
+
o.evict !== void 0 && (await e.cancelRun(a.workflowName, o.evict.executionId).catch(() => {}), await W(e.store, o.evict.executionId, i).catch(() => {}), r.evicted++);
|
|
1217
|
+
for (let t of o.consume) await G(e.store, t).catch(() => {});
|
|
1218
|
+
o.ledgerId !== void 0 && await Ge(e.store, o.ledgerId, s.executionId, s.runId ?? null).catch(() => {}), await G(e.store, t.id), r.admitted++;
|
|
1219
|
+
}, yt = async (e, t, n, r, i) => {
|
|
1162
1220
|
let a = t[0];
|
|
1163
1221
|
if (a === void 0) return;
|
|
1164
1222
|
let o = e.controls.get(a.workflowName);
|
|
@@ -1180,10 +1238,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1180
1238
|
return;
|
|
1181
1239
|
}
|
|
1182
1240
|
let l = I(o, c.payload);
|
|
1183
|
-
await
|
|
1241
|
+
await bt(e, {
|
|
1184
1242
|
control: o,
|
|
1185
1243
|
intent: c,
|
|
1186
|
-
decision: await
|
|
1244
|
+
decision: await Ve({
|
|
1187
1245
|
store: e.store,
|
|
1188
1246
|
control: o,
|
|
1189
1247
|
keys: l,
|
|
@@ -1196,10 +1254,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1196
1254
|
now: i,
|
|
1197
1255
|
items: s
|
|
1198
1256
|
});
|
|
1199
|
-
},
|
|
1257
|
+
}, bt = async (e, t) => {
|
|
1200
1258
|
let { control: n, intent: r, decision: i, keys: a, counters: o, now: s, items: c } = t;
|
|
1201
1259
|
if (i.kind === "defer") {
|
|
1202
|
-
await
|
|
1260
|
+
await Ne({
|
|
1203
1261
|
store: e.store,
|
|
1204
1262
|
control: n,
|
|
1205
1263
|
decision: i,
|
|
@@ -1212,7 +1270,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1212
1270
|
return;
|
|
1213
1271
|
}
|
|
1214
1272
|
if (i.kind === "drop") {
|
|
1215
|
-
await
|
|
1273
|
+
await U({
|
|
1216
1274
|
store: e.store,
|
|
1217
1275
|
control: n,
|
|
1218
1276
|
keys: a,
|
|
@@ -1231,7 +1289,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1231
1289
|
return;
|
|
1232
1290
|
}
|
|
1233
1291
|
if (i.kind === "skip") {
|
|
1234
|
-
await
|
|
1292
|
+
await U({
|
|
1235
1293
|
store: e.store,
|
|
1236
1294
|
control: n,
|
|
1237
1295
|
keys: a,
|
|
@@ -1249,7 +1307,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1249
1307
|
o.skipped++;
|
|
1250
1308
|
return;
|
|
1251
1309
|
}
|
|
1252
|
-
i.evict !== void 0 && (await e.cancelRun(n.workflowName, i.evict.executionId), await
|
|
1310
|
+
i.evict !== void 0 && (await e.cancelRun(n.workflowName, i.evict.executionId), await W(e.store, i.evict.executionId, s), await U({
|
|
1253
1311
|
store: e.store,
|
|
1254
1312
|
control: n,
|
|
1255
1313
|
keys: a,
|
|
@@ -1264,7 +1322,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1264
1322
|
now: s
|
|
1265
1323
|
}), o.evicted++);
|
|
1266
1324
|
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);
|
|
1267
|
-
await
|
|
1325
|
+
await U({
|
|
1268
1326
|
store: e.store,
|
|
1269
1327
|
control: n,
|
|
1270
1328
|
keys: a,
|
|
@@ -1280,7 +1338,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1280
1338
|
});
|
|
1281
1339
|
for (let t of c ?? [r]) await G(e.store, t.id);
|
|
1282
1340
|
o.admitted++;
|
|
1283
|
-
},
|
|
1341
|
+
}, xt = async (e, t) => {
|
|
1284
1342
|
if (e.listRunningRuns === void 0) return 0;
|
|
1285
1343
|
let n = 0;
|
|
1286
1344
|
for (let r of e.controls.values()) {
|
|
@@ -1289,7 +1347,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1289
1347
|
for (let a of i) Se(r, {
|
|
1290
1348
|
startedAt: a.startedAt,
|
|
1291
1349
|
terminal: !1
|
|
1292
|
-
}, t) && (await e.cancelRun(r.workflowName, a.executionId), await
|
|
1350
|
+
}, t) && (await e.cancelRun(r.workflowName, a.executionId), await W(e.store, a.executionId, t), await e.onAbandoned({
|
|
1293
1351
|
workflowName: r.workflowName,
|
|
1294
1352
|
payload: null,
|
|
1295
1353
|
callerContext: null,
|
|
@@ -1297,82 +1355,107 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1297
1355
|
}), n++);
|
|
1298
1356
|
}
|
|
1299
1357
|
return n;
|
|
1300
|
-
},
|
|
1358
|
+
}, St = 5 * 6e4, Ct, wt = (e) => {
|
|
1359
|
+
Ct = e !== void 0 && Number.isFinite(e) && e > 0 ? e : void 0;
|
|
1360
|
+
}, Tt = () => {
|
|
1361
|
+
let e = process.env.VOLTRO_WORKFLOW_SUSPEND_HINT_MS;
|
|
1362
|
+
if (e !== void 0) {
|
|
1363
|
+
let t = Number(e);
|
|
1364
|
+
if (Number.isFinite(t) && t > 0) return t;
|
|
1365
|
+
}
|
|
1366
|
+
return Ct ?? 3e5;
|
|
1367
|
+
}, Et = /* @__PURE__ */ new Set(), Dt = () => {
|
|
1368
|
+
Et.clear();
|
|
1369
|
+
}, Ot = (e) => {
|
|
1370
|
+
let t = Tt();
|
|
1371
|
+
if (!(e.timeoutMs > t)) return !1;
|
|
1372
|
+
let n = `${e.workflowName ?? ""}\u0000${e.signalName}`;
|
|
1373
|
+
if (Et.has(n)) return !1;
|
|
1374
|
+
Et.add(n);
|
|
1375
|
+
let r = e.workflowName === void 0 ? "" : ` in workflow '${e.workflowName}'`;
|
|
1376
|
+
return (e.warn ?? ((e) => console.warn(e)))(`awaitSignal('${e.signalName}')${r} declares a ${Math.round(e.timeoutMs / 1e3)}s timeout — a wait that long holds a worker fiber for its whole duration. For human-approval-length waits, awaitSignalSuspending (same call shape, from @voltro/workflow) SUSPENDS the run and frees the slot until the signal arrives. This is a hint, not a behaviour change; it is logged once per workflow. Threshold: workflows.suspendSignalHintMs in app.config.ts, or VOLTRO_WORKFLOW_SUSPEND_HINT_MS.`), !0;
|
|
1377
|
+
}, kt = async (e, t) => {
|
|
1301
1378
|
if (e) try {
|
|
1302
1379
|
await e.recordEvent(t);
|
|
1303
1380
|
} catch {}
|
|
1304
|
-
},
|
|
1305
|
-
let
|
|
1306
|
-
let
|
|
1307
|
-
|
|
1308
|
-
|
|
1309
|
-
|
|
1310
|
-
|
|
1381
|
+
}, At = (e, t) => {
|
|
1382
|
+
let r = m.gen(function* () {
|
|
1383
|
+
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 1440 * 6e4, s = yield* m.serviceOption(se);
|
|
1384
|
+
Ot({
|
|
1385
|
+
workflowName: s._tag === "Some" ? s.value.workflow.name : void 0,
|
|
1386
|
+
signalName: t.name,
|
|
1387
|
+
timeoutMs: o
|
|
1388
|
+
});
|
|
1389
|
+
let c = yield* a, l = yield* m.serviceOption(n), u = l._tag === "Some" ? l.value : void 0;
|
|
1390
|
+
if (c === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitSignal: no active workflow run id in scope"));
|
|
1391
|
+
let d = c;
|
|
1392
|
+
yield* m.promise(() => kt(u, {
|
|
1393
|
+
runId: d,
|
|
1311
1394
|
eventType: "signal-awaited",
|
|
1312
|
-
payload: { signalName:
|
|
1395
|
+
payload: { signalName: t.name }
|
|
1313
1396
|
}));
|
|
1314
|
-
let
|
|
1397
|
+
let f = Date.now(), p = r;
|
|
1315
1398
|
for (;;) {
|
|
1316
|
-
let
|
|
1317
|
-
if (
|
|
1318
|
-
let
|
|
1399
|
+
let n = Date.now() - f;
|
|
1400
|
+
if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitSignal('${t.name}') timed out after ${n}ms`));
|
|
1401
|
+
let r = {
|
|
1319
1402
|
table: "_voltro_workflow_run_events",
|
|
1320
1403
|
order: [{
|
|
1321
1404
|
column: "occurredAt",
|
|
1322
1405
|
direction: "asc"
|
|
1323
1406
|
}],
|
|
1324
|
-
predicate: b(x("runId",
|
|
1407
|
+
predicate: b(x("runId", d), x("eventType", "signal-sent")),
|
|
1325
1408
|
projection: void 0,
|
|
1326
1409
|
skip: void 0,
|
|
1327
1410
|
take: 1e3
|
|
1328
|
-
},
|
|
1329
|
-
try: () =>
|
|
1411
|
+
}, a = (yield* m.tryPromise({
|
|
1412
|
+
try: () => e.store.query(r),
|
|
1330
1413
|
catch: (e) => e
|
|
1331
|
-
})).find((e) => e.payload?.signalName ===
|
|
1332
|
-
if (
|
|
1333
|
-
let e = yield* y.decodeUnknown(
|
|
1334
|
-
return yield* m.promise(() =>
|
|
1335
|
-
runId:
|
|
1414
|
+
})).find((e) => e.payload?.signalName === t.name);
|
|
1415
|
+
if (a !== void 0) {
|
|
1416
|
+
let e = yield* y.decodeUnknown(t.schema)(a.payload?.value);
|
|
1417
|
+
return yield* m.promise(() => kt(u, {
|
|
1418
|
+
runId: d,
|
|
1336
1419
|
eventType: "signal-received",
|
|
1337
1420
|
payload: {
|
|
1338
|
-
signalName:
|
|
1339
|
-
value:
|
|
1421
|
+
signalName: t.name,
|
|
1422
|
+
value: a.payload?.value
|
|
1340
1423
|
}
|
|
1341
1424
|
})), e;
|
|
1342
1425
|
}
|
|
1343
|
-
yield* m.sleep(`${
|
|
1426
|
+
yield* m.sleep(`${p} millis`), p = Math.min(p * 2, i);
|
|
1344
1427
|
}
|
|
1345
1428
|
});
|
|
1346
1429
|
return c.make({
|
|
1347
|
-
name: `await-signal:${
|
|
1348
|
-
success:
|
|
1349
|
-
execute:
|
|
1430
|
+
name: `await-signal:${t.name}`,
|
|
1431
|
+
success: t.schema,
|
|
1432
|
+
execute: r
|
|
1350
1433
|
});
|
|
1351
|
-
},
|
|
1434
|
+
}, jt = async (e, t) => {
|
|
1352
1435
|
if (e !== void 0) try {
|
|
1353
1436
|
await e.recordEvent(t);
|
|
1354
1437
|
} catch {}
|
|
1355
|
-
},
|
|
1356
|
-
let
|
|
1357
|
-
let
|
|
1438
|
+
}, Mt = (e, t) => {
|
|
1439
|
+
let r = m.gen(function* () {
|
|
1440
|
+
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 1440 * 6e4, s = t.take ?? 500, c = yield* a, l = yield* m.serviceOption(n), u = l._tag === "Some" ? l.value : void 0;
|
|
1358
1441
|
if (c === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitEvent: no active workflow run id in scope"));
|
|
1359
|
-
let d = c, f = yield*
|
|
1360
|
-
yield* m.promise(() =>
|
|
1442
|
+
let d = c, f = yield* t.since === "run-start" ? Nt(e, d) : m.succeed(/* @__PURE__ */ new Date());
|
|
1443
|
+
yield* m.promise(() => jt(u, {
|
|
1361
1444
|
runId: d,
|
|
1362
1445
|
eventType: "event-awaited",
|
|
1363
1446
|
payload: {
|
|
1364
|
-
event:
|
|
1365
|
-
since:
|
|
1447
|
+
event: t.event,
|
|
1448
|
+
since: t.since ?? "wait-start",
|
|
1366
1449
|
cutoff: f.toISOString()
|
|
1367
1450
|
}
|
|
1368
1451
|
}));
|
|
1369
|
-
let p = Date.now(), h =
|
|
1452
|
+
let p = Date.now(), h = r, g = 0;
|
|
1370
1453
|
for (;;) {
|
|
1371
|
-
let
|
|
1372
|
-
if (
|
|
1373
|
-
let
|
|
1454
|
+
let n = Date.now() - p;
|
|
1455
|
+
if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitEvent('${t.event}') timed out after ${n}ms having examined ${g} candidate event(s). ${g === 0 ? "NONE were published under that name in the window — check the spelling against ctx.events.publish, and consider since: 'run-start' if the event may have arrived before this step began." : "The predicate rejected all of them — log one payload and compare it with what `match` expects."}`));
|
|
1456
|
+
let r = {
|
|
1374
1457
|
table: "_voltro_workflow_events",
|
|
1375
|
-
predicate: b(x("name",
|
|
1458
|
+
predicate: b(x("name", t.event), te("occurredAt", f)),
|
|
1376
1459
|
order: [{
|
|
1377
1460
|
column: "occurredAt",
|
|
1378
1461
|
direction: "asc"
|
|
@@ -1380,31 +1463,31 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1380
1463
|
take: s,
|
|
1381
1464
|
skip: void 0,
|
|
1382
1465
|
projection: void 0
|
|
1383
|
-
},
|
|
1384
|
-
try: () =>
|
|
1466
|
+
}, a = yield* m.tryPromise({
|
|
1467
|
+
try: () => e.store.query(r),
|
|
1385
1468
|
catch: (e) => e
|
|
1386
1469
|
});
|
|
1387
|
-
g =
|
|
1388
|
-
for (let e of
|
|
1389
|
-
let
|
|
1390
|
-
if (
|
|
1470
|
+
g = a.length;
|
|
1471
|
+
for (let e of a) {
|
|
1472
|
+
let n = yield* y.decodeUnknown(t.schema)(e.payload);
|
|
1473
|
+
if (t.match(n)) return yield* m.promise(() => jt(u, {
|
|
1391
1474
|
runId: d,
|
|
1392
1475
|
eventType: "event-received",
|
|
1393
1476
|
payload: {
|
|
1394
|
-
event:
|
|
1477
|
+
event: t.event,
|
|
1395
1478
|
eventId: e.id
|
|
1396
1479
|
}
|
|
1397
|
-
})),
|
|
1480
|
+
})), n;
|
|
1398
1481
|
}
|
|
1399
|
-
yield* m.sleep(`${h} millis`), h = Math.min(h * 2,
|
|
1482
|
+
yield* m.sleep(`${h} millis`), h = Math.min(h * 2, i);
|
|
1400
1483
|
}
|
|
1401
1484
|
});
|
|
1402
1485
|
return c.make({
|
|
1403
|
-
name: `awaitEvent:${
|
|
1404
|
-
success:
|
|
1405
|
-
execute:
|
|
1486
|
+
name: `awaitEvent:${t.event}`,
|
|
1487
|
+
success: t.schema,
|
|
1488
|
+
execute: r
|
|
1406
1489
|
});
|
|
1407
|
-
},
|
|
1490
|
+
}, Nt = (e, t) => m.gen(function* () {
|
|
1408
1491
|
let n = (yield* m.tryPromise({
|
|
1409
1492
|
try: () => e.store.query({
|
|
1410
1493
|
table: "_voltro_workflow_runs",
|
|
@@ -1422,10 +1505,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1422
1505
|
if (!Number.isNaN(e.getTime())) return e;
|
|
1423
1506
|
}
|
|
1424
1507
|
return /* @__PURE__ */ new Date(0);
|
|
1425
|
-
}),
|
|
1508
|
+
}), Pt = (e) => new Promise((t) => setTimeout(t, e)), Ft = () => {
|
|
1426
1509
|
let e = globalThis.crypto;
|
|
1427
1510
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
1428
|
-
},
|
|
1511
|
+
}, It = () => `wfu_${Ft()}`, Lt = async (e, t) => {
|
|
1429
1512
|
let n = t.id ?? t.executionId;
|
|
1430
1513
|
if (!n) throw Error("workflow message target requires target.id or target.executionId");
|
|
1431
1514
|
let r = await e.query({
|
|
@@ -1447,8 +1530,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1447
1530
|
}))[0];
|
|
1448
1531
|
if (!i) throw Error(`workflow message target not found: ${n}`);
|
|
1449
1532
|
return i;
|
|
1450
|
-
},
|
|
1451
|
-
let t = await
|
|
1533
|
+
}, Rt = async (e) => {
|
|
1534
|
+
let t = await Lt(e.store, e.target);
|
|
1452
1535
|
return { eventId: (await e.recorder.recordEvent({
|
|
1453
1536
|
runId: t.id,
|
|
1454
1537
|
eventType: "signal-sent",
|
|
@@ -1457,8 +1540,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1457
1540
|
value: e.payload
|
|
1458
1541
|
}
|
|
1459
1542
|
})).id };
|
|
1460
|
-
},
|
|
1461
|
-
let t = await
|
|
1543
|
+
}, zt = async (e) => {
|
|
1544
|
+
let t = await Lt(e.store, e.target), n = It(), r = await e.recorder.recordEvent({
|
|
1462
1545
|
runId: t.id,
|
|
1463
1546
|
eventType: "update-requested",
|
|
1464
1547
|
payload: {
|
|
@@ -1495,44 +1578,44 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1495
1578
|
}), t;
|
|
1496
1579
|
}
|
|
1497
1580
|
if (Date.now() - i >= a) throw Error(`Timed out waiting for workflow update '${e.updateName}' (${n})`);
|
|
1498
|
-
await
|
|
1581
|
+
await Pt(o);
|
|
1499
1582
|
}
|
|
1500
|
-
},
|
|
1583
|
+
}, Bt = 1440 * 6e4, Vt = "voltro/suspending-signal", Ht = (e, t) => `${Vt}/${e}/${t}`, Ut = (e) => u.make(e, { success: y.Unknown }), Wt = async (e, t) => {
|
|
1501
1584
|
if (e) try {
|
|
1502
1585
|
await e.recordEvent(t);
|
|
1503
1586
|
} catch {}
|
|
1504
|
-
},
|
|
1505
|
-
let
|
|
1506
|
-
|
|
1507
|
-
runId:
|
|
1587
|
+
}, Gt = (e, t) => m.gen(function* () {
|
|
1588
|
+
let e = t.timeoutMs ?? Bt, r = Ut(Ht((yield* f.WorkflowInstance).workflow.name, t.name)), i = yield* a, o = yield* m.serviceOption(n), s = o._tag === "Some" ? o.value : void 0;
|
|
1589
|
+
i !== void 0 && (yield* m.promise(() => Wt(s, {
|
|
1590
|
+
runId: i,
|
|
1508
1591
|
eventType: "signal-awaited",
|
|
1509
|
-
payload: { signalName:
|
|
1592
|
+
payload: { signalName: t.name }
|
|
1510
1593
|
})));
|
|
1511
|
-
let c = u.await(
|
|
1512
|
-
name: `await-signal-timeout/${
|
|
1513
|
-
duration: `${
|
|
1514
|
-
}).pipe(m.andThen(m.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${
|
|
1515
|
-
return
|
|
1516
|
-
runId:
|
|
1594
|
+
let c = u.await(r), d = Number.isFinite(e) ? yield* m.race(c, l.sleep({
|
|
1595
|
+
name: `await-signal-timeout/${t.name}`,
|
|
1596
|
+
duration: `${e} millis`
|
|
1597
|
+
}).pipe(m.andThen(m.die(/* @__PURE__ */ Error(`awaitSignalSuspending('${t.name}') timed out after ${e}ms`))))) : yield* c, p = yield* y.decodeUnknown(t.schema)(d);
|
|
1598
|
+
return i !== void 0 && (yield* m.promise(() => Wt(s, {
|
|
1599
|
+
runId: i,
|
|
1517
1600
|
eventType: "signal-received",
|
|
1518
1601
|
payload: {
|
|
1519
|
-
signalName:
|
|
1602
|
+
signalName: t.name,
|
|
1520
1603
|
value: p
|
|
1521
1604
|
}
|
|
1522
1605
|
}))), p;
|
|
1523
|
-
}),
|
|
1606
|
+
}), Kt = (e) => m.gen(function* () {
|
|
1524
1607
|
let t = e.target.executionId, n = e.target.workflowName;
|
|
1525
1608
|
if (t === void 0 || n === void 0) {
|
|
1526
1609
|
let r = e.store;
|
|
1527
1610
|
if (r === void 0) return yield* m.die(/* @__PURE__ */ Error("completeSuspendingSignal: provide a store, or target.executionId AND target.workflowName"));
|
|
1528
1611
|
let i = yield* m.tryPromise({
|
|
1529
|
-
try: () =>
|
|
1612
|
+
try: () => Lt(r, e.target),
|
|
1530
1613
|
catch: (e) => e
|
|
1531
1614
|
});
|
|
1532
1615
|
t ??= i.executionId, n ??= i.tag;
|
|
1533
1616
|
}
|
|
1534
1617
|
if (t === void 0 || n === void 0) return { completed: !1 };
|
|
1535
|
-
let r =
|
|
1618
|
+
let r = Ht(n, e.signalName), i = Ut(r), a = new u.TokenParsed({
|
|
1536
1619
|
workflowName: n,
|
|
1537
1620
|
executionId: t,
|
|
1538
1621
|
deferredName: r
|
|
@@ -1541,51 +1624,51 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1541
1624
|
token: a,
|
|
1542
1625
|
exit: g.succeed(e.payload)
|
|
1543
1626
|
}), { completed: !0 };
|
|
1544
|
-
}), X = "_voltro_budget_holds",
|
|
1627
|
+
}), X = "_voltro_budget_holds", qt = "budget-hold", Jt = (e) => `${qt}:${e}`, Yt = (e) => `${e.executionId}/${e.stepName}/${e.budget}#${e.generation}`, Xt = async (e, t) => (await e.query({
|
|
1545
1628
|
table: X,
|
|
1546
1629
|
predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
|
|
1547
1630
|
order: []
|
|
1548
|
-
})).length,
|
|
1631
|
+
})).length, Zt = j(X, {
|
|
1549
1632
|
id: w({ prefix: "bhd" }),
|
|
1550
|
-
holdKey:
|
|
1551
|
-
budget:
|
|
1552
|
-
tenantId:
|
|
1553
|
-
executionId:
|
|
1554
|
-
workflowName:
|
|
1555
|
-
signalName:
|
|
1556
|
-
stepName:
|
|
1557
|
-
spentMicroUsd:
|
|
1558
|
-
limitMicroUsd:
|
|
1559
|
-
heldAt:
|
|
1560
|
-
releasedAt:
|
|
1561
|
-
outcome:
|
|
1562
|
-
}).index(["budget", "releasedAt"]),
|
|
1563
|
-
|
|
1633
|
+
holdKey: M().maxLength(191),
|
|
1634
|
+
budget: M(),
|
|
1635
|
+
tenantId: M().nullable(),
|
|
1636
|
+
executionId: M(),
|
|
1637
|
+
workflowName: M(),
|
|
1638
|
+
signalName: M(),
|
|
1639
|
+
stepName: M(),
|
|
1640
|
+
spentMicroUsd: M().nullable(),
|
|
1641
|
+
limitMicroUsd: M().nullable(),
|
|
1642
|
+
heldAt: N().default("now"),
|
|
1643
|
+
releasedAt: N().nullable(),
|
|
1644
|
+
outcome: M().nullable()
|
|
1645
|
+
}).index(["budget", "releasedAt"]), Qt = () => {
|
|
1646
|
+
ie({
|
|
1564
1647
|
source: "framework",
|
|
1565
1648
|
table: X,
|
|
1566
1649
|
timeColumn: "releasedAt",
|
|
1567
|
-
ttlMs:
|
|
1650
|
+
ttlMs: ae(process.env.VOLTRO_BUDGET_HOLDS_TTL_HOURS, 720)
|
|
1568
1651
|
});
|
|
1569
|
-
},
|
|
1652
|
+
}, $t = class extends Error {
|
|
1570
1653
|
budget;
|
|
1571
1654
|
holdKey;
|
|
1572
1655
|
constructor(e, t, n) {
|
|
1573
1656
|
super(`budget '${e}': the run was suspended waiting for headroom and gave up after ${n}ms (hold ${t}). Nothing was spent. Raise the budget, reset its window, or lift the hold, then re-drive the run.`), this.name = "BudgetHoldExpired", this.budget = e, this.holdKey = t;
|
|
1574
1657
|
}
|
|
1575
|
-
},
|
|
1576
|
-
|
|
1658
|
+
}, en = 10080 * 6e4, tn = (e) => m.gen(function* () {
|
|
1659
|
+
Qt();
|
|
1577
1660
|
let t = e.timeoutMs ?? 6048e5, n = e.recheckEveryMs ?? 9e5, r = {
|
|
1578
1661
|
executionId: e.executionId,
|
|
1579
1662
|
stepName: e.stepName,
|
|
1580
1663
|
budget: e.budget
|
|
1581
1664
|
};
|
|
1582
1665
|
for (;;) {
|
|
1583
|
-
let i = yield* m.promise(() =>
|
|
1666
|
+
let i = yield* m.promise(() => rn(e.store, r)), a = i.length, o = i.length === 0 ? Date.now() : nn(i[0]?.heldAt), s = Number.isFinite(t) ? t - (Date.now() - o) : Infinity, c = Yt({
|
|
1584
1667
|
...r,
|
|
1585
1668
|
generation: a
|
|
1586
1669
|
});
|
|
1587
|
-
if (s <= 0) return yield* m.promise(() =>
|
|
1588
|
-
let l =
|
|
1670
|
+
if (s <= 0) return yield* m.promise(() => an(e.store, r, "expired")), yield* m.fail(new $t(e.budget, c, t));
|
|
1671
|
+
let l = Jt(c);
|
|
1589
1672
|
yield* m.promise(() => e.store.insertIgnore(X, {
|
|
1590
1673
|
id: S({
|
|
1591
1674
|
kind: "typeid",
|
|
@@ -1605,7 +1688,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1605
1688
|
outcome: null
|
|
1606
1689
|
}, { conflictColumns: ["holdKey"] }));
|
|
1607
1690
|
let u = Math.min(n, s);
|
|
1608
|
-
if (yield*
|
|
1691
|
+
if (yield* Gt({ store: e.store }, {
|
|
1609
1692
|
name: l,
|
|
1610
1693
|
schema: y.Unknown,
|
|
1611
1694
|
timeoutMs: u
|
|
@@ -1614,16 +1697,16 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1614
1697
|
outcome: "recheck"
|
|
1615
1698
|
}, { where: b(x("holdKey", c), E("releasedAt")) })), yield* e.hasHeadroom) return;
|
|
1616
1699
|
}
|
|
1617
|
-
}),
|
|
1700
|
+
}), nn = (e) => e instanceof Date ? e.getTime() : typeof e == "string" ? Date.parse(e) : Date.now(), rn = async (e, t) => [...await e.query({
|
|
1618
1701
|
table: X,
|
|
1619
1702
|
predicate: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget)),
|
|
1620
1703
|
order: []
|
|
1621
|
-
})].sort((e, t) => String(e.id).localeCompare(String(t.id))),
|
|
1704
|
+
})].sort((e, t) => String(e.id).localeCompare(String(t.id))), an = async (e, t, n) => {
|
|
1622
1705
|
await e.updateMany(X, {
|
|
1623
1706
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
1624
1707
|
outcome: n
|
|
1625
1708
|
}, { where: b(x("executionId", t.executionId), x("stepName", t.stepName), x("budget", t.budget), E("releasedAt")) });
|
|
1626
|
-
},
|
|
1709
|
+
}, on = (e) => m.gen(function* () {
|
|
1627
1710
|
let t = e.tenantId === void 0 ? b(x("budget", e.budget), E("releasedAt")) : b(x("budget", e.budget), x("tenantId", e.tenantId), E("releasedAt")), n = yield* m.promise(() => e.store.query({
|
|
1628
1711
|
table: X,
|
|
1629
1712
|
predicate: t,
|
|
@@ -1632,7 +1715,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1632
1715
|
for (let t of n) (yield* m.promise(() => e.store.updateMany("_voltro_budget_holds", {
|
|
1633
1716
|
releasedAt: /* @__PURE__ */ new Date(),
|
|
1634
1717
|
outcome: e.outcome ?? "released"
|
|
1635
|
-
}, { where: b(x("id", String(t.id)), E("releasedAt")) }))) === 1 && (yield*
|
|
1718
|
+
}, { where: b(x("id", String(t.id)), E("releasedAt")) }))) === 1 && (yield* Kt({
|
|
1636
1719
|
target: {
|
|
1637
1720
|
executionId: String(t.executionId),
|
|
1638
1721
|
workflowName: String(t.workflowName)
|
|
@@ -1644,7 +1727,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1644
1727
|
}
|
|
1645
1728
|
}).pipe(m.catchAll(() => m.succeed({ completed: !1 }))), r += 1);
|
|
1646
1729
|
return { released: r };
|
|
1647
|
-
}),
|
|
1730
|
+
}), sn = async (e, t) => {
|
|
1648
1731
|
let n = t?.budget === void 0 ? E("releasedAt") : b(x("budget", t.budget), E("releasedAt"));
|
|
1649
1732
|
return (await e.query({
|
|
1650
1733
|
table: X,
|
|
@@ -1660,8 +1743,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1660
1743
|
stepName: String(e.stepName),
|
|
1661
1744
|
heldAt: e.heldAt instanceof Date ? e.heldAt.toISOString() : String(e.heldAt ?? "")
|
|
1662
1745
|
}));
|
|
1663
|
-
},
|
|
1664
|
-
let t = await
|
|
1746
|
+
}, cn = async (e) => {
|
|
1747
|
+
let t = await sn(e), n = /* @__PURE__ */ new Map();
|
|
1665
1748
|
for (let e of t) {
|
|
1666
1749
|
let t = `${e.budget}\u0000${e.tenantId ?? ""}`;
|
|
1667
1750
|
n.has(t) || n.set(t, {
|
|
@@ -1670,25 +1753,25 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1670
1753
|
});
|
|
1671
1754
|
}
|
|
1672
1755
|
return [...n.values()];
|
|
1673
|
-
},
|
|
1756
|
+
}, ln = async (e, t) => {
|
|
1674
1757
|
if (e) try {
|
|
1675
1758
|
await e.recordEvent(t);
|
|
1676
1759
|
} catch {}
|
|
1677
|
-
},
|
|
1760
|
+
}, un = (e) => {
|
|
1678
1761
|
let t = p.failureOption(e), n = Array.from(p.defects(e)), r = t._tag === "Some" ? t.value : n[0] ?? p.squash(e);
|
|
1679
1762
|
return {
|
|
1680
1763
|
errorTag: r && typeof r == "object" && "_tag" in r ? String(r._tag) : null,
|
|
1681
1764
|
errorMessage: r?.message ?? String(r)
|
|
1682
1765
|
};
|
|
1683
|
-
},
|
|
1684
|
-
let
|
|
1685
|
-
let
|
|
1766
|
+
}, dn = (e, t) => {
|
|
1767
|
+
let r = m.gen(function* () {
|
|
1768
|
+
let r = t.pollIntervalMs ?? 200, i = t.maxPollIntervalMs ?? 5e3, o = t.timeoutMs ?? 3e4, s = yield* a, c = yield* m.serviceOption(n), l = c._tag === "Some" ? c.value : void 0;
|
|
1686
1769
|
if (s === void 0) return yield* m.die(/* @__PURE__ */ Error("awaitUpdate: no active workflow run id in scope"));
|
|
1687
|
-
let u = s, d = Date.now(), f =
|
|
1770
|
+
let u = s, d = Date.now(), f = r;
|
|
1688
1771
|
for (;;) {
|
|
1689
|
-
let
|
|
1690
|
-
if (
|
|
1691
|
-
let
|
|
1772
|
+
let n = Date.now() - d;
|
|
1773
|
+
if (n > o) return yield* m.die(/* @__PURE__ */ Error(`awaitUpdate('${t.name}') timed out after ${n}ms`));
|
|
1774
|
+
let r = {
|
|
1692
1775
|
table: "_voltro_workflow_run_events",
|
|
1693
1776
|
order: [{
|
|
1694
1777
|
column: "occurredAt",
|
|
@@ -1698,56 +1781,56 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1698
1781
|
projection: void 0,
|
|
1699
1782
|
skip: void 0,
|
|
1700
1783
|
take: 1e3
|
|
1701
|
-
},
|
|
1702
|
-
try: () =>
|
|
1784
|
+
}, a = yield* m.tryPromise({
|
|
1785
|
+
try: () => e.store.query(r),
|
|
1703
1786
|
catch: (e) => e
|
|
1704
|
-
}), s = new Set(
|
|
1787
|
+
}), s = new Set(a.filter((e) => e.eventType === "update-completed" || e.eventType === "update-failed").map((e) => e.payload?.updateId).filter((e) => typeof e == "string" && e.length > 0)), c = a.find((e) => e.eventType === "update-requested" && e.payload?.updateName === t.name && typeof e.payload.updateId == "string" && !s.has(e.payload.updateId));
|
|
1705
1788
|
if (c !== void 0) {
|
|
1706
1789
|
let e = c.payload.updateId;
|
|
1707
|
-
yield* m.promise(() =>
|
|
1790
|
+
yield* m.promise(() => ln(l, {
|
|
1708
1791
|
runId: u,
|
|
1709
1792
|
eventType: "update-received",
|
|
1710
1793
|
payload: {
|
|
1711
1794
|
updateId: e,
|
|
1712
|
-
updateName:
|
|
1795
|
+
updateName: t.name
|
|
1713
1796
|
}
|
|
1714
1797
|
}));
|
|
1715
|
-
let
|
|
1798
|
+
let n = yield* y.decodeUnknown(t.schema)(c.payload?.value).pipe(m.tapErrorCause((n) => m.promise(() => ln(l, {
|
|
1716
1799
|
runId: u,
|
|
1717
1800
|
eventType: "update-failed",
|
|
1718
1801
|
payload: {
|
|
1719
1802
|
updateId: e,
|
|
1720
|
-
updateName:
|
|
1721
|
-
...
|
|
1803
|
+
updateName: t.name,
|
|
1804
|
+
...un(n)
|
|
1722
1805
|
}
|
|
1723
|
-
})))),
|
|
1806
|
+
})))), r = yield* (t.handle ? t.handle(n) : m.succeed(n)).pipe(m.flatMap((e) => t.success ? y.decodeUnknown(t.success)(e) : m.succeed(e))).pipe(m.tapErrorCause((n) => m.promise(() => ln(l, {
|
|
1724
1807
|
runId: u,
|
|
1725
1808
|
eventType: "update-failed",
|
|
1726
1809
|
payload: {
|
|
1727
1810
|
updateId: e,
|
|
1728
|
-
updateName:
|
|
1729
|
-
...
|
|
1811
|
+
updateName: t.name,
|
|
1812
|
+
...un(n)
|
|
1730
1813
|
}
|
|
1731
1814
|
}))));
|
|
1732
|
-
return yield* m.promise(() =>
|
|
1815
|
+
return yield* m.promise(() => ln(l, {
|
|
1733
1816
|
runId: u,
|
|
1734
1817
|
eventType: "update-completed",
|
|
1735
1818
|
payload: {
|
|
1736
1819
|
updateId: e,
|
|
1737
|
-
updateName:
|
|
1738
|
-
result:
|
|
1820
|
+
updateName: t.name,
|
|
1821
|
+
result: r
|
|
1739
1822
|
}
|
|
1740
|
-
})),
|
|
1823
|
+
})), r;
|
|
1741
1824
|
}
|
|
1742
|
-
yield* m.sleep(`${f} millis`), f = Math.min(f * 2,
|
|
1825
|
+
yield* m.sleep(`${f} millis`), f = Math.min(f * 2, i);
|
|
1743
1826
|
}
|
|
1744
1827
|
});
|
|
1745
1828
|
return c.make({
|
|
1746
|
-
name: `await-update:${
|
|
1747
|
-
success:
|
|
1748
|
-
execute:
|
|
1829
|
+
name: `await-update:${t.name}`,
|
|
1830
|
+
success: t.success ?? t.schema,
|
|
1831
|
+
execute: r
|
|
1749
1832
|
});
|
|
1750
|
-
},
|
|
1833
|
+
}, fn = 8 * 1024, pn = 3, mn = 2e3, hn = () => {
|
|
1751
1834
|
let e = (e) => {
|
|
1752
1835
|
if (e === void 0) return;
|
|
1753
1836
|
let t = Number(e);
|
|
@@ -1757,7 +1840,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1757
1840
|
...t === void 0 ? {} : { maxRunReclaims: t },
|
|
1758
1841
|
...n === void 0 ? {} : { replayShapeLimit: n }
|
|
1759
1842
|
};
|
|
1760
|
-
},
|
|
1843
|
+
}, gn = (e) => {
|
|
1761
1844
|
let t = typeof e == "string" ? (() => {
|
|
1762
1845
|
try {
|
|
1763
1846
|
return JSON.parse(e);
|
|
@@ -1766,10 +1849,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1766
1849
|
}
|
|
1767
1850
|
})() : e;
|
|
1768
1851
|
if (Array.isArray(t)) return t.filter((e) => typeof e == "string");
|
|
1769
|
-
},
|
|
1852
|
+
}, _n = () => {
|
|
1770
1853
|
let e = globalThis.crypto;
|
|
1771
1854
|
return typeof e?.randomUUID == "function" ? e.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
|
|
1772
|
-
},
|
|
1855
|
+
}, vn = (e) => `${e}_${_n()}`, Z = (e, t = fn) => {
|
|
1773
1856
|
if (e == null) return e;
|
|
1774
1857
|
try {
|
|
1775
1858
|
let n = JSON.stringify(e);
|
|
@@ -1785,19 +1868,19 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1785
1868
|
let t = {};
|
|
1786
1869
|
for (let [n, r] of Object.entries(e)) t[n] = r instanceof Date ? r.toISOString() : r;
|
|
1787
1870
|
return t;
|
|
1788
|
-
},
|
|
1789
|
-
let t = e.truncateBytes ??
|
|
1871
|
+
}, yn = (e) => {
|
|
1872
|
+
let t = e.truncateBytes ?? fn, n = e.makeId ?? vn, r = (t, n) => e.log?.warn(t, n), i = e.encryptStepPayload ?? ((e) => e), a = e.emit, o = e.recording === "coarse";
|
|
1790
1873
|
return {
|
|
1791
|
-
startStep: async ({ runId:
|
|
1792
|
-
try {
|
|
1874
|
+
startStep: async ({ runId: s, stepName: c, attempt: l, stepInput: u, retryPolicy: d }) => {
|
|
1875
|
+
if (!o) try {
|
|
1793
1876
|
let r = await e.store.insert("_voltro_workflow_run_steps", {
|
|
1794
1877
|
id: n("ws"),
|
|
1795
|
-
runId:
|
|
1796
|
-
stepName:
|
|
1797
|
-
attempt:
|
|
1878
|
+
runId: s,
|
|
1879
|
+
stepName: c,
|
|
1880
|
+
attempt: l,
|
|
1798
1881
|
status: "running",
|
|
1799
|
-
input:
|
|
1800
|
-
retryPolicy:
|
|
1882
|
+
input: u === void 0 ? null : i(Z(u, t)),
|
|
1883
|
+
retryPolicy: d ?? null,
|
|
1801
1884
|
output: null,
|
|
1802
1885
|
errorTag: null,
|
|
1803
1886
|
errorMessage: null,
|
|
@@ -1811,21 +1894,21 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1811
1894
|
}), r.id;
|
|
1812
1895
|
} catch (e) {
|
|
1813
1896
|
r("failed to record step start (continuing)", {
|
|
1814
|
-
runId:
|
|
1815
|
-
stepName:
|
|
1816
|
-
attempt:
|
|
1897
|
+
runId: s,
|
|
1898
|
+
stepName: c,
|
|
1899
|
+
attempt: l,
|
|
1817
1900
|
reason: e?.message ?? String(e)
|
|
1818
1901
|
});
|
|
1819
1902
|
return;
|
|
1820
1903
|
}
|
|
1821
1904
|
},
|
|
1822
|
-
endStepSuccess: async ({ stepRecordId: n, output:
|
|
1823
|
-
try {
|
|
1905
|
+
endStepSuccess: async ({ stepRecordId: n, output: s, durationMs: c }) => {
|
|
1906
|
+
if (!o) try {
|
|
1824
1907
|
let r = await e.store.update("_voltro_workflow_run_steps", n, {
|
|
1825
1908
|
status: "succeeded",
|
|
1826
|
-
output: i(Z(
|
|
1909
|
+
output: i(Z(s, t)),
|
|
1827
1910
|
completedAt: /* @__PURE__ */ new Date(),
|
|
1828
|
-
durationMs:
|
|
1911
|
+
durationMs: c
|
|
1829
1912
|
});
|
|
1830
1913
|
r && a?.("workflowSteps", {
|
|
1831
1914
|
op: "update",
|
|
@@ -1838,15 +1921,15 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1838
1921
|
});
|
|
1839
1922
|
}
|
|
1840
1923
|
},
|
|
1841
|
-
endStepFailure: async ({ stepRecordId: n, errorTag:
|
|
1842
|
-
try {
|
|
1924
|
+
endStepFailure: async ({ stepRecordId: n, errorTag: s, errorMessage: c, errorCause: l, durationMs: u }) => {
|
|
1925
|
+
if (!o) try {
|
|
1843
1926
|
let r = await e.store.update("_voltro_workflow_run_steps", n, {
|
|
1844
1927
|
status: "failed",
|
|
1845
|
-
errorTag:
|
|
1846
|
-
errorMessage:
|
|
1847
|
-
errorCause:
|
|
1928
|
+
errorTag: s,
|
|
1929
|
+
errorMessage: c,
|
|
1930
|
+
errorCause: l === void 0 ? null : i(Z(l, t)),
|
|
1848
1931
|
completedAt: /* @__PURE__ */ new Date(),
|
|
1849
|
-
durationMs:
|
|
1932
|
+
durationMs: u
|
|
1850
1933
|
});
|
|
1851
1934
|
r && a?.("workflowSteps", {
|
|
1852
1935
|
op: "update",
|
|
@@ -1889,10 +1972,10 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1889
1972
|
return { id: l };
|
|
1890
1973
|
}
|
|
1891
1974
|
};
|
|
1892
|
-
},
|
|
1975
|
+
}, bn = (e, t, n) => m.gen(function* () {
|
|
1893
1976
|
let r = e.store.query;
|
|
1894
1977
|
if (r === void 0) return;
|
|
1895
|
-
let
|
|
1978
|
+
let i = e.replayShapeLimit ?? 2e3, a = yield* m.promise(() => r({
|
|
1896
1979
|
table: "_voltro_workflow_run_steps",
|
|
1897
1980
|
order: [{
|
|
1898
1981
|
column: "startedAt",
|
|
@@ -1901,52 +1984,52 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1901
1984
|
predicate: x("runId", t),
|
|
1902
1985
|
projection: ["stepName"],
|
|
1903
1986
|
skip: void 0,
|
|
1904
|
-
take:
|
|
1987
|
+
take: i + 1
|
|
1905
1988
|
}).catch((e) => (n("failed to read the replay shape (nondeterminism tripwire disabled for this attempt)", {
|
|
1906
1989
|
runId: t,
|
|
1907
1990
|
reason: e?.message ?? String(e)
|
|
1908
1991
|
}), [])));
|
|
1909
|
-
if (
|
|
1910
|
-
if (
|
|
1992
|
+
if (a.length === 0) return;
|
|
1993
|
+
if (a.length > i) {
|
|
1911
1994
|
n("replay shape exceeds the step limit — nondeterminism tripwire disabled for this run", {
|
|
1912
1995
|
runId: t,
|
|
1913
|
-
limit:
|
|
1996
|
+
limit: i
|
|
1914
1997
|
});
|
|
1915
1998
|
return;
|
|
1916
1999
|
}
|
|
1917
|
-
let s =
|
|
2000
|
+
let s = a.flatMap((e) => {
|
|
1918
2001
|
let t = e.stepName;
|
|
1919
2002
|
return typeof t == "string" ? [{ stepName: t }] : [];
|
|
1920
2003
|
});
|
|
1921
|
-
return s.length === 0 ? void 0 :
|
|
1922
|
-
}),
|
|
1923
|
-
let l =
|
|
1924
|
-
if (
|
|
1925
|
-
await
|
|
1926
|
-
workflowName:
|
|
2004
|
+
return s.length === 0 ? void 0 : o(s);
|
|
2005
|
+
}), xn = (o, c) => {
|
|
2006
|
+
let l = o.truncateBytes ?? fn, u = o.makeId ?? vn, f = o.recorder ?? yn(o), h = (e, t) => o.log?.warn(e, t), v = o.emit, y = (e, t, n) => m.promise(async () => {
|
|
2007
|
+
if (o.onParentClose) try {
|
|
2008
|
+
await o.onParentClose({
|
|
2009
|
+
workflowName: o.name,
|
|
1927
2010
|
executionId: e,
|
|
1928
2011
|
...n === void 0 ? {} : { runId: n },
|
|
1929
2012
|
status: t
|
|
1930
2013
|
});
|
|
1931
2014
|
} catch (n) {
|
|
1932
2015
|
h("failed to apply workflow parent-close policy", {
|
|
1933
|
-
tag:
|
|
2016
|
+
tag: o.name,
|
|
1934
2017
|
executionId: e,
|
|
1935
2018
|
status: t,
|
|
1936
2019
|
reason: n?.message ?? String(n)
|
|
1937
2020
|
});
|
|
1938
2021
|
}
|
|
1939
2022
|
}), b = (e, t, n) => m.promise(async () => {
|
|
1940
|
-
if (
|
|
1941
|
-
await
|
|
1942
|
-
workflowName:
|
|
2023
|
+
if (o.onTerminal) try {
|
|
2024
|
+
await o.onTerminal({
|
|
2025
|
+
workflowName: o.name,
|
|
1943
2026
|
executionId: e,
|
|
1944
2027
|
...n === void 0 ? {} : { runId: n },
|
|
1945
2028
|
status: t
|
|
1946
2029
|
});
|
|
1947
2030
|
} catch (n) {
|
|
1948
2031
|
h("failed to release the workflow admission lease", {
|
|
1949
|
-
tag:
|
|
2032
|
+
tag: o.name,
|
|
1950
2033
|
executionId: e,
|
|
1951
2034
|
status: t,
|
|
1952
2035
|
reason: n?.message ?? String(n)
|
|
@@ -1954,14 +2037,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1954
2037
|
}
|
|
1955
2038
|
});
|
|
1956
2039
|
return (ee, S) => m.gen(function* () {
|
|
1957
|
-
let C = Date.now(), te = yield* _.get(r), w =
|
|
2040
|
+
let C = Date.now(), te = yield* _.get(r), w = o.parentExecutionId ?? te ?? null, ne = o.parentClosePolicy ?? null, T, E = (e, t) => t.pipe(m.catchAllCause((t) => p.isInterrupted(t) ? m.failCause(t) : m.sync(() => {
|
|
1958
2041
|
let n = p.squash(t);
|
|
1959
2042
|
h(e, {
|
|
1960
|
-
tag:
|
|
2043
|
+
tag: o.name,
|
|
1961
2044
|
executionId: S,
|
|
1962
2045
|
reason: n?.message ?? String(n)
|
|
1963
2046
|
});
|
|
1964
|
-
}))), D = (
|
|
2047
|
+
}))), D = (o.store.query ? yield* m.promise(() => o.store.query({
|
|
1965
2048
|
table: "_voltro_workflow_runs",
|
|
1966
2049
|
order: [],
|
|
1967
2050
|
predicate: x("executionId", S),
|
|
@@ -1969,8 +2052,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1969
2052
|
skip: void 0,
|
|
1970
2053
|
take: 1
|
|
1971
2054
|
})) : [])[0], O = D?.workflowVersion ?? null;
|
|
1972
|
-
if (D?.id !== void 0 && O !== null &&
|
|
1973
|
-
let e = `Workflow '${
|
|
2055
|
+
if (D?.id !== void 0 && O !== null && o.workflowCompatibleVersions !== void 0 && o.workflowCompatibleVersions !== null && !o.workflowCompatibleVersions.includes(O)) {
|
|
2056
|
+
let e = `Workflow '${o.name}' run '${S}' was started on version ${O}, but current code is compatible with ${o.workflowCompatibleVersions.join(", ")}`, t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", D.id, {
|
|
1974
2057
|
status: "failed",
|
|
1975
2058
|
errorTag: "WorkflowVersionIncompatible",
|
|
1976
2059
|
errorMessage: e,
|
|
@@ -1986,24 +2069,24 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
1986
2069
|
payload: {
|
|
1987
2070
|
errorTag: "WorkflowVersionIncompatible",
|
|
1988
2071
|
errorMessage: e,
|
|
1989
|
-
workflowVersion:
|
|
1990
|
-
compatibleWith:
|
|
2072
|
+
workflowVersion: o.workflowVersion ?? null,
|
|
2073
|
+
compatibleWith: o.workflowCompatibleVersions,
|
|
1991
2074
|
previousVersion: O
|
|
1992
2075
|
}
|
|
1993
|
-
})), yield* m.sync(() =>
|
|
1994
|
-
name:
|
|
2076
|
+
})), yield* m.sync(() => o.recordRun?.({
|
|
2077
|
+
name: o.name,
|
|
1995
2078
|
status: "failed",
|
|
1996
2079
|
durationMs: 0
|
|
1997
2080
|
})), yield* m.fail(Error(e));
|
|
1998
2081
|
}
|
|
1999
|
-
let k =
|
|
2082
|
+
let k = o.workflowPatches ?? [], A;
|
|
2000
2083
|
if (D?.id !== void 0) {
|
|
2001
|
-
T = D.id, k =
|
|
2002
|
-
let e = D.runnerEnteredAt !== null && D.runnerEnteredAt !== void 0, t = typeof D.reclaimCount == "number" ? D.reclaimCount : Number(D.reclaimCount ?? 0), n = e ? (Number.isFinite(t) ? t : 0) + 1 : 0, r =
|
|
2084
|
+
T = D.id, k = gn(D.workflowPatches) ?? k;
|
|
2085
|
+
let e = D.runnerEnteredAt !== null && D.runnerEnteredAt !== void 0, t = typeof D.reclaimCount == "number" ? D.reclaimCount : Number(D.reclaimCount ?? 0), n = e ? (Number.isFinite(t) ? t : 0) + 1 : 0, r = o.maxRunReclaims ?? 3;
|
|
2003
2086
|
if (e && n >= r) {
|
|
2004
|
-
let e = `Workflow '${
|
|
2087
|
+
let e = `Workflow '${o.name}' run '${S}' killed its runner ${n} times in a row; parked instead of reclaimed again (maxRunReclaims=${r}).`;
|
|
2005
2088
|
yield* E("failed to record workflow crash-loop park", m.gen(function* () {
|
|
2006
|
-
let t = yield* m.promise(() =>
|
|
2089
|
+
let t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2007
2090
|
status: "suspended",
|
|
2008
2091
|
errorTag: "WorkflowCrashLooped",
|
|
2009
2092
|
errorMessage: e,
|
|
@@ -2020,21 +2103,21 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2020
2103
|
reclaimCount: n,
|
|
2021
2104
|
maxRunReclaims: r,
|
|
2022
2105
|
executionId: S,
|
|
2023
|
-
tag:
|
|
2106
|
+
tag: o.name
|
|
2024
2107
|
}
|
|
2025
2108
|
}));
|
|
2026
2109
|
})), h("workflow run parked after repeated runner deaths", {
|
|
2027
|
-
tag:
|
|
2110
|
+
tag: o.name,
|
|
2028
2111
|
executionId: S,
|
|
2029
2112
|
runId: T,
|
|
2030
2113
|
reclaimCount: n,
|
|
2031
2114
|
maxRunReclaims: r
|
|
2032
2115
|
});
|
|
2033
|
-
let t = yield*
|
|
2116
|
+
let t = yield* se;
|
|
2034
2117
|
return yield* d.suspend(t);
|
|
2035
2118
|
}
|
|
2036
|
-
A = yield*
|
|
2037
|
-
let t = yield* m.promise(() =>
|
|
2119
|
+
A = yield* bn(o, T, h), yield* E("failed to record workflow re-entry", m.gen(function* () {
|
|
2120
|
+
let t = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2038
2121
|
status: "running",
|
|
2039
2122
|
errorTag: null,
|
|
2040
2123
|
errorMessage: null,
|
|
@@ -2056,24 +2139,24 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2056
2139
|
})));
|
|
2057
2140
|
}));
|
|
2058
2141
|
} else yield* E("failed to record workflow start (continuing)", m.gen(function* () {
|
|
2059
|
-
let e = yield* m.promise(() =>
|
|
2142
|
+
let e = yield* m.promise(() => o.store.insert("_voltro_workflow_runs", {
|
|
2060
2143
|
id: u("wr"),
|
|
2061
|
-
tag:
|
|
2144
|
+
tag: o.name,
|
|
2062
2145
|
executionId: S,
|
|
2063
2146
|
status: "running",
|
|
2064
2147
|
payload: ee,
|
|
2065
|
-
workflowVersion:
|
|
2066
|
-
workflowPatches:
|
|
2148
|
+
workflowVersion: o.workflowVersion ?? null,
|
|
2149
|
+
workflowPatches: o.workflowPatches ?? null,
|
|
2067
2150
|
output: null,
|
|
2068
|
-
subject:
|
|
2069
|
-
source:
|
|
2151
|
+
subject: o.subject ?? null,
|
|
2152
|
+
source: o.source ?? null,
|
|
2070
2153
|
errorTag: null,
|
|
2071
2154
|
errorMessage: null,
|
|
2072
2155
|
cancelled: !1,
|
|
2073
2156
|
startedAt: /* @__PURE__ */ new Date(),
|
|
2074
2157
|
completedAt: null,
|
|
2075
2158
|
durationMs: null,
|
|
2076
|
-
traceId:
|
|
2159
|
+
traceId: o.traceId ?? null,
|
|
2077
2160
|
parentExecutionId: w,
|
|
2078
2161
|
parentClosePolicy: ne,
|
|
2079
2162
|
runnerEnteredAt: /* @__PURE__ */ new Date(),
|
|
@@ -2088,25 +2171,25 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2088
2171
|
runId: e,
|
|
2089
2172
|
eventType: "run-started",
|
|
2090
2173
|
payload: {
|
|
2091
|
-
tag:
|
|
2174
|
+
tag: o.name,
|
|
2092
2175
|
executionId: S,
|
|
2093
|
-
source:
|
|
2094
|
-
workflowVersion:
|
|
2095
|
-
workflowPatches:
|
|
2176
|
+
source: o.source ?? null,
|
|
2177
|
+
workflowVersion: o.workflowVersion ?? null,
|
|
2178
|
+
workflowPatches: o.workflowPatches ?? null,
|
|
2096
2179
|
parentExecutionId: w,
|
|
2097
2180
|
parentClosePolicy: ne
|
|
2098
2181
|
}
|
|
2099
2182
|
}));
|
|
2100
2183
|
}
|
|
2101
2184
|
}));
|
|
2102
|
-
let
|
|
2103
|
-
if (d.isResult(
|
|
2104
|
-
let e =
|
|
2105
|
-
t && (yield* m.sync(() =>
|
|
2185
|
+
let re = o.subject?.tenantId, ie = c(ee, S).pipe(m.locally(a, T), m.locally(r, S), m.locally(t, typeof re == "string" ? re : void 0), m.locally(i, k), m.locally(s, A), m.provideService(n, f)), ae = o.pluginWorkflowStepLayer ? ie.pipe(m.provide(o.pluginWorkflowStepLayer)) : ie, j = yield* d.intoResult(ae);
|
|
2186
|
+
if (d.isResult(j) && j._tag === "Suspended") {
|
|
2187
|
+
let e = j.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;
|
|
2188
|
+
t && (yield* m.sync(() => ce({
|
|
2106
2189
|
error: n,
|
|
2107
2190
|
source: "workflow",
|
|
2108
|
-
name:
|
|
2109
|
-
...
|
|
2191
|
+
name: o.name,
|
|
2192
|
+
...o.traceId ? { traceId: o.traceId } : {},
|
|
2110
2193
|
fields: {
|
|
2111
2194
|
executionId: S,
|
|
2112
2195
|
suspendedOnFailure: !0,
|
|
@@ -2114,12 +2197,12 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2114
2197
|
...T ? { runId: T } : {}
|
|
2115
2198
|
}
|
|
2116
2199
|
}))), T && (yield* E("failed to record workflow suspend", m.gen(function* () {
|
|
2117
|
-
let e = yield* m.promise(() =>
|
|
2200
|
+
let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2118
2201
|
status: "suspended",
|
|
2119
2202
|
runnerEnteredAt: null,
|
|
2120
2203
|
...t ? {
|
|
2121
2204
|
errorTag: r,
|
|
2122
|
-
errorMessage:
|
|
2205
|
+
errorMessage: i
|
|
2123
2206
|
} : {}
|
|
2124
2207
|
}));
|
|
2125
2208
|
e && v?.("workflowRuns", {
|
|
@@ -2131,49 +2214,49 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2131
2214
|
payload: t ? {
|
|
2132
2215
|
reason: "suspend-on-failure",
|
|
2133
2216
|
errorTag: r,
|
|
2134
|
-
errorMessage:
|
|
2217
|
+
errorMessage: i
|
|
2135
2218
|
} : { reason: "workflow-suspend" }
|
|
2136
2219
|
}));
|
|
2137
2220
|
})));
|
|
2138
|
-
let
|
|
2139
|
-
return yield* d.suspend(
|
|
2221
|
+
let a = yield* se;
|
|
2222
|
+
return yield* d.suspend(a);
|
|
2140
2223
|
}
|
|
2141
|
-
let
|
|
2224
|
+
let M = j;
|
|
2142
2225
|
if (A !== void 0 && T !== void 0) {
|
|
2143
|
-
let
|
|
2144
|
-
if (
|
|
2226
|
+
let t = A.settle();
|
|
2227
|
+
if (t.length > 0) {
|
|
2145
2228
|
let n = T;
|
|
2146
2229
|
h("workflow replay reached a different step shape than this run recorded", {
|
|
2147
|
-
tag:
|
|
2230
|
+
tag: o.name,
|
|
2148
2231
|
executionId: S,
|
|
2149
2232
|
runId: n,
|
|
2150
|
-
findings:
|
|
2233
|
+
findings: t.map((e) => `${e.kind}:${e.stepName}`)
|
|
2151
2234
|
}), yield* E("failed to record nondeterminism findings", m.promise(async () => {
|
|
2152
|
-
for (let r of
|
|
2235
|
+
for (let r of t) await f.recordEvent({
|
|
2153
2236
|
runId: n,
|
|
2154
2237
|
eventType: "nondeterminism-suspected",
|
|
2155
|
-
payload:
|
|
2238
|
+
payload: e(r)
|
|
2156
2239
|
}).catch(() => void 0);
|
|
2157
2240
|
}));
|
|
2158
2241
|
}
|
|
2159
2242
|
}
|
|
2160
|
-
if (g.isFailure(
|
|
2161
|
-
let e =
|
|
2162
|
-
return yield* m.sync(() =>
|
|
2243
|
+
if (g.isFailure(M.exit)) {
|
|
2244
|
+
let e = M.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);
|
|
2245
|
+
return yield* m.sync(() => ce({
|
|
2163
2246
|
error: n,
|
|
2164
2247
|
source: "workflow",
|
|
2165
|
-
name:
|
|
2166
|
-
...
|
|
2248
|
+
name: o.name,
|
|
2249
|
+
...o.traceId ? { traceId: o.traceId } : {},
|
|
2167
2250
|
fields: {
|
|
2168
2251
|
executionId: S,
|
|
2169
2252
|
...r ? { errorTag: r } : {},
|
|
2170
2253
|
...T ? { runId: T } : {}
|
|
2171
2254
|
}
|
|
2172
2255
|
})), T && (yield* E("failed to record workflow failure", m.gen(function* () {
|
|
2173
|
-
let e = yield* m.promise(() =>
|
|
2256
|
+
let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2174
2257
|
status: "failed",
|
|
2175
2258
|
errorTag: r,
|
|
2176
|
-
errorMessage:
|
|
2259
|
+
errorMessage: i,
|
|
2177
2260
|
completedAt: /* @__PURE__ */ new Date(),
|
|
2178
2261
|
durationMs: Date.now() - C,
|
|
2179
2262
|
runnerEnteredAt: null
|
|
@@ -2186,21 +2269,21 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2186
2269
|
eventType: "run-failed",
|
|
2187
2270
|
payload: {
|
|
2188
2271
|
errorTag: r,
|
|
2189
|
-
errorMessage:
|
|
2272
|
+
errorMessage: i,
|
|
2190
2273
|
durationMs: Date.now() - C
|
|
2191
2274
|
}
|
|
2192
2275
|
})), yield* y(S, "failed", T);
|
|
2193
|
-
}))), yield* b(S, "failed", T), yield* m.sync(() =>
|
|
2194
|
-
name:
|
|
2276
|
+
}))), yield* b(S, "failed", T), yield* m.sync(() => o.recordRun?.({
|
|
2277
|
+
name: o.name,
|
|
2195
2278
|
status: "failed",
|
|
2196
2279
|
durationMs: Date.now() - C
|
|
2197
2280
|
})), yield* m.failCause(e);
|
|
2198
2281
|
}
|
|
2199
|
-
let
|
|
2282
|
+
let N = M.exit.value;
|
|
2200
2283
|
return T && (yield* E("failed to record workflow success", m.gen(function* () {
|
|
2201
|
-
let e = yield* m.promise(() =>
|
|
2284
|
+
let e = yield* m.promise(() => o.store.update("_voltro_workflow_runs", T, {
|
|
2202
2285
|
status: "succeeded",
|
|
2203
|
-
output: Z(
|
|
2286
|
+
output: Z(N, l),
|
|
2204
2287
|
completedAt: /* @__PURE__ */ new Date(),
|
|
2205
2288
|
durationMs: Date.now() - C,
|
|
2206
2289
|
runnerEnteredAt: null
|
|
@@ -2213,14 +2296,14 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2213
2296
|
eventType: "run-succeeded",
|
|
2214
2297
|
payload: { durationMs: Date.now() - C }
|
|
2215
2298
|
})), yield* y(S, "succeeded", T);
|
|
2216
|
-
}))), yield* b(S, "succeeded", T), yield* m.sync(() =>
|
|
2217
|
-
name:
|
|
2299
|
+
}))), yield* b(S, "succeeded", T), yield* m.sync(() => o.recordRun?.({
|
|
2300
|
+
name: o.name,
|
|
2218
2301
|
status: "succeeded",
|
|
2219
2302
|
durationMs: Date.now() - C,
|
|
2220
2303
|
completedAtSec: Date.now() / 1e3
|
|
2221
|
-
})),
|
|
2304
|
+
})), N;
|
|
2222
2305
|
});
|
|
2223
|
-
},
|
|
2306
|
+
}, Sn = (e) => e === "cancel" || e === "terminate", Cn = (e) => e === "running" || e === "suspended", wn = async (e) => {
|
|
2224
2307
|
let t = await e.store.query({
|
|
2225
2308
|
table: "_voltro_workflow_runs",
|
|
2226
2309
|
order: [{
|
|
@@ -2246,7 +2329,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2246
2329
|
});
|
|
2247
2330
|
continue;
|
|
2248
2331
|
}
|
|
2249
|
-
if (!
|
|
2332
|
+
if (!Sn(r.parentClosePolicy)) {
|
|
2250
2333
|
n.push({
|
|
2251
2334
|
...t,
|
|
2252
2335
|
action: "skipped",
|
|
@@ -2254,7 +2337,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2254
2337
|
});
|
|
2255
2338
|
continue;
|
|
2256
2339
|
}
|
|
2257
|
-
if (!
|
|
2340
|
+
if (!Cn(r.status)) {
|
|
2258
2341
|
n.push({
|
|
2259
2342
|
...t,
|
|
2260
2343
|
action: "skipped",
|
|
@@ -2302,7 +2385,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2302
2385
|
}
|
|
2303
2386
|
}
|
|
2304
2387
|
return n;
|
|
2305
|
-
},
|
|
2388
|
+
}, Tn = (e) => {
|
|
2306
2389
|
if (e == null) return null;
|
|
2307
2390
|
if (e instanceof Date) return e;
|
|
2308
2391
|
if (typeof e == "string" || typeof e == "number") {
|
|
@@ -2310,7 +2393,7 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2310
2393
|
return Number.isNaN(t.getTime()) ? null : t;
|
|
2311
2394
|
}
|
|
2312
2395
|
return null;
|
|
2313
|
-
},
|
|
2396
|
+
}, En = (e) => typeof e == "number" ? e : e == null ? null : Number(e), $ = (e) => e == null ? null : String(e), Dn = (e) => {
|
|
2314
2397
|
let t = /* @__PURE__ */ new Map();
|
|
2315
2398
|
for (let n of e) {
|
|
2316
2399
|
let e = String(n.stepName), r = t.get(e);
|
|
@@ -2318,27 +2401,27 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2318
2401
|
}
|
|
2319
2402
|
let n = [];
|
|
2320
2403
|
for (let [e, r] of t) {
|
|
2321
|
-
r.sort((e, t) => (
|
|
2404
|
+
r.sort((e, t) => (En(e.attempt) ?? 0) - (En(t.attempt) ?? 0));
|
|
2322
2405
|
let t = r[r.length - 1], i = $(t.errorTag), a = $(t.errorMessage), o = i !== null || a !== null ? {
|
|
2323
2406
|
tag: i,
|
|
2324
2407
|
message: a ?? ""
|
|
2325
2408
|
} : null;
|
|
2326
2409
|
n.push({
|
|
2327
2410
|
name: e,
|
|
2328
|
-
attempt:
|
|
2411
|
+
attempt: En(t.attempt) ?? r.length,
|
|
2329
2412
|
attempts: r.length,
|
|
2330
2413
|
status: t.status ?? "running",
|
|
2331
2414
|
input: t.input ?? null,
|
|
2332
2415
|
output: t.output ?? null,
|
|
2333
2416
|
error: o,
|
|
2334
|
-
durationMs:
|
|
2417
|
+
durationMs: En(t.durationMs)
|
|
2335
2418
|
});
|
|
2336
2419
|
}
|
|
2337
2420
|
return n.sort((t, n) => {
|
|
2338
2421
|
let r = e.find((e) => String(e.stepName) === t.name), i = e.find((e) => String(e.stepName) === n.name);
|
|
2339
|
-
return (
|
|
2422
|
+
return (Tn(r?.startedAt)?.getTime() ?? 0) - (Tn(i?.startedAt)?.getTime() ?? 0);
|
|
2340
2423
|
}), n;
|
|
2341
|
-
},
|
|
2424
|
+
}, On = (e) => {
|
|
2342
2425
|
if (e == null) return null;
|
|
2343
2426
|
if (typeof e == "string") try {
|
|
2344
2427
|
return JSON.parse(e);
|
|
@@ -2346,8 +2429,8 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2346
2429
|
return null;
|
|
2347
2430
|
}
|
|
2348
2431
|
return typeof e == "object" ? e : null;
|
|
2349
|
-
},
|
|
2350
|
-
let n = A(
|
|
2432
|
+
}, kn = async (e, t) => {
|
|
2433
|
+
let n = A(P), r = (await t.query(n.where(k(x("id", e), x("executionId", e))).limit(1).descriptor))[0];
|
|
2351
2434
|
if (r === void 0) return null;
|
|
2352
2435
|
let i = String(r.id), a = A(ue), o = await t.query(a.where(x("runId", i)).descriptor);
|
|
2353
2436
|
return {
|
|
@@ -2357,16 +2440,16 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2357
2440
|
status: r.status ?? "running",
|
|
2358
2441
|
input: r.payload ?? null,
|
|
2359
2442
|
output: r.output ?? null,
|
|
2360
|
-
subject:
|
|
2443
|
+
subject: On(r.subject),
|
|
2361
2444
|
source: $(r.source),
|
|
2362
|
-
steps:
|
|
2363
|
-
startedAt:
|
|
2364
|
-
finishedAt:
|
|
2445
|
+
steps: Dn(o),
|
|
2446
|
+
startedAt: Tn(r.startedAt) ?? /* @__PURE__ */ new Date(0),
|
|
2447
|
+
finishedAt: Tn(r.completedAt),
|
|
2365
2448
|
traceId: $(r.traceId),
|
|
2366
2449
|
parentExecutionId: $(r.parentExecutionId),
|
|
2367
2450
|
parentClosePolicy: $(r.parentClosePolicy)
|
|
2368
2451
|
};
|
|
2369
|
-
},
|
|
2452
|
+
}, An = () => {
|
|
2370
2453
|
let e = [], t = [], r = 0, i = 0;
|
|
2371
2454
|
return {
|
|
2372
2455
|
layer: v.succeed(n, {
|
|
@@ -2415,4 +2498,4 @@ var ce = f.layerMemory, le = M("_voltro_workflow_runs", {
|
|
|
2415
2498
|
};
|
|
2416
2499
|
};
|
|
2417
2500
|
//#endregion
|
|
2418
|
-
export {
|
|
2501
|
+
export { Je as $, zt as A, _e as At, at as B, tn as C, Ae as Ct, It as D, Se as Dt, Ht as E, ye as Et, Dt as F, fe as Ft, Qe as G, ot as H, Tt as I, de as It, Xe as J, $e as K, wt as L, ue as Lt, At as M, me as Mt, St as N, he as Nt, Lt as O, xe as Ot, Ot as P, pe as Pt, Ye as Q, ht as R, P as Rt, on as S, W as St, Kt as T, Ce as Tt, pt as U, st as V, K as W, it as X, et as Y, tt as Z, Xt as _, Ne as _t, mn as a, we as at, cn as b, Oe as bt, hn as c, G as ct, xn as d, Ve as dt, Ke as et, dn as f, Be as ft, Zt as g, Le as gt, en as h, Ee as ht, pn as i, Te as it, Mt as j, I as jt, Rt as k, ve as kt, Q as l, ze as lt, $t as m, ke as mt, kn as n, Ge as nt, yn as o, R as ot, X as p, Pe as pt, Ze as q, wn as r, z as rt, gn as s, Re as st, An as t, Ue as tt, Z as u, Ie as ut, Yt as v, He as vt, Gt as w, ge as wt, sn as x, U as xt, Jt as y, je as yt, gt as z, le as zt };
|