react-redux-cache 0.13.0 → 0.16.0-rc.0

package/README.md

@@ -9,7 +9,7 @@
 
 # react-redux-cache (RRC)
 
-**Powerful** yet **lightweight** data fetching and caching library that supports **normalization** unlike `react-query` and `rtk-query`, while having similar but very simple interface. Built on top of `redux`, covered with tests, fully typed and written on Typescript.
+**Powerful**, **performant** yet **lightweight** data fetching and caching library that supports **normalization** unlike `React Query` and `RTK-Query`, while having similar but not over-engineered, simple interface. Another advantage over `RTK-Query` is that it **doesn't use Immer** ([perf issue](https://github.com/reduxjs/redux-toolkit/issues/4793)). Built on top of `Redux`, covered with tests, fully typed and written on Typescript.
 
 **Normalization** is the best way to keep the state of the app **consistent** between different views, reduces the number of fetches and allows to show cached data when navigating, which greatly improves **user experience**.
 
@@ -127,11 +127,21 @@ Examples of states, generated by cache reducer from `/example` project:
    - [How race conditions are handled?](https://github.com/gentlee/react-redux-cache#how-race-conditions-are-handled)
 
 ### Installation
-`react`, `redux` and `react-redux` are peer dependencies.
+`react` is a peer dependency.
+
+`react-redux` and `fast-deep-equal` are optional peer dependencies:
+  - `react-redux` required when `storeHooks` is not provided when creating cache.
+  - `fast-deep-equal` required if `deepComparisonEnabled` cache option is enabled (default is true).
 
-`fast-deep-equal` is an optional peer dependency if `deepComparisonEnabled` cache option is enabled (default is true).
 ```sh
-npm add react-redux-cache react redux react-redux fast-deep-equal
+# required
+npm add react-redux-cache react
+
+# without react-redux
+npm add react-redux-cache react fast-deep-equal
+
+# all required and optional peers
+npm add react-redux-cache react react-redux fast-deep-equal
 ```
 ### Initialization
 The only function that needs to be imported is either `withTypenames`, which is needed for normalization, or directly `createCache` if it is not needed. `createCache` creates fully typed reducer, hooks, actions, selectors and utils to be used in the app. You can create as many caches as needed, but keep in mind that normalization is not shared between them.
@@ -145,15 +155,14 @@ export type CacheTypenames = {
   banks: Bank,
 }
 
+// `withTypenames` is only needed to provide proper Typenames for normalization - limitation of Typescript.
+// `createCache` can be imported directly without `withTypenames`.
 export const {
   cache,
   reducer,
   hooks: {useClient, useMutation, useQuery},
-  // `withTypenames` is only needed to provide proper Typenames for normalization - limitation of Typescript.
-  // `createCache` can be imported directly without `withTypenames`.
 } = withTypenames<CacheTypenames>().createCache({
-  // Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state.
-  name: 'cache',
+  name: 'cache', // Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state.
   queries: {
     getUsers: { query: getUsers },
     getUser: {
@@ -176,15 +185,11 @@ For normalization two things are required:
 - Return an object from queries and mutations that contains the following fields (besides `result`):
 
 ```typescript
-type EntityChanges<T extends Typenames> = {  
-  /** Entities that will be merged with existing. */
-  merge?: PartialEntitiesMap<T>
-  /** Entities that will replace existing. */
-  replace?: Partial<EntitiesMap<T>>
-  /** Ids of entities that will be removed. */
-  remove?: EntityIds<T>
-  /** Alias for `merge` to support normalizr. */
-  entities?: EntityChanges<T>['merge']
+type EntityChanges<T extends Typenames> = {
+  merge?: PartialEntitiesMap<T>         /** Entities that will be merged with existing. */
+  replace?: Partial<EntitiesMap<T>>     /** Entities that will replace existing. */
+  remove?: EntityIds<T>                 /** Ids of entities that will be removed. */
+  entities?: EntityChanges<T>['merge']  /** Alias for `merge` to support normalizr. */
 }
 ```
 
@@ -200,21 +205,18 @@ const store = configureStore({
 })
 ```
 #### api.ts
-Query result should be of type `QueryResponse`, mutation result should be of type `MutationResponse`.
 For normalization `normalizr` package is used in this example, but any other tool can be used if query result is of proper type.
 Perfect implementation is when the backend already returns normalized data.
 ```typescript
 
 // Example of query with normalization (recommended)
 
+// 1. Result can be get by any way - fetch, axios etc, even with database connection. There is no limitation here.
+// 2. `satisfies` keyword is used here for proper typing of params and returned value.
 export const getUser = (async (id) => {
-  // Result can be get by any way - fetch, axios etc, even with database connection.
-  // There is no limitation here.
   const response = await ...
 
-  // In this example normalizr package is used, but it is not necessary.
   return normalize(response, getUserSchema)
-  // satisfies keyword is used here for proper typing of params and returned value.
 }) satisfies NormalizedQuery<CacheTypenames, number>
 
 // Example of query without normalization (not recommended), with selecting access token from the store
@@ -278,10 +280,8 @@ export const updateBank = (async (bank) => {
   const {httpError, response} = ...
   return {
     result: {
-      // Error is a part of the result, containing e.g. map of not valid fields and threir error messages
-      httpError,
-      // Bank still can be returned from the backend with error e.g. when only some of fields were udpated
-      bank: response?.bank
+      httpError,            // Error is a part of the result, containing e.g. map of not valid fields and threir error messages
+      bank: response?.bank  // Bank still can be returned from the backend with error e.g. when only some of fields were udpated
     }
   }
 }) satisfies Mutation<Partial<Bank>>
@@ -432,7 +432,6 @@ export const GetUsersScreen = () => {
   const onLoadNextPage = () => {
     const lastLoadedPage = usersResult?.page ?? 0
     fetchUsers({
-      query: 'getUsers',
       params: lastLoadedPage + 1,
     })
   }
@@ -504,7 +503,7 @@ export const defaultGetCacheKey = <P = unknown>(params: P): Key => {
 
 It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order.
 
-As example, can be overriden when implementing pagination.
+As example, can be overridden when implementing pagination.
 
 #### How race conditions are handled?
 

package/dist/createActions.d.ts

@@ -1,4 +1,5 @@
 import type { EntityChanges, Key, MutationState, QueryState, Typenames } from './types';
+import { CacheState } from './types';
 export type Actions<N extends string = string, T extends Typenames = Typenames, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = ReturnType<typeof createActions<N, T, QP, QR, MP, MR>>;
 export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(name: N) => {
     updateQueryStateAndEntities: {
@@ -72,4 +73,11 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
         };
         type: `@rrc/${N}/clearMutationState`;
     };
+    clearCache: {
+        (stateToKeep?: Partial<CacheState<T, QP, QR, MP, MR>>): {
+            type: `@rrc/${N}/clearCache`;
+            stateToKeep: Partial<CacheState<T, QP, QR, MP, MR>> | undefined;
+        };
+        type: `@rrc/${N}/clearCache`;
+    };
 };

package/dist/createActions.js

@@ -45,6 +45,12 @@ const createActions = (name) => {
         mutationKeys,
     });
     clearMutationState.type = clearMutationStateType;
+    const clearCacheType = `${actionPrefix}clearCache`;
+    const clearCache = (stateToKeep) => ({
+        type: clearCacheType,
+        stateToKeep,
+    });
+    clearCache.type = clearCacheType;
     return {
         updateQueryStateAndEntities,
         updateMutationStateAndEntities,
@@ -52,6 +58,7 @@ const createActions = (name) => {
         invalidateQuery,
         clearQueryState,
         clearMutationState,
+        clearCache,
     };
 };
 exports.createActions = createActions;

package/dist/createCache.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, CacheOptions, Globals, Key, MutateOptions, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import type { Cache, CacheOptions, Globals, Key, MutateOptions, MutationResult, OptionalPartial, QueryOptions, QueryResult, Store, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 import { applyEntityChanges } from './utilsAndConstants';
@@ -11,17 +11,13 @@ import { applyEntityChanges } from './utilsAndConstants';
  * })
  */
 export declare const withTypenames: <T extends Typenames = Typenames>() => {
-    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Omit<Cache<N, T, QP, QR, MP, MR>, "globals">, "options" | "queries" | "mutations" | "cacheStateSelector"> & {
+    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Omit<Cache<N, T, QP, QR, MP, MR>, "globals">, "options" | "queries" | "mutations" | "cacheStateSelector" | "storeHooks"> & {
         globals?: OptionalPartial<Cache<N, T, QP, QR, MP, MR>["globals"], "queries">;
     }) => {
         /** Keeps all options, passed while creating the cache. */
         cache: Cache<N, T, QP, QR, MP, MR>;
         /** Reducer of the cache, should be added to redux store. */
-        reducer: (state: {
-            entities: import("./types").EntitiesMap<T>;
-            queries: { [QK in keyof (QP | QR)]: import("./types").Dict<import("./types").QueryState<QP[QK], QR[QK]> | undefined>; };
-            mutations: { [MK in keyof (MP | MR)]: import("./types").MutationState<MP[MK], MR[MK]>; };
-        } | undefined, action: {
+        reducer: (state: import("./types").CacheState<T, QP, QR, MP, MR> | undefined, action: {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: keyof QP & keyof QR;
             queryCacheKey: Key;
@@ -51,11 +47,10 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         } | {
             type: `@rrc/${N}/clearMutationState`;
             mutationKeys: (keyof MP & keyof MR)[];
-        }) => {
-            entities: import("./types").EntitiesMap<T>;
-            queries: { [QK in keyof (QP | QR)]: import("./types").Dict<import("./types").QueryState<QP[QK], QR[QK]> | undefined>; };
-            mutations: { [MK in keyof (MP | MR)]: import("./types").MutationState<MP[MK], MR[MK]>; };
-        };
+        } | {
+            type: `@rrc/${N}/clearCache`;
+            stateToKeep: Partial<import("./types").CacheState<T, QP, QR, MP, MR>> | undefined;
+        }) => import("./types").CacheState<T, QP, QR, MP, MR>;
         actions: {
             /** Updates query state, and optionally merges entity changes in a single action. */
             updateQueryStateAndEntities: {
@@ -78,7 +73,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 };
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
             };
-            /** Merge EntityChanges to the state. */
+            /** Merges EntityChanges to the state. */
             mergeEntityChanges: {
                 (changes: import("./types").EntityChanges<T>): {
                     type: `@rrc/${N}/mergeEntityChanges`;
@@ -102,7 +97,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 };
                 type: `@rrc/${N}/invalidateQuery`;
             };
-            /** Clear states for provided query keys and cache keys.
+            /** Clears states for provided query keys and cache keys.
              * If cache key for query key is not provided, the whole state for query key is cleared. */
             clearQueryState: {
                 <K extends keyof QP & keyof QR>(queries: {
@@ -117,7 +112,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 };
                 type: `@rrc/${N}/clearQueryState`;
             };
-            /** Clear states for provided mutation keys. */
+            /** Clears states for provided mutation keys. */
             clearMutationState: {
                 <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
                     type: `@rrc/${N}/clearMutationState`;
@@ -125,8 +120,18 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 };
                 type: `@rrc/${N}/clearMutationState`;
             };
+            /** Replaces cache state with initial, optionally merging with provided state. Doesn't cancel running fetches and shoult be used with caution. */
+            clearCache: {
+                (stateToKeep?: Partial<import("./types").CacheState<T, QP, QR, MP, MR>> | undefined): {
+                    type: `@rrc/${N}/clearCache`;
+                    stateToKeep: Partial<import("./types").CacheState<T, QP, QR, MP, MR>> | undefined;
+                };
+                type: `@rrc/${N}/clearCache`;
+            };
         };
         selectors: {
+            /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
+            selectCacheState: (state: any) => import("./types").CacheState<T, QP, QR, MP, MR>;
             /** Selects query state. */
             selectQueryState: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => import("./types").QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>;
             /** Selects query latest result. */
@@ -183,18 +188,18 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
     queries: Partial<{ [QK in keyof (QP & QR)]: QK extends keyof QP & keyof QR ? import("./types").QueryInfo<N, Typenames, QP[QK], QR[QK], QP, QR, MP, MR> : never; }>;
     mutations: Partial<{ [MK in keyof (MP & MR)]: MK extends keyof MP & keyof MR ? import("./types").MutationInfo<N, Typenames, MP[MK], MR[MK], QP, QR, MP, MR> : never; }>;
     options: Partial<CacheOptions>;
-    cacheStateSelector: Partial<(state: any) => import("./createCacheReducer").ReduxCacheState<Typenames, QP, QR, MP, MR>>;
-}> & Omit<Omit<Cache<N, Typenames, QP, QR, MP, MR>, "globals">, "queries" | "mutations" | "options" | "cacheStateSelector"> & {
+    storeHooks: Partial<{
+        useStore: () => Store;
+        useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R;
+    }>;
+    cacheStateSelector: Partial<(state: any) => import("./types").CacheState<Typenames, QP, QR, MP, MR>>;
+}> & Omit<Omit<Cache<N, Typenames, QP, QR, MP, MR>, "globals">, "queries" | "mutations" | "options" | "storeHooks" | "cacheStateSelector"> & {
     globals?: OptionalPartial<Globals<N, Typenames, QP, QR, MP, MR>, "queries"> | undefined;
 }) => {
     /** Keeps all options, passed while creating the cache. */
     cache: Cache<N, Typenames, QP, QR, MP, MR>;
     /** Reducer of the cache, should be added to redux store. */
-    reducer: (state: {
-        entities: import("./types").EntitiesMap<Typenames>;
-        queries: { [QK_1 in keyof (QP | QR)]: import("./types").Dict<import("./types").QueryState<QP[QK_1], QR[QK_1]> | undefined>; };
-        mutations: { [MK_1 in keyof (MP | MR)]: import("./types").MutationState<MP[MK_1], MR[MK_1]>; };
-    } | undefined, action: {
+    reducer: (state: import("./types").CacheState<Typenames, QP, QR, MP, MR> | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
@@ -224,11 +229,10 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
     } | {
         type: `@rrc/${N}/clearMutationState`;
         mutationKeys: (keyof MP & keyof MR)[];
-    }) => {
-        entities: import("./types").EntitiesMap<Typenames>;
-        queries: { [QK_1 in keyof (QP | QR)]: import("./types").Dict<import("./types").QueryState<QP[QK_1], QR[QK_1]> | undefined>; };
-        mutations: { [MK_1 in keyof (MP | MR)]: import("./types").MutationState<MP[MK_1], MR[MK_1]>; };
-    };
+    } | {
+        type: `@rrc/${N}/clearCache`;
+        stateToKeep: Partial<import("./types").CacheState<Typenames, QP, QR, MP, MR>> | undefined;
+    }) => import("./types").CacheState<Typenames, QP, QR, MP, MR>;
     actions: {
         /** Updates query state, and optionally merges entity changes in a single action. */
         updateQueryStateAndEntities: {
@@ -251,7 +255,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
         };
-        /** Merge EntityChanges to the state. */
+        /** Merges EntityChanges to the state. */
         mergeEntityChanges: {
             (changes: import("./types").EntityChanges<Typenames>): {
                 type: `@rrc/${N}/mergeEntityChanges`;
@@ -275,7 +279,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             };
             type: `@rrc/${N}/invalidateQuery`;
         };
-        /** Clear states for provided query keys and cache keys.
+        /** Clears states for provided query keys and cache keys.
          * If cache key for query key is not provided, the whole state for query key is cleared. */
         clearQueryState: {
             <K extends keyof QP & keyof QR>(queries: {
@@ -290,7 +294,7 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             };
             type: `@rrc/${N}/clearQueryState`;
         };
-        /** Clear states for provided mutation keys. */
+        /** Clears states for provided mutation keys. */
         clearMutationState: {
             <K extends keyof MP & keyof MR>(mutationKeys: K[]): {
                 type: `@rrc/${N}/clearMutationState`;
@@ -298,8 +302,18 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             };
             type: `@rrc/${N}/clearMutationState`;
         };
+        /** Replaces cache state with initial, optionally merging with provided state. Doesn't cancel running fetches and shoult be used with caution. */
+        clearCache: {
+            (stateToKeep?: Partial<import("./types").CacheState<Typenames, QP, QR, MP, MR>> | undefined): {
+                type: `@rrc/${N}/clearCache`;
+                stateToKeep: Partial<import("./types").CacheState<Typenames, QP, QR, MP, MR>> | undefined;
+            };
+            type: `@rrc/${N}/clearCache`;
+        };
     };
     selectors: {
+        /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
+        selectCacheState: (state: any) => import("./types").CacheState<Typenames, QP, QR, MP, MR>;
         /** Selects query state. */
         selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => import("./types").QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
         /** Selects query latest result. */

package/dist/createCache.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = exports.withTypenames = void 0;
 const react_1 = require("react");
-const react_redux_1 = require("react-redux");
 const createActions_1 = require("./createActions");
 const createCacheReducer_1 = require("./createCacheReducer");
 const createSelectors_1 = require("./createSelectors");
@@ -25,22 +24,26 @@ const withTypenames = () => {
      */
     return {
         createCache: (partialCache) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
-            var _m, _o, _p, _q, _r, _s;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+            var _q, _r, _s, _t, _u, _v, _w, _x;
             const abortControllers = new WeakMap();
             // provide all optional fields
             (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
-            (_b = (_m = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_m.logsEnabled = false);
-            (_c = (_o = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_o.additionalValidation = utilsAndConstants_1.IS_DEV);
-            (_d = (_p = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_p.deepComparisonEnabled = true);
-            (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
-            (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
-            (_g = partialCache.globals) !== null && _g !== void 0 ? _g : (partialCache.globals = {});
-            (_h = (_q = partialCache.globals).queries) !== null && _h !== void 0 ? _h : (_q.queries = {});
-            (_j = (_r = partialCache.globals.queries).fetchPolicy) !== null && _j !== void 0 ? _j : (_r.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired);
-            (_k = (_s = partialCache.globals.queries).skipFetch) !== null && _k !== void 0 ? _k : (_s.skipFetch = false);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (_l = partialCache.cacheStateSelector) !== null && _l !== void 0 ? _l : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+            (_b = (_q = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_q.logsEnabled = false);
+            (_c = (_r = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_r.additionalValidation = utilsAndConstants_1.IS_DEV);
+            (_d = (_s = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_s.deepComparisonEnabled = true);
+            (_e = partialCache.globals) !== null && _e !== void 0 ? _e : (partialCache.globals = {});
+            (_f = (_t = partialCache.globals).queries) !== null && _f !== void 0 ? _f : (_t.queries = {});
+            (_g = (_u = partialCache.globals.queries).fetchPolicy) !== null && _g !== void 0 ? _g : (_u.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired);
+            (_h = (_v = partialCache.globals.queries).skipFetch) !== null && _h !== void 0 ? _h : (_v.skipFetch = false);
+            (_j = partialCache.storeHooks) !== null && _j !== void 0 ? _j : (partialCache.storeHooks = {});
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            (_k = (_w = partialCache.storeHooks).useStore) !== null && _k !== void 0 ? _k : (_w.useStore = require('react-redux').useStore);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            (_l = (_x = partialCache.storeHooks).useSelector) !== null && _l !== void 0 ? _l : (_x.useSelector = require('react-redux').useSelector);
+            (_m = partialCache.cacheStateSelector) !== null && _m !== void 0 ? _m : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+            (_o = partialCache.mutations) !== null && _o !== void 0 ? _o : (partialCache.mutations = {});
+            (_p = partialCache.queries) !== null && _p !== void 0 ? _p : (partialCache.queries = {});
             // @ts-expect-error private field for testing
             partialCache.abortControllers = abortControllers;
             const cache = partialCache;
@@ -49,11 +52,11 @@ const withTypenames = () => {
                 console.warn('react-redux-cache: optional dependency for fast-deep-equal was not provided, while deepComparisonEnabled option is true');
             }
             // selectors
-            const selectors = (0, createSelectors_1.createSelectors)(cache);
-            const { selectQueryState, selectQueryResult, selectQueryLoading, selectQueryError, selectQueryParams, selectQueryExpiresAt, selectMutationState, selectMutationResult, selectMutationLoading, selectMutationError, selectMutationParams, selectEntityById, selectEntities, selectEntitiesByTypename, } = selectors;
+            const selectors = Object.assign({ selectCacheState: cache.cacheStateSelector }, (0, createSelectors_1.createSelectors)(cache));
+            const { selectCacheState, selectQueryState, selectQueryResult, selectQueryLoading, selectQueryError, selectQueryParams, selectQueryExpiresAt, selectMutationState, selectMutationResult, selectMutationLoading, selectMutationError, selectMutationParams, selectEntityById, selectEntities, selectEntitiesByTypename, } = selectors;
             // actions
             const actions = (0, createActions_1.createActions)(cache.name);
-            const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, } = actions;
+            const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, clearCache, } = actions;
             return {
                 /** Keeps all options, passed while creating the cache. */
                 cache,
@@ -64,17 +67,21 @@ const withTypenames = () => {
                     updateQueryStateAndEntities,
                     /** Updates mutation state, and optionally merges entity changes in a single action. */
                     updateMutationStateAndEntities,
-                    /** Merge EntityChanges to the state. */
+                    /** Merges EntityChanges to the state. */
                     mergeEntityChanges,
                     /** Invalidates query states. */
                     invalidateQuery,
-                    /** Clear states for provided query keys and cache keys.
+                    /** Clears states for provided query keys and cache keys.
                      * If cache key for query key is not provided, the whole state for query key is cleared. */
                     clearQueryState,
-                    /** Clear states for provided mutation keys. */
+                    /** Clears states for provided mutation keys. */
                     clearMutationState,
+                    /** Replaces cache state with initial, optionally merging with provided state. Doesn't cancel running fetches and shoult be used with caution. */
+                    clearCache,
                 },
                 selectors: {
+                    /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
+                    selectCacheState,
                     /** Selects query state. */
                     selectQueryState,
                     /** Selects query latest result. */
@@ -107,7 +114,7 @@ const withTypenames = () => {
                 hooks: {
                     /** Returns client object with query and mutate functions. */
                     useClient: () => {
-                        const store = (0, react_redux_1.useStore)();
+                        const store = cache.storeHooks.useStore();
                         return (0, react_1.useMemo)(() => {
                             const client = {
                                 query: (options) => {
@@ -135,7 +142,7 @@ const withTypenames = () => {
                     useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, selectors, options, abortControllers),
                     /** useSelector + selectEntityById. */
                     useSelectEntityById: (id, typename) => {
-                        return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));
+                        return cache.storeHooks.useSelector((state) => selectEntityById(state, id, typename));
                     },
                 },
                 utils: {

package/dist/createCacheReducer.d.ts

@@ -1,12 +1,3 @@
 import type { Actions } from './createActions';
-import type { CacheOptions, Dict, EntitiesMap, MutationState, QueryState, Typenames } from './types';
-export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QP, QR, MP, MR>>>;
-export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: Actions<N, T, QP, QR, MP, MR>, queryKeys: (keyof (QP | QR))[], cacheOptions: CacheOptions) => (state: {
-    entities: EntitiesMap<T>;
-    queries: { [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
-    mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
-} | undefined, action: ReturnType<(typeof actions)[keyof typeof actions]>) => {
-    entities: EntitiesMap<T>;
-    queries: { [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; };
-    mutations: { [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>; };
-};
+import type { CacheOptions, CacheState, Typenames } from './types';
+export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: Actions<N, T, QP, QR, MP, MR>, queryKeys: (keyof (QP | QR))[], cacheOptions: CacheOptions) => (state: CacheState<T, QP, QR, MP, MR> | undefined, action: ReturnType<(typeof actions)[keyof typeof actions]>) => CacheState<T, QP, QR, MP, MR>;

package/dist/createCacheReducer.js

@@ -16,17 +16,14 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params'];
 const optionalMutationKeys = ['error', 'result', 'params'];
 const createCacheReducer = (actions, queryKeys, cacheOptions) => {
-    const entitiesMap = {};
-    const queryStateMap = {};
-    for (const key of queryKeys) {
-        queryStateMap[key] = {};
-    }
-    const mutationStateMap = {};
-    const initialState = {
-        entities: entitiesMap,
-        queries: queryStateMap,
-        mutations: mutationStateMap,
-    };
+    const initialState = Object.freeze({
+        entities: Object.freeze({}),
+        queries: Object.freeze(queryKeys.reduce((result, x) => {
+            result[x] = Object.freeze({});
+            return result;
+        }, {})),
+        mutations: Object.freeze({}),
+    });
     cacheOptions.logsEnabled &&
         (0, utilsAndConstants_1.log)('createCacheReducer', {
             queryKeys,
@@ -205,6 +202,11 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                     ? state
                     : Object.assign(Object.assign({}, state), { mutations: newMutations });
             }
+            case actions.clearCache.type: {
+                const { stateToKeep } = action;
+                return stateToKeep
+                    ? Object.assign(Object.assign({}, initialState), stateToKeep) : initialState;
+            }
         }
         return state;
     };

package/dist/index.js

@@ -27,12 +27,11 @@ Object.defineProperty(exports, "FetchPolicy", { enumerable: true, get: function
 Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: function () { return utilsAndConstants_1.isEmptyObject; } });
 // Backlog
 // ! high (1.0.0-rc.0)
+// optimistic response
 // generate full api docs
 // ! medium
-// optimistic response
 // onCancel & onAbort
 // remove empty entities and queries from state
-// reset [whole] cache to initial / to provided state
 // globals for success, completions and loading states?
 // make query key / cache key difference more clear in the docs
 // check type of function arguments in dev
@@ -41,7 +40,6 @@ Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: functio
 // ! low
 // make error type generic
 // allow multiple mutation with same keys?
-// custom useStore & useSelector to support multiple stores?
 // easy access to all currently loading queries and mutations?
 // cancellation to queries
 // if mutation & query already loading - make options: last, throttle, debounce, parallel?

package/dist/mutate.d.ts

@@ -1,5 +1,4 @@
-import { Store } from 'redux';
 import type { Actions } from './createActions';
 import { Selectors } from './createSelectors';
-import type { Cache, Key, MutationResult, Typenames } from './types';
+import type { Cache, Key, MutationResult, Store, Typenames } from './types';
 export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, mutationKey: MK, params: MK extends keyof (MP | MR) ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof (MP | MR) ? MR[MK] : never>>;

package/dist/query.d.ts

@@ -1,5 +1,4 @@
-import { Store } from 'redux';
 import type { Actions } from './createActions';
 import { Selectors } from './createSelectors';
-import type { Cache, Key, QueryResult, Typenames } from './types';
+import type { Cache, Key, QueryResult, Store, Typenames } from './types';
 export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, params: QK extends keyof (QP | QR) ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof (QP | QR) ? QR[QK] : never>>;

package/dist/types.d.ts

@@ -1,13 +1,11 @@
-import type { Store } from 'redux';
 import type { Actions } from './createActions';
-import type { ReduxCacheState } from './createCacheReducer';
 import type { Selectors } from './createSelectors';
 export type Key = string | number | symbol;
 export type Dict<T> = Record<Key, T>;
 export type OptionalPartial<T, K extends keyof T> = Partial<{
     [A in K]: Partial<T[A]>;
 }> & Omit<T, K>;
-/** Entity changes to be merged to redux state. */
+/** Entity changes to be merged to the state. */
 export type EntityChanges<T extends Typenames> = {
     /** Entities that will be merged with existing. */
     merge?: PartialEntitiesMap<T>;
@@ -18,22 +16,34 @@ export type EntityChanges<T extends Typenames> = {
     /** Alias for `merge` to support normalizr. */
     entities?: EntityChanges<T>['merge'];
 };
+export type Store<S = unknown> = {
+    dispatch: (action: ReturnType<Actions[keyof Actions]>) => unknown;
+    getState: () => S;
+};
 /** Record of typename and its corresponding entity type */
 export type Typenames = Record<string, object>;
 export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
-    /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state. */
+    /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from store root state. */
     name: N;
+    /** Cache options. */
+    options: CacheOptions;
+    /** Default options for queries and mutations. */
+    globals: Globals<N, T, QP, QR, MP, MR>;
+    /** Hooks to access and subscribe to the store. Imported from react-redux if not overridden. */
+    storeHooks: {
+        useStore: () => Store;
+        useSelector: <R>(selector: (state: unknown) => R, comparer?: (x: R, y: R) => boolean) => R;
+    };
+    /** Should return cache state from store root state. Default implementation returns `state[name]`. */
+    cacheStateSelector: (state: any) => CacheState<T, QP, QR, MP, MR>;
+    /** Queries. */
     queries: {
         [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<N, T, QP[QK], QR[QK], QP, QR, MP, MR> : never;
     };
+    /** Mutations. */
     mutations: {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<N, T, MP[MK], MR[MK], QP, QR, MP, MR> : never;
     };
-    /** Default options for queries and mutations. */
-    globals: Globals<N, T, QP, QR, MP, MR>;
-    options: CacheOptions;
-    /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
-    cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
 };
 export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     /** Handles errors, not handled by onError from queries and mutations. @Default undefined. */
@@ -72,6 +82,15 @@ export type EntitiesMap<T extends Typenames> = {
 export type EntityIds<T extends Typenames> = {
     [K in keyof T]?: Key[];
 };
+export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
+    entities: EntitiesMap<T>;
+    queries: {
+        [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>;
+    };
+    mutations: {
+        [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>;
+    };
+};
 export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Partial<Pick<Globals<N, T, QP, QR, MP, MR>['queries'], 'skipFetch' | 'secondsToLive'>> & {
     query: NormalizedQuery<T, P, R>;
     /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
@@ -96,7 +115,7 @@ export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unk
 export type Query<P = unknown, R = unknown> = (
 /** Query parameters */
 params: P, 
-/** Redux store */
+/** Store */
 store: Store) => Promise<QueryResponse<R>>;
 export type NormalizedQuery<T extends Typenames = Typenames, P = unknown, R = unknown> = (...args: Parameters<Query<P, R>>) => Promise<NormalizedQueryResponse<T, R>>;
 export type QueryState<P, R> = MutationState<P, R> & {
@@ -127,7 +146,7 @@ export type MutationInfo<N extends string, T extends Typenames = Typenames, P =
 export type Mutation<P = unknown, R = unknown> = (
 /** Mutation parameters */
 params: P, 
-/** Redux store */
+/** Store */
 store: Store, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<R>>;

package/dist/useMutation.d.ts

@@ -1,5 +1,4 @@
-import { Store } from 'redux';
 import { Actions } from './createActions';
 import { Selectors } from './createSelectors';
-import { Cache, Key, MutateOptions, MutationState, Typenames } from './types';
+import { Cache, Key, MutateOptions, MutationState, Store, Typenames } from './types';
 export declare const useMutation: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: Omit<MutateOptions<N, T, QP, QR, MP, MR, MK>, "params">, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<import("./types").MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -11,13 +11,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMutation = void 0;
 const react_1 = require("react");
-const react_redux_1 = require("react-redux");
 const mutate_1 = require("./mutate");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useMutation = (cache, actions, selectors, options, abortControllers) => {
     var _a;
     const { mutation: mutationKey, onCompleted, onSuccess, onError } = options;
-    const store = (0, react_redux_1.useStore)();
+    const store = cache.storeHooks.useStore();
     // Using single useMemo for performance reasons
     const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
         return [
@@ -53,7 +52,7 @@ const useMutation = (cache, actions, selectors, options, abortControllers) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [mutationKey, store]);
     // @ts-expect-error fix later
-    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
+    const mutationState = (_a = cache.storeHooks.useSelector(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
             options,

package/dist/useQuery.js

@@ -11,7 +11,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useQuerySelectorStateComparer = exports.useQuery = void 0;
 const react_1 = require("react");
-const react_redux_1 = require("react-redux");
 const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, selectors, options) => {
@@ -20,11 +19,11 @@ const useQuery = (cache, actions, selectors, options) => {
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheStateSelector = cache.cacheStateSelector;
-    const store = (0, react_redux_1.useStore)();
+    const store = cache.storeHooks.useStore();
     // @ts-expect-error fix types later
     const cacheKey = getCacheKey(params);
     /** Fetch query with the new parameters, or refetch with the same if parameters not provided. */
-    const fetch = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
+    const performFetch = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
         const paramsPassed = options && 'params' in options;
         return yield (0, query_1.query)('useQuery.fetch', store, cache, actions, selectors, queryKey, 
         // @ts-expect-error fix later
@@ -36,7 +35,7 @@ const useQuery = (cache, actions, selectors, options) => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [store, queryKey, cacheKey]);
     /** Query state */
-    const queryState = (_c = (0, react_redux_1.useSelector)((state) => {
+    const queryState = (_c = cache.storeHooks.useSelector((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
     }, (exports.useQuerySelectorStateComparer))) !== null && _c !== void 0 ? _c : utilsAndConstants_1.EMPTY_OBJECT;
@@ -46,8 +45,9 @@ const useQuery = (cache, actions, selectors, options) => {
             return;
         }
         const expired = queryState.expiresAt != null && queryState.expiresAt <= Date.now();
+        if (!fetchPolicy(expired, 
         // @ts-expect-error params
-        if (!fetchPolicy(expired, params, queryState, store, selectors)) {
+        params, queryState, store, selectors)) {
             logsEnabled &&
                 (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch due to fetch policy', {
                     queryState,
@@ -57,7 +57,7 @@ const useQuery = (cache, actions, selectors, options) => {
                 });
             return;
         }
-        fetch();
+        performFetch();
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [cacheKey, skipFetch]);
     logsEnabled &&
@@ -66,7 +66,7 @@ const useQuery = (cache, actions, selectors, options) => {
             options,
             queryState,
         });
-    return [queryState, fetch];
+    return [queryState, performFetch];
 };
 exports.useQuery = useQuery;
 /** Omit `expiresAt` from comparison */

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.13.0",
+  "version": "0.16.0-rc.0",
   "description": "Powerful data fetching and caching library that supports normalization, built on top of redux",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,12 +19,14 @@
   "peerDependencies": {
     "fast-deep-equal": "*",
     "react": "^16",
-    "react-redux": "^4",
-    "redux": "^4"
+    "react-redux": "^4"
   },
   "peerDependenciesMeta": {
     "fast-deep-equal": {
       "optional": true
+    },
+    "react-redux": {
+      "optional": true
     }
   },
   "devDependencies": {