react-redux-cache 0.0.11 → 0.1.1

package/README.md

@@ -6,8 +6,6 @@
 
 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.
-    
 ### Table of contents
 
  - [Installation](https://github.com/gentlee/react-redux-cache#Installation)
@@ -17,8 +15,12 @@ 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 a query cache key?](https://github.com/gentlee/react-redux-cache#what-is-a-query-cache-key)
+   - [How mutation fetching differs from queries?](https://github.com/gentlee/react-redux-cache#how-mutation-fetching-differs-from-queries)
 
 ### Installation
 `react`, `redux` and `react-redux` are peer dependencies.
@@ -26,7 +28,7 @@ Usage example can be found in `example/` folder and run by `npm run example` com
 npm add react-redux-cache react redux react-redux
 ```
 ### Initialization
-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.
+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. Only **single** cache reducer per store is supported currenlty.
 All typenames, queries and mutations should be passed while initializing the cache for proper typing.
 #### cache.ts
 ```typescript
@@ -35,7 +37,7 @@ export const {
   hooks: {useClient, useMutation, useQuery, useSelectEntityById},
   // Actions, selectors and utils may be not used at all
   selectors: {entitiesSelector, entitiesByTypenameSelector},
-  actions: {setQueryStateAndEntities, setMutationStateAndEntities, mergeEntityChanges},
+  actions: {updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges},
   utils: {applyEntityChanges},
 } = createCache({
   // This selector should return the cache state based on the path to its reducer.
@@ -108,6 +110,9 @@ export const removeUser = async (id: number) => {
 ```
 
 ### Usage
+
+Please check `example/` folder (`npm run example` to run).
+
 #### UserScreen.tsx
 ```typescript
 export const UserScreen = () => {
@@ -138,6 +143,46 @@ 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.
@@ -225,3 +270,34 @@ const persistedReducer = persistReducer(
   reducer
 )
 ```
+
+### FAQ
+
+#### What is a query 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.
+
+#### How mutation fetching differs from queries?
+
+**Queries:** For each cache key (= unique params by default) of each query fetch is running in parallel. If fetch is already running for specific cache key, all next fetches are cancelled until it finishes.
+
+**Mutations:** Only one mutation can be run for each mutation key at a time. If another one called, previous is aborted.

package/dist/actions.d.ts

@@ -0,0 +1,32 @@
+import type { EntityChanges, Key, QueryMutationState, Typenames } from './types';
+export declare const updateQueryStateAndEntities: <T extends Typenames, QR, K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
+    type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
+    queryKey: K;
+    queryCacheKey: Key;
+    state: Partial<QueryMutationState<QR[K]>> | undefined;
+    entityChagnes: EntityChanges<T> | undefined;
+};
+export declare const updateMutationStateAndEntities: <T extends Typenames, MR, K extends keyof MR>(mutationKey: K, state?: Partial<QueryMutationState<MR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
+    type: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
+    mutationKey: K;
+    state: Partial<QueryMutationState<MR[K]>> | undefined;
+    entityChagnes: EntityChanges<T> | undefined;
+};
+export declare const mergeEntityChanges: <T extends Typenames>(changes: EntityChanges<T>) => {
+    type: `${string}MERGE_ENTITY_CHANGES`;
+    changes: EntityChanges<T>;
+};
+export declare const clearQueryState: <QR, K extends keyof QR>(queryKeys: {
+    key: K;
+    cacheKey?: Key | undefined;
+}[]) => {
+    type: `${string}CLEAR_QUERY_STATE`;
+    queryKeys: {
+        key: K;
+        cacheKey?: Key | undefined;
+    }[];
+};
+export declare const clearMutationState: <MR, K extends keyof MR>(mutationKeys: K[]) => {
+    type: `${string}CLEAR_MUTATION_STATE`;
+    mutationKeys: K[];
+};

package/dist/actions.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearMutationState = exports.clearQueryState = exports.mergeEntityChanges = exports.updateMutationStateAndEntities = exports.updateQueryStateAndEntities = void 0;
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const ACTION_PREFIX = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/`;
+const updateQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
+    type: `${ACTION_PREFIX}UPDATE_QUERY_STATE_AND_ENTITIES`,
+    queryKey,
+    queryCacheKey,
+    state,
+    entityChagnes,
+});
+exports.updateQueryStateAndEntities = updateQueryStateAndEntities;
+const updateMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
+    type: `${ACTION_PREFIX}UPDATE_MUTATION_STATE_AND_ENTITIES`,
+    mutationKey,
+    state,
+    entityChagnes,
+});
+exports.updateMutationStateAndEntities = updateMutationStateAndEntities;
+const mergeEntityChanges = (changes) => ({
+    type: `${ACTION_PREFIX}MERGE_ENTITY_CHANGES`,
+    changes,
+});
+exports.mergeEntityChanges = mergeEntityChanges;
+const clearQueryState = (queryKeys) => ({
+    type: `${ACTION_PREFIX}CLEAR_QUERY_STATE`,
+    queryKeys,
+});
+exports.clearQueryState = clearQueryState;
+const clearMutationState = (mutationKeys) => ({
+    type: `${ACTION_PREFIX}CLEAR_MUTATION_STATE`,
+    mutationKeys,
+});
+exports.clearMutationState = clearMutationState;

package/dist/createCache.d.ts

@@ -1,12 +1,12 @@
-import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import { clearMutationState, clearQueryState, mergeEntityChanges, updateMutationStateAndEntities, updateQueryStateAndEntities } from './actions';
+import type { 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.
  */
-export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: OptionalPartial<Cache<T, QP, QR, MP, MR>, "queries" | "mutations" | "options">) => {
+export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<T, QP, QR, MP, MR>, "queries" | "mutations" | "options">) => {
     cache: Cache<T, QP, QR, MP, MR>;
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
@@ -17,16 +17,25 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
         type: `${string}MERGE_ENTITY_CHANGES`;
         changes: import("./types").EntityChanges<T>;
     } | {
-        type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+        type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
         queryKey: keyof QR;
         queryCacheKey: Key;
         state: Partial<import("./types").QueryMutationState<QR[keyof QR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
-        type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+        type: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
         mutationKey: keyof MR;
         state: Partial<import("./types").QueryMutationState<MR[keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
+    } | {
+        type: `${string}CLEAR_QUERY_STATE`;
+        queryKeys: {
+            key: keyof QR;
+            cacheKey?: Key | undefined;
+        }[];
+    } | {
+        type: `${string}CLEAR_MUTATION_STATE`;
+        mutationKeys: (keyof MR)[];
     }) => {
         entities: EntitiesMap<T>;
         queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
@@ -34,16 +43,16 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
     };
     actions: {
         /** Updates query state, and optionally merges entity changes in a single action. */
-        setQueryStateAndEntities: <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
-            type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+        updateQueryStateAndEntities: <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
+            type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
             queryKey: K;
             queryCacheKey: Key;
             state: Partial<import("./types").QueryMutationState<QR[K]>> | undefined;
             entityChagnes: import("./types").EntityChanges<T> | undefined;
         };
         /** Updates mutation state, and optionally merges entity changes in a single action. */
-        setMutationStateAndEntities: <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
-            type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+        updateMutationStateAndEntities: <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
+            type: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
             mutationKey: K_1;
             state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
             entityChagnes: import("./types").EntityChanges<T> | undefined;
@@ -53,10 +62,29 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
             type: `${string}MERGE_ENTITY_CHANGES`;
             changes: import("./types").EntityChanges<T>;
         };
+        /** Clear 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_2 extends keyof QR>(queryKeys: {
+            key: K_2;
+            cacheKey?: Key | undefined;
+        }[]) => {
+            type: `${string}CLEAR_QUERY_STATE`;
+            queryKeys: {
+                key: K_2;
+                cacheKey?: Key | undefined;
+            }[];
+        };
+        /** Clear states for provided mutation keys. */
+        clearMutationState: <K_3 extends keyof MR>(mutationKeys: K_3[]) => {
+            type: `${string}CLEAR_MUTATION_STATE`;
+            mutationKeys: K_3[];
+        };
     };
     selectors: {
+        /** Select all entities from the state. */
         entitiesSelector: (state: unknown) => EntitiesMap<T>;
-        entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_2 in keyof T]: (state: unknown) => EntitiesMap<T>[K_2]; }[TN];
+        /** Select all entities of provided typename. */
+        entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_4 in keyof T]: (state: unknown) => EntitiesMap<T>[K_4]; }[TN];
     };
     hooks: {
         /** Returns client object with query function */
@@ -74,7 +102,7 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
             mutation: MK_2;
         }) => 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;
