@dudousxd/nestjs-durable-testing 0.23.1 → 0.23.3

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.d.ts CHANGED
@@ -262,6 +262,12 @@ interface StateStoreContext {
262
262
  * for a wide batch, not one per row.
263
263
  */
264
264
  statements?: () => number;
265
+ /**
266
+ * Every statement the store has sent to its database so far, each as its SQL text followed by its
267
+ * parameters (from the driver's query log). When given, the contract checks that settling a step
268
+ * sends none of the step's input.
269
+ */
270
+ statementLog?: () => string[];
265
271
  }
266
272
  /** Builds a fresh, empty store for one test. Called once per `it` (in `beforeEach`). */
267
273
  type StateStoreFactory = () => Promise<StateStoreContext>;
package/dist/index.js CHANGED
@@ -834,6 +834,15 @@ var checkpoint = /* @__PURE__ */ __name((over = {}) => ({
834
834
  finishedAt: at,
835
835
  ...over
836
836
  }), "checkpoint");
837
+ async function loggedSince(log, before) {
838
+ let seen = -1;
839
+ for (let i = 0; i < 50 && log().length !== seen; i += 1) {
840
+ seen = log().length;
841
+ await new Promise((resolve) => setTimeout(resolve, 10));
842
+ }
843
+ return log().slice(before);
844
+ }
845
+ __name(loggedSince, "loggedSince");
837
846
  function runStateStoreContract(name, makeStore) {
838
847
  describe2(`StateStore contract: ${name}`, () => {
839
848
  let store;
@@ -842,6 +851,7 @@ function runStateStoreContract(name, makeStore) {
842
851
  let supportsAsyncTransaction = true;
843
852
  let supportsTagFilter = true;
844
853
  let statements;
854
+ let statementLog;
845
855
  let skipReason;
846
856
  let loggedSkip = false;
847
857
  beforeEach(async () => {
@@ -853,6 +863,7 @@ function runStateStoreContract(name, makeStore) {
853
863
  supportsAsyncTransaction = ctx.supportsAsyncTransaction ?? true;
854
864
  supportsTagFilter = ctx.supportsTagFilter ?? true;
855
865
  statements = ctx.statements;
866
+ statementLog = ctx.statementLog;
856
867
  skipReason = void 0;
857
868
  } catch (err) {
858
869
  if (isUnavailable(err) && !process.env.DURABLE_TEST_REQUIRE_BACKENDS) {
@@ -1735,6 +1746,71 @@ function runStateStoreContract(name, makeStore) {
1735
1746
  ])).toBe(0);
1736
1747
  expect3(await store.countCheckpoints("r1", 0, 4, [])).toBe(0);
1737
1748
  });
1749
+ t("hasCheckpoints answers whether a seq range holds a status", async () => {
1750
+ expect3(store.hasCheckpoints).toBeDefined();
1751
+ if (!store.hasCheckpoints) return;
1752
+ await store.createRun(run());
1753
+ for (const [seq, status] of [
1754
+ [
1755
+ 0,
1756
+ "completed"
1757
+ ],
1758
+ [
1759
+ 1,
1760
+ "pending"
1761
+ ],
1762
+ [
1763
+ 2,
1764
+ "completed"
1765
+ ],
1766
+ [
1767
+ 3,
1768
+ "failed"
1769
+ ],
1770
+ [
1771
+ 4,
1772
+ "completed"
1773
+ ]
1774
+ ]) {
1775
+ await store.saveCheckpoint(checkpoint({
1776
+ seq,
1777
+ status,
1778
+ stepId: `r1:${seq}`
1779
+ }));
1780
+ }
1781
+ await store.createRun(run({
1782
+ id: "other"
1783
+ }));
1784
+ await store.saveCheckpoint(checkpoint({
1785
+ runId: "other",
1786
+ seq: 4,
1787
+ status: "pending",
1788
+ stepId: "other:4"
1789
+ }));
1790
+ expect3(await store.hasCheckpoints("r1", 0, 4, [
1791
+ "pending"
1792
+ ])).toBe(true);
1793
+ expect3(await store.hasCheckpoints("r1", 1, 1, [
1794
+ "pending"
1795
+ ])).toBe(true);
1796
+ expect3(await store.hasCheckpoints("r1", 2, 4, [
1797
+ "pending"
1798
+ ])).toBe(false);
1799
+ expect3(await store.hasCheckpoints("r1", 2, 4, [
1800
+ "pending",
1801
+ "failed"
1802
+ ])).toBe(true);
1803
+ expect3(await store.hasCheckpoints("r1", 4, 4, [
1804
+ "pending"
1805
+ ])).toBe(false);
1806
+ expect3(await store.hasCheckpoints("other", 0, 9, [
1807
+ "pending"
1808
+ ])).toBe(true);
1809
+ expect3(await store.hasCheckpoints("r1", 5, 9, [
1810
+ "completed"
1811
+ ])).toBe(false);
1812
+ expect3(await store.hasCheckpoints("r1", 0, 4, [])).toBe(false);
1813
+ });
1738
1814
  registerCheckpointAggregationCases(t, () => store, run);
1739
1815
  t("listOrphanedRuns returns incomplete runs with a free or expired lease, oldest first", async () => {
1740
1816
  expect3(store.listOrphanedRuns).toBeDefined();
@@ -2306,6 +2382,28 @@ function runStateStoreContract(name, makeStore) {
2306
2382
  expect3(await store.countCheckpoints?.("r1", 0, n - 1, [
2307
2383
  "completed"
2308
2384
  ])).toBe(n);
2385
+ if (!store.settleCheckpointsIfPending) return;
2386
+ await store.saveCheckpoints?.(rows.map((row) => ({
2387
+ ...row,
2388
+ seq: row.seq + n
2389
+ })));
2390
+ const settlements = rows.map((row) => ({
2391
+ runId: "r1",
2392
+ seq: row.seq + n,
2393
+ status: "completed",
2394
+ output: {
2395
+ seq: row.seq
2396
+ },
2397
+ startedAt: row.startedAt,
2398
+ finishedAt: row.finishedAt
2399
+ }));
2400
+ expect3(await sent(async () => {
2401
+ wrote = await store.settleCheckpointsIfPending?.(settlements) ?? [];
2402
+ })).toBeLessThanOrEqual(limit);
2403
+ expect3(wrote.every((w) => w)).toBe(true);
2404
+ expect3(await store.countCheckpoints?.("r1", n, 2 * n - 1, [
2405
+ "completed"
2406
+ ])).toBe(n);
2309
2407
  });
2310
2408
  t("saveCheckpointsIfPending writes a wide batch", async () => {
2311
2409
  if (!store.saveCheckpointsIfPending) return;
@@ -2336,6 +2434,457 @@ function runStateStoreContract(name, makeStore) {
2336
2434
  seq: n - 1
2337
2435
  });
2338
2436
  });
2437
+ t("settleCheckpointsIfPending writes only what a result changes, row by row", async () => {
2438
+ expect3(store.settleCheckpointsIfPending).toBeDefined();
2439
+ if (!store.settleCheckpointsIfPending) return;
2440
+ expect3(await store.settleCheckpointsIfPending([])).toEqual([]);
2441
+ await store.createRun(run());
2442
+ await store.createRun(run({
2443
+ id: "r2"
2444
+ }));
2445
+ const pending = /* @__PURE__ */ __name((runId, seq) => checkpoint({
2446
+ runId,
2447
+ seq,
2448
+ name: "ask",
2449
+ kind: "remote",
2450
+ stepId: `${runId}:${seq}`,
2451
+ status: "pending",
2452
+ input: {
2453
+ prompt: `p${seq}`
2454
+ },
2455
+ output: void 0,
2456
+ attempts: 2,
2457
+ workerGroup: "llm",
2458
+ parallelGroup: "all:0:2",
2459
+ wakeAt: 5e3
2460
+ }), "pending");
2461
+ for (const seq of [
2462
+ 0,
2463
+ 1,
2464
+ 2,
2465
+ 3
2466
+ ]) await store.saveCheckpoint(pending("r1", seq));
2467
+ await store.saveCheckpoint(pending("r2", 0));
2468
+ await store.saveCheckpoint({
2469
+ ...pending("r1", 1),
2470
+ status: "completed",
2471
+ output: {
2472
+ first: 1
2473
+ }
2474
+ });
2475
+ const later = new Date(at.getTime() + 6e4);
2476
+ const done = /* @__PURE__ */ __name((runId, seq, output) => ({
2477
+ runId,
2478
+ seq,
2479
+ status: "completed",
2480
+ output,
2481
+ startedAt: new Date(at.getTime() + 1e3),
2482
+ finishedAt: later
2483
+ }), "done");
2484
+ const wrote = await store.settleCheckpointsIfPending([
2485
+ done("r1", 0, {
2486
+ n: 0
2487
+ }),
2488
+ // Already settled: refused.
2489
+ done("r1", 1, {
2490
+ n: 1
2491
+ }),
2492
+ // A second settlement of the same row: the first one settled it, so refused.
2493
+ done("r1", 0, {
2494
+ n: "dup"
2495
+ }),
2496
+ {
2497
+ runId: "r1",
2498
+ seq: 2,
2499
+ status: "failed",
2500
+ error: {
2501
+ message: "boom"
2502
+ },
2503
+ events: [
2504
+ {
2505
+ at: 7,
2506
+ level: "error",
2507
+ message: "boom"
2508
+ }
2509
+ ],
2510
+ startedAt: at,
2511
+ finishedAt: later
2512
+ },
2513
+ // No such row: nothing is written.
2514
+ done("r1", 9, {
2515
+ n: 9
2516
+ }),
2517
+ // Another run's row, same seq as one above.
2518
+ done("r2", 0, {
2519
+ n: "r2"
2520
+ })
2521
+ ]);
2522
+ expect3(wrote).toEqual([
2523
+ true,
2524
+ false,
2525
+ false,
2526
+ true,
2527
+ false,
2528
+ true
2529
+ ]);
2530
+ const r1 = await store.listCheckpoints("r1");
2531
+ expect3(r1.map((c) => [
2532
+ c.seq,
2533
+ c.status,
2534
+ c.output
2535
+ ])).toEqual([
2536
+ [
2537
+ 0,
2538
+ "completed",
2539
+ {
2540
+ n: 0
2541
+ }
2542
+ ],
2543
+ [
2544
+ 1,
2545
+ "completed",
2546
+ {
2547
+ first: 1
2548
+ }
2549
+ ],
2550
+ [
2551
+ 2,
2552
+ "failed",
2553
+ void 0
2554
+ ],
2555
+ [
2556
+ 3,
2557
+ "pending",
2558
+ void 0
2559
+ ]
2560
+ ]);
2561
+ const [first, , failed] = r1;
2562
+ expect3(first?.input).toEqual({
2563
+ prompt: "p0"
2564
+ });
2565
+ expect3(first?.name).toBe("ask");
2566
+ expect3(first?.kind).toBe("remote");
2567
+ expect3(first?.stepId).toBe("r1:0");
2568
+ expect3(first?.attempts).toBe(2);
2569
+ expect3(first?.workerGroup).toBe("llm");
2570
+ expect3(first?.parallelGroup).toBe("all:0:2");
2571
+ expect3(first?.wakeAt).toBe(5e3);
2572
+ expect3(first?.enqueuedAt.getTime()).toBe(at.getTime());
2573
+ expect3(first?.startedAt.getTime()).toBe(at.getTime() + 1e3);
2574
+ expect3(first?.finishedAt.getTime()).toBe(later.getTime());
2575
+ expect3(first?.error).toBeUndefined();
2576
+ expect3(failed?.input).toEqual({
2577
+ prompt: "p2"
2578
+ });
2579
+ expect3(failed?.error).toEqual({
2580
+ message: "boom"
2581
+ });
2582
+ expect3(failed?.events).toEqual([
2583
+ {
2584
+ at: 7,
2585
+ level: "error",
2586
+ message: "boom"
2587
+ }
2588
+ ]);
2589
+ expect3(await store.getCheckpoint("r1", 9)).toBeNull();
2590
+ expect3((await store.getCheckpoint("r2", 0))?.output).toEqual({
2591
+ n: "r2"
2592
+ });
2593
+ expect3((await store.getCheckpoint("r2", 0))?.input).toEqual({
2594
+ prompt: "p0"
2595
+ });
2596
+ });
2597
+ t("settleCheckpointsIfPending sends none of the input of the steps it settles", async () => {
2598
+ if (!statementLog || !store.settleCheckpointsIfPending) return;
2599
+ await store.createRun(run());
2600
+ const prompt = `prompt-${"x".repeat(1e5)}`;
2601
+ for (const seq of [
2602
+ 0,
2603
+ 1
2604
+ ]) {
2605
+ await store.saveCheckpoint(checkpoint({
2606
+ seq,
2607
+ kind: "remote",
2608
+ stepId: `r1:${seq}`,
2609
+ status: "pending",
2610
+ input: {
2611
+ prompt
2612
+ },
2613
+ output: void 0
2614
+ }));
2615
+ }
2616
+ const before = statementLog().length;
2617
+ const settle2 = /* @__PURE__ */ __name((seqs) => store.settleCheckpointsIfPending?.(seqs.map((seq) => ({
2618
+ runId: "r1",
2619
+ seq,
2620
+ status: "completed",
2621
+ output: {
2622
+ answer: seq
2623
+ },
2624
+ startedAt: at,
2625
+ finishedAt: at
2626
+ }))), "settle");
2627
+ expect3(await settle2([
2628
+ 0
2629
+ ])).toEqual([
2630
+ true
2631
+ ]);
2632
+ expect3(await settle2([
2633
+ 1,
2634
+ 0
2635
+ ])).toEqual([
2636
+ true,
2637
+ false
2638
+ ]);
2639
+ const sent = await loggedSince(statementLog, before);
2640
+ expect3(sent.length).toBeGreaterThan(0);
2641
+ expect3(sent.some((statement) => statement.includes("xxxxxxxxxx"))).toBe(false);
2642
+ expect3(sent.join("").length).toBeLessThan(2e4);
2643
+ expect3((await store.getCheckpoint("r1", 1))?.input).toEqual({
2644
+ prompt
2645
+ });
2646
+ });
2647
+ t("getCheckpointsForSettle reads getCheckpoints rows without their input", async () => {
2648
+ expect3(store.getCheckpointsForSettle).toBeDefined();
2649
+ if (!store.getCheckpointsForSettle) return;
2650
+ expect3(await store.getCheckpointsForSettle("r1", [])).toEqual([]);
2651
+ await store.createRun(run());
2652
+ for (const seq of [
2653
+ 0,
2654
+ 1,
2655
+ 2
2656
+ ]) {
2657
+ await store.saveCheckpoint(checkpoint({
2658
+ seq,
2659
+ kind: "remote",
2660
+ stepId: `r1:${seq}`,
2661
+ status: seq === 0 ? "completed" : "pending",
2662
+ input: {
2663
+ prompt: `p${seq}`
2664
+ },
2665
+ output: seq === 0 ? {
2666
+ answer: 0
2667
+ } : void 0,
2668
+ events: [
2669
+ {
2670
+ at: seq,
2671
+ level: "info",
2672
+ message: `m${seq}`
2673
+ }
2674
+ ],
2675
+ workerGroup: "llm",
2676
+ parallelGroup: "all:0:3",
2677
+ wakeAt: 5e3 + seq
2678
+ }));
2679
+ }
2680
+ const full = await store.getCheckpoints?.("r1", [
2681
+ 2,
2682
+ 0,
2683
+ 9
2684
+ ]);
2685
+ const read = await store.getCheckpointsForSettle("r1", [
2686
+ 2,
2687
+ 0,
2688
+ 9
2689
+ ]);
2690
+ expect3(read.map((c) => c.seq)).toEqual([
2691
+ 0,
2692
+ 2
2693
+ ]);
2694
+ expect3(read.map((c) => c.input)).toEqual([
2695
+ void 0,
2696
+ void 0
2697
+ ]);
2698
+ const withoutInput = /* @__PURE__ */ __name(({ input: _input, ...rest }) => rest, "withoutInput");
2699
+ expect3(read.map(withoutInput)).toEqual((full ?? []).map(withoutInput));
2700
+ expect3((await store.getCheckpoint("r1", 2))?.input).toEqual({
2701
+ prompt: "p2"
2702
+ });
2703
+ });
2704
+ t("getCheckpointsForSettle reads no input column", async () => {
2705
+ if (!statementLog || !store.getCheckpointsForSettle) return;
2706
+ await store.createRun(run());
2707
+ for (const seq of [
2708
+ 0,
2709
+ 1
2710
+ ]) {
2711
+ await store.saveCheckpoint(checkpoint({
2712
+ seq,
2713
+ kind: "remote",
2714
+ stepId: `r1:${seq}`,
2715
+ status: "pending",
2716
+ input: {
2717
+ prompt: "x".repeat(1e5)
2718
+ },
2719
+ output: void 0
2720
+ }));
2721
+ }
2722
+ const before = statementLog().length;
2723
+ const read = await store.getCheckpointsForSettle("r1", [
2724
+ 0,
2725
+ 1
2726
+ ]);
2727
+ const sent = await loggedSince(statementLog, before);
2728
+ expect3(read).toHaveLength(2);
2729
+ expect3(sent.length).toBeGreaterThan(0);
2730
+ expect3(sent.filter((statement) => /\binput\b|\*\s+from/i.test(statement))).toEqual([]);
2731
+ });
2732
+ t("settleCheckpointsIfPending settles a wide batch", async () => {
2733
+ if (!store.settleCheckpointsIfPending) return;
2734
+ await store.createRun(run());
2735
+ const n = 600;
2736
+ const rows = Array.from({
2737
+ length: n
2738
+ }, (_, seq) => checkpoint({
2739
+ seq,
2740
+ stepId: `r1:${seq}`,
2741
+ status: "pending",
2742
+ input: {
2743
+ seq
2744
+ },
2745
+ output: void 0
2746
+ }));
2747
+ if (store.saveCheckpoints) await store.saveCheckpoints(rows);
2748
+ else for (const row of rows) await store.saveCheckpoint(row);
2749
+ const wrote = await store.settleCheckpointsIfPending(rows.map((row) => ({
2750
+ runId: row.runId,
2751
+ seq: row.seq,
2752
+ status: "completed",
2753
+ output: {
2754
+ seq: row.seq
2755
+ },
2756
+ startedAt: at,
2757
+ finishedAt: at
2758
+ })));
2759
+ expect3(wrote).toHaveLength(n);
2760
+ expect3(wrote.every((w) => w === true)).toBe(true);
2761
+ expect3(await store.countCheckpoints?.("r1", 0, n - 1, [
2762
+ "completed"
2763
+ ])).toBe(n);
2764
+ const last = await store.getCheckpoint("r1", n - 1);
2765
+ expect3(last?.output).toEqual({
2766
+ seq: n - 1
2767
+ });
2768
+ expect3(last?.input).toEqual({
2769
+ seq: n - 1
2770
+ });
2771
+ });
2772
+ t("listCheckpointsForReplay lists every checkpoint, a completed one without its input", async () => {
2773
+ expect3(store.listCheckpointsForReplay).toBeDefined();
2774
+ if (!store.listCheckpointsForReplay) return;
2775
+ await store.createRun(run());
2776
+ await store.createRun(run({
2777
+ id: "r2"
2778
+ }));
2779
+ const remote = /* @__PURE__ */ __name((seq, over) => checkpoint({
2780
+ seq,
2781
+ name: `ask-${seq}`,
2782
+ kind: "remote",
2783
+ stepId: `r1:${seq}`,
2784
+ input: {
2785
+ prompt: `p${seq}`
2786
+ },
2787
+ workerGroup: "llm",
2788
+ ...over
2789
+ }), "remote");
2790
+ await store.saveCheckpoint(remote(0, {
2791
+ output: {
2792
+ answer: 0
2793
+ }
2794
+ }));
2795
+ await store.saveCheckpoint(remote(1, {
2796
+ status: "pending",
2797
+ output: void 0,
2798
+ wakeAt: 9e3
2799
+ }));
2800
+ await store.saveCheckpoint(remote(2, {
2801
+ status: "failed",
2802
+ output: void 0,
2803
+ error: {
2804
+ message: "boom"
2805
+ }
2806
+ }));
2807
+ await store.saveCheckpoint(checkpoint({
2808
+ seq: 3,
2809
+ stepId: "r1:3",
2810
+ status: "running"
2811
+ }));
2812
+ await store.saveCheckpoint(remote(4, {
2813
+ output: {
2814
+ answer: 4
2815
+ },
2816
+ parallelGroup: "all:4:1"
2817
+ }));
2818
+ await store.saveCheckpoint(checkpoint({
2819
+ runId: "r2",
2820
+ stepId: "r2:0",
2821
+ input: {
2822
+ other: true
2823
+ }
2824
+ }));
2825
+ const full = await store.listCheckpoints("r1");
2826
+ const replay = await store.listCheckpointsForReplay("r1");
2827
+ expect3(replay.map((c) => c.seq)).toEqual([
2828
+ 0,
2829
+ 1,
2830
+ 2,
2831
+ 3,
2832
+ 4
2833
+ ]);
2834
+ expect3(replay.map((c) => c.input)).toEqual([
2835
+ void 0,
2836
+ {
2837
+ prompt: "p1"
2838
+ },
2839
+ {
2840
+ prompt: "p2"
2841
+ },
2842
+ void 0,
2843
+ void 0
2844
+ ]);
2845
+ const withoutInput = /* @__PURE__ */ __name(({ input: _input, ...rest }) => rest, "withoutInput");
2846
+ expect3(replay.map(withoutInput)).toEqual(full.map(withoutInput));
2847
+ expect3(full[0]?.input).toEqual({
2848
+ prompt: "p0"
2849
+ });
2850
+ expect3((await store.getCheckpoint("r1", 4))?.input).toEqual({
2851
+ prompt: "p4"
2852
+ });
2853
+ expect3(await store.listCheckpointsForReplay("missing")).toEqual([]);
2854
+ });
2855
+ t("listCheckpointsForReplay reads no input column for a run whose steps completed", async () => {
2856
+ if (!statementLog || !store.listCheckpointsForReplay) return;
2857
+ await store.createRun(run());
2858
+ for (const seq of [
2859
+ 0,
2860
+ 1
2861
+ ]) {
2862
+ await store.saveCheckpoint(checkpoint({
2863
+ seq,
2864
+ kind: "remote",
2865
+ stepId: `r1:${seq}`,
2866
+ input: {
2867
+ prompt: "x".repeat(1e5)
2868
+ },
2869
+ output: {
2870
+ answer: seq
2871
+ }
2872
+ }));
2873
+ }
2874
+ const before = statementLog().length;
2875
+ const replay = await store.listCheckpointsForReplay("r1");
2876
+ const sent = await loggedSince(statementLog, before);
2877
+ expect3(replay.map((c) => c.output)).toEqual([
2878
+ {
2879
+ answer: 0
2880
+ },
2881
+ {
2882
+ answer: 1
2883
+ }
2884
+ ]);
2885
+ expect3(sent.length).toBeGreaterThan(0);
2886
+ expect3(sent.filter((statement) => /\binput\b|\*\s+from/i.test(statement))).toEqual([]);
2887
+ });
2339
2888
  t("upserts checkpoints, reads them by (runId, seq), and lists them ordered by seq", async () => {
2340
2889
  await store.createRun(run());
2341
2890
  await store.saveCheckpoint(checkpoint());
@@ -5790,7 +6339,9 @@ function counted(inner, counts) {
5790
6339
  return (...args) => {
5791
6340
  const name = String(prop);
5792
6341
  counts.calls.set(name, (counts.calls.get(name) ?? 0) + 1);
5793
- if (name === "saveCheckpointsIfPending") counts.batches.push(args[0].length);
6342
+ if (name === "settleCheckpointsIfPending" || name === "saveCheckpointsIfPending") {
6343
+ counts.batches.push(args[0].length);
6344
+ }
5794
6345
  if (name === "saveCheckpointIfPending") counts.batches.push(1);
5795
6346
  return new Promise((resolve) => setImmediate(resolve)).then(() => value.apply(target, args));
5796
6347
  };