refactor: simplify error handing

.changeset/cyan-candies-return.md

@@ -0,0 +1,5 @@
+---
+"@reactive-dot/react": patch
+---
+
+Refactored error handling.

packages/react/src/hooks/use-chain-spec-data.ts

@@ -24,9 +24,11 @@ export function useChainSpecData(options?: ChainHookOptions) {
  */
 export const chainSpecDataAtom = atomFamilyWithErrorCatcher(
   (withErrorCatcher, config: Config, chainId: ChainId) =>
-    withErrorCatcher(atom)(async (get) => {
-      const client = await get(clientAtom(config, chainId));
+    withErrorCatcher(
+      atom(async (get) => {
+        const client = await get(clientAtom(config, chainId));
 
-      return client.getChainSpecData();
-    }),
+        return client.getChainSpecData();
+      }),
+    ),
 );

packages/react/src/hooks/use-client.ts

@@ -23,13 +23,15 @@ export function useClient(options?: ChainHookOptions) {
  */
 export const clientAtom = atomFamilyWithErrorCatcher(
   (withErrorCatcher, config: Config, chainId: ChainId) =>
-    withErrorCatcher(atom)(() => {
-      const chainConfig = config.chains[chainId];
+    withErrorCatcher(
+      atom(() => {
+        const chainConfig = config.chains[chainId];
 
-      if (chainConfig === undefined) {
-        throw new ReactiveDotError(`No config provided for ${chainId}`);
-      }
+        if (chainConfig === undefined) {
+          throw new ReactiveDotError(`No config provided for ${chainId}`);
+        }
 
-      return getClient(chainConfig);
-    }),
+        return getClient(chainConfig);
+      }),
+    ),
 );

packages/react/src/hooks/use-query.ts

@@ -184,14 +184,13 @@ const instructionPayloadAtom = atomFamilyWithErrorCatcher(
   ) => {
     switch (preflight(instruction)) {
       case "promise": {
-        const atom = withErrorCatcher(atomWithRefresh)(async (
-          get,
-          { signal },
-        ) => {
-          const api = await get(typedApiAtom(config, chainId));
+        const atom = withErrorCatcher(
+          atomWithRefresh(async (get, { signal }) => {
+            const api = await get(typedApiAtom(config, chainId));
 
-          return query(api, instruction, { signal });
-        });
+            return query(api, instruction, { signal });
+          }),
+        );
 
         return {
           observableAtom: atom,
@@ -256,27 +255,29 @@ export const queryPayloadAtom = atomFamilyWithErrorCatcher(
     ) => (asObservable ? atoms.observableAtom : atoms.promiseAtom);
 
     const createAtom = (asObservable: boolean) =>
-      withErrorCatcher(atom)((get) => {
-        return Promise.all(
-          atoms.map((atomOrAtoms) =>
-            !Array.isArray(atomOrAtoms)
-              ? atomOrAtoms
-              : Promise.all(
-                  atomOrAtoms.map((atomOrAtoms) => {
-                    if (Array.isArray(atomOrAtoms)) {
-                      return Promise.all(
-                        atomOrAtoms.map((atom) =>
-                          get(unwrap(atom, asObservable)),
-                        ),
-                      );
-                    }
+      withErrorCatcher(
+        atom((get) => {
+          return Promise.all(
+            atoms.map((atomOrAtoms) =>
+              !Array.isArray(atomOrAtoms)
+                ? atomOrAtoms
+                : Promise.all(
+                    atomOrAtoms.map((atomOrAtoms) => {
+                      if (Array.isArray(atomOrAtoms)) {
+                        return Promise.all(
+                          atomOrAtoms.map((atom) =>
+                            get(unwrap(atom, asObservable)),
+                          ),
+                        );
+                      }
 
-                    return get(unwrap(atomOrAtoms, asObservable));
-                  }),
-                ).then(flatHead),
-          ),
-        );
-      });
+                      return get(unwrap(atomOrAtoms, asObservable));
+                    }),
+                  ).then(flatHead),
+            ),
+          );
+        }),
+      );
 
     return { promiseAtom: createAtom(false), observableAtom: createAtom(true) };
   },

packages/react/src/hooks/use-typed-api.ts

@@ -32,15 +32,17 @@ export function useTypedApi<TChainId extends ChainId | undefined>(
  */
 export const typedApiAtom = atomFamilyWithErrorCatcher(
   (withErrorCatcher, config: Config, chainId: ChainId) =>
-    withErrorCatcher(atom)(async (get) => {
-      const chainConfig = config.chains[chainId];
+    withErrorCatcher(
+      atom(async (get) => {
+        const chainConfig = config.chains[chainId];
 
-      if (chainConfig === undefined) {
-        throw new ReactiveDotError(`No config provided for chain ${chainId}`);
-      }
+        if (chainConfig === undefined) {
+          throw new ReactiveDotError(`No config provided for chain ${chainId}`);
+        }
 
-      const client = await get(clientAtom(config, chainId));
+        const client = await get(clientAtom(config, chainId));
 
-      return client.getTypedApi(chainConfig.descriptor);
-    }),
+        return client.getTypedApi(chainConfig.descriptor);
+      }),
+    ),
 );

packages/react/src/hooks/use-wallets.ts

@@ -33,7 +33,7 @@ export function useConnectedWallets() {
  */
 export const walletsAtom = atomFamilyWithErrorCatcher(
   (withErrorCatcher, config: Config) =>
-    withErrorCatcher(atom)(() => aggregateWallets(config.wallets ?? [])),
+    withErrorCatcher(atom(() => aggregateWallets(config.wallets ?? []))),
 );
 
 /**

packages/react/src/utils/jotai/atom-family-with-error-catcher.test.ts

@@ -13,7 +13,7 @@ beforeEach(() => {
 it("should create an atom family", () => {
   const myAtomFamily = atomFamilyWithErrorCatcher(
     (withErrorCatcher, param: string) => {
-      return withErrorCatcher(atom)(`Hello ${param}`);
+      return withErrorCatcher(atom(`Hello ${param}`));
     },
   );
 
@@ -26,7 +26,7 @@ it("should create an atom family", () => {
 it("should return different atoms for different params", () => {
   const myAtomFamily = atomFamilyWithErrorCatcher(
     (withErrorCatcher, param: string) => {
-      return withErrorCatcher(atom)(`Hello ${param}`);
+      return withErrorCatcher(atom(`Hello ${param}`));
     },
   );
 
@@ -39,13 +39,15 @@ it("should return different atoms for different params", () => {
 it("should catch errors in synchronous reads", () => {
   const myAtomFamily = atomFamilyWithErrorCatcher(
     (withErrorCatcher, param: string) => {
-      return withErrorCatcher(atom)(() => {
-        if (param === "Error") {
-          throw new Error("Intentional Error");
-        }
-
-        return `Hello ${param}`;
-      });
+      return withErrorCatcher(
+        atom(() => {
+          if (param === "Error") {
+            throw new Error("Intentional Error");
+          }
+
+          return `Hello ${param}`;
+        }),
+      );
     },
   );
 
@@ -56,13 +58,15 @@ it("should catch errors in synchronous reads", () => {
 it("should catch errors in Promise reads", async () => {
   const myAtomFamily = atomFamilyWithErrorCatcher(
     (withErrorCatcher, param: string) => {
-      return withErrorCatcher(atom)(async () => {
-        if (param === "Error") {
-          throw new Error("Intentional Promise Error");
-        }
-
-        return `Hello ${param}`;
-      });
+      return withErrorCatcher(
+        atom(async () => {
+          if (param === "Error") {
+            throw new Error("Intentional Promise Error");
+          }
+
+          return `Hello ${param}`;
+        }),
+      );
     },
   );
 
@@ -75,10 +79,12 @@ it("should catch errors in Promise reads", async () => {
 it("should catch errors in Observable reads", async () => {
   const myAtomFamily = atomFamilyWithErrorCatcher(
     (withErrorCatcher, param: string) => {
-      return withErrorCatcher(atomWithObservable)(() =>
-        param === "Error"
-          ? throwError(() => new Error("Intentional Observable Error"))
-          : of(`Hello ${param}`),
+      return withErrorCatcher(
+        atomWithObservable(() =>
+          param === "Error"
+            ? throwError(() => new Error("Intentional Observable Error"))
+            : of(`Hello ${param}`),
+        ),
       );
     },
   );

packages/react/src/utils/jotai/atom-family-with-error-catcher.ts

@@ -1,7 +1,5 @@
 import { type AtomFamily, atomFamily } from "./atom-family.js";
-import { atom, type Getter } from "jotai";
-import { Observable } from "rxjs";
-import { catchError } from "rxjs/operators";
+import { type Atom, atom, type Getter, type WritableAtom } from "jotai";
 
 export const atomFamilyErrorsAtom = atom(
   () =>
@@ -18,70 +16,58 @@ export const atomFamilyErrorsAtom = atom(
 export function atomFamilyWithErrorCatcher<
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   TArguments extends any[],
-  TAtomType,
+  TCached,
 >(
   initializeAtom: (
-    withErrorCatcher: <TAtomCreator>(atomCreator: TAtomCreator) => TAtomCreator,
+    withErrorCatcher: <TAtomType extends Atom<unknown>>(
+      atom: TAtomType,
+    ) => TAtomType,
     ...args: TArguments
-  ) => TAtomType,
+  ) => TCached,
   getKey?: (...args: TArguments) => unknown,
-): AtomFamily<TArguments, TAtomType> {
+): AtomFamily<TArguments, TCached> {
   const baseAtomFamily = atomFamily((...args: TArguments) => {
-    const withErrorCatcher: <
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      TRead extends (get: Getter, ...args: unknown[]) => any,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      TAtomCreator extends (read: TRead, ...args: any[]) => unknown,
-    >(
-      atomCreator: TAtomCreator,
-    ) => TAtomCreator = (atomCreator) => {
-      // @ts-expect-error complex sub-type
-      const atomCatching: TAtomCreator = (read, ...args) => {
-        // @ts-expect-error complex sub-type
-        const readCatching: TRead = (...readArgs) => {
-          const addError = <T>(error: T) => {
-            const get = readArgs[0] as Getter;
+    const withErrorCatcher = <TAtomType extends Atom<unknown>>(
+      childAtom: TAtomType,
+    ) => {
+      const read = (get: Getter) => {
+        try {
+          const value = get(childAtom);
+
+          if (!(value instanceof Promise)) {
+            return value;
+          }
+
+          return value.catch((error) => {
             get(atomFamilyErrorsAtom).add({
               atomFamily: baseAtomFamily,
               args,
             });
-            return error;
-          };
-
-          try {
-            const value = read(...readArgs);
 
-            if (value instanceof Promise) {
-              return value.catch((error) => {
-                throw addError(error);
-              });
-            }
-
-            if (value instanceof Observable) {
-              return value.pipe(
-                catchError((error) => {
-                  throw addError(error);
-                }),
-              );
-            }
-
-            return value;
-          } catch (error) {
-            throw addError(error);
-          }
-        };
+            throw error;
+          });
+        } catch (error) {
+          get(atomFamilyErrorsAtom).add({
+            atomFamily: baseAtomFamily,
+            args,
+          });
 
-        return atomCreator(readCatching, ...args);
+          throw error;
+        }
       };
 
-      return atomCatching;
+      return "write" in childAtom
+        ? atom(read, (_, set, ...args: unknown[]) =>
+            set(
+              childAtom as unknown as WritableAtom<unknown, unknown[], unknown>,
+              ...args,
+            ),
+          )
+        : atom(read);
     };
 
-    return initializeAtom(
-      // @ts-expect-error complex type
-      withErrorCatcher,
-      ...args,
-    );
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return initializeAtom(withErrorCatcher as any, ...args);
   }, getKey);
 
   return baseAtomFamily;

packages/react/src/utils/jotai/atom-with-observable-and-promise.ts

@@ -7,11 +7,9 @@ type Data<T> = { value: T | Promise<T> } | { error: unknown };
 
 export function atomWithObservableAndPromise<
   TValue,
-  TAtomEnhancer extends <
-    TAtomCreator extends (...args: never[]) => Atom<unknown>,
-  >(
-    atomCreator: TAtomCreator,
-  ) => TAtomCreator,
+  TAtomEnhancer extends <TAtomType extends Atom<unknown>>(
+    atomType: TAtomType,
+  ) => TAtomType,
 >(
   getObservable: (get: Getter) => Observable<TValue>,
   enhanceAtom: TAtomEnhancer = ((atomCreator) => atomCreator) as TAtomEnhancer,
@@ -25,22 +23,24 @@ export function atomWithObservableAndPromise<
 
   const dataAtom = atom<Data<TValue>>({ value: initialPromise });
 
-  const promiseAtom = enhanceAtom(atom)((get) => {
-    const data = get(dataAtom);
+  const promiseAtom = enhanceAtom(
+    atom((get) => {
+      const data = get(dataAtom);
 
-    if ("error" in data) {
-      throw data.error;
-    }
+      if ("error" in data) {
+        throw data.error;
+      }
 
-    if ("value" in data && data.value !== initialPromise) {
-      return data.value;
-    }
+      if ("value" in data && data.value !== initialPromise) {
+        return data.value;
+      }
 
-    return firstValueFrom(get(rawObservableAtom));
-  });
+      return firstValueFrom(get(rawObservableAtom));
+    }),
+  );
 
   const observableAtom = withAtomEffect(
-    enhanceAtom(atomWithObservable)((get) => get(rawObservableAtom)),
+    enhanceAtom(atomWithObservable((get) => get(rawObservableAtom))),
     (get, set) => {
       try {
         set(dataAtom, { value: get(observableAtom) });