react-redux-cache 0.0.10 → 0.0.12

package/README.md

@@ -1,10 +1,10 @@
 # react-redux-cache
 
-**Powerful** yet **lightweight** data fetching and caching library that supports **normalization** unlike `react-query` and `rtk-query`, while having similar interface. Built on top of `redux`.
+**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`, fully typed and written on Typescript. Can be considered as `ApolloClient` for protocols other than `GraphQL`.
 
-**Normalization** is the only 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**.
+**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**.
 
-Hooks, reducer, actions and selectors are fully typed and written on Typescript, so redux store will be properly typed and you will remain a **full control** of its state with ability to write custom selectors, actions and reducers to manage cached state.
+Remains **full control** of redux state with ability to write custom selectors, actions and reducers to manage cached state.
     
 Usage example can be found in `example/` folder and run by `npm run example` command from the root folder.
     
@@ -17,29 +17,36 @@ Usage example can be found in `example/` folder and run by `npm run example` com
    - [api.ts](https://github.com/gentlee/react-redux-cache#apits) 
  - [Usage](https://github.com/gentlee/react-redux-cache#usage)
  - [Advanced](https://github.com/gentlee/react-redux-cache#advanced)
+   - [resultSelector](https://github.com/gentlee/react-redux-cache#resultselector)
+   - [Infinite scroll pagination](https://github.com/gentlee/react-redux-cache#infinite-scroll-pagination)
    - [redux-persist](https://github.com/gentlee/react-redux-cache#redux-persist)
+ - [FAQ](https://github.com/gentlee/react-redux-cache#faq)
+   - [What is cache key?](https://github.com/gentlee/react-redux-cache#what-is-cache-key)
 
 ### Installation
-`react` and `redux` are peer dependencies.
+`react`, `redux` and `react-redux` are peer dependencies.
 ```sh