+        useSelectEntityById: <K_5 extends keyof T>(id: Key | null | undefined, typename: K_5) => T[K_5] | undefined;
     };
     utils: {
         applyEntityChanges: (entities: EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => EntitiesMap<T> | undefined;

package/dist/createCache.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const actions_1 = require("./actions");
 const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const reducer_1 = require("./reducer");
@@ -12,44 +13,48 @@ 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);
+const createCache = (partialCache) => {
+    var _a, _b, _c, _d, _e;
+    var _f, _g;
     const abortControllers = new WeakMap();
     // provide all optional fields
-    (_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 = {});
+    (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
+    (_b = (_f = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_f.logsEnabled = false);
+    (_c = (_g = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_g.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
+    (_d = partialCache.queries) !== null && _d !== void 0 ? _d : (partialCache.queries = {});
+    (_e = partialCache.mutations) !== null && _e !== void 0 ? _e : (partialCache.mutations = {});
     // @ts-expect-error for testing
-    cache.abortControllers = abortControllers;
-    const nonPartialCache = cache;
+    partialCache.abortControllers = abortControllers;
+    const cache = partialCache;
     // make selectors
     const entitiesSelector = (state) => {
-        return nonPartialCache.cacheStateSelector(state).entities;
+        return cache.cacheStateSelector(state).entities;
     };
-    const enitityMapSelectorByTypename = Object.keys(cache.typenames).reduce((result, x) => {
-        result[x] = (state) => nonPartialCache.cacheStateSelector(state).entities[x];
+    const enitityMapSelectorByTypename = Object.keys(partialCache.typenames).reduce((result, x) => {
+        result[x] = (state) => cache.cacheStateSelector(state).entities[x];
         return result;
     }, {});
     return {
-        cache: nonPartialCache,
+        cache,
         /** Reducer of the cache, should be added to redux store. */
-        reducer: (0, reducer_1.createCacheReducer)(nonPartialCache.typenames, nonPartialCache.queries, nonPartialCache.mutations, nonPartialCache.options),
+        reducer: (0, reducer_1.createCacheReducer)(cache.typenames, cache.queries, cache.mutations, cache.options),
         actions: {
             /** Updates query state, and optionally merges entity changes in a single action. */
-            setQueryStateAndEntities: reducer_1.setQueryStateAndEntities,
+            updateQueryStateAndEntities: actions_1.updateQueryStateAndEntities,
             /** Updates mutation state, and optionally merges entity changes in a single action. */
-            setMutationStateAndEntities: reducer_1.setMutationStateAndEntities,
+            updateMutationStateAndEntities: actions_1.updateMutationStateAndEntities,
             /** Merge EntityChanges to the state. */
-            mergeEntityChanges: reducer_1.mergeEntityChanges,
+            mergeEntityChanges: actions_1.mergeEntityChanges,
+            /** Clear 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: actions_1.clearQueryState,
+            /** Clear states for provided mutation keys. */
+            clearMutationState: actions_1.clearMutationState,
         },
         selectors: {
+            /** Select all entities from the state. */
             entitiesSelector,
+            /** Select all entities of provided typename. */
             entitiesByTypenameSelector: (typename) => {
                 return enitityMapSelectorByTypename[typename];
             },
@@ -61,33 +66,32 @@ const createCache = (cache) => {
                 return (0, react_1.useMemo)(() => {
                     const client = {
                         query: (options) => {
-                            var _a, _b;
+                            var _a;
                             const { query: queryKey, params } = options;
-                            const getParamsKey = (_a = nonPartialCache.queries[queryKey].getParamsKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetParamsKey);
-                            const getCacheKey = (_b = nonPartialCache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : getParamsKey;
+                            const getCacheKey = (_a = cache.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);
+                            return (0, query_1.query)('query', true, store, cache, queryKey, cacheKey, params);
                         },
                         mutate: (options) => {
-                            return (0, mutate_1.mutate)('mutate', true, store, nonPartialCache, options.mutation, options.params, abortControllers);
+                            return (0, mutate_1.mutate)('mutate', true, store, cache, options.mutation, options.params, abortControllers);
                         },
                     };
                     return client;
                 }, [store]);
             },
             /** Fetches query when params change and subscribes to query state. */
-            useQuery: (options) => (0, useQuery_1.useQuery)(nonPartialCache, options),
+            useQuery: (options) => (0, useQuery_1.useQuery)(cache, options),
             /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: (options) => (0, useMutation_1.useMutation)(nonPartialCache, options, abortControllers),
+            useMutation: (options) => (0, useMutation_1.useMutation)(cache, 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]);
+                return (0, react_redux_1.useSelector)((state) => id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id]);
             },
         },
         utils: {
             applyEntityChanges: (entities, changes) => {
-                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, nonPartialCache.options);
+                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options);
             },
         },
     };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createCache } from './createCache';
 export type { ReduxCacheState } from './reducer';
 export * from './types';
-export { defaultGetParamsKey, defaultQueryMutationState } from './utilsAndConstants';
+export { defaultGetCacheKey, DEFAULT_QUERY_MUTATION_STATE as defaultQueryMutationState, } from './utilsAndConstants';

package/dist/index.js

@@ -14,51 +14,43 @@ 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.defaultQueryMutationState = exports.defaultGetParamsKey = 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 utilsAndConstants_1 = require("./utilsAndConstants");
-Object.defineProperty(exports, "defaultGetParamsKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetParamsKey; } });
-Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.defaultQueryMutationState; } });
+Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
+Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE; } });
 // Backlog
 // ! high
