@swan-io/lake 15.1.1 → 15.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swan-io/lake",
-  "version": "15.1.1",
+  "version": "15.1.2",
   "engines": {
     "node": ">22.12.0"
   },

package/src/utils/__tests__/polling.test.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/__tests__/polling.test.js

@@ -0,0 +1,49 @@
+import { Future, Result } from "@swan-io/boxed";
+import { describe, expect, it } from "vitest";
+import { pollUntilOk } from "../polling";
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+describe("pollUntilOk", () => {
+    it("resolves Ok and stops after the first successful attempt", async () => {
+        let attempts = 0;
+        const result = await pollUntilOk(() => {
+            attempts += 1;
+            return Future.value(Result.Ok("ok"));
+        }, { maxAttempts: 5, intervalMs: 1 }).toPromise();
+        expect(result.isOk()).toBe(true);
+        expect(result.match({ Ok: value => value, Error: () => "" })).toBe("ok");
+        expect(attempts).toBe(1);
+    });
+    it("retries while the attempt returns Error, then resolves Ok", async () => {
+        let attempts = 0;
+        const result = await pollUntilOk(() => {
+            attempts += 1;
+            return attempts < 3
+                ? Future.value(Result.Error("not ready"))
+                : Future.value(Result.Ok("ok"));
+        }, { maxAttempts: 5, intervalMs: 1 }).toPromise();
+        expect(result.isOk()).toBe(true);
+        expect(attempts).toBe(3);
+    });
+    it("gives up after maxAttempts and resolves with the last error", async () => {
+        let attempts = 0;
+        const result = await pollUntilOk(() => {
+            attempts += 1;
+            return Future.value(Result.Error(`error-${attempts}`));
+        }, { maxAttempts: 4, intervalMs: 1 }).toPromise();
+        expect(result.isError()).toBe(true);
+        expect(result.match({ Ok: () => "", Error: error => error })).toBe("error-4");
+        expect(attempts).toBe(4);
+    });
+    it("stops the loop when the returned future is cancelled", async () => {
+        let attempts = 0;
+        const future = pollUntilOk(() => {
+            attempts += 1;
+            return Future.value(Result.Error(undefined));
+        }, { maxAttempts: 5, intervalMs: 50 });
+        // Cancel during the first wait, before any attempt runs.
+        future.cancel();
+        // Wait well past when the first (and subsequent) attempts would have fired.
+        await sleep(120);
+        expect(attempts).toBe(0);
+    });
+});

package/src/utils/polling.d.ts

@@ -0,0 +1,12 @@
+import { Future, Result } from "@swan-io/boxed";
+type Options = {
+    maxAttempts: number;
+    /** Delay before each attempt, including the first. Defaults to 1000ms. */
+    intervalMs?: number;
+};
+/**
+ * Waits `intervalMs`, runs `attempt`, repeats while it returns `Error` (up to `maxAttempts`).
+ * Cancelling the returned future stops the loop — unlike `Future.retry`, which keeps polling.
+ */
+export declare const pollUntilOk: <Ok, Err>(attempt: () => Future<Result<Ok, Err>>, { maxAttempts, intervalMs }: Options) => Future<Result<Ok, Err>>;
+export {};

package/src/utils/polling.js

@@ -0,0 +1,20 @@
+import { Future, Result } from "@swan-io/boxed";
+/**
+ * Waits `intervalMs`, runs `attempt`, repeats while it returns `Error` (up to `maxAttempts`).
+ * Cancelling the returned future stops the loop — unlike `Future.retry`, which keeps polling.
+ */
+export const pollUntilOk = (attempt, { maxAttempts, intervalMs = 1000 }) => {
+    let isStopped = false;
+    let pendingWait;
+    const loop = (attemptsLeft) => {
+        const wait = Future.wait(intervalMs);
+        pendingWait = wait;
+        return wait.flatMap(() => attempt().flatMapError(error => attemptsLeft > 1 && !isStopped ? loop(attemptsLeft - 1) : Future.value(Result.Error(error))));
+    };
+    const future = loop(maxAttempts);
+    future.onCancel(() => {
+        isStopped = true;
+        pendingWait === null || pendingWait === void 0 ? void 0 : pendingWait.cancel();
+    });
+    return future;
+};