-npm add react-redux-cache react redux
+npm add react-redux-cache react redux react-redux
 ```
 ### Initialization
-Create reducer, hooks, actions and selectors with `createCache`.
-All queries and mutations should be passed while initializing the cache, for proper typing and later access by key.
-In this example we omit usage of actions and selectors.
+The only function that needs to be imported is `createCache`, which creates fully typed reducer, hooks, actions, selectors and utils to be used in the app.
+All typenames, queries and mutations should be passed while initializing the cache for proper typing.
 #### cache.ts
 ```typescript
 export const {
   reducer,
-  hooks: {useMutation, useQuery, useSelectEntityById},
+  hooks: {useClient, useMutation, useQuery, useSelectEntityById},
+  // Actions, selectors and utils may be not used at all
+  selectors: {entitiesSelector, entitiesByTypenameSelector},
+  actions: {setQueryStateAndEntities, setMutationStateAndEntities, mergeEntityChanges},
+  utils: {applyEntityChanges},
 } = createCache({
-  // This selector should select cache state from redux store state, based on the path to its reducer.
+  // This selector should return the cache state based on the path to its reducer.
   cacheStateSelector: (state) => state.cache,
-  // Typenames provide a mapping of all typenames to their entity types.
+  // Typenames provide a mapping of all typenames to their entity types, which is needed for normalization.
   // Empty objects with type casting can be used as values.
   typenames: {
-    users: {} as User,
+    users: {} as User, // here `users` entities will have type `User`
     banks: {} as Bank,
   },
   queries: {
@@ -54,6 +61,8 @@ export const {
 ```
 #### store.ts
 ```typescript
+// Create store as usual, passing the new cache reducer
+// under the key, previously used in cacheStateSelector
 const store = configureStore({
   reducer: {
     cache: reducer,
@@ -65,11 +74,16 @@ Query result should be of type `QueryResponse`, mutation result should be of typ
 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)
+
 export const getUser = async (id: number) => {
   const result = await ...
   
   const normalizedResult: {
+     // result is id of the user
     result: number
+    // entities contain all normalized objects 
     entities: {
       users: Record<number, User>
       banks: Record<string, Bank>
@@ -79,6 +93,15 @@ export const getUser = async (id: number) => {
   return normalizedResult
 }
 
+// Example of query without normalization (not recommended)
+
+export const getBank = (id: string) => {
+  const result: Bank = ...
+  return {result} // result is bank object, no entities passed
+}
+
+// Example of mutation with normalization
+
 export const removeUser = async (id: number) => {
   await ...
   return {
@@ -93,8 +116,8 @@ export const removeUser = async (id: number) => {
 export const UserScreen = () => {
   const {id} = useParams()
 
-  // useQuery will infer all types from created cache,
-  // telling you that params and result here are of type `number`.
+  // useQuery connects to redux state and if user with that id is already cached, fetch won't happen (with default cachePolicy 'cache-first')
+  // Infers all types from created cache, telling here that params and result are of type `number`.
   const [{result: userId, loading, error}] = useQuery({
     query: 'getUser',
     params: Number(id),
@@ -104,7 +127,7 @@ export const UserScreen = () => {
     mutation: 'updateUser',
   })
 
-  // This selector is created by createCache and also returns proper types - User and Bank
+  // This selector is used for denormalization and returns entities with proper types - User and Bank
   const user = useSelectEntityById(userId, 'users')
   const bank = useSelectEntityById(user?.bankId, 'banks')
 
@@ -117,6 +140,113 @@ export const UserScreen = () => {
 ```
 
 ### Advanced
+
+#### resultSelector
+
+By default result of a query is stored under its **cache key**, but sometimes it makes sense to take result from other queries or normalized entities.
+
+For example when single `User` entity is requested by `userId` for the first time, the entity can already be in the cache after `getUsers` query finished.
+
+For that case `resultSelector` can be used:
+
+```typescript
+
+// createCache
+
+... = createCache({
+  ...
+  queries: {
+    ...
+    getUser: {
+      query: getUser,
+      resultSelector: (state, id) => state.entities.users[id]?.id, // <-- Result is selected from cached entities
+    },
+  },
+})
+
+// component
+
+export const UserScreen = () => {
+  ...
+
+  // When screen mounts for the first time, query is not fetched
+  // and cached value is returned if user entity was already in the cache
+  const [{result, loading, error}] = useQuery({
+    query: 'getUser',
+    params: userId,
+  })
+
+  ...
+}
+
+```
+
+#### Infinite scroll pagination
+
+Here is an example of `getUsers` query configuration with pagination support. You can check full implementation in `/example` folder.
+
+```typescript
+// createCache
+
+...
+} = createCache({
+  ...
+  queries: {
+    getUsers: {
+      query: getUsers,
+      getCacheKey: () => 'all-pages', // single cache key is used for all pages
+      mergeResults: (oldResult, {result: newResult}) => {
+        if (!oldResult || newResult.page === 1) {
+          return newResult
+        }
+        if (newResult.page === oldResult.page + 1) {
+          return {
+            ...newResult,
+            items: [...oldResult.items, ...newResult.items],
+          }
+        }
+        return oldResult
+      },
+    },
+  },
+  ...
+})
+
+// Component
+
+export const GetUsersScreen = () => {
+  const {query} = useClient()
+
+  const [{result: usersResult, loading, error}, refetch] = useQuery({
+    query: 'getUsers',
+    params: 1 // page
+  })
+
+  const onLoadNextPage = () => {
+    const lastLoadedPage = usersResult?.page ?? 0
+    query({
+      query: 'getUsers',
+      params: lastLoadedPage + 1,
+    })
+  }
+
+  const renderUser = (userId: number) => (
+    <UserRow key={userId} userId={userId}>
+  )
+
+  ...
+
+  return (
+    <div>
+      {usersResult?.items.map(renderUser)}
+      <button onClick={refetch}>Refresh</button>
+      <button onClick={onLoadNextPage}>Load next page</button>
+    </div>
+  )
+}
+
+```
+
 #### redux-persist
 
 Here is a simple `redux-persist` configuration:
@@ -138,3 +268,28 @@ const persistedReducer = persistReducer(
   reducer
 )
 ```
+
+### FAQ
+
+#### What is cache key?
+
+**Cache key** is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
+
+Default implementation for `getCacheKey` is:
+```typescript
+export const defaultGetCacheKey = <P = unknown>(params: P): Key => {
+  switch (typeof params) {
+    case 'string':
+    case 'symbol':
+      return params
+    case 'object':
+      return JSON.stringify(params)
+    default:
+      return String(params)
+  }
+}
+```
+
+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.

package/dist/createCache.d.ts

@@ -1,7 +1,8 @@
 import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, MutationCacheOptions, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
+import { applyEntityChanges } from './utilsAndConstants';
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
@@ -64,7 +65,6 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
             mutate: <MK_1 extends keyof MP | keyof MR>(options: {
                 mutation: MK_1;
                 params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never;
-                cacheOptions?: MutationCacheOptions | undefined;
             }) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
         };
         /** Fetches query when params change and subscribes to query state. */
@@ -72,9 +72,11 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
         /** Subscribes to provided mutation state and provides mutate function. */
         useMutation: <MK_2 extends keyof MP | keyof MR>(options: {
             mutation: MK_2;
-            cacheOptions?: MutationCacheOptions | undefined;
         }) => readonly [(params: MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never) => Promise<void>, import("./types").QueryMutationState<MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never>, () => boolean];
         /** Selects entity by id and subscribes to the changes. */
         useSelectEntityById: <K_3 extends keyof T>(id: Key | null | undefined, typename: K_3) => T[K_3] | undefined;
     };
+    utils: {
+        applyEntityChanges: (entities: EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => EntitiesMap<T> | undefined;
+    };
 };

package/dist/createCache.js

@@ -13,23 +13,17 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
 const createCache = (cache) => {
-    var _a, _b, _c, _d, _e, _f;
-    var _g, _h, _j;
-    // @ts-expect-error hot
-    const hotReloadEnabled = Boolean(module === null || module === void 0 ? void 0 : module.hot);
+    var _a, _b, _c, _d, _e;
+    var _f, _g;
+    const abortControllers = new WeakMap();
     // provide all optional fields
-    // and transform cacheOptions from QueryCachePolicy to QueryCacheOptions
     (_a = cache.options) !== null && _a !== void 0 ? _a : (cache.options = {});
-    (_b = (_g = cache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_g.logsEnabled = false);
-    (_c = (_h = cache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_h.validateFunctionArguments = utilsAndConstants_1.isDev);
-    (_d = (_j = cache.options).validateHookArguments) !== null && _d !== void 0 ? _d : (_j.validateHookArguments = utilsAndConstants_1.isDev && !hotReloadEnabled);
-    (_e = cache.queries) !== null && _e !== void 0 ? _e : (cache.queries = {});
-    (_f = cache.mutations) !== null && _f !== void 0 ? _f : (cache.mutations = {});
-    for (const queryInfo of Object.values(cache.queries)) {
-        if (typeof queryInfo.cacheOptions === 'string') {
-            queryInfo.cacheOptions = useQuery_1.queryCacheOptionsByPolicy[queryInfo.cacheOptions];
-        }
-    }
+    (_b = (_f = cache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_f.logsEnabled = false);
+    (_c = (_g = cache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_g.validateFunctionArguments = utilsAndConstants_1.isDev);
+    (_d = cache.queries) !== null && _d !== void 0 ? _d : (cache.queries = {});
+    (_e = cache.mutations) !== null && _e !== void 0 ? _e : (cache.mutations = {});
+    // @ts-expect-error for testing
+    cache.abortControllers = abortControllers;
     const nonPartialCache = cache;
     // make selectors
     const entitiesSelector = (state) => {
@@ -64,24 +58,15 @@ const createCache = (cache) => {
                 return (0, react_1.useMemo)(() => {
                     const client = {
                         query: (options) => {
-                            var _a, _b;
-                            const { query: queryKey, params, 
-                            // TODO can be memoized for all query keys while creating cache
-                            cacheOptions: cacheOptionsOrPolicy = Object.assign(Object.assign({}, ((_a = nonPartialCache.queries[queryKey].cacheOptions) !== null && _a !== void 0 ? _a : useQuery_1.defaultQueryCacheOptions)), { policy: 'cache-and-fetch' }), getCacheKey = nonPartialCache.queries[queryKey].getCacheKey, } = options;
-                            const cacheOptions = typeof cacheOptionsOrPolicy === 'string'
-                                ? useQuery_1.queryCacheOptionsByPolicy[cacheOptionsOrPolicy]
-                                : cacheOptionsOrPolicy;
-                            const getParamsKey = (_b = nonPartialCache.queries[queryKey].getParamsKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetParamsKey);
-                            const cacheKey = getCacheKey
-                                ? // @ts-expect-error fix later
-                                    getCacheKey(params)
-                                : // @ts-expect-error fix later
-                                    getParamsKey(params);
-                            return (0, query_1.query)('query', true, store, nonPartialCache, queryKey, cacheKey, cacheOptions, params);
+                            var _a;
+                            const { query: queryKey, params } = options;
+                            const getCacheKey = (_a = nonPartialCache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
+                            // @ts-expect-error fix later
+                            const cacheKey = getCacheKey(params);
+                            return (0, query_1.query)('query', true, store, nonPartialCache, queryKey, cacheKey, params);
                         },
                         mutate: (options) => {
-                            var _a;
-                            return (0, mutate_1.mutate)('mutate', true, store, nonPartialCache, options.mutation, (_a = options.cacheOptions) !== null && _a !== void 0 ? _a : useMutation_1.defaultMutationCacheOptions, options.params);
+                            return (0, mutate_1.mutate)('mutate', true, store, nonPartialCache, options.mutation, options.params, abortControllers);
                         },
                     };
                     return client;
@@ -90,12 +75,17 @@ const createCache = (cache) => {
             /** Fetches query when params change and subscribes to query state. */
             useQuery: (options) => (0, useQuery_1.useQuery)(nonPartialCache, options),
             /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: (options) => (0, useMutation_1.useMutation)(nonPartialCache, options),
+            useMutation: (options) => (0, useMutation_1.useMutation)(nonPartialCache, options, abortControllers),
             /** Selects entity by id and subscribes to the changes. */
             useSelectEntityById: (id, typename) => {
                 return (0, react_redux_1.useSelector)((state) => id == null ? undefined : nonPartialCache.cacheStateSelector(state).entities[typename][id]);
             },
         },
+        utils: {
+            applyEntityChanges: (entities, changes) => {
+                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, nonPartialCache.options);
+            },
+        },
     };
 };
 exports.createCache = createCache;

package/dist/index.d.ts

@@ -1,6 +1,4 @@
 export { createCache } from './createCache';
 export type { ReduxCacheState } from './reducer';
 export * from './types';
-export { defaultMutationCacheOptions } from './useMutation';
-export { defaultQueryCacheOptions, queryCacheOptionsByPolicy } from './useQuery';
-export { defaultCacheOptions, defaultGetParamsKey, defaultQueryMutationState, processEntityChanges, } from './utilsAndConstants';
+export { defaultGetCacheKey, defaultQueryMutationState } from './utilsAndConstants';

package/dist/index.js

@@ -14,26 +14,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processEntityChanges = exports.defaultQueryMutationState = exports.defaultGetParamsKey = exports.defaultCacheOptions = exports.queryCacheOptionsByPolicy = exports.defaultQueryCacheOptions = exports.defaultMutationCacheOptions = exports.createCache = void 0;
+exports.defaultQueryMutationState = exports.defaultGetCacheKey = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
 __exportStar(require("./types"), exports);
-var useMutation_1 = require("./useMutation");
-Object.defineProperty(exports, "defaultMutationCacheOptions", { enumerable: true, get: function () { return useMutation_1.defaultMutationCacheOptions; } });
-var useQuery_1 = require("./useQuery");
-Object.defineProperty(exports, "defaultQueryCacheOptions", { enumerable: true, get: function () { return useQuery_1.defaultQueryCacheOptions; } });
-Object.defineProperty(exports, "queryCacheOptionsByPolicy", { enumerable: true, get: function () { return useQuery_1.queryCacheOptionsByPolicy; } });
 var utilsAndConstants_1 = require("./utilsAndConstants");
-Object.defineProperty(exports, "defaultCacheOptions", { enumerable: true, get: function () { return utilsAndConstants_1.defaultCacheOptions; } });
-Object.defineProperty(exports, "defaultGetParamsKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetParamsKey; } });
+Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
 Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.defaultQueryMutationState; } });
-Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get: function () { return utilsAndConstants_1.processEntityChanges; } });
 // Backlog
 // ! high
-// mutate
 // cover with tests
-// suport persist (no loading etc)
 // ! medium
+// allow multiple mutation with sam keys?
 // type extractors from cache
 // custom useStore
 // return back deserialize selector?

package/dist/mutate.d.ts

@@ -1,5 +1,3 @@
 import { Store } from 'redux';
-import { Cache, Key, MutationCacheOptions, MutationResult, Typenames } from './types';
-export declare const abortControllers: WeakMap<Store<any, import("redux").AnyAction>, Record<Key, AbortController>>;
-export declare const getAbortController: (store: Store, mutationKey: Key) => AbortController | undefined;
-export declare const mutate: <T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, mutationKey: MK, cacheOptions: MutationCacheOptions, params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void | MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
+import { Cache, Key, MutationResult, Typenames } from './types';
+export declare const mutate: <T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => Promise<void | MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;

package/dist/mutate.js

@@ -9,17 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mutate = exports.getAbortController = exports.abortControllers = void 0;
+exports.mutate = void 0;
 const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-exports.abortControllers = new WeakMap();
-const getAbortController = (store, mutationKey) => { var _a; return (_a = exports.abortControllers.get(store)) === null || _a === void 0 ? void 0 : _a[mutationKey]; };
-exports.getAbortController = getAbortController;
-const mutate = (logTag, returnResult, store, cache, mutationKey, cacheOptions, params) => __awaiter(void 0, void 0, void 0, function* () {
-    let abortControllersOfStore = exports.abortControllers.get(store);
+const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
+    let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
-        exports.abortControllers.set(store, abortControllersOfStore);
+        abortControllers.set(store, abortControllersOfStore);
     }
     {
         const abortController = abortControllersOfStore[mutationKey];
@@ -33,11 +30,10 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, cacheOptions, p
             abortController.abort();
         }
         else {
-            cacheOptions.cacheMutationState &&
-                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
-                    loading: true,
-                    result: undefined,
-                }));
+            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                loading: true,
+                result: undefined,
+            }));
         }
     }
     const abortController = new AbortController();
@@ -64,23 +60,19 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, cacheOptions, p
     }
     delete abortControllersOfStore[mutationKey];
     if (error) {
-        if (cacheOptions.cacheMutationState) {
-            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
-                error: error,
-                loading: false,
-            }));
-        }
+        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+            error: error,
+            loading: false,
+        }));
         return { error };
     }
     if (response) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, cacheOptions.cacheMutationState
-            ? {
-                error: undefined,
-                loading: false,
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                result: response.result,
-            }
-            : undefined, cacheOptions.cacheEntities ? response : undefined));
+        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+            error: undefined,
+            loading: false,
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            result: response.result,
+        }, response));
         // @ts-expect-error fix later
         return returnResult ? { result: response.result } : undefined;
     }