+// screenshot of redux state to README
+// optimistic response
 // cover with tests
+// try use skip for refreshing strategy?
+// add example without normalization
+// make query key / cache key difference more clear in the docs
 // ! medium
-// allow multiple mutation with sam keys?
+// make named caches to produce named hooks, actions etc (same as slices in RTK)?
+// allow multiple mutation with same keys?
 // type extractors from cache
 // custom useStore
 // return back deserialize selector?
-// resultSelector - return also boolean that result is full enough
+// resultSelector - return also boolean that result is full enough or make cache policy as a function
 // selector for entities by typename
-// provide call query/mutation function to call them without hooks, but with all state updates
-// get typenames from schema? (useSelectDenormalized)
 // callback option on error / success?
-// cache policy as function? needsRefetch
-// add verbose debug logs
-// refetch queries on query / mutation success?
-// remove state when it finished without errors
-// set default options like getParams
-// selectors for loading state of similar query or mutation (wihout using params as key)
+// refetch queries on mutation success
+// remove query/mutation state when it finished without errors
 // deep equal entities while merging state
-// support multiple stores
-// add validation if entity is full enough
-// optimistic response
 // make error type generic
-// proper types, remove as, any, todo
+// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?
 // ! low
-// make types readonly
-// support changing query key?
-// remove defaultState and keep values undefined?
 // add params to the state?
 // cancellation to queries
 // if mutation & query alrady loading - make options: last, throttle, debounce, parallel?
 // add time-to-live option, and/or time-to-refresh
