react-redux-cache 0.0.5 → 0.0.6

package/dist/index.js

@@ -53,6 +53,7 @@ Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get:
 // make error type generic
 // proper types, remove as, any, todo
 // ! low
+// remove defaultState and keep values undefined?
 // add params to the state?
 // cancellation to queries
 // if mutation & query alrady loading - make options: last, throttle, debounce, parallel?

package/dist/useQuery.js

@@ -24,6 +24,7 @@ exports.queryCacheOptionsByPolicy = {
     'cache-and-fetch': Object.assign(Object.assign({}, cacheFirstOptions), { policy: 'cache-and-fetch' }),
 };
 exports.defaultQueryCacheOptions = cacheFirstOptions;
+const defaultRefState = {};
 const useQuery = (cache, options) => {
     var _a, _b, _c, _d;
     const getParamsKey = (_a = cache.queries[options.query].getParamsKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetParamsKey);
@@ -56,39 +57,43 @@ const useQuery = (cache, options) => {
     const forceUpdate = (0, utilsAndConstants_1.useForceUpdate)();
     // Keeps most of local state.
     // Reference because state is changed not only by changing hook arguments, but also by calling fetch, and it should be done synchronously.
-    const stateRef = (0, react_1.useRef)({});
+    const stateRef = (0, react_1.useRef)(defaultRefState);
     (0, react_1.useMemo)(() => {
-        if (skip || stateRef.current.paramsKey === hookParamsKey) {
+        if (stateRef.current.paramsKey === hookParamsKey) {
             return;
         }
-        const resultSelectorImpl = cache.queries[queryKey].resultSelector;
         const state = stateRef.current;
+        state.resultSelector = createResultSelector(
+        // @ts-expect-error fix later
+        cache.queries[queryKey].resultSelector, cache.cacheStateSelector, hookParams);
+        if (skip) {
+            return;
+        }
         state.params = hookParams;
         state.paramsKey = hookParamsKey;
         state.latestHookParamsKey = state.paramsKey;
         // @ts-expect-error fix later
         state.cacheKey = getCacheKey(hookParams);
-        state.resultSelector = createResultSelector(
-        // @ts-expect-error fix later
-        resultSelectorImpl, cache.cacheStateSelector, hookParams);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [hookParamsKey, skip]);
     const resultFromSelector = 
     // eslint-disable-next-line react-hooks/rules-of-hooks
     stateRef.current.resultSelector && (0, react_redux_1.useSelector)(stateRef.current.resultSelector);
     const hasResultFromSelector = resultFromSelector !== undefined;
-    const queryStateSelector = (0, react_1.useCallback)((state) => {
+    const queryStateSelector = (0, react_1.useCallback)((state, cacheKey = stateRef.current.cacheKey) => {
         cache.options.logsEnabled &&
             (0, utilsAndConstants_1.log)('queryStateSelector', {
                 state,
                 queryKey,
-                cacheKey: stateRef.current.cacheKey,
+                cacheKey,
                 cacheState: cache.cacheStateSelector(state),
             });
-        const queryState = cache.cacheStateSelector(state).queries[queryKey][stateRef.current.cacheKey];
+        const queryState = cache.cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
+    }, 
+    // cacheKey needed only to re-evaluate queryStateSelector later
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [stateRef.current.cacheKey]);
     const queryStateFromSelector = (_d = (0, react_redux_1.useSelector)(queryStateSelector)) !== null && _d !== void 0 ? _d : utilsAndConstants_1.defaultQueryMutationState;
     const queryState = hasResultFromSelector
         ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
@@ -99,11 +104,11 @@ const useQuery = (cache, options) => {
         if (queryState.loading) {
             return;
         }
+        const { params, cacheKey } = stateRef.current;
         cacheOptions.cacheQueryState &&
-            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, {
+            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
                 loading: true,
             }));
-        const { paramsKey, params } = stateRef.current;
         let response;
         const fetchFn = cache.queries[queryKey].query;
         try {
@@ -112,17 +117,14 @@ const useQuery = (cache, options) => {
             params);
         }
         catch (error) {
-            if (stateRef.current.paramsKey === paramsKey && cacheOptions.cacheQueryState) {
-                store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, {
-                    error: error,
-                    loading: false,
-                }));
-            }
+            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+                error: error,
+                loading: false,
+            }));
         }
-        if (response && stateRef.current.paramsKey === paramsKey) {
-            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, !cacheOptions.cacheQueryState
-                ? undefined
-                : {
+        if (response) {
+            const newState = cacheOptions.cacheQueryState
+                ? {
                     error: undefined,
                     loading: false,
                     result: hasResultFromSelector
@@ -130,13 +132,18 @@ const useQuery = (cache, options) => {
                         : mergeResults
                             ? mergeResults(
                             // @ts-expect-error fix later
-                            (_e = queryStateSelector(store.getState())) === null || _e === void 0 ? void 0 : _e.result, response, params)
+                            (_e = queryStateSelector(store.getState(), cacheKey)) === null || _e === void 0 ? void 0 : _e.result, response, params)
                             : response.result,
-                }, cacheOptions.cacheEntities ? response : undefined));
+                }
+                : undefined;
+            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, cacheOptions.cacheEntities ? response : undefined));
         }
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }), [mergeResults, queryState.loading, hasResultFromSelector]);
     (0, react_1.useEffect)(() => {
+        if (skip) {
+            return;
+        }
         if (queryState.result != null && cacheOptions.policy === 'cache-first') {
             return;
         }
@@ -165,6 +172,13 @@ const useQuery = (cache, options) => {
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [fetchImpl, getCacheKey]);
+    cache.options.logsEnabled &&
+        console.debug('[useQuery]', {
+            state: stateRef.current,
+            options,
+            resultFromSelector,
+            queryState,
+        });
     return [queryState, fetch];
 };
 exports.useQuery = useQuery;

package/dist/utilsAndConstants.d.ts

@@ -9,6 +9,7 @@ export declare const defaultCacheOptions: {
 };
 export declare const defaultQueryMutationState: {
     readonly loading: false;
+    readonly error: undefined;
 };
 export declare const defaultGetParamsKey: <P = unknown>(params: P) => string;
 /**

package/dist/utilsAndConstants.js

@@ -18,7 +18,7 @@ exports.defaultCacheOptions = {
     validateFunctionArguments: true,
     validateHookArguments: true,
 };
-exports.defaultQueryMutationState = { loading: false };
+exports.defaultQueryMutationState = { loading: false, error: undefined };
 const defaultGetParamsKey = (params) => {
     switch (typeof params) {
         case 'string':

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Powerful data fetching and caching library that supports normalization, built on top of redux",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
     "example": "(cd example && yarn && yarn start)",
     "clean": "rm -rf dist",
     "build": "yarn clean && tsc && yarn pack -f package.tgz",
-    "test": "node node_modules/jest/bin/jest.js",
+    "test": "node node_modules/jest/bin/jest.js --env=jsdom",
     "prepublishOnly": "yarn build && yarn test"
   },
   "devDependencies": {