atomirx 0.0.2 → 0.0.5

package/src/core/selector.test.ts

@@ -1,12 +1,13 @@
 import { describe, it, expect } from "vitest";
 import { atom } from "./atom";
 import { select } from "./select";
+import { promisesEqual } from "./promiseCache";
 
 describe("select", () => {
-  describe("get()", () => {
+  describe("read()", () => {
     it("should read value from sync atom", () => {
       const count$ = atom(5);
-      const result = select(({ get }) => get(count$));
+      const result = select(({ read }) => read(count$));
 
       expect(result.value).toBe(5);
       expect(result.error).toBe(undefined);
@@ -17,7 +18,7 @@ describe("select", () => {
       const a$ = atom(1);
       const b$ = atom(2);
 
-      const result = select(({ get }) => get(a$) + get(b$));
+      const result = select(({ read }) => read(a$) + read(b$));
 
       expect(result.dependencies.size).toBe(2);
       expect(result.dependencies.has(a$)).toBe(true);
@@ -28,8 +29,8 @@ describe("select", () => {
       const count$ = atom(5);
       const error = new Error("Test error");
 
-      const result = select(({ get }) => {
-        get(count$);
+      const result = select(({ read }) => {
+        read(count$);
         throw error;
       });
 
@@ -45,7 +46,7 @@ describe("select", () => {
       const b$ = atom(2);
       const c$ = atom(3);
 
-      const result = select(({ all }) => all(a$, b$, c$));
+      const result = select(({ all }) => all([a$, b$, c$]));
 
       expect(result.value).toEqual([1, 2, 3]);
     });
@@ -54,7 +55,7 @@ describe("select", () => {
       const a$ = atom(1);
       const b$ = atom(new Promise<number>(() => {}));
 
-      const result = select(({ all }) => all(a$, b$));
+      const result = select(({ all }) => all([a$, b$]));
 
       expect(result.promise).toBeDefined();
       expect(result.value).toBe(undefined);
@@ -63,32 +64,37 @@ describe("select", () => {
     it("should throw error if any atom has rejected promise", async () => {
       const error = new Error("Test error");
       const a$ = atom(1);
-      const rejectedPromise = Promise.reject(error);
+      // Create rejected promise with immediate catch to prevent unhandled rejection warning
+      let rejectFn: (e: Error) => void;
+      const rejectedPromise = new Promise<number>((_, reject) => {
+        rejectFn = reject;
+      });
       rejectedPromise.catch(() => {}); // Prevent unhandled rejection
+      rejectFn!(error);
       const b$ = atom(rejectedPromise);
 
       // First call to select tracks the promise but returns pending
-      select(({ all }) => all(a$, b$));
+      select(({ all }) => all([a$, b$]));
 
       // Wait for promise handlers to run
       await Promise.resolve();
       await Promise.resolve();
 
       // Now the promise state should be updated
-      const result = select(({ all }) => all(a$, b$));
+      const result = select(({ all }) => all([a$, b$]));
 
       expect(result.error).toBe(error);
     });
   });
 
   describe("race()", () => {
-    it("should return first fulfilled value", () => {
+    it("should return first fulfilled value with key", () => {
       const a$ = atom(1);
       const b$ = atom(2);
 
-      const result = select(({ race }) => race(a$, b$));
+      const result = select(({ race }) => race({ a: a$, b: b$ }));
 
-      expect(result.value).toBe(1);
+      expect(result.value).toEqual({ key: "a", value: 1 });
     });
 
     it("should throw first error if first atom is rejected", async () => {
@@ -99,11 +105,11 @@ describe("select", () => {
       const b$ = atom(2);
 
       // Track the promise first
-      select(({ race }) => race(a$, b$));
+      select(({ race }) => race({ a: a$, b: b$ }));
       await Promise.resolve();
       await Promise.resolve();
 
-      const result = select(({ race }) => race(a$, b$));
+      const result = select(({ race }) => race({ a: a$, b: b$ }));
 
       expect(result.error).toBe(error);
     });
@@ -112,23 +118,23 @@ describe("select", () => {
       const a$ = atom(new Promise<number>(() => {}));
       const b$ = atom(new Promise<number>(() => {}));
 
-      const result = select(({ race }) => race(a$, b$));
+      const result = select(({ race }) => race({ a: a$, b: b$ }));
 
       expect(result.promise).toBeDefined();
     });
   });
 
   describe("any()", () => {
-    it("should return first fulfilled value", () => {
+    it("should return first fulfilled value with key", () => {
       const a$ = atom(1);
       const b$ = atom(2);
 
-      const result = select(({ any }) => any(a$, b$));
+      const result = select(({ any }) => any({ a: a$, b: b$ }));
 
-      expect(result.value).toBe(1);
+      expect(result.value).toEqual({ key: "a", value: 1 });
     });
 
-    it("should skip rejected and return next fulfilled", async () => {
+    it("should skip rejected and return next fulfilled with key", async () => {
       const error = new Error("Test error");
       const rejectedPromise = Promise.reject(error);
       rejectedPromise.catch(() => {});
@@ -136,32 +142,41 @@ describe("select", () => {
       const b$ = atom(2);
 
       // Track first, then wait for microtasks
-      select(({ any }) => any(a$, b$));
+      select(({ any }) => any({ a: a$, b: b$ }));
       await Promise.resolve();
       await Promise.resolve();
 
-      const result = select(({ any }) => any(a$, b$));
+      const result = select(({ any }) => any({ a: a$, b: b$ }));
 
-      expect(result.value).toBe(2);
+      expect(result.value).toEqual({ key: "b", value: 2 });
     });
 
     it("should throw AggregateError if all rejected", async () => {
       const error1 = new Error("Error 1");
       const error2 = new Error("Error 2");
-      const p1 = Promise.reject(error1);
-      const p2 = Promise.reject(error2);
+      // Create rejected promises with immediate catch to prevent unhandled rejection warning
+      let reject1: (e: Error) => void;
+      let reject2: (e: Error) => void;
+      const p1 = new Promise<number>((_, reject) => {
+        reject1 = reject;
+      });
+      const p2 = new Promise<number>((_, reject) => {
+        reject2 = reject;
+      });
       p1.catch(() => {});
       p2.catch(() => {});
+      reject1!(error1);
+      reject2!(error2);
 
       const a$ = atom(p1);
       const b$ = atom(p2);
 
       // Track first, then wait for microtasks
-      select(({ any }) => any(a$, b$));
+      select(({ any }) => any({ a: a$, b: b$ }));
       await Promise.resolve();
       await Promise.resolve();
 
-      const result = select(({ any }) => any(a$, b$));
+      const result = select(({ any }) => any({ a: a$, b: b$ }));
 
       expect(result.error).toBeDefined();
       expect((result.error as Error).name).toBe("AggregateError");
@@ -172,16 +187,21 @@ describe("select", () => {
     it("should return array of settled results", async () => {
       const a$ = atom(1);
       const error = new Error("Test error");
-      const rejectedPromise = Promise.reject(error);
+      // Create rejected promise with immediate catch to prevent unhandled rejection warning
+      let rejectFn: (e: Error) => void;
+      const rejectedPromise = new Promise<number>((_, reject) => {
+        rejectFn = reject;
+      });
       rejectedPromise.catch(() => {});
+      rejectFn!(error);
       const b$ = atom(rejectedPromise);
 
       // Track first, wait for microtasks
-      select(({ settled }) => settled(a$, b$));
+      select(({ settled }) => settled([a$, b$]));
       await Promise.resolve();
       await Promise.resolve();
 
-      const result = select(({ settled }) => settled(a$, b$));
+      const result = select(({ settled }) => settled([a$, b$]));
 
       expect(result.value).toEqual([
         { status: "ready", value: 1 },
@@ -193,7 +213,7 @@ describe("select", () => {
       const a$ = atom(1);
       const b$ = atom(new Promise<number>(() => {}));
 
-      const result = select(({ settled }) => settled(a$, b$));
+      const result = select(({ settled }) => settled([a$, b$]));
 
       expect(result.promise).toBeDefined();
     });
@@ -205,7 +225,9 @@ describe("select", () => {
       const a$ = atom(1);
       const b$ = atom(2);
 
-      const result = select(({ get }) => (get(condition$) ? get(a$) : get(b$)));
+      const result = select(({ read }) =>
+        read(condition$) ? read(a$) : read(b$)
+      );
 
       expect(result.dependencies.size).toBe(2);
       expect(result.dependencies.has(condition$)).toBe(true);
@@ -254,4 +276,524 @@ describe("select", () => {
       expect(result.promise).toBe(undefined);
     });
   });
+
+  describe("safe()", () => {
+    it("should return [undefined, result] on success", () => {
+      const count$ = atom(5);
+
+      const result = select(({ read, safe }) => {
+        const [err, value] = safe(() => read(count$) * 2);
+        return { err, value };
+      });
+
+      expect(result.value).toEqual({ err: undefined, value: 10 });
+    });
+
+    it("should return [error, undefined] on sync error", () => {
+      const result = select(({ safe }) => {
+        const [err, value] = safe(() => {
+          throw new Error("Test error");
+        });
+        return { err, value };
+      });
+
+      expect(result.value?.err).toBeInstanceOf(Error);
+      expect((result.value?.err as Error).message).toBe("Test error");
+      expect(result.value?.value).toBe(undefined);
+    });
+
+    it("should re-throw Promise to preserve Suspense", () => {
+      const pending$ = atom(new Promise(() => {})); // Never resolves
+
+      const result = select(({ read, safe }) => {
+        const [err, value] = safe(() => read(pending$));
+        return { err, value };
+      });
+
+      // Promise should be thrown, not caught
+      expect(result.promise).toBeDefined();
+      expect(result.value).toBe(undefined);
+    });
+
+    it("should catch JSON.parse errors", () => {
+      const raw$ = atom("invalid json");
+
+      const result = select(({ read, safe }) => {
+        const [err, data] = safe(() => {
+          const raw = read(raw$);
+          return JSON.parse(raw);
+        });
+
+        if (err) {
+          return { error: "Parse failed" };
+        }
+        return { data };
+      });
+
+      expect(result.value).toEqual({ error: "Parse failed" });
+    });
+
+    it("should allow graceful degradation", () => {
+      const user$ = atom({ name: "John" });
+
+      const result = select(({ read, safe }) => {
+        const [err1, user] = safe(() => read(user$));
+        if (err1) return { user: null, posts: [] };
+
+        const [err2] = safe(() => {
+          throw new Error("Posts failed");
+        });
+        if (err2) return { user, posts: [] }; // Graceful degradation
+
+        return { user, posts: ["post1"] };
+      });
+
+      expect(result.value).toEqual({
+        user: { name: "John" },
+        posts: [], // Gracefully degraded
+      });
+    });
+
+    it("should preserve error type information", () => {
+      class CustomError extends Error {
+        code = "CUSTOM";
+      }
+
+      const result = select(({ safe }) => {
+        const [err] = safe(() => {
+          throw new CustomError("Custom error");
+        });
+
+        if (err instanceof CustomError) {
+          return { code: err.code };
+        }
+        return { code: "UNKNOWN" };
+      });
+
+      expect(result.value).toEqual({ code: "CUSTOM" });
+    });
+  });
+
+  describe("async context detection", () => {
+    it("should throw error when read() is called outside selection context", async () => {
+      const count$ = atom(5);
+      let capturedRead: ((atom: typeof count$) => number) | null = null;
+
+      select(({ read }) => {
+        capturedRead = read;
+        return read(count$);
+      });
+
+      // Calling read() after select() has finished should throw
+      expect(() => capturedRead!(count$)).toThrow(
+        "read() was called outside of the selection context"
+      );
+    });
+
+    it("should throw error when all() is called outside selection context", async () => {
+      const a$ = atom(1);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedAll: any = null;
+
+      select(({ all }) => {
+        capturedAll = all;
+        return all([a$]);
+      });
+
+      expect(() => capturedAll([a$])).toThrow(
+        "all() was called outside of the selection context"
+      );
+    });
+
+    it("should throw error when race() is called outside selection context", async () => {
+      const a$ = atom(1);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedRace: any = null;
+
+      select(({ race }) => {
+        capturedRace = race;
+        return race({ a: a$ });
+      });
+
+      expect(() => capturedRace({ a: a$ })).toThrow(
+        "race() was called outside of the selection context"
+      );
+    });
+
+    it("should throw error when any() is called outside selection context", async () => {
+      const a$ = atom(1);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedAny: any = null;
+
+      select(({ any }) => {
+        capturedAny = any;
+        return any({ a: a$ });
+      });
+
+      expect(() => capturedAny({ a: a$ })).toThrow(
+        "any() was called outside of the selection context"
+      );
+    });
+
+    it("should throw error when settled() is called outside selection context", async () => {
+      const a$ = atom(1);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedSettled: any = null;
+
+      select(({ settled }) => {
+        capturedSettled = settled;
+        return settled([a$]);
+      });
+
+      expect(() => capturedSettled([a$])).toThrow(
+        "settled() was called outside of the selection context"
+      );
+    });
+
+    it("should throw error when safe() is called outside selection context", async () => {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedSafe: any = null;
+
+      select(({ safe }) => {
+        capturedSafe = safe;
+        return safe(() => 42);
+      });
+
+      expect(() => capturedSafe(() => 42)).toThrow(
+        "safe() was called outside of the selection context"
+      );
+    });
+  });
+
+  describe("state()", () => {
+    it("should return ready state for sync atom", () => {
+      const count$ = atom(5);
+
+      const result = select(({ state }) => state(count$));
+
+      expect(result.value).toEqual({ status: "ready", value: 5 });
+    });
+
+    it("should return loading state for pending promise atom", () => {
+      const promise = new Promise<number>(() => {});
+      const async$ = atom(promise);
+
+      const result = select(({ state }) => state(async$));
+
+      expect(result.value).toEqual({
+        status: "loading",
+        value: undefined,
+        error: undefined,
+      });
+    });
+
+    it("should return error state for rejected promise atom", async () => {
+      const error = new Error("Test error");
+      const rejectedPromise = Promise.reject(error);
+      rejectedPromise.catch(() => {});
+      const async$ = atom(rejectedPromise);
+
+      // Track first
+      select(({ state }) => state(async$));
+      await Promise.resolve();
+      await Promise.resolve();
+
+      const result = select(({ state }) => state(async$));
+
+      expect(result.value).toEqual({ status: "error", error });
+    });
+
+    it("should track dependencies when using state(atom)", () => {
+      const a$ = atom(1);
+      const b$ = atom(2);
+
+      const result = select(({ state }) => {
+        state(a$);
+        state(b$);
+        return "done";
+      });
+
+      expect(result.dependencies.size).toBe(2);
+      expect(result.dependencies.has(a$)).toBe(true);
+      expect(result.dependencies.has(b$)).toBe(true);
+    });
+
+    it("should wrap selector function with try/catch and return ready state", () => {
+      const a$ = atom(10);
+      const b$ = atom(20);
+
+      const result = select(({ read, state }) =>
+        state(() => read(a$) + read(b$))
+      );
+
+      expect(result.value).toEqual({ status: "ready", value: 30 });
+    });
+
+    it("should wrap selector function and return loading state when promise thrown", () => {
+      const async$ = atom(new Promise<number>(() => {}));
+
+      const result = select(({ read, state }) => state(() => read(async$)));
+
+      expect(result.value).toEqual({
+        status: "loading",
+        value: undefined,
+        error: undefined,
+      });
+    });
+
+    it("should wrap selector function and return error state when error thrown", () => {
+      const result = select(({ state }) =>
+        state(() => {
+          throw new Error("Test error");
+        })
+      );
+
+      expect(result.value?.status).toBe("error");
+      expect(
+        (result.value as { status: "error"; error: unknown }).error
+      ).toBeInstanceOf(Error);
+    });
+
+    it("should work with all() inside state()", () => {
+      const a$ = atom(1);
+      const b$ = atom(2);
+
+      const result = select(({ all, state }) => state(() => all([a$, b$])));
+
+      expect(result.value).toEqual({
+        status: "ready",
+        value: [1, 2],
+        error: undefined,
+      });
+    });
+
+    it("should return loading state when all() has pending atoms", () => {
+      const a$ = atom(1);
+      const b$ = atom(new Promise<number>(() => {}));
+
+      const result = select(({ all, state }) => state(() => all([a$, b$])));
+
+      expect(result.value?.status).toBe("loading");
+    });
+
+    it("should allow building dashboard-style derived atoms", () => {
+      const user$ = atom({ name: "John" });
+      const posts$ = atom(new Promise<string[]>(() => {})); // Loading
+
+      const result = select(({ state }) => {
+        const userState = state(user$);
+        const postsState = state(posts$);
+
+        return {
+          user: userState.status === "ready" ? userState.value : null,
+          posts: postsState.status === "ready" ? postsState.value : [],
+          isLoading:
+            userState.status === "loading" || postsState.status === "loading",
+        };
+      });
+
+      expect(result.value).toEqual({
+        user: { name: "John" },
+        posts: [],
+        isLoading: true,
+      });
+    });
+
+    it("should throw error when called outside selection context", () => {
+      const a$ = atom(1);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let capturedState: any = null;
+
+      select(({ state }) => {
+        capturedState = state;
+        return state(a$);
+      });
+
+      expect(() => capturedState(a$)).toThrow(
+        "state() was called outside of the selection context"
+      );
+    });
+  });
+
+  describe("parallel waiting behavior", () => {
+    it("all() should throw combined Promise.all for parallel waiting", async () => {
+      let resolve1: (value: number) => void;
+      let resolve2: (value: number) => void;
+      const p1 = new Promise<number>((r) => {
+        resolve1 = r;
+      });
+      const p2 = new Promise<number>((r) => {
+        resolve2 = r;
+      });
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      // First call should throw a combined promise
+      const result1 = select(({ all }) => all([a$, b$]));
+      expect(result1.promise).toBeDefined();
+
+      // Resolve promises in reverse order
+      resolve2!(20);
+      await Promise.resolve();
+
+      // Still loading (a$ not resolved yet)
+      const result2 = select(({ all }) => all([a$, b$]));
+      expect(result2.promise).toBeDefined();
+
+      // Resolve first promise
+      resolve1!(10);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      // Now should be ready with both values
+      const result3 = select(({ all }) => all([a$, b$]));
+      expect(result3.value).toEqual([10, 20]);
+    });
+
+    it("all() should return equivalent promises when atoms unchanged", async () => {
+      const p1 = new Promise<number>(() => {});
+      const p2 = new Promise<number>(() => {});
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      // Get promise from first call
+      const result1 = select(({ all }) => all([a$, b$]));
+      const promise1 = result1.promise;
+
+      // Second call should return equivalent promise (same source promises)
+      const result2 = select(({ all }) => all([a$, b$]));
+      const promise2 = result2.promise;
+
+      // Promises are equivalent via metadata comparison
+      expect(promisesEqual(promise1, promise2)).toBe(true);
+    });
+
+    it("race() should throw combined Promise.race for parallel racing", async () => {
+      let resolve1: (value: number) => void;
+      let resolve2: (value: number) => void;
+      const p1 = new Promise<number>((r) => {
+        resolve1 = r;
+      });
+      const p2 = new Promise<number>((r) => {
+        resolve2 = r;
+      });
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      // First call should throw a combined promise
+      const result1 = select(({ race }) => race({ a: a$, b: b$ }));
+      expect(result1.promise).toBeDefined();
+
+      // Resolve second promise first (it should win the race)
+      resolve2!(20);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      // Race should return second value (first to resolve) with key
+      const result2 = select(({ race }) => race({ a: a$, b: b$ }));
+      expect(result2.value).toEqual({ key: "b", value: 20 });
+
+      // Clean up: resolve first promise
+      resolve1!(10);
+    });
+
+    it("race() should return equivalent promises when atoms unchanged", async () => {
+      const p1 = new Promise<number>(() => {});
+      const p2 = new Promise<number>(() => {});
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      const result1 = select(({ race }) => race({ a: a$, b: b$ }));
+      const promise1 = result1.promise;
+
+      const result2 = select(({ race }) => race({ a: a$, b: b$ }));
+      const promise2 = result2.promise;
+
+      // Promises are equivalent via metadata comparison
+      expect(promisesEqual(promise1, promise2)).toBe(true);
+    });
+
+    it("any() should race all loading promises in parallel", async () => {
+      let resolve1: (value: number) => void;
+      let resolve2: (value: number) => void;
+      const p1 = new Promise<number>((r) => {
+        resolve1 = r;
+      });
+      const p2 = new Promise<number>((r) => {
+        resolve2 = r;
+      });
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      // First call should throw combined race promise
+      const result1 = select(({ any }) => any({ a: a$, b: b$ }));
+      expect(result1.promise).toBeDefined();
+
+      // Resolve second promise first
+      resolve2!(20);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      // any() should return second value (first to resolve) with key
+      const result2 = select(({ any }) => any({ a: a$, b: b$ }));
+      expect(result2.value).toEqual({ key: "b", value: 20 });
+
+      // Clean up
+      resolve1!(10);
+    });
+
+    it("settled() should wait for all in parallel", async () => {
+      let resolve1: (value: number) => void;
+      let reject2: (error: Error) => void;
+      const p1 = new Promise<number>((r) => {
+        resolve1 = r;
+      });
+      const p2 = new Promise<number>((_, reject) => {
+        reject2 = reject;
+      });
+      p2.catch(() => {}); // Prevent unhandled rejection
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      // First call should throw combined promise
+      const result1 = select(({ settled }) => settled([a$, b$]));
+      expect(result1.promise).toBeDefined();
+
+      // Settle promises in any order
+      reject2!(new Error("fail"));
+      await Promise.resolve();
+
+      // Still loading (a$ not settled yet)
+      const result2 = select(({ settled }) => settled([a$, b$]));
+      expect(result2.promise).toBeDefined();
+
+      // Settle first
+      resolve1!(10);
+      await Promise.resolve();
+      await Promise.resolve();
+
+      // Now should have settled results
+      const result3 = select(({ settled }) => settled([a$, b$]));
+      expect(result3.value).toEqual([
+        { status: "ready", value: 10 },
+        { status: "error", error: expect.any(Error) },
+      ]);
+    });
+
+    it("settled() should return equivalent promises when atoms unchanged", async () => {
+      const p1 = new Promise<number>(() => {});
+      const p2 = new Promise<number>(() => {});
+      const a$ = atom(p1);
+      const b$ = atom(p2);
+
+      const result1 = select(({ settled }) => settled([a$, b$]));
+      const promise1 = result1.promise;
+
+      const result2 = select(({ settled }) => settled([a$, b$]));
+      const promise2 = result2.promise;
+
+      // Promises are equivalent via metadata comparison
+      expect(promisesEqual(promise1, promise2)).toBe(true);
+    });
+  });
 });