react-redux-cache 0.21.0 → 0.22.0

package/README.md

@@ -21,9 +21,9 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
 |Supports all kinds of queries / mutations|REST, GraphQL, databases - any async operations can be cached.|
 |Fully typed|Written on TypeScript, everything is checked by compiler.|
 |Not overengineered|Simplicity is the main goal.|
-|Performance|Every function is heavily optimized, Immer is not used ([RTK [Query] issue](https://github.com/reduxjs/redux-toolkit/issues/4793)).|
+|Performance|Every function is heavily optimized. Immer is not used ([RTK performance issue](https://github.com/reduxjs/redux-toolkit/issues/4793)). Supports mutable collections (O(n) > O(1)).|
 |Reliability|High test coverage, zero issue policy.|
-|Lightweight|`npx minified-size dist/esm/*.js`<br/>minified: 18.2 kB<br/>gzipped: 7.91 kB<br/>brotlied: 7.03 kB
+|Lightweight|`npx minified-size dist/esm/*.js`<br/>minified: 19.1 kB<br/>gzipped: 8.29 kB<br/>brotlied: 7.41 kB
 
 |Feature|Description|
 |--|--|
@@ -35,6 +35,7 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
 |Fetch policies|Decide if data is full enough or need to be fetched.|
 |Normalization|Consistent state accross the app - better UX, minimum loading states and lower traffic consumption.|
 |Minimal state|Default values such as `undefined` or default query states are removed from the state tree.|
+|BETA: Mutable collections|Optimizes state merges from O(n) to O(1) by using mutable collections. Separate entities, query and mutation states are still immutable.|
 
 #### Examples of states, generated by cache reducer from `/example` project:
 <details>
@@ -140,6 +141,7 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
    - [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)
+   - [Mutable collections](https://github.com/gentlee/react-redux-cache#mutable-collections)
    - [Error handling](https://github.com/gentlee/react-redux-cache#error-handling)
    - [Invalidation](https://github.com/gentlee/react-redux-cache#invalidation)
    - [Extended & custom fetch policy](https://github.com/gentlee/react-redux-cache#extended--custom-fetch-policy)
@@ -323,6 +325,38 @@ export const UserScreen = () => {
 
 ### Advanced
 
+#### Mutable collections
+
+For huge collections (> 1000 items, see benchmark) immutable approach may be a bottleneck - every merge of entity, query or mutation state is O(n). There is an option `mutableCollections` that makes it O(1) by using mutable approach when working with collections, while still keeping separate entities, query and mutation states immutable.
+
+[Benchmark](https://github.com/gentlee/react-redux-cache/blob/main/benchmark.ts) results of adding item to collection depending on collection size, in microseconds (less is better):
+    
+| Collection size | 0 | 1000 | 10000 | 100000 | 1000000 |
+|-|-|-|-|-|-|
+| immutable | 1.78 | 1.69 | 5.64 | 117.4 | 1284.6 |
+| mutable | 1.68 | 0.92 | 0.98 | 0.98 | 0.99 |
+
+Well written code should not subcribe to whole collections, so just enabling this options most of the times should not break anything. But if it is still needed, you should subscribe to both collection (it may still change e.g. when clearing state) and to its `_changeKey`.
+
+```tsx
+const Component = () => {
+  // It is usually a bad idea to subscribe to whole collections, consider using order of ids and subscribe to a single entity in each cell.
+  const allUsers = useSelector((state) => selectEntitiesByTypename(state, 'users'))
+  const allUsersChangeKey = useSelector((state) => selectEntitiesByTypename(state, 'users')._changeKey) // <-- Add this line while subscribing to collections
+
+  // For memoized components you should also pass it as extra prop to cause its re-render.
+  return <List data={allUsers} extra={allUsersChangeKey}/>
+}
+
+// Or just use existing hook.
+
+const Component = () => {
+  const allUsers = useEntitiesByTypename('users')
+
+  return <List data={allUsers} extra={allUsers._changeKey}>
+}
+```
+
 #### Error handling
 
 Queries and mutations are wrapped in try/catch, so any error will lead to cancelling of any updates to the state except loading state and the caught error. If you still want to make some state updates, or just want to use thrown errors only for unexpected cases, consider returning expected errors as a part of the result:

package/dist/cjs/createCache.js

@@ -14,36 +14,39 @@ const utilsAndConstants_1 = require('./utilsAndConstants')
 const withTypenames = () => {
   return {
     createCache: (partialCache) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m
-      var _o, _p, _q, _r, _s, _t
+      var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o
+      var _p, _q, _r, _s, _t, _u, _v
       const abortControllers = new WeakMap()
       ;(_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {})
-      ;(_b = (_o = partialCache.options).logsEnabled) !== null && _b !== void 0
+      ;(_b = (_p = partialCache.options).mutableCollections) !== null && _b !== void 0
         ? _b
-        : (_o.logsEnabled = false)
-      ;(_c = (_p = partialCache.options).additionalValidation) !== null && _c !== void 0
+        : (_p.mutableCollections = false)
+      ;(_c = (_q = partialCache.options).logsEnabled) !== null && _c !== void 0
         ? _c
-        : (_p.additionalValidation = utilsAndConstants_1.IS_DEV)
-      ;(_d = (_q = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0
+        : (_q.logsEnabled = false)
+      ;(_d = (_r = partialCache.options).additionalValidation) !== null && _d !== void 0
         ? _d
-        : (_q.deepComparisonEnabled = true)
-      ;(_e = partialCache.globals) !== null && _e !== void 0 ? _e : (partialCache.globals = {})
-      ;(_f = (_r = partialCache.globals).queries) !== null && _f !== void 0 ? _f : (_r.queries = {})
-      ;(_g = (_s = partialCache.globals.queries).fetchPolicy) !== null && _g !== void 0
-        ? _g
-        : (_s.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired)
-      ;(_h = (_t = partialCache.globals.queries).skipFetch) !== null && _h !== void 0
+        : (_r.additionalValidation = utilsAndConstants_1.IS_DEV)
+      ;(_e = (_s = partialCache.options).deepComparisonEnabled) !== null && _e !== void 0
+        ? _e
+        : (_s.deepComparisonEnabled = true)
+      ;(_f = partialCache.globals) !== null && _f !== void 0 ? _f : (partialCache.globals = {})
+      ;(_g = (_t = partialCache.globals).queries) !== null && _g !== void 0 ? _g : (_t.queries = {})
+      ;(_h = (_u = partialCache.globals.queries).fetchPolicy) !== null && _h !== void 0
         ? _h
-        : (_t.skipFetch = false)
-      ;(_j = partialCache.cacheStateSelector) !== null && _j !== void 0
+        : (_u.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired)
+      ;(_j = (_v = partialCache.globals.queries).skipFetch) !== null && _j !== void 0
         ? _j
+        : (_v.skipFetch = false)
+      ;(_k = partialCache.cacheStateSelector) !== null && _k !== void 0
+        ? _k
         : (partialCache.cacheStateSelector = (state) => state[cache.name])
-      ;(_k = partialCache.mutations) !== null && _k !== void 0 ? _k : (partialCache.mutations = {})
-      ;(_l = partialCache.queries) !== null && _l !== void 0 ? _l : (partialCache.queries = {})
+      ;(_l = partialCache.mutations) !== null && _l !== void 0 ? _l : (partialCache.mutations = {})
+      ;(_m = partialCache.queries) !== null && _m !== void 0 ? _m : (partialCache.queries = {})
       partialCache.abortControllers = abortControllers
       try {
-        ;(_m = partialCache.storeHooks) !== null && _m !== void 0
-          ? _m
+        ;(_o = partialCache.storeHooks) !== null && _o !== void 0
+          ? _o
           : (partialCache.storeHooks = {
               useStore: require('react-redux').useStore,
               useSelector: require('react-redux').useSelector,
@@ -188,6 +191,17 @@ const withTypenames = () => {
           useSelectEntityById: (id, typename) => {
             return cache.storeHooks.useSelector((state) => selectEntityById(state, id, typename))
           },
+          useEntitiesByTypename: (typename) => {
+            if (cache.options.mutableCollections) {
+              cache.storeHooks.useSelector((state) => {
+                var _a
+                return (_a = selectEntitiesByTypename(state, typename)) === null || _a === void 0
+                  ? void 0
+                  : _a._changeKey
+              })
+            }
+            return cache.storeHooks.useSelector((state) => selectEntitiesByTypename(state, typename))
+          },
         },
         utils: {
           createClient,

package/dist/cjs/createReducer.js

@@ -3,48 +3,65 @@ var __rest =
   (this && this.__rest) ||
   function (s, e) {
     var t = {}
-    for (var p in s) {
-      if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) {
-        t[p] = s[p]
-      }
-    }
-    if (s != null && typeof Object.getOwnPropertySymbols === 'function') {
+    for (var p in s) {if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];}
+    if (s != null && typeof Object.getOwnPropertySymbols === 'function')
       for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) {
-          t[p[i]] = s[p[i]]
-        }
+        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]]
       }
-    }
     return t
   }
 Object.defineProperty(exports, '__esModule', {value: true})
 exports.createReducer = void 0
 const utilsAndConstants_1 = require('./utilsAndConstants')
-
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
 const optionalMutationKeys = ['error', 'result', 'params', 'loading']
 const createReducer = (actions, queryKeys, cacheOptions) => {
-  const initialState = Object.freeze({
-    entities: Object.freeze({}),
-    queries: Object.freeze(
-      queryKeys.reduce((result, x) => {
-        result[x] = Object.freeze({})
-        return result
-      }, {})
-    ),
-    mutations: Object.freeze({}),
-  })
+  const mutable = cacheOptions.mutableCollections
   cacheOptions.logsEnabled &&
     (0, utilsAndConstants_1.logDebug)('createCacheReducer', {
       queryKeys,
-      initialState,
+      mutable,
     })
+  const getMutableInitialState = mutable
+    ? () => {
+        return {
+          entities: {},
+          queries: queryKeys.reduce((result, x) => {
+            result[x] = {}
+            return result
+          }, {}),
+          mutations: {},
+        }
+      }
+    : undefined
+  const immutableInitialState = mutable
+    ? undefined
+    : Object.freeze({
+        entities: Object.freeze({}),
+        queries: Object.freeze(
+          queryKeys.reduce((result, x) => {
+            result[x] = Object.freeze({})
+            return result
+          }, {})
+        ),
+        mutations: Object.freeze({}),
+      })
+  const {
+    clearCache,
+    clearMutationState,
+    clearQueryState,
+    invalidateQuery,
+    mergeEntityChanges,
+    updateMutationStateAndEntities,
+    updateQueryStateAndEntities,
+  } = actions
   const deepEqual = cacheOptions.deepComparisonEnabled
     ? utilsAndConstants_1.optionalUtils.deepEqual
     : undefined
-  return (state = initialState, action) => {
+  return (state = mutable ? getMutableInitialState() : immutableInitialState, action) => {
     switch (action.type) {
-      case actions.updateQueryStateAndEntities.type: {
+      case updateQueryStateAndEntities.type: {
         const {queryKey, queryCacheKey, state: queryState, entityChanges} = action
         const oldQueryState = state.queries[queryKey][queryCacheKey]
         let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState)
@@ -92,23 +109,36 @@ const createReducer = (actions, queryKeys, cacheOptions) => {
         if (newQueryState) {
           if (!(0, utilsAndConstants_1.isEmptyObject)(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,
-              }),
-            })
-          } else if (oldQueryState !== undefined) {
-            const _a = state.queries[queryKey],
-              _b = queryCacheKey,
-              _ = _a[_b],
-              withoutCacheKey = __rest(_a, [typeof _b === 'symbol' ? _b : _b + ''])
+            if (mutable) {
+              newState.queries[queryKey][queryCacheKey] = newQueryState
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newState.queries)
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newState.queries[queryKey])
+            } else {
+              newState.queries = Object.assign(Object.assign({}, state.queries), {
+                [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), {
+                  [queryCacheKey]: newQueryState,
+                }),
+              })
+            } else if (oldQueryState !== undefined) {
             newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state))
-            newState.queries = Object.assign(Object.assign({}, state.queries), {[queryKey]: withoutCacheKey})
+            if (mutable) {
+              delete newState.queries[queryKey][queryCacheKey]
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newState.queries)
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newState.queries[queryKey])
+            } else {
+              const _a = state.queries[queryKey],
+                _b = queryCacheKey,
+                _ = _a[_b],
+                withoutCacheKey = __rest(_a, [typeof _b === 'symbol' ? _b : _b + ''])
+              newState.queries = Object.assign(Object.assign({}, state.queries), {
+                [queryKey]: withoutCacheKey,
+              })
+            }
           }
         }
         return newState !== null && newState !== void 0 ? newState : state
       }
-      case actions.updateMutationStateAndEntities.type: {
+      case updateMutationStateAndEntities.type: {
         const {mutationKey, state: mutationState, entityChanges} = action
         const oldMutationState = state.mutations[mutationKey]
         let newMutationState =
@@ -151,112 +181,150 @@ const createReducer = (actions, queryKeys, cacheOptions) => {
           (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
+          newState = Object.assign(Object.assign({}, state), {entities: newEntities})
         }
         if (newMutationState) {
           if (!(0, utilsAndConstants_1.isEmptyObject)(newMutationState)) {
             newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state))
-            newState.mutations = Object.assign(Object.assign({}, state.mutations), {
-              [mutationKey]: newMutationState,
-            })
-          } else if (oldMutationState !== undefined) {
-            const _c = state.mutations,
-              _d = mutationKey,
-              _ = _c[_d],
-              withoutMutationKey = __rest(_c, [typeof _d === 'symbol' ? _d : _d + ''])
+            if (mutable) {
+              state.mutations[mutationKey] = newMutationState
+              ;(0, utilsAndConstants_1.incrementChangeKey)(state.mutations)
+            } else {
+              newState.mutations = Object.assign(Object.assign({}, state.mutations), {
+                [mutationKey]: newMutationState,
+              })
+            } else if (oldMutationState !== undefined) {
             newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state))
-            newState.mutations = withoutMutationKey
+            if (mutable) {
+              delete state.mutations[mutationKey]
+              ;(0, utilsAndConstants_1.incrementChangeKey)(state.mutations)
+            } else {
+              const _c = state.mutations,
+                _d = mutationKey,
+                _ = _c[_d],
+                withoutMutationKey = __rest(_c, [typeof _d === 'symbol' ? _d : _d + ''])
+              newState.mutations = withoutMutationKey
+            }
           }
         }
         return newState !== null && newState !== void 0 ? newState : state
       }
-      case actions.mergeEntityChanges.type: {
+      case mergeEntityChanges.type: {
         const {changes} = action
         const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions)
         return newEntities ? Object.assign(Object.assign({}, state), {entities: newEntities}) : state
       }
-      case actions.invalidateQuery.type: {
+      case invalidateQuery.type: {
         const {queries: queriesToInvalidate} = action
         if (queriesToInvalidate.length === 0) {
           return state
         }
         const now = Date.now()
-        let newQueries = undefined
+        let newStatesByQueryKey
+        const copiedQueryKeys = mutable ? undefined : new Set()
         for (const {query: queryKey, cacheKey, expiresAt = now} of queriesToInvalidate) {
-          const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[
-            queryKey
-          ]
-          if (cacheKey != null) {
-            if (queryStates[cacheKey]) {
-              const queryState = queryStates[cacheKey]
-              if (queryState && queryState.expiresAt !== expiresAt) {
-                newQueries !== null && newQueries !== void 0
-                  ? newQueries
-                  : (newQueries = Object.assign({}, state.queries))
-                if (state.queries[queryKey] === newQueries[queryKey]) {
-                  newQueries[queryKey] = Object.assign({}, newQueries[queryKey])
-                }
-                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), {expiresAt})
-                if (expiresAt === undefined) {
-                  delete newQueries[queryKey][cacheKey].expiresAt
-                }
+          const statesByCacheKey = (
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : state.queries
+          )[queryKey]
+          const cacheKeysToInvalidate = cacheKey != null ? [cacheKey] : Object.keys(statesByCacheKey)
+          for (const cacheKey of cacheKeysToInvalidate) {
+            const queryState = statesByCacheKey[cacheKey]
+            if (!queryState || queryState.expiresAt === expiresAt) {
+              continue
+            }
+            if (mutable) {
+              newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+                ? newStatesByQueryKey
+                : (newStatesByQueryKey = state.queries)
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newStatesByQueryKey[queryKey])
+            } else {
+              newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+                ? newStatesByQueryKey
+                : (newStatesByQueryKey = Object.assign({}, state.queries))
+              if (!copiedQueryKeys.has(queryKey)) {
+                newStatesByQueryKey[queryKey] = Object.assign({}, newStatesByQueryKey[queryKey])
+                copiedQueryKeys.add(queryKey)
               }
             }
-          } else {
-            for (const cacheKey in queryStates) {
-              const queryState = queryStates[cacheKey]
-              if (queryState && queryState.expiresAt !== expiresAt) {
-                newQueries !== null && newQueries !== void 0
-                  ? newQueries
-                  : (newQueries = Object.assign({}, state.queries))
-                if (state.queries[queryKey] === newQueries[queryKey]) {
-                  newQueries[queryKey] = Object.assign({}, newQueries[queryKey])
-                }
-                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), {expiresAt})
-                if (expiresAt === undefined) {
-                  delete newQueries[queryKey][cacheKey].expiresAt
-                }
+            if (expiresAt !== undefined) {
+              newStatesByQueryKey[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), {
+                expiresAt,
+              })
+            } else {
+              const {expiresAt: _} = queryState,
+                newQueryState = __rest(queryState, ['expiresAt'])
+              if ((0, utilsAndConstants_1.isEmptyObject)(newQueryState)) {
+                delete newStatesByQueryKey[queryKey][cacheKey]
+              } else {
+                newStatesByQueryKey[queryKey][cacheKey] = newQueryState
               }
             }
           }
         }
-        return newQueries === undefined
-          ? state
-          : Object.assign(Object.assign({}, state), {queries: newQueries})
+        if (!newStatesByQueryKey) {
+          return state
+        }
+        if (mutable) {
+          ;(0, utilsAndConstants_1.incrementChangeKey)(newStatesByQueryKey)
+        }
+        return Object.assign(Object.assign({}, state), {queries: newStatesByQueryKey})
       }
-      case actions.clearQueryState.type: {
+      case clearQueryState.type: {
         const {queries: queriesToClear} = action
         if (queriesToClear.length === 0) {
           return state
         }
-        let newQueries = undefined
+        let newStatesByQueryKey
+        const copiedQueryKeys = mutable ? undefined : new Set()
         for (const {query: queryKey, cacheKey} of queriesToClear) {
-          const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[
-            queryKey
-          ]
+          const statesByCacheKey = (
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : state.queries
+          )[queryKey]
           if (cacheKey != null) {
-            if (queryStates[cacheKey]) {
-              newQueries !== null && newQueries !== void 0
-                ? newQueries
-                : (newQueries = Object.assign({}, state.queries))
-              if (state.queries[queryKey] === newQueries[queryKey]) {
-                newQueries[queryKey] = Object.assign({}, newQueries[queryKey])
+            if (!statesByCacheKey[cacheKey]) {
+              continue
+            }
+            if (mutable) {
+              newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+                ? newStatesByQueryKey
+                : (newStatesByQueryKey = state.queries)
+              ;(0, utilsAndConstants_1.incrementChangeKey)(newStatesByQueryKey[queryKey])
+            } else {
+              newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+                ? newStatesByQueryKey
+                : (newStatesByQueryKey = Object.assign({}, state.queries))
+              if (!copiedQueryKeys.has(queryKey)) {
+                newStatesByQueryKey[queryKey] = Object.assign({}, newStatesByQueryKey[queryKey])
+                copiedQueryKeys.add(queryKey)
               }
-              delete newQueries[queryKey][cacheKey]
             }
-          } else if (queryStates !== utilsAndConstants_1.EMPTY_OBJECT) {
-            newQueries !== null && newQueries !== void 0
-              ? newQueries
-              : (newQueries = Object.assign({}, state.queries))
-            newQueries[queryKey] = utilsAndConstants_1.EMPTY_OBJECT
+            delete newStatesByQueryKey[queryKey][cacheKey]
+          } else if (mutable) {
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : (newStatesByQueryKey = state.queries)
+            newStatesByQueryKey[queryKey] = {}
+          } else if (statesByCacheKey !== utilsAndConstants_1.EMPTY_OBJECT) {
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : (newStatesByQueryKey = Object.assign({}, state.queries))
+            newStatesByQueryKey[queryKey] = utilsAndConstants_1.EMPTY_OBJECT
+            copiedQueryKeys.add(queryKey)
           }
         }
-        return newQueries === undefined
-          ? state
-          : Object.assign(Object.assign({}, state), {queries: newQueries})
+        if (newStatesByQueryKey === undefined) {
+          return state
+        }
+        if (mutable) {
+          ;(0, utilsAndConstants_1.incrementChangeKey)(newStatesByQueryKey)
+        }
+        return Object.assign(Object.assign({}, state), {queries: newStatesByQueryKey})
       }
-      case actions.clearMutationState.type: {
+      case clearMutationState.type: {
         const {mutationKeys} = action
         if (mutationKeys.length === 0) {
           return state
@@ -266,16 +334,21 @@ const createReducer = (actions, queryKeys, cacheOptions) => {
           if (state.mutations[mutation]) {
             newMutations !== null && newMutations !== void 0
               ? newMutations
-              : (newMutations = Object.assign({}, state.mutations))
+              : (newMutations = mutable ? state.mutations : Object.assign({}, state.mutations))
             delete newMutations[mutation]
           }
         }
-        return newMutations === undefined
-          ? state
-          : Object.assign(Object.assign({}, state), {mutations: newMutations})
+        if (newMutations === undefined) {
+          return state
+        }
+        if (mutable) {
+          ;(0, utilsAndConstants_1.incrementChangeKey)(newMutations)
+        }
+        return Object.assign(Object.assign({}, state), {mutations: newMutations})
       }
-      case actions.clearCache.type: {
+      case clearCache.type: {
         const {stateToKeep} = action
+        const initialState = mutable ? getMutableInitialState() : immutableInitialState
         return stateToKeep ? Object.assign(Object.assign({}, initialState), stateToKeep) : initialState
       }
     }

package/dist/cjs/createSelectors.js

@@ -25,6 +25,7 @@ const createSelectors = (cache) => {
       : utilsAndConstants_1.EMPTY_OBJECT
   }
   return {
+    selectEntityById,
     selectQueryState,
     selectQueryResult: (state, query, cacheKey) => {
       return selectQueryState(state, query, cacheKey).result
@@ -56,7 +57,6 @@ const createSelectors = (cache) => {
     selectMutationParams: (state, mutation) => {
       return selectMutationState(state, mutation).params
     },
-    selectEntityById,
     selectEntities: (state) => {
       return cache.cacheStateSelector(state).entities
     },