package/dist/query.d.ts

@@ -1,3 +1,3 @@
 import { Store } from 'redux';
-import { Cache, Key, QueryCacheOptions, QueryResult, Typenames } from './types';
-export declare const query: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, cacheOptions: QueryCacheOptions, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<void | QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+import { Cache, Key, QueryResult, Typenames } from './types';
+export declare const query: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<void | QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const query = (logTag, returnResult, store, cache, queryKey, cacheKey, cacheOptions, params) => __awaiter(void 0, void 0, void 0, function* () {
+const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const logsEnabled = cache.options.logsEnabled;
     const cacheStateSelector = cache.cacheStateSelector;
@@ -28,10 +28,9 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, cacheOpti
             });
         return returnResult ? { cancelled: true } : undefined;
     }
-    cacheOptions.cacheQueryState &&
-        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
-            loading: true,
-        }));
+    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+        loading: true,
+    }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
     let response;
     const fetchFn = cache.queries[queryKey].query;
@@ -47,20 +46,18 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, cacheOpti
         }));
         return returnResult ? { error } : undefined;
     }
-    const newState = cacheOptions.cacheQueryState
-        ? {
-            error: undefined,
-            loading: false,
-            result: cacheResultSelector
-                ? undefined
-                : mergeResults
-                    ? mergeResults(
-                    // @ts-expect-error fix later
-                    (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params)
-                    : response.result,
-        }
-        : undefined;
-    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, cacheOptions.cacheEntities ? response : undefined));
+    const newState = {
+        error: undefined,
+        loading: false,
+        result: cacheResultSelector
+            ? undefined
+            : mergeResults
+                ? mergeResults(
+                // @ts-expect-error fix later
+                (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params)
+                : response.result,
+    };
+    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, response));
     // @ts-expect-error fix types
     return returnResult
         ? {

package/dist/reducer.js

@@ -28,7 +28,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
         switch (action.type) {
             case '@RRC/SET_QUERY_STATE_AND_ENTITIES': {
                 const { queryKey, queryCacheKey, state: queryState, entityChagnes } = action;
-                const newEntities = entityChagnes && (0, utilsAndConstants_1.processEntityChanges)(state.entities, entityChagnes, cacheOptions);
+                const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!queryState && !newEntities) {
                     return state;
                 }
@@ -36,7 +36,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
             }
             case '@RRC/SET_MUTATION_STATE_AND_ENTITIES': {
                 const { mutationKey, state: mutationState, entityChagnes } = action;
-                const newEntities = entityChagnes && (0, utilsAndConstants_1.processEntityChanges)(state.entities, entityChagnes, cacheOptions);
+                const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!mutationState && !newEntities) {
                     return state;
                 }
@@ -44,7 +44,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
             }
             case '@RRC/MERGE_ENTITY_CHANGES': {
                 const { changes } = action;
-                const newEntities = (0, utilsAndConstants_1.processEntityChanges)(state.entities, changes, cacheOptions);
+                const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions);
                 return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
             }
         }

