@dudousxd/nestjs-durable-testing 0.22.2 → 0.23.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/dist/index.js CHANGED
@@ -841,6 +841,7 @@ function runStateStoreContract(name, makeStore) {
841
841
  let cleanup;
842
842
  let supportsAsyncTransaction = true;
843
843
  let supportsTagFilter = true;
844
+ let statements;
844
845
  let skipReason;
845
846
  let loggedSkip = false;
846
847
  beforeEach(async () => {
@@ -851,6 +852,7 @@ function runStateStoreContract(name, makeStore) {
851
852
  cleanup = ctx.cleanup;
852
853
  supportsAsyncTransaction = ctx.supportsAsyncTransaction ?? true;
853
854
  supportsTagFilter = ctx.supportsTagFilter ?? true;
855
+ statements = ctx.statements;
854
856
  skipReason = void 0;
855
857
  } catch (err) {
856
858
  if (isUnavailable(err) && !process.env.DURABLE_TEST_REQUIRE_BACKENDS) {
@@ -1484,6 +1486,70 @@ function runStateStoreContract(name, makeStore) {
1484
1486
  "chatty-old"
1485
1487
  ]);
1486
1488
  });
1489
+ t("a parent joining children that already finished settles them from their rows", async () => {
1490
+ const engine = new WorkflowEngine3({
1491
+ store,
1492
+ reconcileMs: 0
1493
+ });
1494
+ engine.register("j-child", "1", async (_ctx, input) => ({
1495
+ n: input.n
1496
+ }));
1497
+ engine.register("j-parent", "1", async (ctx) => {
1498
+ const lone = await ctx.child("j-child", {
1499
+ n: 9
1500
+ }, "j-own-id");
1501
+ const fan = await ctx.allSettled("j-child", [
1502
+ {
1503
+ n: 0
1504
+ },
1505
+ {
1506
+ n: 1
1507
+ }
1508
+ ]);
1509
+ return {
1510
+ lone,
1511
+ fan
1512
+ };
1513
+ });
1514
+ await engine.start("j-child", {
1515
+ n: 9
1516
+ }, "j-own-id");
1517
+ await engine.start("j-child", {
1518
+ n: 1
1519
+ }, "jp.all.1.1");
1520
+ expect3((await engine.waitForRun("j-own-id", {
1521
+ timeoutMs: 2e4
1522
+ })).status).toBe("completed");
1523
+ expect3((await engine.waitForRun("jp.all.1.1", {
1524
+ timeoutMs: 2e4
1525
+ })).status).toBe("completed");
1526
+ await engine.start("j-parent", {}, "jp");
1527
+ const deadline = Date.now() + 2e4;
1528
+ while ((await store.getRun("jp"))?.status !== "completed") {
1529
+ if (Date.now() > deadline) throw new Error("parent never completed");
1530
+ await new Promise((resolve) => setTimeout(resolve, 20));
1531
+ }
1532
+ expect3((await store.getRun("jp"))?.output).toEqual({
1533
+ lone: {
1534
+ n: 9
1535
+ },
1536
+ fan: [
1537
+ {
1538
+ status: "fulfilled",
1539
+ value: {
1540
+ n: 0
1541
+ }
1542
+ },
1543
+ {
1544
+ status: "fulfilled",
1545
+ value: {
1546
+ n: 1
1547
+ }
1548
+ }
1549
+ ]
1550
+ });
1551
+ await engine.drain(5e3);
1552
+ });
1487
1553
  t("engine.purgeRuns deletes a scope with its child subtrees and cancels live runs", async () => {
1488
1554
  const engine = new WorkflowEngine3({
1489
1555
  store
@@ -2056,6 +2122,191 @@ function runStateStoreContract(name, makeStore) {
2056
2122
  n: 3
2057
2123
  });
2058
2124
  });
2125
+ t("getCheckpoints reads many of a run's checkpoints at once, in seq order", async () => {
2126
+ expect3(store.getCheckpoints).toBeDefined();
2127
+ if (!store.getCheckpoints) return;
2128
+ await store.createRun(run());
2129
+ await store.createRun(run({
2130
+ id: "r2"
2131
+ }));
2132
+ expect3(await store.getCheckpoints("r1", [])).toEqual([]);
2133
+ for (const seq of [
2134
+ 0,
2135
+ 1,
2136
+ 2,
2137
+ 5
2138
+ ]) {
2139
+ await store.saveCheckpoint(checkpoint({
2140
+ seq,
2141
+ stepId: `r1:${seq}`,
2142
+ output: {
2143
+ seq
2144
+ },
2145
+ wakeAt: seq === 2 ? 7e3 : void 0
2146
+ }));
2147
+ }
2148
+ await store.saveCheckpoint(checkpoint({
2149
+ runId: "r2",
2150
+ seq: 3,
2151
+ stepId: "r2:3"
2152
+ }));
2153
+ const read = await store.getCheckpoints("r1", [
2154
+ 5,
2155
+ 0,
2156
+ 3,
2157
+ 2,
2158
+ 0
2159
+ ]);
2160
+ expect3(read.map((c) => [
2161
+ c.runId,
2162
+ c.seq,
2163
+ c.output
2164
+ ])).toEqual([
2165
+ [
2166
+ "r1",
2167
+ 0,
2168
+ {
2169
+ seq: 0
2170
+ }
2171
+ ],
2172
+ [
2173
+ "r1",
2174
+ 2,
2175
+ {
2176
+ seq: 2
2177
+ }
2178
+ ],
2179
+ [
2180
+ "r1",
2181
+ 5,
2182
+ {
2183
+ seq: 5
2184
+ }
2185
+ ]
2186
+ ]);
2187
+ expect3(read[1]).toEqual(await store.getCheckpoint("r1", 2));
2188
+ const n = 1200;
2189
+ for (let seq = 10; seq < 10 + n; seq += 1) {
2190
+ await store.saveCheckpoint(checkpoint({
2191
+ seq,
2192
+ stepId: `r1:${seq}`
2193
+ }));
2194
+ }
2195
+ const wide = await store.getCheckpoints("r1", Array.from({
2196
+ length: n
2197
+ }, (_, i) => 10 + i));
2198
+ expect3(wide.map((c) => c.seq)).toEqual(Array.from({
2199
+ length: n
2200
+ }, (_, i) => 10 + i));
2201
+ });
2202
+ t("saveCheckpoints writes many checkpoints at once, inserting or overwriting each", async () => {
2203
+ expect3(store.saveCheckpoints).toBeDefined();
2204
+ if (!store.saveCheckpoints) return;
2205
+ await store.saveCheckpoints([]);
2206
+ await store.createRun(run());
2207
+ await store.saveCheckpoint(checkpoint({
2208
+ seq: 1,
2209
+ stepId: "r1:1",
2210
+ output: {
2211
+ old: true
2212
+ }
2213
+ }));
2214
+ await store.saveCheckpoints([
2215
+ checkpoint({
2216
+ seq: 0,
2217
+ stepId: "r1:0",
2218
+ status: "pending",
2219
+ output: void 0,
2220
+ wakeAt: 4e3
2221
+ }),
2222
+ checkpoint({
2223
+ seq: 1,
2224
+ stepId: "r1:1",
2225
+ output: {
2226
+ new: true
2227
+ },
2228
+ parallelGroup: "g"
2229
+ }),
2230
+ checkpoint({
2231
+ seq: 2,
2232
+ stepId: "r1:2",
2233
+ input: {
2234
+ i: 2
2235
+ },
2236
+ workerGroup: "w"
2237
+ })
2238
+ ]);
2239
+ const rows = await store.listCheckpoints("r1");
2240
+ expect3(rows.map((c) => [
2241
+ c.seq,
2242
+ c.status,
2243
+ c.output
2244
+ ])).toEqual([
2245
+ [
2246
+ 0,
2247
+ "pending",
2248
+ void 0
2249
+ ],
2250
+ [
2251
+ 1,
2252
+ "completed",
2253
+ {
2254
+ new: true
2255
+ }
2256
+ ],
2257
+ [
2258
+ 2,
2259
+ "completed",
2260
+ {
2261
+ ok: true
2262
+ }
2263
+ ]
2264
+ ]);
2265
+ expect3(rows[0]?.wakeAt).toBe(4e3);
2266
+ expect3(rows[1]?.parallelGroup).toBe("g");
2267
+ expect3(rows[2]?.input).toEqual({
2268
+ i: 2
2269
+ });
2270
+ expect3(rows[2]?.workerGroup).toBe("w");
2271
+ });
2272
+ t("the batched checkpoint methods send a fixed number of statements for a wide batch", async () => {
2273
+ if (!statements || !store.saveCheckpoints || !store.saveCheckpointsIfPending) return;
2274
+ if (!store.getCheckpoints) return;
2275
+ await store.createRun(run());
2276
+ const n = 600;
2277
+ const limit = n / 20;
2278
+ const rows = Array.from({
2279
+ length: n
2280
+ }, (_, seq) => checkpoint({
2281
+ seq,
2282
+ stepId: `r1:${seq}`,
2283
+ status: "pending",
2284
+ output: void 0
2285
+ }));
2286
+ const sent = /* @__PURE__ */ __name(async (work) => {
2287
+ const before = statements();
2288
+ await work();
2289
+ return statements() - before;
2290
+ }, "sent");
2291
+ expect3(await sent(() => store.saveCheckpoints?.(rows))).toBeLessThanOrEqual(limit);
2292
+ const seqs = rows.map((r) => r.seq);
2293
+ expect3(await sent(() => store.getCheckpoints?.("r1", seqs))).toBeLessThanOrEqual(limit);
2294
+ const settled = rows.map((row) => ({
2295
+ ...row,
2296
+ status: "completed",
2297
+ output: {
2298
+ seq: row.seq
2299
+ }
2300
+ }));
2301
+ let wrote = [];
2302
+ expect3(await sent(async () => {
2303
+ wrote = await store.saveCheckpointsIfPending?.(settled) ?? [];
2304
+ })).toBeLessThanOrEqual(limit);
2305
+ expect3(wrote.every((w) => w)).toBe(true);
2306
+ expect3(await store.countCheckpoints?.("r1", 0, n - 1, [
2307
+ "completed"
2308
+ ])).toBe(n);
2309
+ });
2059
2310
  t("saveCheckpointsIfPending writes a wide batch", async () => {
2060
2311
  if (!store.saveCheckpointsIfPending) return;
2061
2312
  await store.createRun(run());
@@ -3963,6 +4214,111 @@ function runStateStoreContract(name, makeStore) {
3963
4214
  seq: 0
3964
4215
  });
3965
4216
  });
4217
+ t("lists buffered signals by token prefix in insertion order, a page at a time", async () => {
4218
+ expect3(store.listBufferedSignals).toBeTypeOf("function");
4219
+ const list = /* @__PURE__ */ __name((prefix, after, limit) => store.listBufferedSignals?.(prefix, after, limit) ?? Promise.resolve([]), "list");
4220
+ await store.bufferSignal("child:a", {
4221
+ ok: true,
4222
+ value: {
4223
+ n: 1
4224
+ }
4225
+ });
4226
+ await store.bufferSignal("order:1", {
4227
+ paid: true
4228
+ });
4229
+ await store.bufferSignal("child:b", {
4230
+ ok: false,
4231
+ error: "x"
4232
+ });
4233
+ await store.bufferSignal("child:a", {
4234
+ ok: true,
4235
+ value: {
4236
+ n: 2
4237
+ }
4238
+ });
4239
+ await store.bufferSignal("wake_x:1", null);
4240
+ await store.bufferSignal("wakeyx:1", null);
4241
+ const all = await list("child:", void 0, 10);
4242
+ expect3(all.map((r) => [
4243
+ r.token,
4244
+ r.payload
4245
+ ])).toEqual([
4246
+ [
4247
+ "child:a",
4248
+ {
4249
+ ok: true,
4250
+ value: {
4251
+ n: 1
4252
+ }
4253
+ }
4254
+ ],
4255
+ [
4256
+ "child:b",
4257
+ {
4258
+ ok: false,
4259
+ error: "x"
4260
+ }
4261
+ ],
4262
+ [
4263
+ "child:a",
4264
+ {
4265
+ ok: true,
4266
+ value: {
4267
+ n: 2
4268
+ }
4269
+ }
4270
+ ]
4271
+ ]);
4272
+ expect3(all.map((r) => typeof r.id)).toEqual([
4273
+ "string",
4274
+ "string",
4275
+ "string"
4276
+ ]);
4277
+ const first = await list("child:", void 0, 2);
4278
+ expect3(first.map((r) => r.id)).toEqual(all.slice(0, 2).map((r) => r.id));
4279
+ const rest = await list("child:", first.at(-1)?.id, 2);
4280
+ expect3(rest.map((r) => r.id)).toEqual([
4281
+ all[2]?.id
4282
+ ]);
4283
+ expect3(await list("child:", all[2]?.id, 2)).toEqual([]);
4284
+ expect3((await list("wake_x:", void 0, 10)).map((r) => r.token)).toEqual([
4285
+ "wake_x:1"
4286
+ ]);
4287
+ });
4288
+ t("deletes buffered signals by id and leaves the rest in FIFO order", async () => {
4289
+ expect3(store.deleteBufferedSignals).toBeTypeOf("function");
4290
+ await store.bufferSignal("child:a", {
4291
+ n: 1
4292
+ });
4293
+ await store.bufferSignal("child:a", {
4294
+ n: 2
4295
+ });
4296
+ await store.bufferSignal("child:a", {
4297
+ n: 3
4298
+ });
4299
+ await store.bufferSignal("child:b", {
4300
+ n: 4
4301
+ });
4302
+ const rows = await store.listBufferedSignals?.("child:", void 0, 10) ?? [];
4303
+ await store.deleteBufferedSignals?.([
4304
+ rows[1]?.id,
4305
+ rows[3]?.id,
4306
+ "999999999"
4307
+ ]);
4308
+ await store.deleteBufferedSignals?.([]);
4309
+ expect3(await store.takeBufferedSignal("child:a")).toEqual({
4310
+ payload: {
4311
+ n: 1
4312
+ }
4313
+ });
4314
+ expect3(await store.takeBufferedSignal("child:a")).toEqual({
4315
+ payload: {
4316
+ n: 3
4317
+ }
4318
+ });
4319
+ expect3(await store.takeBufferedSignal("child:a")).toBeNull();
4320
+ expect3(await store.takeBufferedSignal("child:b")).toBeNull();
4321
+ });
3966
4322
  t("buffers signals and takes them FIFO per token", async () => {
3967
4323
  await store.bufferSignal("sig", {
3968
4324
  n: 1
@@ -4526,6 +4882,26 @@ var MID_TURN = [
4526
4882
  signal: true
4527
4883
  }
4528
4884
  ];
4885
+ var HOLDER_DIES = [
4886
+ {
4887
+ when: "after deciding to run the turn a kept wake asks for, before running it",
4888
+ // The lease of that turn, or its dispatch on the run queue.
4889
+ storeTrigger: [
4890
+ "tryLockRun"
4891
+ ],
4892
+ transportTrigger: [
4893
+ "dispatchRuns"
4894
+ ]
4895
+ },
4896
+ {
4897
+ when: "right after writing its suspension, before looking at the kept wake",
4898
+ // Releasing the lease, which comes before the look.
4899
+ storeTrigger: [
4900
+ "releaseRunLock"
4901
+ ],
4902
+ transportTrigger: []
4903
+ }
4904
+ ];
4529
4905
  async function shutdown(all, transports) {
4530
4906
  await Promise.allSettled(all.map(({ engine }) => engine.drain(2e3)));
4531
4907
  await Promise.allSettled(transports.map((t) => t.close?.()));
@@ -5092,6 +5468,59 @@ function runRunDispatchContract(name, makeHarness, options = {}) {
5092
5468
  await Promise.allSettled(pair.map((t) => t.close?.()));
5093
5469
  }
5094
5470
  }, timeoutMs + 1e4);
5471
+ for (const { fan, settle: settle2 } of FANS) {
5472
+ it3(`a ${fan} joined after some of its children finished settles them at once (reconcile off)`, async (ctx) => {
5473
+ const pair = await pairOrSkip(() => ctx.skip());
5474
+ if (!pair) return;
5475
+ const store = new InMemoryStateStore4();
5476
+ const all = instances(store, pair);
5477
+ for (const { engine } of all) {
5478
+ engine.register("line", "1", async (_ctx, input) => input.i * 10);
5479
+ engine.register("parent", "1", async (c) => {
5480
+ const inputs = [
5481
+ 0,
5482
+ 1,
5483
+ 2,
5484
+ 3
5485
+ ].map((i) => ({
5486
+ i
5487
+ }));
5488
+ return settle2 ? c.allSettled("line", inputs) : c.all("line", inputs);
5489
+ });
5490
+ }
5491
+ try {
5492
+ for (const { engine } of all) engine.consumeRuns();
5493
+ const [first] = all;
5494
+ for (const i of [
5495
+ 1,
5496
+ 3
5497
+ ]) await first.engine.start("line", {
5498
+ i
5499
+ }, `p.all.0.${i}`);
5500
+ await until(async () => {
5501
+ const runs = await Promise.all([
5502
+ 1,
5503
+ 3
5504
+ ].map((i) => store.getRun(`p.all.0.${i}`)));
5505
+ return runs.every((r) => r?.status === "completed");
5506
+ }, timeoutMs);
5507
+ await first.engine.start("parent", {}, "p");
5508
+ await until(async () => (await store.getRun("p"))?.status === "completed", timeoutMs);
5509
+ const values = [
5510
+ 0,
5511
+ 10,
5512
+ 20,
5513
+ 30
5514
+ ];
5515
+ expect4((await store.getRun("p"))?.output).toEqual(settle2 ? values.map((value) => ({
5516
+ status: "fulfilled",
5517
+ value
5518
+ })) : values);
5519
+ } finally {
5520
+ await shutdown(all, pair);
5521
+ }
5522
+ }, timeoutMs + 1e4);
5523
+ }
5095
5524
  it3("drain waits for a run taken off the queue, and the draining instance takes no more", async (ctx) => {
5096
5525
  const pair = await pairOrSkip(() => ctx.skip());
5097
5526
  if (!pair) return;
@@ -5198,13 +5627,287 @@ function runRunDispatchContract(name, makeHarness, options = {}) {
5198
5627
  }
5199
5628
  }, timeoutMs + 2e4);
5200
5629
  }
5630
+ for (const { when, storeTrigger, transportTrigger } of HOLDER_DIES) {
5631
+ it3(`a wake kept for a turn survives the instance holding the run going down ${when}`, async (ctx) => {
5632
+ const pair = await pairOrSkip(() => ctx.skip());
5633
+ if (!pair) return;
5634
+ const inner = new InMemoryStateStore4();
5635
+ let now = Date.now();
5636
+ const clock = /* @__PURE__ */ __name(() => now, "clock");
5637
+ let armed = false;
5638
+ let dead = false;
5639
+ const hang = /* @__PURE__ */ __name(() => new Promise(() => {
5640
+ }), "hang");
5641
+ const cutOff = /* @__PURE__ */ __name((target, trigger) => new Proxy(target, {
5642
+ get(t, prop, receiver) {
5643
+ const value = Reflect.get(t, prop, receiver);
5644
+ if (typeof value !== "function") return value;
5645
+ return (...args) => {
5646
+ if (armed && trigger.includes(String(prop))) dead = true;
5647
+ return dead ? hang() : value.apply(t, args);
5648
+ };
5649
+ }
5650
+ }), "cutOff");
5651
+ const holderStore = cutOff(inner, storeTrigger);
5652
+ const holderTransport = cutOff(pair[0], transportTrigger);
5653
+ let requesterDead = false;
5654
+ const requesterStore = new Proxy(inner, {
5655
+ get(t, prop, receiver) {
5656
+ const value = Reflect.get(t, prop, receiver);
5657
+ if (typeof value !== "function") return value;
5658
+ return (...args) => requesterDead ? hang() : value.apply(t, args);
5659
+ }
5660
+ });
5661
+ let turns = 0;
5662
+ let openTurn;
5663
+ const held = new Promise((resolve) => {
5664
+ openTurn = resolve;
5665
+ });
5666
+ const make = /* @__PURE__ */ __name((store, transport) => {
5667
+ const engine = new WorkflowEngine5({
5668
+ store,
5669
+ transport,
5670
+ clock,
5671
+ reconcileMs: 3e5
5672
+ });
5673
+ engine.register("kept", "1", async (wctx) => {
5674
+ turns += 1;
5675
+ if (turns === 2) await held;
5676
+ await wctx.waitForSignal("go");
5677
+ });
5678
+ return engine;
5679
+ }, "make");
5680
+ const holder = make(holderStore, holderTransport);
5681
+ const requester = make(requesterStore, pair[1]);
5682
+ let survivor;
5683
+ try {
5684
+ holder.consumeRuns();
5685
+ await holder.start("kept", {}, "p");
5686
+ await until(async () => (await inner.getRun("p"))?.status === "suspended", timeoutMs);
5687
+ void holder.resume("p").catch(() => void 0);
5688
+ await until(() => turns === 2, timeoutMs);
5689
+ await requester.resume("p");
5690
+ await until(async () => {
5691
+ const run2 = await inner.getRun("p");
5692
+ return run2?.wakeAt !== void 0 && run2.wakeAt <= now + 31e3;
5693
+ }, timeoutMs);
5694
+ await pause(100);
5695
+ requesterDead = true;
5696
+ armed = true;
5697
+ openTurn();
5698
+ await until(() => dead, timeoutMs);
5699
+ expect4(turns).toBe(2);
5700
+ await Promise.race([
5701
+ pair[0].close?.(),
5702
+ pause(2e3)
5703
+ ]);
5704
+ await pause(1500);
5705
+ survivor = make(inner, pair[1]);
5706
+ survivor.consumeRuns();
5707
+ now += 31e3;
5708
+ await survivor.resumeDueTimers(now);
5709
+ await until(() => turns === 3, timeoutMs);
5710
+ expect4((await inner.getRun("p"))?.status).toBe("suspended");
5711
+ } finally {
5712
+ openTurn();
5713
+ requesterDead = true;
5714
+ await Promise.allSettled([
5715
+ survivor?.drain(2e3)
5716
+ ]);
5717
+ await Promise.race([
5718
+ Promise.allSettled(pair.map((t) => t.close?.())),
5719
+ pause(5e3)
5720
+ ]);
5721
+ }
5722
+ }, timeoutMs + 2e4);
5723
+ }
5201
5724
  });
5202
5725
  }
