atomirx 0.0.4 → 0.0.5

package/src/core/derived.test.ts

@@ -1033,4 +1033,183 @@ describe("derived", () => {
       });
     });
   });
+
+  describe("onError callback", () => {
+    it("should call onError when computation throws synchronously", async () => {
+      const onError = vi.fn();
+      const source$ = atom(0);
+
+      const derived$ = derived(
+        ({ read }) => {
+          const val = read(source$);
+          if (val > 0) {
+            throw new Error("Value too high");
+          }
+          return val;
+        },
+        { onError }
+      );
+
+      // Initial value - no error
+      await derived$.get();
+      expect(onError).not.toHaveBeenCalled();
+
+      // Trigger error - catch the rejection to avoid unhandled rejection warning
+      source$.set(5);
+      derived$.get().catch(() => {}); // Catch expected rejection
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(onError).toHaveBeenCalledTimes(1);
+      expect(onError).toHaveBeenCalledWith(expect.any(Error));
+      expect((onError.mock.calls[0][0] as Error).message).toBe("Value too high");
+    });
+
+    it("should call onError when async atom dependency rejects", async () => {
+      const onError = vi.fn();
+
+      // Create an atom with a rejecting Promise
+      const asyncSource$ = atom(Promise.reject(new Error("Async error")));
+
+      const derived$ = derived(
+        ({ read }) => {
+          return read(asyncSource$);
+        },
+        { onError }
+      );
+
+      // Access to trigger computation
+      derived$.get().catch(() => {}); // Catch to avoid unhandled rejection
+
+      await new Promise((r) => setTimeout(r, 20));
+
+      expect(onError).toHaveBeenCalledTimes(1);
+      expect((onError.mock.calls[0][0] as Error).message).toBe("Async error");
+    });
+
+    it("should call onError on each recomputation that throws", async () => {
+      const onError = vi.fn();
+      const source$ = atom(0);
+
+      const derived$ = derived(
+        ({ read }) => {
+          const val = read(source$);
+          if (val > 0) {
+            throw new Error(`Error for ${val}`);
+          }
+          return val;
+        },
+        { onError }
+      );
+
+      await derived$.get();
+      expect(onError).not.toHaveBeenCalled();
+
+      // First error - catch to avoid unhandled rejection
+      source$.set(1);
+      derived$.get().catch(() => {});
+      await new Promise((r) => setTimeout(r, 0));
+      expect(onError).toHaveBeenCalledTimes(1);
+
+      // Second error - catch to avoid unhandled rejection
+      source$.set(2);
+      derived$.get().catch(() => {});
+      await new Promise((r) => setTimeout(r, 0));
+      expect(onError).toHaveBeenCalledTimes(2);
+      expect((onError.mock.calls[1][0] as Error).message).toBe("Error for 2");
+    });
+
+    it("should not call onError when computation succeeds", async () => {
+      const onError = vi.fn();
+      const source$ = atom(5);
+
+      const derived$ = derived(({ read }) => read(source$) * 2, { onError });
+
+      await derived$.get();
+      source$.set(10);
+      await derived$.get();
+      source$.set(15);
+      await derived$.get();
+
+      expect(onError).not.toHaveBeenCalled();
+    });
+
+    it("should not call onError for Promise throws (Suspense)", async () => {
+      const onError = vi.fn();
+      let resolvePromise: (value: number) => void;
+      const asyncSource$ = atom(
+        new Promise<number>((resolve) => {
+          resolvePromise = resolve;
+        })
+      );
+
+      const derived$ = derived(({ read }) => read(asyncSource$) * 2, {
+        onError,
+      });
+
+      // Still loading - onError should NOT be called
+      await new Promise((r) => setTimeout(r, 10));
+      expect(onError).not.toHaveBeenCalled();
+
+      // Resolve successfully
+      resolvePromise!(5);
+      expect(await derived$.get()).toBe(10);
+      expect(onError).not.toHaveBeenCalled();
+    });
+
+    it("should work without onError callback", async () => {
+      const source$ = atom(0);
+
+      const derived$ = derived(({ read }) => {
+        const val = read(source$);
+        if (val > 0) {
+          throw new Error("Error");
+        }
+        return val;
+      });
+
+      // Should not throw even without onError
+      await derived$.get();
+      source$.set(5);
+      derived$.get().catch(() => {}); // Catch expected rejection
+      await new Promise((r) => setTimeout(r, 0));
+
+      expect(derived$.state().status).toBe("error");
+    });
+
+    it("should allow error recovery and call onError again on subsequent errors", async () => {
+      const onError = vi.fn();
+      const source$ = atom(0);
+
+      const derived$ = derived(
+        ({ read }) => {
+          const val = read(source$);
+          if (val === 1) {
+            throw new Error("First error");
+          }
+          if (val === 3) {
+            throw new Error("Second error");
+          }
+          return val * 2;
+        },
+        { onError }
+      );
+
+      await derived$.get(); // 0 -> success
+      expect(onError).not.toHaveBeenCalled();
+
+      source$.set(1); // error
+      derived$.get().catch(() => {}); // Catch expected rejection
+      await new Promise((r) => setTimeout(r, 0));
+      expect(onError).toHaveBeenCalledTimes(1);
+
+      source$.set(2); // recover
+      expect(await derived$.get()).toBe(4);
+      expect(onError).toHaveBeenCalledTimes(1); // still 1
+
+      source$.set(3); // error again
+      derived$.get().catch(() => {}); // Catch expected rejection
+      await new Promise((r) => setTimeout(r, 0));
+      expect(onError).toHaveBeenCalledTimes(2);
+    });
+  });
 });

