react-redux-cache 0.5.1 → 0.6.1

package/README.md

@@ -7,7 +7,7 @@
   <b>DOGE:</b> D7GMQdKhKC9ymbT9PtcetSFTQjyPRRfkwT <br>
 </details>
 
-# react-redux-cache
+# react-redux-cache (RRC)
 
 **Powerful** yet **lightweight** data fetching and caching library that supports **normalization** unlike `react-query` and `rtk-query`, while having similar but very simple interface. Built on top of `redux`, covered with tests, fully typed and written on Typescript.
 
@@ -122,15 +122,17 @@ Examples of states, generated by cache reducer from `/example` project:
    - [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)
-   - [Advanced cache policy](https://github.com/gentlee/react-redux-cache#advanced-cache-policy)
+   - [Extended cache policy](https://github.com/gentlee/react-redux-cache#extended-cache-policy)
    - [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)
+   - [How race conditions are handled?](https://github.com/gentlee/react-redux-cache#how-race-conditions-are-handled)
 
 ### Installation
 `react`, `redux` and `react-redux` are peer dependencies.
+
+`fast-deep-equal` is an optional peer dependency if `deepComparisonEnabled` cache option is enabled (default is true).
 ```sh
 npm add react-redux-cache react redux react-redux
 ```
@@ -146,7 +148,7 @@ export const {
 } = createCache({
   // Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state.
   name: 'cache',
-  // Typenames provide a mapping of all typenames to their entity types, which is needed for proper typing and normalization.
+  // Mapping of all typenames to their entity types, which is needed for proper normalization. Should be empty if normalization is not needed.
   // Empty objects with type casting can be used as values.
   typenames: {
     users: {} as User, // here `users` entities will have type `User`
@@ -162,6 +164,24 @@ export const {
   },
 })
 ```
+
+For normalization two things are required:
+- Set proper typenames while creating the cache - mapping of all entities and their corresponding TS types.
+- Return an object from queries and mutations, that contains the following fields (besides `result`):
+
+```typescript
+type EntityChanges<T extends Typenames> = {  
+  /** Entities that will be merged with existing. */
+  merge?: PartialEntitiesMap<T>
+  /** Entities that will replace existing. */
+  replace?: Partial<EntitiesMap<T>>
+  /** Ids of entities that will be removed. */
+  remove?: EntityIds<T>
+  /** Alias for `merge` to support normalizr. */
+  entities?: EntityChanges<T>['merge']
+}
+```
+
 #### store.ts
 ```typescript
 // Create store as usual, passing the new cache reducer under the name of the cache.
@@ -248,31 +268,33 @@ export const UserScreen = () => {
 
 ### Advanced
 
-#### Advanced cache policy
+#### Extended cache policy
 
 `cache-first` cache policy skips fetching if result is already cached, but sometimes it can't determine that we already have result in some other's query result or in normalized entities cache. In that case we can use `skip` parameter of a query:
 
 ```typescript
 export const UserScreen = () => {
+  ...
+
   const user = useSelectEntityById(userId, 'users')
 
   const [{loading, error}] = useQuery({
     query: 'getUser',
     params: userId,
-    skip: !!user // we skip fetching if we already have user cached by some other query, e.g. getUsers
+    skip: !!user // skip fetching if we already have user cached by some other query, e.g. getUsers
   })
 
   ...
 }
 ```
 
-We can additional check that entity is full enough:
+We can additionally check that entity is full or "fresh" enough:
 
 ```typescript
-  skip: !!user && isFullUser(user)
+skip: !!user && isFullUser(user)
 ```
 
-Other approach is to set `skip: true` and manually run `fetch` when needed:
+Another approach is to set `skip: true` and manually run `fetch` when needed:
 
 ```typescript
 export const UserScreen = () => {
@@ -289,6 +311,7 @@ export const UserScreen = () => {
       fetchUser()
     }
   }, [screenIsVisible])
+
   ...
 }
 ```
@@ -412,8 +435,8 @@ It is recommended to override it when default implementation is not optimal or w
 
 As example, can be overriden when implementing pagination.
 
-#### How mutation fetching differs from queries?
+#### How race conditions are handled?
 
-**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.
+**Queries:** Queries are throttled: query with the same cache key (generated from params by default) is cancelled if already running.
 
-**Mutations:** Only one mutation can be run for each mutation key at a time. If another one called, previous is aborted.
+**Mutations:** Mutations are debounced: previous similar mutation is aborted if it was running when the new one started. Second argument in mutations is `AbortSignal`, which can be used e.g. for cancelling http requests.

package/dist/createActions.d.ts

@@ -3,22 +3,22 @@ export type ActionMap<N extends string, T extends Typenames, QP, QR, MP, MR> = R
 export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(name: N) => {
     /** Updates query state, and optionally merges entity changes in a single action. */
     updateQueryStateAndEntities: {
-        <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChanges?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: K;
             queryCacheKey: Key;
             state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
-            entityChagnes: EntityChanges<T> | undefined;
+            entityChanges: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateQueryStateAndEntities`;
     };
     /** Updates mutation state, and optionally merges entity changes in a single action. */
     updateMutationStateAndEntities: {
-        <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateMutationStateAndEntities`;
             mutationKey: K_1;
             state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
-            entityChagnes: EntityChanges<T> | undefined;
+            entityChanges: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateMutationStateAndEntities`;
     };

package/dist/createActions.js

@@ -5,20 +5,20 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 const createActions = (name) => {
     const actionPrefix = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/${name}/`;
     const updateQueryStateAndEntitiesType = `${actionPrefix}updateQueryStateAndEntities`;
-    const updateQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
+    const updateQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChanges) => ({
         type: updateQueryStateAndEntitiesType,
         queryKey,
         queryCacheKey,
         state,
-        entityChagnes,
+        entityChanges,
     });
     updateQueryStateAndEntities.type = updateQueryStateAndEntitiesType;
     const updateMutationStateAndEntitiesType = `${actionPrefix}updateMutationStateAndEntities`;
-    const updateMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
+    const updateMutationStateAndEntities = (mutationKey, state, entityChanges) => ({
         type: updateMutationStateAndEntitiesType,
         mutationKey,
         state,
-        entityChagnes,
+        entityChanges,
     });
     updateMutationStateAndEntities.type = updateMutationStateAndEntitiesType;
     const mergeEntityChangesType = `${actionPrefix}mergeEntityChanges`;

package/dist/createCache.d.ts

@@ -18,12 +18,12 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
         state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
-        entityChagnes: import("./types").EntityChanges<T> | undefined;
+        entityChanges: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
         mutationKey: keyof MP & keyof MR;
         state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
-        entityChagnes: import("./types").EntityChanges<T> | undefined;
+        entityChanges: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
         changes: import("./types").EntityChanges<T>;
@@ -43,21 +43,21 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     };
     actions: {
         updateQueryStateAndEntities: {
-            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
                 state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
-                entityChagnes: import("./types").EntityChanges<T> | undefined;
+                entityChanges: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K_1;
                 state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
-                entityChagnes: import("./types").EntityChanges<T> | undefined;
+                entityChanges: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
         };
@@ -91,11 +91,11 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     };
     selectors: {
         /** Selects query state. */
-        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never> | undefined;
+        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
         /** Selects query latest result. */
         selectQueryResult: <QK_2 extends keyof QP | keyof QR>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
         /** Selects query loading state. */
-        selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
+        selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean;
         /** Selects query latest error. */
         selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
         /** Selects query latest params. */
@@ -109,7 +109,7 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         /** Selects mutation latest error. */
         selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
         /** Selects mutation latest params. */
-        selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never;
+        selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => (MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never) | undefined;
         /** Selects entity by id and typename. */
         selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
         /** Selects all entities. */

package/dist/createCache.js

@@ -14,17 +14,18 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
 const createCache = (partialCache) => {
-    var _a, _b, _c, _d, _e, _f;
-    var _g, _h;
+    var _a, _b, _c, _d, _e, _f, _g;
+    var _h, _j, _k;
     const abortControllers = new WeakMap();
     // provide all optional fields
     (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
-    (_b = (_g = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_g.logsEnabled = false);
-    (_c = (_h = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_h.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 = {});
+    (_b = (_h = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_h.logsEnabled = false);
+    (_c = (_j = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_j.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
+    (_d = (_k = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_k.deepComparisonEnabled = true);
+    (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
+    (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (_f = partialCache.cacheStateSelector) !== null && _f !== void 0 ? _f : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+    (_g = partialCache.cacheStateSelector) !== null && _g !== void 0 ? _g : (partialCache.cacheStateSelector = (state) => state[cache.name]);
     // @ts-expect-error private field for testing
     partialCache.abortControllers = abortControllers;
     const cache = partialCache;
@@ -33,12 +34,14 @@ const createCache = (partialCache) => {
         return id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id];
     };
     const selectQueryState = (state, query, cacheKey) => {
+        var _a;
         // @ts-expect-error fix later
-        return cache.cacheStateSelector(state).queries[query][cacheKey];
+        return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     };
     const selectMutationState = (state, mutation) => {
+        var _a;
         // @ts-expect-error fix later
-        return cache.cacheStateSelector(state).mutations[mutation];
+        return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     };
     const actions = (0, createActions_1.createActions)(cache.name);
     return {
@@ -52,23 +55,19 @@ const createCache = (partialCache) => {
             selectQueryState,
             /** Selects query latest result. */
             selectQueryResult: (state, query, cacheKey) => {
-                var _a;
-                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.result;
+                return selectQueryState(state, query, cacheKey).result;
             },
             /** Selects query loading state. */
             selectQueryLoading: (state, query, cacheKey) => {
-                var _a;
-                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.loading;
+                return selectQueryState(state, query, cacheKey).loading;
             },
             /** Selects query latest error. */
             selectQueryError: (state, query, cacheKey) => {
-                var _a;
-                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.error;
+                return selectQueryState(state, query, cacheKey).error;
             },
             /** Selects query latest params. */
             selectQueryParams: (state, query, cacheKey) => {
-                var _a;
-                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.params;
+                return selectQueryState(state, query, cacheKey).params;
             },
             /** Selects mutation state. */
             selectMutationState,

package/dist/index.js

@@ -23,11 +23,14 @@ Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: fu
 Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE; } });
 // Backlog
 // ! high
+// optimistic response
+// type extractors?
+// skip -> enabled?
 // add full api docs
 // update readme with how to use mergeResults for invalidating / updating caches?
-// optimistic response
-// make query key / cache key difference more clear in the docs, and/or rename queryKey -> query
+// make query key / cache key difference more clear in the docs, and/or rename queryKey -> query?
 // ! medium
+// check type of function arguments in dev
 // allow multiple mutation with same keys?
 // type extractors from cache
 // custom useStore

package/dist/reducer.d.ts

@@ -10,12 +10,12 @@ export declare const createCacheReducer: <N extends string, T extends Typenames,
     queryKey: keyof QP & keyof QR;
     queryCacheKey: import("./types").Key;
     state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
-    entityChagnes: import("./types").EntityChanges<T> | undefined;
+    entityChanges: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/updateMutationStateAndEntities`;
     mutationKey: keyof MP & keyof MR;
     state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
-    entityChagnes: import("./types").EntityChanges<T> | undefined;
+    entityChanges: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/mergeEntityChanges`;
     changes: import("./types").EntityChanges<T>;

package/dist/reducer.js

@@ -24,24 +24,47 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
             queryKeys,
             initialState,
         });
+    const deepEqual = cacheOptions.deepComparisonEnabled ? utilsAndConstants_1.optionalUtils.deepEqual : undefined;
     return (state = initialState, action) => {
         var _a, _b;
         switch (action.type) {
             case actions.updateQueryStateAndEntities.type: {
-                const { queryKey, queryCacheKey, state: queryState, entityChagnes, } = action;
-                const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
-                if (!queryState && !newEntities) {
-                    return state;
+                const { queryKey, queryCacheKey, state: queryState, entityChanges, } = action;
+                const oldQueryState = (_a = state.queries[queryKey][queryCacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState);
+                if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldQueryState, newQueryState)) {
+                    newQueryState = undefined;
+                }
+                const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
+                let newState;
+                if (newEntities) {
+                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                    newState.entities = newEntities;
+                }
+                if (newQueryState) {
+                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                    newState.queries = Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: newQueryState }) });
                 }
-                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) }) }) });
+                return newState !== null && newState !== void 0 ? newState : state;
             }
             case actions.updateMutationStateAndEntities.type: {
-                const { mutationKey, state: mutationState, entityChagnes, } = action;
-                const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
-                if (!mutationState && !newEntities) {
-                    return state;
+                const { mutationKey, state: mutationState, entityChanges, } = action;
+                const oldMutationState = (_b = state.mutations[mutationKey]) !== null && _b !== void 0 ? _b : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+                let newMutationState = mutationState && Object.assign(Object.assign({}, oldMutationState), mutationState);
+                if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldMutationState, newMutationState)) {
+                    newMutationState = undefined;
+                }
+                const newEntities = entityChanges && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChanges, cacheOptions);
+                let newState;
+                if (newEntities) {
+                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                    newState.entities = newEntities;
                 }
-                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) }) });
+                if (newMutationState) {
+                    newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state));
+                    newState.mutations = Object.assign(Object.assign({}, state.mutations), { [mutationKey]: newMutationState });
+                }
+                return newState !== null && newState !== void 0 ? newState : state;
             }
             case actions.mergeEntityChanges.type: {
                 const { changes } = action;
@@ -55,22 +78,24 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                 }
                 let newQueries = undefined;
                 for (const query of queryKeysToClear) {
+                    const queryState = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key];
                     if (query.cacheKey != null) {
-                        if ((newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key][query.cacheKey]) {
+                        if (queryState[query.cacheKey]) {
                             newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                            newQueries[query.key] = Object.assign({}, newQueries[query.key]);
+                            if (state.queries[query.key] === newQueries[query.key]) {
+                                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) {
+                    else if (queryState !== 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 });
+                return !newQueries
+                    ? state
+                    : Object.assign(Object.assign({}, state), { queries: newQueries });
             }
             case actions.clearMutationState.type: {
                 const { mutationKeys } = action;
@@ -84,10 +109,9 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                         delete newMutations[mutation];
                     }
                 }
-                if (!newMutations) {
-                    return state;
-                }
-                return Object.assign(Object.assign({}, state), { mutations: newMutations });
+                return !newMutations
+                    ? state
+                    : Object.assign(Object.assign({}, state), { mutations: newMutations });
             }
         }
         return state;