-// add getUpdateTime option to check entities while merging
-// useLocalMutation - uses local component state, or make store option - redux or component state or context? 1 version: redux only
+// add refresh interval for queries that are mounted
 // replace try/catch with returned error
 // support any store, not only redux
-// QueryInfo.defaultOptions
-// set options in refresh/mutate functions
-// multiple reducers instead of 1?
-// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?
+// readonly types?
+// proper types, remove as, any, todo
+// add number of retries param?

package/dist/mutate.js

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
-const reducer_1 = require("./reducer");
+const actions_1 = require("./actions");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
@@ -30,7 +30,7 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
             abortController.abort();
         }
         else {
-            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+            store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
                 loading: true,
                 result: undefined,
             }));
@@ -60,14 +60,14 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
     }
     delete abortControllersOfStore[mutationKey];
     if (error) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
             error: error,
             loading: false,
         }));
         return { error };
     }
     if (response) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
             error: undefined,
             loading: false,
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/dist/query.d.ts

@@ -1,3 +1,3 @@
 import { Store } from 'redux';
-import { Cache, Key, QueryResult, Typenames } from './types';
+import type { 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

@@ -10,7 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
-const reducer_1 = require("./reducer");
+const actions_1 = require("./actions");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
@@ -28,7 +28,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
             });
         return returnResult ? { cancelled: true } : undefined;
     }