package/dist/types.d.ts

@@ -35,12 +35,6 @@ export type CacheOptions = {
      * Default is true in dev mode.
      * */
     validateFunctionArguments: boolean;
-    /**
-     * Enables validation of package hook arguments. Recommened to enable in dev/testing mode and disable in production.
-     * Should be disabled with hot reloading.
-     * Default is true in dev mode without hot reloading.
-     * */
-    validateHookArguments: boolean;
     /**
      * Enable console logs.
      * Default is false.
@@ -60,12 +54,10 @@ export type Query<T extends Typenames, P, R> = (params: P) => Promise<QueryRespo
 export type QueryInfo<T extends Typenames, P, R, S> = {
     query: Query<T, P, R>;
     /**
-     * Cache policy string or cache options object. After cache created, all strings are converted to objects.
-     * Default is { policy: 'cache-first', cacheQueryState: true, cacheEntities: true }
-     * @param cache-first for each params key fetch is not called if cache exists.
-     * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
+     * Cache policy.
+     * @default cache-first
      */
-    cacheOptions?: QueryCacheOptions | QueryCachePolicy;
+    cachePolicy?: QueryCachePolicy;
     /**
      * Selector for query result from redux state.
      * Can prevent hook from doing unnecessary fetches.
@@ -75,15 +67,9 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
     /** Merges results before saving to the store. */
     mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined) => R;
     /**
-     * Params key is used for determining if parameters were changed and fetch is needed.
-     * Also used as cache key, of `getCacheKey` wasn't provided.
+     * Cache key is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
      * Default implementation uses `JSON.stringify` or `String()` depending on type.
-     * */
-    getParamsKey?: (params?: P) => Key;
-    /**
-     * Cache key is a key in redux state for caching query state.
-     * Queries with equal cache keys have the same state.
-     * Default implementation is equal to `getParamsKey`.
+     * It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order etc.
      * */
     getCacheKey?: (params?: P) => Key;
 };
