react-redux-cache 0.20.0 → 0.22.0

package/dist/cjs/utilsAndConstants.js

@@ -1,6 +1,7 @@
 'use strict'
 Object.defineProperty(exports, '__esModule', {value: true})
-exports.FetchPolicy =
+exports.incrementChangeKey =
+  exports.FetchPolicy =
   exports.createStateComparer =
   exports.isEmptyObject =
   exports.applyEntityChanges =
@@ -55,7 +56,7 @@ const defaultGetCacheKey = (params) => {
 }
 exports.defaultGetCacheKey = defaultGetCacheKey
 const applyEntityChanges = (entities, changes, options) => {
-  var _a, _b, _c, _d
+  var _a, _b, _c
   if (changes.merge && changes.entities) {
     ;(0, exports.logWarn)('applyEntityChanges', 'merge and entities should not be both set')
   }
@@ -63,6 +64,7 @@ const applyEntityChanges = (entities, changes, options) => {
   if (!merge && !replace && !remove) {
     return undefined
   }
+  const mutable = options.mutableCollections
   const deepEqual = options.deepComparisonEnabled ? exports.optionalUtils.deepEqual : undefined
   let result
   const objectWithAllTypenames = Object.assign(
@@ -108,37 +110,48 @@ const applyEntityChanges = (entities, changes, options) => {
         )
       }
     }
-    const oldEntities = (_d = entities[typename]) !== null && _d !== void 0 ? _d : exports.EMPTY_OBJECT
+    const oldEntities = entities[typename]
     let newEntities
     entitiesToRemove === null || entitiesToRemove === void 0
       ? void 0
       : entitiesToRemove.forEach((id) => {
-          if (oldEntities[id]) {
+          if (oldEntities === null || oldEntities === void 0 ? void 0 : oldEntities[id]) {
             newEntities !== null && newEntities !== void 0
               ? newEntities
-              : (newEntities = Object.assign({}, oldEntities))
+              : (newEntities = mutable ? oldEntities : Object.assign({}, oldEntities))
             delete newEntities[id]
           }
         })
     if (entitiesToReplace) {
       for (const id in entitiesToReplace) {
         const newEntity = entitiesToReplace[id]
-        if (!(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))) {
+        if (
+          oldEntities === undefined ||
+          !(deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldEntities[id], newEntity))
+        ) {
           newEntities !== null && newEntities !== void 0
             ? newEntities
-            : (newEntities = Object.assign({}, oldEntities))
+            : (newEntities = mutable
+                ? oldEntities !== null && oldEntities !== void 0
+                  ? oldEntities
+                  : {}
+                : Object.assign({}, oldEntities))
           newEntities[id] = newEntity
         }
       }
     }
     if (entitiesToMerge) {
       for (const id in entitiesToMerge) {
-        const oldEntity = oldEntities[id]
+        const oldEntity = oldEntities === null || oldEntities === void 0 ? void 0 : 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 = mutable
+                ? oldEntities !== null && oldEntities !== void 0
+                  ? oldEntities
+                  : {}
+                : Object.assign({}, oldEntities))
           newEntities[id] = newEntity
         }
       }
@@ -146,7 +159,15 @@ const applyEntityChanges = (entities, changes, options) => {
     if (!newEntities) {
       continue
     }
-    result !== null && result !== void 0 ? result : (result = Object.assign({}, entities))
+    if (mutable) {
+      ;(0, exports.incrementChangeKey)(newEntities)
+      if (result === undefined) {
+        ;(0, exports.incrementChangeKey)(entities)
+        result = entities
+      }
+    } else {
+      result !== null && result !== void 0 ? result : (result = Object.assign({}, entities))
+    }
     result[typename] = newEntities
   }
   options.logsEnabled &&
@@ -159,8 +180,8 @@ const applyEntityChanges = (entities, changes, options) => {
   return result
 }
 exports.applyEntityChanges = applyEntityChanges
-const isEmptyObject = (o) => {
-  for (const _ in o) {
+const isEmptyObject = (obj) => {
+  for (const _ in obj) {
     return false
   }
   return true
@@ -190,3 +211,11 @@ exports.FetchPolicy = {
   },
   Always: () => true,
 }
+const incrementChangeKey = (mutable) => {
+  if (mutable._changeKey === undefined) {
+    mutable._changeKey = 0
+  } else {
+    mutable._changeKey += 1
+  }
+}
+exports.incrementChangeKey = incrementChangeKey

package/dist/esm/createCache.js

@@ -21,36 +21,39 @@ import {
 export 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 = 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 = FetchPolicy.NoCacheOrExpired)
-      ;(_h = (_t = partialCache.globals.queries).skipFetch) !== null && _h !== void 0
+        : (_r.additionalValidation = 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 = 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,
@@ -189,6 +192,17 @@ export 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/esm/createReducer.js

@@ -2,45 +2,69 @@ 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 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]]
-        }
-      }
-    }
+    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]];
+        }}
     return t
   }
-import {applyEntityChanges, EMPTY_OBJECT, isEmptyObject, logDebug, optionalUtils} from './utilsAndConstants'
-
+import {
+  applyEntityChanges,
+  EMPTY_OBJECT,
+  incrementChangeKey,
+  isEmptyObject,
+  logDebug,
+  optionalUtils,
+} from './utilsAndConstants'
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
 const optionalMutationKeys = ['error', 'result', 'params', 'loading']
-
 export 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 &&
     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 ? 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)
@@ -84,23 +108,36 @@ export const createReducer = (actions, queryKeys, cacheOptions) => {
         if (newQueryState) {
           if (!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
+              incrementChangeKey(newState.queries)
+              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]
+              incrementChangeKey(newState.queries)
+              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 =
@@ -139,112 +176,150 @@ export const createReducer = (actions, queryKeys, cacheOptions) => {
         const newEntities = entityChanges && 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 (!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
+              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]
+              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 = 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)
+              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 (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) {
+          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)
+              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 !== EMPTY_OBJECT) {
-            newQueries !== null && newQueries !== void 0
-              ? newQueries
-              : (newQueries = Object.assign({}, state.queries))
-            newQueries[queryKey] = EMPTY_OBJECT
+            delete newStatesByQueryKey[queryKey][cacheKey]
+          } else if (mutable) {
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : (newStatesByQueryKey = state.queries)
+            newStatesByQueryKey[queryKey] = {}
+          } else if (statesByCacheKey !== EMPTY_OBJECT) {
+            newStatesByQueryKey !== null && newStatesByQueryKey !== void 0
+              ? newStatesByQueryKey
+              : (newStatesByQueryKey = Object.assign({}, state.queries))
+            newStatesByQueryKey[queryKey] = EMPTY_OBJECT
+            copiedQueryKeys.add(queryKey)
           }
         }
-        return newQueries === undefined
-          ? state
-          : Object.assign(Object.assign({}, state), {queries: newQueries})
+        if (newStatesByQueryKey === undefined) {
+          return state
+        }
+        if (mutable) {
+          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
@@ -254,16 +329,21 @@ export 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) {
+          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/esm/createSelectors.js

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