package/src/core/derived.ts

@@ -1,6 +1,7 @@
-import { onCreateHook } from "./onCreateHook";
+import { CreateInfo, DerivedInfo, onCreateHook } from "./onCreateHook";
 import { emitter } from "./emitter";
 import { resolveEquality } from "./equality";
+import { onErrorHook } from "./onErrorHook";
 import { scheduleNotifyHook } from "./scheduleNotifyHook";
 import { ReactiveSelector, select, SelectContext } from "./select";
 import {
@@ -14,6 +15,19 @@ import {
 } from "./types";
 import { withReady, WithReadySelectContext } from "./withReady";
 
+/**
+ * Internal options for derived atoms.
+ * These are not part of the public API.
+ * @internal
+ */
+export interface DerivedInternalOptions {
+  /**
+   * Override the error source for onErrorHook.
+   * Used by effect() to attribute errors to the effect instead of the internal derived.
+   */
+  _errorSource?: CreateInfo;
+}
+
 /**
  * Context object passed to derived atom selector functions.
  * Provides utilities for reading atoms: `{ read, all, any, race, settled }`.
@@ -147,19 +161,19 @@ export interface DerivedContext extends SelectContext, WithReadySelectContext {}
 // Overload: Without fallback - staleValue is T | undefined
 export function derived<T>(
   fn: ReactiveSelector<T, DerivedContext>,
-  options?: DerivedOptions<T>
+  options?: DerivedOptions<T> & DerivedInternalOptions
 ): DerivedAtom<T, false>;
 
 // Overload: With fallback - staleValue is guaranteed T
 export function derived<T>(
   fn: ReactiveSelector<T, DerivedContext>,
-  options: DerivedOptions<T> & { fallback: T }
+  options: DerivedOptions<T> & { fallback: T } & DerivedInternalOptions
 ): DerivedAtom<T, true>;
 
 // Implementation
 export function derived<T>(
   fn: ReactiveSelector<T, DerivedContext>,
-  options: DerivedOptions<T> & { fallback?: T } = {}
+  options: DerivedOptions<T> & { fallback?: T } & DerivedInternalOptions = {}
 ): DerivedAtom<T, boolean> {
   const changeEmitter = emitter();
   const eq = resolveEquality(options.equals as Equality<unknown>);
@@ -183,6 +197,23 @@ export function derived<T>(
   // Track current subscriptions (atom -> unsubscribe function)
   const subscriptions = new Map<Atom<unknown>, VoidFunction>();
 
+  // CreateInfo for this derived - stored for onErrorHook
+  // Will be set after derivedAtom is created
+  let createInfo: DerivedInfo;
+
+  /**
+   * Handles errors by calling both the user's onError callback and the global onErrorHook.
+   */
+  const handleError = (error: unknown) => {
+    // Invoke user's error callback if provided
+    options.onError?.(error);
+
+    // Invoke global error hook
+    // Use _errorSource if provided (for effect), otherwise use this derived's createInfo
+    const source = options._errorSource ?? createInfo;
+    onErrorHook.current?.({ source, error });
+  };
+
   /**
    * Schedules notification to all subscribers.
    */
@@ -235,6 +266,11 @@ export function derived<T>(
         resolvePromise = resolve;
         rejectPromise = reject;
       });
+      // Prevent unhandled rejection warnings - errors are accessible via:
+      // 1. onError callback (if provided)
+      // 2. state() returning { status: "error", error }
+      // 3. .get().catch() by consumers
+      currentPromise.catch(() => {});
     }
 
     // Run select to compute value and track dependencies
@@ -267,6 +303,8 @@ export function derived<T>(
             // Clear resolve/reject so next computation creates new promise
             resolvePromise = null;
             rejectPromise = null;
+            // Invoke error handlers
+            handleError(error);
             // Always notify when promise rejects - subscribers need to know
             // state changed from loading to error
             notify();
@@ -280,6 +318,8 @@ export function derived<T>(
         // Clear resolve/reject so next computation creates new promise
         resolvePromise = null;
         rejectPromise = null;
+        // Invoke error handlers
+        handleError(result.error);
         if (!silent) notify();
       } else {
         // Success - update lastResolved and resolve
@@ -395,13 +435,16 @@ export function derived<T>(
     },
   };
 
-  // Notify devtools/plugins of derived atom creation
-  onCreateHook.current?.({
+  // Store createInfo for use in onErrorHook
+  createInfo = {
     type: "derived",
     key: options.meta?.key,
     meta: options.meta,
-    atom: derivedAtom,
-  });
+    instance: derivedAtom,
+  };
+
+  // Notify devtools/plugins of derived atom creation
+  onCreateHook.current?.(createInfo);
 
   return derivedAtom;
 }