-    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+    store.dispatch((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, {
         loading: true,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
@@ -40,7 +40,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
         params);
     }
     catch (error) {
-        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+        store.dispatch((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, {
             error: error,
             loading: false,
         }));
@@ -57,7 +57,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
                 (_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));
+    store.dispatch((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, newState, response));
     // @ts-expect-error fix types
     return returnResult
         ? {

package/dist/reducer.d.ts

@@ -1,4 +1,5 @@
-import { Cache, Dict, EntitiesMap, EntityChanges, Key, QueryMutationState, Typenames } from './types';
+import { clearMutationState, clearQueryState, mergeEntityChanges, updateMutationStateAndEntities, updateQueryStateAndEntities } from './actions';
+import type { Cache, Dict, EntitiesMap, QueryMutationState, Typenames } from './types';
 export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<T, QP, QR, MP, MR>>>;
 export declare const createCacheReducer: <T extends Typenames, QP, QR, MP, MR>(typenames: T, queries: QP & QR extends infer T_1 ? { [QK in keyof T_1]: QK extends keyof QP & keyof QR ? import("./types").QueryInfo<T, QP[QK], QR[QK], {
     entities: EntitiesMap<T>;
@@ -9,38 +10,30 @@ export declare const createCacheReducer: <T extends Typenames, QP, QR, MP, MR>(t
     queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
     mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
 } | undefined, action: {
-    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+    type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
     queryKey: keyof QR;
-    queryCacheKey: Key;
+    queryCacheKey: import("./types").Key;
     state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
+    entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
-    type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+    type: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
     mutationKey: keyof MR;
     state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
+    entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `${string}MERGE_ENTITY_CHANGES`;
-    changes: EntityChanges<T>;
+    changes: import("./types").EntityChanges<T>;
+} | {
+    type: `${string}CLEAR_QUERY_STATE`;
+    queryKeys: {
+        key: keyof QR;
+        cacheKey?: import("./types").Key | undefined;
+    }[];
+} | {
+    type: `${string}CLEAR_MUTATION_STATE`;
+    mutationKeys: (keyof MR)[];
 }) => {
     entities: EntitiesMap<T>;
     queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
     mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
 };
-export declare const setQueryStateAndEntities: <T extends Typenames, QR, K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
-    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
-    queryKey: K;
-    queryCacheKey: Key;
-    state: Partial<QueryMutationState<QR[K]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
-};
-export declare const setMutationStateAndEntities: <T extends Typenames, MR, K extends keyof MR>(mutationKey: K, state?: Partial<QueryMutationState<MR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
-    type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
-    mutationKey: K;
-    state: Partial<QueryMutationState<MR[K]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
-};
-export declare const mergeEntityChanges: <T extends Typenames>(changes: EntityChanges<T>) => {
-    type: `${string}MERGE_ENTITY_CHANGES`;
-    changes: EntityChanges<T>;
-};

package/dist/reducer.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEntityChanges = exports.setMutationStateAndEntities = exports.setQueryStateAndEntities = exports.createCacheReducer = void 0;
+exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
+const EMPTY_QUERY_STATE = Object.freeze({});
 const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
     const entitiesMap = {};
     for (const key in typenames) {
-        entitiesMap[key] = {};
+        entitiesMap[key] = EMPTY_QUERY_STATE;
     }
     const queriesMap = {};
     for (const key in queries) {
@@ -25,51 +26,72 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
             initialState,
         });
     return (state = initialState, action) => {
+        var _a, _b;
         switch (action.type) {
-            case '@RRC/SET_QUERY_STATE_AND_ENTITIES': {
+            case '@RRC/UPDATE_QUERY_STATE_AND_ENTITIES': {
                 const { queryKey, queryCacheKey, state: queryState, entityChagnes } = action;
                 const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!queryState && !newEntities) {
                     return state;
                 }
-                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { queries: Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: Object.assign(Object.assign({}, state.queries[queryKey][queryCacheKey]), queryState) }) }) });
+                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { queries: Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: Object.assign(Object.assign({}, ((_a = state.queries[queryKey][queryCacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE)), queryState) }) }) });
             }