@@ -91,23 +77,12 @@ export type UseQueryOptions<T extends Typenames, QP, QR, MP, MR, QK extends keyo
     query: QK;
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
     skip?: boolean;
-} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QP, QR, MP, MR>> : never, 'cacheOptions' | 'mergeResults' | 'getCacheKey'>;
+} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QP, QR, MP, MR>> : never, 'cachePolicy' | 'mergeResults' | 'getCacheKey'>;
 /**
  * @param cache-first for each params key fetch is not called if cache exists.
  * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
  */
 export type QueryCachePolicy = 'cache-first' | 'cache-and-fetch';
-export type QueryCacheOptions = {
-    /**
-     * @param cache-first for each params key fetch is not called if cache exists.
-     * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
-     */
-    policy: QueryCachePolicy;
-    /** If `false`, query state is not saved in the store. Default is `true`. */
-    cacheQueryState: boolean;
-    /** If `false`, entities from response are not saved to the store. Default is `true`. */
-    cacheEntities: boolean;
-};
 export type QueryResponse<T extends Typenames, R> = EntityChanges<T> & {
     /** Normalized result of a query. */
     result: R;
@@ -123,11 +98,6 @@ export type Mutation<T extends Typenames, P, R> = (params: P,
 abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;
 export type MutationInfo<T extends Typenames, P, R> = {
     mutation: Mutation<T, P, R>;
-    cacheOptions?: MutationCacheOptions;
-};
-export type MutationCacheOptions = Pick<QueryCacheOptions, 'cacheEntities'> & {
-    /** If `false`, mutation state is not saved in the store. Default is `true`. */
-    cacheMutationState: boolean;
 };
 export type MutationResponse<T extends Typenames, R> = EntityChanges<T> & {
     /** Normalized result of a mutation. */

package/dist/useMutation.d.ts

@@ -1,6 +1,5 @@
-import { Cache, MutationCacheOptions, QueryMutationState, Typenames } from './types';
-export declare const defaultMutationCacheOptions: MutationCacheOptions;
+import { Store } from 'redux';
+import { Cache, Key, QueryMutationState, Typenames } from './types';
 export declare const useMutation: <T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<T, unknown, unknown, MP, MR>, options: {
     mutation: MK;
-    cacheOptions?: MutationCacheOptions | undefined;
-}) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+}, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -9,36 +9,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMutation = exports.defaultMutationCacheOptions = void 0;
+exports.useMutation = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const mutate_1 = require("./mutate");
 const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-exports.defaultMutationCacheOptions = {
-    cacheMutationState: true,
-    cacheEntities: true,
-};
-const useMutation = (cache, options) => {
-    var _a, _b;
-    const { mutation: mutationKey, cacheOptions = (_a = cache.mutations[mutationKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.defaultMutationCacheOptions, } = options;
-    // Check values that should be set once.
-    // Can be removed from deps.
-    cache.options.validateHookArguments &&
-        (() => {
-            ;
-            [
-                ['cache', cache],
-                ['cache.options', cache.options],
-                ['cache.options.logsEnabled', cache.options.logsEnabled],
-                ['cacheStateSelector', cache.cacheStateSelector],
-                ['mutationKey', mutationKey],
-                ['cacheOptions.cacheEntities', cacheOptions.cacheEntities],
-                ['cacheOptions.cacheMutationState', cacheOptions.cacheMutationState],
-            ]
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
-        })();
+const useMutation = (cache, options, abortControllers) => {
+    var _a;
+    const { mutation: mutationKey } = options;
     const store = (0, react_redux_1.useStore)();
     // Using single useMemo for performance reasons
     const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
@@ -54,27 +33,26 @@ const useMutation = (cache, options) => {
             },
             // mutate
             (params) => __awaiter(void 0, void 0, void 0, function* () {
-                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, mutationKey, cacheOptions, params);
+                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, mutationKey, params, abortControllers);
             }),
             // abort
             () => {
-                const abortController = (0, mutate_1.getAbortController)(store, mutationKey);
+                var _a;
+                const abortController = (_a = abortControllers.get(store)) === null || _a === void 0 ? void 0 : _a[mutationKey];
                 if (abortController === undefined || abortController.signal.aborted) {
                     return false;
                 }
                 abortController.abort();
-                cacheOptions.cacheMutationState &&
-                    store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
-                        loading: false,
-                    }));
+                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                    loading: false,
+                }));
                 return true;
             },
         ];