5203
5726
  __name(runRunDispatchContract, "runRunDispatchContract");
5727
+
5728
+ // src/step-fan-results-contract.ts
5729
+ import { DURABLE_STEP_NAME, InMemoryStateStore as InMemoryStateStore5, WorkflowEngine as WorkflowEngine6 } from "@dudousxd/nestjs-durable-core";
5730
+ import { describe as describe4, expect as expect5, it as it4 } from "vitest";
5731
+ var STEP_FAN_STEP = "fan-results-double";
5732
+ var doubleLine = /* @__PURE__ */ __name(() => {
5733
+ }, "doubleLine");
5734
+ doubleLine[DURABLE_STEP_NAME] = STEP_FAN_STEP;
5735
+ function counted(inner, counts) {
5736
+ return new Proxy(inner, {
5737
+ get(target, prop, receiver) {
5738
+ const value = Reflect.get(target, prop, receiver);
5739
+ if (typeof value !== "function") return value;
5740
+ return (...args) => {
5741
+ const name = String(prop);
5742
+ counts.calls.set(name, (counts.calls.get(name) ?? 0) + 1);
5743
+ if (name === "saveCheckpointsIfPending") counts.batches.push(args[0].length);
5744
+ if (name === "saveCheckpointIfPending") counts.batches.push(1);
5745
+ return new Promise((resolve) => setImmediate(resolve)).then(() => value.apply(target, args));
5746
+ };
5747
+ }
5748
+ });
5749
+ }
5750
+ __name(counted, "counted");
5751
+ function behind(transport, gate, dispatched) {
5752
+ return new Proxy(transport, {
5753
+ get(target, prop, receiver) {
5754
+ if (prop === "dispatch") {
5755
+ return (...args) => {
5756
+ dispatched.one += 1;
5757
+ return target.dispatch(...args);
5758
+ };
5759
+ }
5760
+ if (prop === "onResult") {
5761
+ return (handler) => target.onResult(async (result) => {
5762
+ await gate;
5763
+ return handler(result);
5764
+ });
5765
+ }
5766
+ const value = Reflect.get(target, prop, receiver);
5767
+ return typeof value === "function" ? value.bind(target) : value;
5768
+ }
5769
+ });
5770
+ }
5771
+ __name(behind, "behind");
5772
+ async function until2(check, timeoutMs) {
5773
+ const deadline = Date.now() + timeoutMs;
5774
+ while (Date.now() < deadline) {
5775
+ if (await check()) return;
5776
+ await new Promise((resolve) => setTimeout(resolve, 20));
5777
+ }
5778
+ throw new Error("condition not met");
5779
+ }
5780
+ __name(until2, "until");
5781
+ var FORMS = [
5782
+ {
5783
+ form: "ctx.all",
5784
+ settle: false,
5785
+ waves: 1
5786
+ },
5787
+ {
5788
+ form: "ctx.allSettled",
5789
+ settle: true,
5790
+ waves: 1
5791
+ },
5792
+ {
5793
+ form: "ctx.all with concurrency",
5794
+ settle: false,
5795
+ waves: 4
5796
+ },
5797
+ {
5798
+ form: "ctx.allSettled with concurrency",
5799
+ settle: true,
5800
+ waves: 4
5801
+ }
5802
+ ];
5803
+ function runStepFanResultsContract(name, makeHarness, options = {}) {
5804
+ const timeoutMs = options.timeoutMs ?? 6e4;
5805
+ const fanSize = options.fanSize ?? 2e3;
5806
+ const minBatch = options.minBatch ?? 8;
5807
+ const bulkDispatch = options.bulkDispatch ?? true;
5808
+ describe4(`Step fan results contract: ${name}`, () => {
5809
+ for (const { form, settle: settle2, waves } of FORMS) {
5810
+ const size = waves === 1 ? fanSize : Math.floor(fanSize / 2);
5811
+ const concurrency = waves === 1 ? void 0 : Math.ceil(size / waves);
5812
+ it4(`settles a ${form} fan of ${size} steps over two instances in batches`, async (ctx) => {
5813
+ const harness = await makeHarness();
5814
+ if (typeof harness === "string") {
5815
+ console.warn(`[step-fan-results contract] ${name} skipped: ${harness}`);
5816
+ ctx.skip();
5817
+ return;
5818
+ }
5819
+ const failing = settle2 ? /* @__PURE__ */ new Set([
5820
+ 1,
5821
+ size - 2
5822
+ ]) : /* @__PURE__ */ new Set();
5823
+ let ran = 0;
5824
+ let openBacklog;
5825
+ const backlog = new Promise((resolve) => {
5826
+ openBacklog = resolve;
5827
+ });
5828
+ const { engines: opened, close } = await harness.open(async (input) => {
5829
+ ran += 1;
5830
+ if (ran >= (concurrency ?? size)) openBacklog();
5831
+ const { i } = input;
5832
+ if (failing.has(i)) throw Object.assign(new Error(`bad ${i}`), {
5833
+ retryable: false
5834
+ });
5835
+ return i * 2;
5836
+ });
5837
+ const dispatched = {
5838
+ one: 0
5839
+ };
5840
+ const transports = opened.map((t) => behind(t, backlog, dispatched));
5841
+ if (bulkDispatch) {
5842
+ for (const t of opened) expect5(t.dispatchMany).toBeTypeOf("function");
5843
+ }
5844
+ const inner = new InMemoryStateStore5();
5845
+ const counts = {
5846
+ calls: /* @__PURE__ */ new Map(),
5847
+ batches: []
5848
+ };
5849
+ let turns = 0;
5850
+ const settled = /* @__PURE__ */ new Map();
5851
+ const engines = transports.map((transport) => {
5852
+ const engine = new WorkflowEngine6({
5853
+ store: counted(inner, counts),
5854
+ transport,
5855
+ reconcileMs: 0
5856
+ });
5857
+ engine.register("fan", "1", async (c) => {
5858
+ turns += 1;
5859
+ const inputs = Array.from({
5860
+ length: size
5861
+ }, (_, i) => ({
5862
+ i
5863
+ }));
5864
+ const opts = concurrency === void 0 ? {} : {
5865
+ concurrency
5866
+ };
5867
+ if (!settle2) return c.all(doubleLine, inputs, opts);
5868
+ const all = await c.allSettled(doubleLine, inputs, opts);
5869
+ return all.map((s) => s.status === "fulfilled" ? s.value : "failed");
5870
+ });
5871
+ engine.subscribe((e) => {
5872
+ if ((e.type === "step.completed" || e.type === "step.failed") && e.seq !== void 0) {
5873
+ settled.set(e.seq, (settled.get(e.seq) ?? 0) + 1);
5874
+ }
5875
+ });
5876
+ return engine;
5877
+ });
5878
+ try {
5879
+ await engines[0].start("fan", {}, "p");
5880
+ await until2(async () => {
5881
+ const status = (await inner.getRun("p"))?.status;
5882
+ return status === "completed" || status === "failed";
5883
+ }, timeoutMs - 5e3);
5884
+ const run2 = await inner.getRun("p");
5885
+ expect5(run2?.status).toBe("completed");
5886
+ expect5(run2?.output).toEqual(Array.from({
5887
+ length: size
5888
+ }, (_, i) => failing.has(i) ? "failed" : i * 2));
5889
+ expect5(settled.size).toBe(size);
5890
+ expect5([
5891
+ ...settled.values()
5892
+ ].every((n) => n === 1)).toBe(true);
5893
+ const barrierReads = counts.calls.get("countCheckpoints") ?? 0;
5894
+ expect5(Math.max(...counts.batches)).toBeGreaterThanOrEqual(minBatch);
5895
+ if (bulkDispatch) expect5(dispatched.one).toBe(0);
5896
+ if (waves === 1) expect5(barrierReads).toBeLessThanOrEqual(size / minBatch);
5897
+ expect5(turns).toBeLessThanOrEqual(1 + 2 * waves + failing.size);
5898
+ } finally {
5899
+ await close();
5900
+ }
5901
+ }, timeoutMs);
5902
+ }
5903
+ });
5904
+ }
5905
+ __name(runStepFanResultsContract, "runStepFanResultsContract");
5204
5906
  export {
5205
5907
  DURABLE_CANONICAL_COLUMNS,
5206
5908
  MutableClock,
5207
5909
  RUN_HISTORY_FIXTURE_VERSION,
5910
+ STEP_FAN_STEP,
5208
5911
  StateStoreUnavailableError,
5209
5912
  aggregationFixture,
5210
5913
  assertDurableColumns,
@@ -5225,6 +5928,7 @@ export {
5225
5928
  runAdmissionBackendContract,
5226
5929
  runRunDispatchContract,
5227
5930
  runStateStoreContract,
5931
+ runStepFanResultsContract,
5228
5932
  serializeRunHistory
5229
5933
  };
5230
5934
  //# sourceMappingURL=index.js.map