-            case '@RRC/SET_MUTATION_STATE_AND_ENTITIES': {
+            case '@RRC/UPDATE_MUTATION_STATE_AND_ENTITIES': {
                 const { mutationKey, state: mutationState, entityChagnes } = action;
                 const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!mutationState && !newEntities) {
                     return state;
                 }
-                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { mutations: Object.assign(Object.assign({}, state.mutations), { [mutationKey]: Object.assign(Object.assign({}, state.mutations[mutationKey]), mutationState) }) });
+                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { mutations: Object.assign(Object.assign({}, state.mutations), { [mutationKey]: Object.assign(Object.assign({}, ((_b = state.mutations[mutationKey]) !== null && _b !== void 0 ? _b : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE)), mutationState) }) });
             }
             case '@RRC/MERGE_ENTITY_CHANGES': {
                 const { changes } = action;
                 const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions);
                 return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
             }
+            case '@RRC/CLEAR_QUERY_STATE': {
+                const { queryKeys } = action;
+                if (!queryKeys.length) {
+                    return state;
+                }
+                let newQueries = undefined;
+                for (const query of queryKeys) {
+                    if (query.cacheKey != null) {
+                        if ((newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key][query.cacheKey]) {
+                            newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
+                            newQueries[query.key] = Object.assign({}, newQueries[query.key]);
+                            delete newQueries[query.key][query.cacheKey];
+                        }
+                    }
+                    else if ((newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key] !== EMPTY_QUERY_STATE) {
+                        newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
+                        newQueries[query.key] = EMPTY_QUERY_STATE;
+                    }
+                }
+                if (!newQueries) {
+                    return state;
+                }
+                return Object.assign(Object.assign({}, state), { queries: newQueries });
+            }
+            case '@RRC/CLEAR_MUTATION_STATE': {
+                const { mutationKeys } = action;
+                if (!mutationKeys.length) {
+                    return state;
+                }
+                let newMutations = undefined;
+                for (const mutation of mutationKeys) {
+                    if (state.mutations[mutation]) {
+                        newMutations !== null && newMutations !== void 0 ? newMutations : (newMutations = Object.assign({}, state.mutations));
+                        delete newMutations[mutation];
+                    }
+                }
+                if (!newMutations) {
+                    return state;
+                }
+                return Object.assign(Object.assign({}, state), { mutations: newMutations });
+            }
         }
         return state;
     };
 };
 exports.createCacheReducer = createCacheReducer;