-    }, 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [store, cacheOptions.cacheEntities, cacheOptions.cacheMutationState]);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [mutationKey, store]);
     // @ts-expect-error fix later
-    const mutationState = (_b = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultQueryMutationState;
+    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.defaultQueryMutationState;
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
             options,

package/dist/useQuery.d.ts

@@ -1,8 +1,2 @@
-import { Cache, QueryCacheOptions, QueryCachePolicy, QueryMutationState, Typenames, UseQueryOptions } from './types';
-export declare const queryCacheOptionsByPolicy: Record<QueryCachePolicy, QueryCacheOptions>;
-export declare const defaultQueryCacheOptions: {
-    readonly policy: "cache-first";
-    readonly cacheQueryState: true;
-    readonly cacheEntities: true;
-};
+import { Cache, QueryMutationState, Typenames, UseQueryOptions } from './types';
 export declare const useQuery: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<void>];

package/dist/useQuery.js

@@ -9,84 +9,34 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useQuery = exports.defaultQueryCacheOptions = exports.queryCacheOptionsByPolicy = void 0;
+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 cacheFirstOptions = {
-    policy: 'cache-first',
-    cacheQueryState: true,
-    cacheEntities: true,
-};
-exports.queryCacheOptionsByPolicy = {
-    'cache-first': cacheFirstOptions,
-    'cache-and-fetch': Object.assign(Object.assign({}, cacheFirstOptions), { policy: 'cache-and-fetch' }),
-};
-exports.defaultQueryCacheOptions = cacheFirstOptions;
 const useQuery = (cache, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, cacheOptions: cacheOptionsOrPolicy = (_a = cache.queries[queryKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.defaultQueryCacheOptions, getCacheKey = cache.queries[queryKey].getCacheKey, } = options;
+    const { query: queryKey, skip, params, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey), } = options;
     const logsEnabled = cache.options.logsEnabled;
-    const getParamsKey = (_b = cache.queries[queryKey].getParamsKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetParamsKey);
     const cacheResultSelector = cache.queries[queryKey].resultSelector;
     const cacheStateSelector = cache.cacheStateSelector;
-    const cacheOptions = typeof cacheOptionsOrPolicy === 'string'
-        ? exports.queryCacheOptionsByPolicy[cacheOptionsOrPolicy]
-        : cacheOptionsOrPolicy;
     const store = (0, react_redux_1.useStore)();
-    // Check values that should be set once.
-    cache.options.validateHookArguments &&
-        (() => {
-            ;
-            [
-                ['store', store],
-                ['cache', cache],
-                ['cache.queries', cache.queries],
-                ['cacheStateSelector', cache.cacheStateSelector],
-                ['cacheOptions.cacheEntities', cacheOptions.cacheEntities],
-                ['cacheOptions.cacheQueryState', cacheOptions.cacheQueryState],
-                ['options.query', options.query],
-                ['queryKey', queryKey],
-                ['resultSelector', cache.queries[queryKey].resultSelector],
-                ['mergeResults', cache.queries[queryKey].mergeResults],
-                ['getParamsKey', cache.queries[queryKey].getParamsKey],
-                ['getCacheKey', cache.queries[queryKey].getCacheKey],
-            ]
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
-        })();
-    const paramsKey = getParamsKey(
-    // @ts-expect-error fix later
-    params);
-    const [cacheKey, resultSelector] = (0, react_1.useMemo)(() => {
-        return [
-            // cacheKey
-            getCacheKey
-                ? // @ts-expect-error fix types later
-                    getCacheKey(params)
-                : paramsKey,
-            // resultSelector
-            cacheResultSelector &&
-                ((state) => cacheResultSelector(cacheStateSelector(state), 
-                // @ts-expect-error fix types later
-                params)),
-        ];
+    // @ts-expect-error fix types later
+    const cacheKey = getCacheKey(params);
+    const resultSelector = (0, react_1.useMemo)(() => {
+        return (cacheResultSelector &&
+            ((state) => cacheResultSelector(cacheStateSelector(state), 
+            // @ts-expect-error fix types later
+            params)));
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [paramsKey]);
+    }, [cacheKey]);
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const resultFromSelector = (resultSelector && (0, react_redux_1.useSelector)(resultSelector));
     const hasResultFromSelector = resultFromSelector !== undefined;
     const fetch = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-        yield (0, query_1.query)('useQuery.fetch', false, store, cache, queryKey, cacheKey, cacheOptions, params);
+        yield (0, query_1.query)('useQuery.fetch', false, store, cache, queryKey, cacheKey, params);
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }), [
-        cacheKey,
-        paramsKey,
-        cacheOptions.policy,
-        cacheOptions.cacheEntities,
-        cacheOptions.cacheQueryState,
-    ]);
+    }), [store, queryKey, cacheKey]);
     const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