package/dist/types.d.ts

@@ -22,7 +22,7 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state. */
     name: N;
     /**
-     * Mapping of all typenames to their entity types, which is needed for proper normalization. Can be empty If normalization not needed.
+     * Mapping of all typenames to their entity types, which is needed for proper normalization. Should be empty if normalization is not needed.
      * @key Typename.
      * @value Object with proper type of the typename. Empty objects with type casting can be used.
      * @example
@@ -44,14 +44,21 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
 export type CacheOptions = {
     /**
      * Enables validation of package function arguments. Recommened to enable in dev/testing mode.
-     * Default is true in dev mode.
+     * @default true in dev mode.
      * */
     validateFunctionArguments: boolean;
     /**
-     * Enable console logs.
-     * Default is false.
+     * Enables console logs.
+     * @default false
      */
     logsEnabled: boolean;
+    /**
+     * Enables deep comparison before merging entities to the state.
+     * Re-rendering is a heavier operation than comparison, so disabling it can lead to performance drop.
+     * Makes sense to disable only if merging equal results & entities to the state is a rare case.
+     * @default true
+     */
+    deepComparisonEnabled: boolean;
 };
 export type PartialEntitiesMap<T extends Typenames> = {
     [K in keyof T]?: Dict<Partial<T[K]>>;
@@ -122,5 +129,5 @@ export type QueryMutationState<P, R> = {
     /** Error of the latest response. */
     error?: Error;
     /** Parameters of the latest request. */
-    params: P;
+    params?: P;
 };

package/dist/useQuery.js

@@ -23,6 +23,7 @@ const useQuery = (cache, actions, options) => {
     const store = (0, react_redux_1.useStore)();
     // @ts-expect-error fix types later
     const cacheKey = getCacheKey(params);
+    /** Fetch query with the new parameters, or refetch with the same if parameters not provided. */
     const fetch = (0, react_1.useCallback)((options) => __awaiter(void 0, void 0, void 0, function* () {
         return yield (0, query_1.query)('useQuery.fetch', store, cache, actions, queryKey, 
         // @ts-expect-error fix later
@@ -30,6 +31,7 @@ const useQuery = (cache, actions, options) => {
     }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [store, queryKey, cacheKey]);
+    /** Query state */
     const queryState = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
@@ -56,11 +58,6 @@ const useQuery = (cache, actions, options) => {
             options,
             queryState,
         });
-    return [
-        /** Query state */
-        queryState,
-        /** Refetch query with the same parameters */
-        fetch,
-    ];
+    return [queryState, fetch];
 };
 exports.useQuery = useQuery;

package/dist/utilsAndConstants.d.ts

@@ -1,9 +1,11 @@
 import type { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "rrc";
+export declare const optionalUtils: {
+    deepEqual?: (a: any, b: any) => boolean;
+};
 export declare const IS_DEV: boolean;
 export declare const DEFAULT_QUERY_MUTATION_STATE: {
     readonly loading: false;
-    readonly error: undefined;
 };
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key;
 export declare const log: (tag: string, data?: unknown) => void;

package/dist/utilsAndConstants.js

@@ -1,7 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.PACKAGE_SHORT_NAME = void 0;
+exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'rrc';
+exports.optionalUtils = {
+    deepEqual: undefined,
+};
+try {
+    exports.optionalUtils.deepEqual = require('fast-deep-equal/es6');
+}
+catch (_a) {
+    console.debug(exports.PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed');
+}
 exports.IS_DEV = (() => {
     try {
         // @ts-expect-error __DEV__ is only for React Native
@@ -11,7 +20,7 @@ exports.IS_DEV = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.DEFAULT_QUERY_MUTATION_STATE = { loading: false, error: undefined };
+exports.DEFAULT_QUERY_MUTATION_STATE = { loading: false };
 const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':
@@ -40,6 +49,7 @@ const applyEntityChanges = (entities, changes, options) => {
     if (!merge && !replace && !remove) {
         return undefined;
     }
+    const deepEqual = options.deepComparisonEnabled ? exports.optionalUtils.deepEqual : undefined;
     let result;
     for (const typename in entities) {
         const entitiesToMerge = merge === null || merge === void 0 ? void 0 : merge[typename];
@@ -60,21 +70,39 @@ const applyEntityChanges = (entities, changes, options) => {
                 throw new Error('Merge, replace and remove changes have intersections for: ' + typename);
             }
         }
-        const newEntities = Object.assign({}, entities[typename]);
+        const oldEntities = entities[typename];
+        let newEntities;
         // remove
-        entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => delete newEntities[id]);
+        entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => {
+            if (oldEntities[id]) {
+                newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
+                delete newEntities[id];
+            }
+        });
         // replace
         if (entitiesToReplace) {
             for (const id in entitiesToReplace) {
-                newEntities[id] = entitiesToReplace[id];
+                const newEntity = entitiesToReplace[id];
+                if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))) {
+                    newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
+                    newEntities[id] = newEntity;
+                }
             }
         }
         // merge
         if (entitiesToMerge) {
             for (const id in entitiesToMerge) {
-                newEntities[id] = Object.assign(Object.assign({}, newEntities[id]), entitiesToMerge[id]);
+                const oldEntity = oldEntities[id];
+                const newEntity = Object.assign(Object.assign({}, oldEntity), entitiesToMerge[id]);
+                if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntity, newEntity))) {
+                    newEntities !== null && newEntities !== void 0 ? newEntities : (newEntities = Object.assign({}, oldEntities));
+                    newEntities[id] = newEntity;
+                }
             }
         }
+        if (!newEntities) {
+            continue;
+        }
         result !== null && result !== void 0 ? result : (result = Object.assign({}, entities));
         result[typename] = newEntities;
     }
@@ -82,6 +110,7 @@ const applyEntityChanges = (entities, changes, options) => {
         (0, exports.log)('applyEntityChanges', {
             entities,
             changes,
+            options,
             result,
         });
     return result;

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.5.1",
+  "version": "0.6.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",
@@ -14,6 +14,17 @@
     "test": "node node_modules/jest/bin/jest.js",
     "prepublishOnly": "yarn build && yarn test"
   },
+  "peerDependencies": {
+    "fast-deep-equal": "*",
+    "react": "^16",
+    "react-redux": "^4",
+    "redux": "^4"
+  },
+  "peerDependenciesMeta": {
+    "fast-deep-equal": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@testing-library/jest-dom": "6.1.4",
     "@testing-library/react": "14.0.0",
@@ -40,11 +51,6 @@
     "ts-jest": "29.1.0",
     "typescript": "5.0"
   },
-  "peerDependencies": {
-    "react": "^16",
-    "react-redux": "^4",
-    "redux": "^4"
-  },
   "files": [
     "dist/*"
   ],