-const actionPrefix = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/`;
-const setQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
-    type: `${actionPrefix}SET_QUERY_STATE_AND_ENTITIES`,
-    queryKey,
-    queryCacheKey,
-    state,
-    entityChagnes,
-});
-exports.setQueryStateAndEntities = setQueryStateAndEntities;
-const setMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
-    type: `${actionPrefix}SET_MUTATION_STATE_AND_ENTITIES`,
-    mutationKey,
-    state,
-    entityChagnes,
-});
-exports.setMutationStateAndEntities = setMutationStateAndEntities;
-const mergeEntityChanges = (changes) => ({
-    type: `${actionPrefix}MERGE_ENTITY_CHANGES`,
-    changes,
-});
-exports.mergeEntityChanges = mergeEntityChanges;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { createCacheReducer, ReduxCacheState } from './reducer';
+import { createCacheReducer, ReduxCacheState } from './reducer';
 export type Key = string | number | symbol;
 export type Dict<T> = Record<Key, T>;
 export type OptionalPartial<T, K extends keyof T> = Partial<{
@@ -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.
@@ -73,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;
 };

package/dist/useMutation.js

@@ -12,27 +12,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMutation = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const actions_1 = require("./actions");
 const mutate_1 = require("./mutate");
-const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useMutation = (cache, options, abortControllers) => {
     var _a;
     const { mutation: mutationKey } = 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],
-            ]
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
-        })();
     const store = (0, react_redux_1.useStore)();
     // Using single useMemo for performance reasons
     const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
@@ -58,17 +43,16 @@ const useMutation = (cache, options, abortControllers) => {
                     return false;
                 }
                 abortController.abort();
-                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
                     loading: false,
                 }));
                 return true;
             },
         ];
-    }, 
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-    [store]);
+        // 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.defaultQueryMutationState;
+    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
             options,

package/dist/useQuery.js

@@ -16,66 +16,37 @@ const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', 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 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],
-                ['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, params);
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }), [cacheKey, paramsKey]);
+    }), [store, queryKey, cacheKey]);
     const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
-    })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.defaultQueryMutationState;
+    })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     const queryState = hasResultFromSelector
         ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
         : 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 && cachePolicy === 'cache-first') {
@@ -88,10 +59,9 @@ const useQuery = (cache, options) => {
         }
         fetch();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [paramsKey, cachePolicy, skip]);
+    }, [cacheKey, cachePolicy, skip]);
     logsEnabled &&
         (0, utilsAndConstants_1.log)('useQuery', {
-            paramsKey,
             cacheKey,
             options,
             resultFromSelector,

package/dist/utilsAndConstants.d.ts

@@ -1,12 +1,11 @@
-import { CacheOptions, EntitiesMap, EntityChanges, Typenames } from './types';
+import type { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "RRC";
-export declare const isDev: boolean;
-export declare const defaultQueryMutationState: {
+export declare const IS_DEV: boolean;
+export declare const DEFAULT_QUERY_MUTATION_STATE: {
     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;
 /**
  * Apply changes to the entities map.

package/dist/utilsAndConstants.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.defaultGetParamsKey = exports.defaultQueryMutationState = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
-const react_1 = require("react");
+exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'RRC';
-exports.isDev = (() => {
+exports.IS_DEV = (() => {
     try {
         // @ts-expect-error __DEV__ is only for React Native
         return __DEV__;
@@ -12,10 +11,11 @@ exports.isDev = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.defaultQueryMutationState = { loading: false, error: undefined };
-const defaultGetParamsKey = (params) => {
+exports.DEFAULT_QUERY_MUTATION_STATE = { loading: false, error: undefined };
+const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':
+        case 'symbol':
             return params;
         case 'object':
             return JSON.stringify(params);
@@ -23,18 +23,7 @@ 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);
 };

package/package.json

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