@@ -96,23 +46,22 @@ const useQuery = (cache, options) => {
         : queryStateFromSelector;
     (0, react_1.useEffect)(() => {
         if (skip) {
-            logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skip, paramsKey });
+            logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skip, cacheKey });
             return;
         }
-        if (queryState.result != null && cacheOptions.policy === 'cache-first') {
+        if (queryState.result != null && cachePolicy === 'cache-first') {
             logsEnabled &&
                 (0, utilsAndConstants_1.log)('useQuery.useEffect don`t fetch due to cache policy', {
                     result: queryState.result,
-                    policy: cacheOptions.policy,
+                    cachePolicy,
                 });
             return;
         }
         fetch();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [paramsKey, cacheOptions.policy, skip]);
+    }, [cacheKey, cachePolicy, skip]);
     logsEnabled &&
         (0, utilsAndConstants_1.log)('useQuery', {
-            paramsKey,
             cacheKey,
             options,
             resultFromSelector,

package/dist/utilsAndConstants.d.ts

@@ -1,20 +1,14 @@
-import { CacheOptions, EntitiesMap, EntityChanges, Typenames } from './types';
+import { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "RRC";
 export declare const isDev: boolean;
-export declare const defaultCacheOptions: {
-    logsEnabled: boolean;
-    validateFunctionArguments: boolean;
-    validateHookArguments: boolean;
-};
 export declare const defaultQueryMutationState: {
     readonly loading: false;
     readonly error: undefined;
 };
-export declare const defaultGetParamsKey: <P = unknown>(params: P) => string;
-export declare const useAssertValueNotChanged: (name: string, value: unknown) => void;
+export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key;
 export declare const log: (tag: string, data?: unknown) => void;
 /**
- * Process changes to entities map.
- * @return `undefined` if nothing to change, otherwise processed entities map.
+ * Apply changes to the entities map.
+ * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
  */
-export declare const processEntityChanges: <T extends Typenames>(entities: EntitiesMap<T>, changes: EntityChanges<T>, options: CacheOptions) => EntitiesMap<T> | undefined;
+export declare const applyEntityChanges: <T extends Typenames>(entities: EntitiesMap<T>, changes: EntityChanges<T>, options: CacheOptions) => EntitiesMap<T> | undefined;

package/dist/utilsAndConstants.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.defaultGetParamsKey = exports.defaultQueryMutationState = exports.defaultCacheOptions = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
-const react_1 = require("react");
+exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.defaultQueryMutationState = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'RRC';
 exports.isDev = (() => {
     try {
@@ -12,15 +11,11 @@ exports.isDev = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.defaultCacheOptions = {
-    logsEnabled: false,
-    validateFunctionArguments: true,
-    validateHookArguments: true,
-};
 exports.defaultQueryMutationState = { loading: false, error: undefined };
-const defaultGetParamsKey = (params) => {
+const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':
+        case 'symbol':
             return params;
         case 'object':
             return JSON.stringify(params);
@@ -28,27 +23,16 @@ const defaultGetParamsKey = (params) => {
             return String(params);
     }
 };
-exports.defaultGetParamsKey = defaultGetParamsKey;
-const useAssertValueNotChanged = (name, value) => {
-    const firstMountRef = (0, react_1.useRef)(false);
-    (0, react_1.useMemo)(() => {
-        if (firstMountRef.current) {
-            throw new Error(`${name} should not be modified`);
-        }
-        firstMountRef.current = true;
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [value]);
-};
-exports.useAssertValueNotChanged = useAssertValueNotChanged;
+exports.defaultGetCacheKey = defaultGetCacheKey;
 const log = (tag, data) => {
     console.debug(`@${exports.PACKAGE_SHORT_NAME} [${tag}]`, data);
 };
 exports.log = log;
 /**
- * Process changes to entities map.
- * @return `undefined` if nothing to change, otherwise processed entities map.
+ * Apply changes to the entities map.
+ * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
  */
-const processEntityChanges = (entities, changes, options) => {
+const applyEntityChanges = (entities, changes, options) => {
     var _a, _b, _c;
     if (options.validateFunctionArguments) {
         // check for merge and entities both set
@@ -99,11 +83,11 @@ const processEntityChanges = (entities, changes, options) => {
         result[typename] = newEntities;
     }
     options.logsEnabled &&
-        (0, exports.log)('processEntityChanges', {
+        (0, exports.log)('applyEntityChanges', {
             entities,
             changes,
             result,
         });
     return result;
 };
-exports.processEntityChanges = processEntityChanges;
+exports.applyEntityChanges = applyEntityChanges;

package/package.json

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