@spoosh/react 0.6.0 → 0.7.1

package/dist/index.js

@@ -24,7 +24,6 @@ var src_exports = {};
 __export(src_exports, {
   createReactSpoosh: () => createReactSpoosh,
   createUseInfiniteRead: () => createUseInfiniteRead,
-  createUseLazyRead: () => createUseLazyRead,
   createUseRead: () => createUseRead,
   createUseWrite: () => createUseWrite
 });
@@ -70,10 +69,11 @@ function createUseRead(options) {
       initialized: false,
       prevContext: null
     });
-    if (controllerRef.current && controllerRef.current.queryKey !== queryKey) {
+    const baseQueryKeyChanged = controllerRef.current && controllerRef.current.baseQueryKey !== queryKey;
+    if (baseQueryKeyChanged) {
       lifecycleRef.current.prevContext = controllerRef.current.controller.getContext();
     }
-    if (!controllerRef.current || controllerRef.current.queryKey !== queryKey) {
+    if (!controllerRef.current || baseQueryKeyChanged) {
       const controller2 = (0, import_core.createOperationController)({
         operationType: "read",
         path: pathSegments,
@@ -90,29 +90,36 @@ function createUseRead(options) {
           return method(fetchOpts);
         }
       });
-      controllerRef.current = { controller: controller2, queryKey };
+      controllerRef.current = { controller: controller2, queryKey, baseQueryKey: queryKey };
     }
     const controller = controllerRef.current.controller;
     controller.setPluginOptions(pluginOpts);
-    const state = (0, import_react.useSyncExternalStore)(
-      controller.subscribe,
-      controller.getState,
-      controller.getState
+    const subscribe = (0, import_react.useCallback)(
+      (callback) => {
+        return controller.subscribe(callback);
+      },
+      [controller]
     );
+    const getSnapshot = (0, import_react.useCallback)(() => {
+      return controller.getState();
+    }, [controller]);
+    const state = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
     const [requestState, setRequestState] = (0, import_react.useState)(() => {
       const cachedEntry = stateManager.getCache(queryKey);
       const hasCachedData = cachedEntry?.state?.data !== void 0;
       return { isPending: enabled && !hasCachedData, error: void 0 };
     });
+    const [, forceUpdate] = (0, import_react.useState)(0);
     const abortRef = (0, import_react.useRef)(controller.abort);
     abortRef.current = controller.abort;
     const pluginOptsKey = JSON.stringify(pluginOpts);
     const tagsKey = JSON.stringify(tags);
     const executeWithTracking = (0, import_react.useCallback)(
-      async (force = false) => {
+      async (force = false, overrideOptions) => {
         setRequestState((prev) => ({ ...prev, isPending: true }));
         try {
-          const response = await controller.execute(void 0, { force });
+          const execOptions = overrideOptions ? { ...capturedCall.options ?? {}, ...overrideOptions } : void 0;
+          const response = await controller.execute(execOptions, { force });
           if (response.error) {
             setRequestState({ isPending: false, error: response.error });
           } else {
@@ -121,10 +128,10 @@ function createUseRead(options) {
           return response;
         } catch (err) {
           setRequestState({ isPending: false, error: err });
-          throw err;
+          return { error: err };
         }
       },
-      [controller]
+      [controller, capturedCall.options]
     );
     (0, import_react.useEffect)(() => {
       return () => {
@@ -159,9 +166,13 @@ function createUseRead(options) {
           }
         }
       );
+      const unsubRefetchAll = eventEmitter.on("refetchAll", () => {
+        executeWithTracking(true);
+      });
       return () => {
         unsubRefetch();
         unsubInvalidate();
+        unsubRefetchAll();
       };
     }, [queryKey, enabled, tagsKey]);
     (0, import_react.useEffect)(() => {
@@ -172,9 +183,84 @@ function createUseRead(options) {
     const abort = (0, import_react.useCallback)(() => {
       abortRef.current();
     }, []);
-    const trigger = (0, import_react.useCallback)(() => {
-      return executeWithTracking(true);
-    }, [executeWithTracking]);
+    const trigger = (0, import_react.useCallback)(
+      async (triggerOptions) => {
+        const { force = false, ...overrideOptions } = triggerOptions ?? {};
+        const hasOverrides = Object.keys(overrideOptions).length > 0;
+        if (!hasOverrides) {
+          return executeWithTracking(force, void 0);
+        }
+        const mergedOptions = {
+          ...capturedCall.options ?? {},
+          ...overrideOptions
+        };
+        const newQueryKey = stateManager.createQueryKey({
+          path: pathSegments,
+          method: capturedCall.method,
+          options: mergedOptions
+        });
+        if (newQueryKey === controllerRef.current?.queryKey) {
+          return executeWithTracking(force, overrideOptions);
+        }
+        const params = mergedOptions?.params;
+        const newResolvedPath = (0, import_core.resolvePath)(pathSegments, params);
+        const newResolvedTags = (0, import_core.resolveTags)({ tags }, newResolvedPath);
+        const newController = (0, import_core.createOperationController)({
+          operationType: "read",
+          path: pathSegments,
+          method: capturedCall.method,
+          tags: newResolvedTags,
+          requestOptions: mergedOptions,
+          stateManager,
+          eventEmitter,
+          pluginExecutor,
+          hookId,
+          fetchFn: async (fetchOpts) => {
+            const pathMethods = api(capturedCall.path);
+            const method = pathMethods[capturedCall.method];
+            return method(fetchOpts);
+          }
+        });
+        newController.setPluginOptions(pluginOpts);
+        const currentBaseQueryKey = controllerRef.current?.baseQueryKey ?? queryKey;
+        controllerRef.current = {
+          controller: newController,
+          queryKey: newQueryKey,
+          baseQueryKey: currentBaseQueryKey
+        };
+        forceUpdate((n) => n + 1);
+        newController.mount();
+        setRequestState((prev) => ({ ...prev, isPending: true }));
+        try {
+          const response = await newController.execute(mergedOptions, {
+            force
+          });
+          if (response.error) {
+            setRequestState({ isPending: false, error: response.error });
+          } else {
+            setRequestState({ isPending: false, error: void 0 });
+          }
+          return response;
+        } catch (err) {
+          setRequestState({ isPending: false, error: err });
+          return { error: err };
+        }
+      },
+      [
+        executeWithTracking,
+        capturedCall.options,
+        capturedCall.method,
+        capturedCall.path,
+        pathSegments,
+        tags,
+        stateManager,
+        eventEmitter,
+        pluginExecutor,
+        hookId,
+        pluginOpts,
+        api
+      ]
+    );
     const entry = stateManager.getCache(queryKey);
     const pluginResultData = entry?.meta ? Object.fromEntries(entry.meta) : {};
     const opts = capturedCall.options;
@@ -286,7 +372,7 @@ function createUseWrite(options) {
           return response;
         } catch (err) {
           setRequestState({ isPending: false, error: err });
-          throw err;
+          return { error: err };
         }
       },
       [selectedEndpoint.path]
@@ -321,141 +407,9 @@ function createUseWrite(options) {
   return useWrite;
 }
 
-// src/useLazyRead/index.ts
+// src/useInfiniteRead/index.ts
 var import_react3 = require("react");
 var import_core3 = require("@spoosh/core");
-function createUseLazyRead(options) {
-  const { api, stateManager, pluginExecutor, eventEmitter } = options;
-  function useLazyRead(readFn) {
-    const hookId = (0, import_react3.useId)();
-    const selectorResultRef = (0, import_react3.useRef)({
-      call: null,
-      selector: null
-    });
-    const selectorProxy = (0, import_core3.createSelectorProxy)((result) => {
-      selectorResultRef.current = result;
-    });
-    readFn(selectorProxy);
-    const selectedEndpoint = selectorResultRef.current.selector;
-    if (!selectedEndpoint) {
-      throw new Error(
-        'useLazyRead requires selecting an HTTP method (GET). Example: useLazyRead((api) => api("posts").GET)'
-      );
-    }
-    if (selectedEndpoint.method !== "GET") {
-      throw new Error(
-        "useLazyRead only supports GET method. Use useWrite for POST, PUT, PATCH, DELETE methods."
-      );
-    }
-    const pathSegments = selectedEndpoint.path.split("/").filter(Boolean);
-    const controllerRef = (0, import_react3.useRef)(null);
-    const emptyStateRef = (0, import_react3.useRef)({ data: void 0, error: void 0 });
-    const [currentQueryKey, setCurrentQueryKey] = (0, import_react3.useState)(null);
-    const [, forceUpdate] = (0, import_react3.useState)(0);
-    const getOrCreateController = (0, import_react3.useCallback)(
-      (triggerOptions) => {
-        const queryKey = stateManager.createQueryKey({
-          path: pathSegments,
-          method: selectedEndpoint.method,
-          options: triggerOptions
-        });
-        if (controllerRef.current?.queryKey === queryKey) {
-          return { controller: controllerRef.current.controller, queryKey };
-        }
-        const controller2 = (0, import_core3.createOperationController)({
-          operationType: "read",
-          path: pathSegments,
-          method: "GET",
-          tags: [],
-          stateManager,
-          eventEmitter,
-          pluginExecutor,
-          hookId,
-          requestOptions: triggerOptions,
-          fetchFn: async (fetchOpts) => {
-            const pathMethods = api(selectedEndpoint.path);
-            const method = pathMethods[selectedEndpoint.method];
-            return method(fetchOpts);
-          }
-        });
-        controllerRef.current = { controller: controller2, queryKey };
-        setCurrentQueryKey(queryKey);
-        forceUpdate((n) => n + 1);
-        return { controller: controller2, queryKey };
-      },
-      [pathSegments, selectedEndpoint.method, selectedEndpoint.path, hookId]
-    );
-    const controller = controllerRef.current?.controller;
-    const subscribe = (0, import_react3.useCallback)(
-      (callback) => {
-        if (!controller) return () => {
-        };
-        return controller.subscribe(callback);
-      },
-      [controller]
-    );
-    const getSnapshot = (0, import_react3.useCallback)(() => {
-      if (!controller) return emptyStateRef.current;
-      return controller.getState();
-    }, [controller]);
-    const state = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-    const [lastTriggerOptions, setLastTriggerOptions] = (0, import_react3.useState)(void 0);
-    const [requestState, setRequestState] = (0, import_react3.useState)({ isPending: false, error: void 0 });
-    const abort = (0, import_react3.useCallback)(() => {
-      controllerRef.current?.controller.abort();
-    }, []);
-    const trigger = (0, import_react3.useCallback)(
-      async (triggerOptions) => {
-        setLastTriggerOptions(triggerOptions);
-        setRequestState((prev) => ({ ...prev, isPending: true }));
-        const params = triggerOptions?.params;
-        (0, import_core3.resolvePath)(pathSegments, params);
-        const { controller: ctrl } = getOrCreateController(triggerOptions);
-        ctrl.setPluginOptions(triggerOptions);
-        try {
-          const response = await ctrl.execute(triggerOptions);
-          if (response.error) {
-            setRequestState({ isPending: false, error: response.error });
-          } else {
-            setRequestState({ isPending: false, error: void 0 });
-          }
-          return response;
-        } catch (err) {
-          setRequestState({ isPending: false, error: err });
-          throw err;
-        }
-      },
-      [pathSegments, getOrCreateController]
-    );
-    const opts = lastTriggerOptions;
-    const inputInner = {};
-    if (opts?.query !== void 0) {
-      inputInner.query = opts.query;
-    }
-    if (opts?.body !== void 0) {
-      inputInner.body = opts.body;
-    }
-    if (opts?.params !== void 0) {
-      inputInner.params = opts.params;
-    }
-    const inputField = Object.keys(inputInner).length > 0 ? { input: inputInner } : {};
-    const loading = requestState.isPending;
-    return {
-      trigger,
-      ...inputField,
-      data: state.data,
-      error: requestState.error ?? state.error,
-      loading,
-      abort
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    };
-  }
-  return useLazyRead;
-}
-
-// src/useInfiniteRead/index.ts
-var import_react4 = require("react");
-var import_core4 = require("@spoosh/core");
 function createUseInfiniteRead(options) {
   const { api, stateManager, eventEmitter, pluginExecutor } = options;
   return function useInfiniteRead(readFn, readOptions) {
@@ -469,12 +423,12 @@ function createUseInfiniteRead(options) {
       prevPageRequest,
       ...pluginOpts
     } = readOptions;
-    const hookId = (0, import_react4.useId)();
-    const selectorResultRef = (0, import_react4.useRef)({
+    const hookId = (0, import_react3.useId)();
+    const selectorResultRef = (0, import_react3.useRef)({
       call: null,
       selector: null
     });
-    const selectorProxy = (0, import_core4.createSelectorProxy)((result2) => {
+    const selectorProxy = (0, import_core3.createSelectorProxy)((result2) => {
       selectorResultRef.current = result2;
     });
     readFn(selectorProxy);
@@ -497,13 +451,13 @@ function createUseInfiniteRead(options) {
       params: void 0,
       body: void 0
     };
-    const resolvedPath = (0, import_core4.resolvePath)(pathSegments, requestOptions?.params);
-    const resolvedTags = (0, import_core4.resolveTags)({ tags }, resolvedPath);
-    const canFetchNextRef = (0, import_react4.useRef)(canFetchNext);
-    const canFetchPrevRef = (0, import_react4.useRef)(canFetchPrev);
-    const nextPageRequestRef = (0, import_react4.useRef)(nextPageRequest);
-    const prevPageRequestRef = (0, import_react4.useRef)(prevPageRequest);
-    const mergerRef = (0, import_react4.useRef)(merger);
+    const resolvedPath = (0, import_core3.resolvePath)(pathSegments, requestOptions?.params);
+    const resolvedTags = (0, import_core3.resolveTags)({ tags }, resolvedPath);
+    const canFetchNextRef = (0, import_react3.useRef)(canFetchNext);
+    const canFetchPrevRef = (0, import_react3.useRef)(canFetchPrev);
+    const nextPageRequestRef = (0, import_react3.useRef)(nextPageRequest);
+    const prevPageRequestRef = (0, import_react3.useRef)(prevPageRequest);
+    const mergerRef = (0, import_react3.useRef)(merger);
     canFetchNextRef.current = canFetchNext;
     canFetchPrevRef.current = canFetchPrev;
     nextPageRequestRef.current = nextPageRequest;
@@ -514,10 +468,10 @@ function createUseInfiniteRead(options) {
       method: capturedCall.method,
       options: baseOptionsForKey
     });
-    const controllerRef = (0, import_react4.useRef)(null);
+    const controllerRef = (0, import_react3.useRef)(null);
     if (!controllerRef.current || controllerRef.current.queryKey !== queryKey) {
       controllerRef.current = {
-        controller: (0, import_core4.createInfiniteReadController)({
+        controller: (0, import_core3.createInfiniteReadController)({
           path: pathSegments,
           method: capturedCall.method,
           tags: resolvedTags,
@@ -550,12 +504,12 @@ function createUseInfiniteRead(options) {
     }
     const controller = controllerRef.current.controller;
     controller.setPluginOptions(pluginOpts);
-    const state = (0, import_react4.useSyncExternalStore)(
+    const state = (0, import_react3.useSyncExternalStore)(
       controller.subscribe,
       controller.getState,
       controller.getState
     );
-    const [isPending, setIsPending] = (0, import_react4.useState)(() => {
+    const [isPending, setIsPending] = (0, import_react3.useState)(() => {
       return enabled && state.data === void 0;
     });
     const fetchingDirection = controller.getFetchingDirection();
@@ -564,18 +518,18 @@ function createUseInfiniteRead(options) {
     const fetchingPrev = fetchingDirection === "prev";
     const hasData = state.data !== void 0;
     const loading = (isPending || fetching) && !hasData;
-    const lifecycleRef = (0, import_react4.useRef)({
+    const lifecycleRef = (0, import_react3.useRef)({
       initialized: false,
       prevContext: null
     });
     const tagsKey = JSON.stringify(tags);
-    (0, import_react4.useEffect)(() => {
+    (0, import_react3.useEffect)(() => {
       return () => {
         controllerRef.current?.controller.unmount();
         lifecycleRef.current.initialized = false;
       };
     }, []);
-    (0, import_react4.useEffect)(() => {
+    (0, import_react3.useEffect)(() => {
       controller.mount();
       lifecycleRef.current.initialized = true;
       const unsubInvalidate = eventEmitter.on(
@@ -590,11 +544,16 @@ function createUseInfiniteRead(options) {
           }
         }
       );
+      const unsubRefetchAll = eventEmitter.on("refetchAll", () => {
+        setIsPending(true);
+        controller.refetch().finally(() => setIsPending(false));
+      });
       return () => {
         unsubInvalidate();
+        unsubRefetchAll();
       };
     }, [tagsKey]);
-    (0, import_react4.useEffect)(() => {
+    (0, import_react3.useEffect)(() => {
       if (!lifecycleRef.current.initialized) return;
       if (enabled) {
         const currentState = controller.getState();
@@ -605,7 +564,7 @@ function createUseInfiniteRead(options) {
         }
       }
     }, [enabled]);
-    (0, import_react4.useEffect)(() => {
+    (0, import_react3.useEffect)(() => {
       if (!enabled || !lifecycleRef.current.initialized) return;
       const prevContext = controller.getContext();
       controller.update(prevContext);
@@ -647,12 +606,6 @@ function createReactSpoosh(instance) {
     eventEmitter,
     pluginExecutor
   });
-  const useLazyRead = createUseLazyRead({
-    api,
-    stateManager,
-    eventEmitter,
-    pluginExecutor
-  });
   const useInfiniteRead = createUseInfiniteRead({
     api,
     stateManager,
@@ -678,7 +631,6 @@ function createReactSpoosh(instance) {
   return {
     useRead,
     useWrite,
-    useLazyRead,
     useInfiniteRead,
     ...instanceApis
   };