react-redux-cache 0.19.3 → 0.19.4-rc.0

package/README.md

@@ -23,7 +23,7 @@ Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with
 |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)).|
 |Reliability|High test coverage, zero issue policy.|
-|Lightweight|`npx minified-size dist/*.js`<br/>minified: 22.9 kB<br/>gzipped: 9.06 kB<br/>brotlied: 8.07 kB|
+|Lightweight|`npx minified-size dist/esm/*.js`<br/>minified: 18.3 kB<br/>gzipped: 7.91 kB<br/>brotlied: 7.02 kB|
 
 |Feature|Description|
 |--|--|

package/dist/cjs/createActions.js

@@ -0,0 +1,65 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.createActions = void 0
+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, entityChanges) => ({
+    type: updateQueryStateAndEntitiesType,
+    queryKey,
+    queryCacheKey,
+    state,
+    entityChanges,
+  })
+  updateQueryStateAndEntities.type = updateQueryStateAndEntitiesType
+  const updateMutationStateAndEntitiesType = `${actionPrefix}updateMutationStateAndEntities`
+  const updateMutationStateAndEntities = (mutationKey, state, entityChanges) => ({
+    type: updateMutationStateAndEntitiesType,
+    mutationKey,
+    state,
+    entityChanges,
+  })
+  updateMutationStateAndEntities.type = updateMutationStateAndEntitiesType
+  const mergeEntityChangesType = `${actionPrefix}mergeEntityChanges`
+  const mergeEntityChanges = (changes) => ({
+    type: mergeEntityChangesType,
+    changes,
+  })
+  mergeEntityChanges.type = mergeEntityChangesType
+  const invalidateQueryType = `${actionPrefix}invalidateQuery`
+  const invalidateQuery = (queries) => ({
+    type: invalidateQueryType,
+    queries,
+  })
+  invalidateQuery.type = invalidateQueryType
+  const clearQueryStateType = `${actionPrefix}clearQueryState`
+  const clearQueryState = (queries) => ({
+    type: clearQueryStateType,
+    queries,
+  })
+  clearQueryState.type = clearQueryStateType
+  const clearMutationStateType = `${actionPrefix}clearMutationState`
+  const clearMutationState = (mutationKeys) => ({
+    type: clearMutationStateType,
+    mutationKeys,
+  })
+  clearMutationState.type = clearMutationStateType
+  const clearCacheType = `${actionPrefix}clearCache`
+  const clearCache = (stateToKeep) => ({
+    type: clearCacheType,
+    stateToKeep,
+  })
+  clearCache.type = clearCacheType
+  return {
+    updateQueryStateAndEntities,
+    updateMutationStateAndEntities,
+    mergeEntityChanges,
+    invalidateQuery,
+    clearQueryState,
+    clearMutationState,
+    clearCache,
+  }
+}
+exports.createActions = createActions

package/dist/cjs/createCache.js

@@ -0,0 +1,208 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.createCache = exports.withTypenames = void 0
+const react_1 = require('react')
+const createActions_1 = require('./createActions')
+const createCacheReducer_1 = require('./createCacheReducer')
+const createSelectors_1 = require('./createSelectors')
+const mutate_1 = require('./mutate')
+const query_1 = require('./query')
+const useMutation_1 = require('./useMutation')
+const useQuery_1 = require('./useQuery')
+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
+      const abortControllers = new WeakMap()
+      ;(_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {})
+      ;(_b = (_o = partialCache.options).logsEnabled) !== null && _b !== void 0
+        ? _b
+        : (_o.logsEnabled = false)
+      ;(_c = (_p = partialCache.options).additionalValidation) !== null && _c !== void 0
+        ? _c
+        : (_p.additionalValidation = utilsAndConstants_1.IS_DEV)
+      ;(_d = (_q = partialCache.options).deepComparisonEnabled) !== 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
+        ? _h
+        : (_t.skipFetch = false)
+      ;(_j = partialCache.cacheStateSelector) !== null && _j !== void 0
+        ? _j
+        : (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 = {})
+      partialCache.abortControllers = abortControllers
+      try {
+        ;(_m = partialCache.storeHooks) !== null && _m !== void 0
+          ? _m
+          : (partialCache.storeHooks = {
+              useStore: require('react-redux').useStore,
+              useSelector: require('react-redux').useSelector,
+            })
+      } catch (e) {
+        throw e
+      }
+      const cache = partialCache
+      if (cache.options.deepComparisonEnabled && !utilsAndConstants_1.optionalUtils.deepEqual) {
+        console.warn(
+          'react-redux-cache: optional dependency for fast-deep-equal was not provided, while deepComparisonEnabled option is true'
+        )
+      }
+      const setDefaultComparer = (target) => {
+        if (
+          (target === null || target === void 0 ? void 0 : target.selectorComparer) != null &&
+          typeof target.selectorComparer === 'object'
+        ) {
+          target.selectorComparer = (0, utilsAndConstants_1.createStateComparer)(target.selectorComparer)
+        }
+      }
+      setDefaultComparer(cache.globals.queries)
+      for (const queryKey in partialCache.queries) {
+        setDefaultComparer(partialCache.queries[queryKey])
+      }
+      const selectors = Object.assign(
+        {selectCacheState: cache.cacheStateSelector},
+        (0, createSelectors_1.createSelectors)(cache)
+      )
+      const {
+        selectCacheState,
+        selectQueryState,
+        selectQueryResult,
+        selectQueryLoading,
+        selectQueryError,
+        selectQueryParams,
+        selectQueryExpiresAt,
+        selectMutationState,
+        selectMutationResult,
+        selectMutationLoading,
+        selectMutationError,
+        selectMutationParams,
+        selectEntityById,
+        selectEntities,
+        selectEntitiesByTypename,
+      } = selectors
+      const actions = (0, createActions_1.createActions)(cache.name)
+      const {
+        updateQueryStateAndEntities,
+        updateMutationStateAndEntities,
+        mergeEntityChanges,
+        invalidateQuery,
+        clearQueryState,
+        clearMutationState,
+        clearCache,
+      } = actions
+      const reducer = (0, createCacheReducer_1.createCacheReducer)(
+        actions,
+        Object.keys(cache.queries),
+        cache.options
+      )
+      const createClient = (store) => {
+        const client = {
+          query: (options) => {
+            var _a
+            const {query: queryKey, params} = options
+            const getCacheKey =
+              (_a = cache.queries[queryKey].getCacheKey) !== null && _a !== void 0
+                ? _a
+                : utilsAndConstants_1.defaultGetCacheKey
+            const cacheKey = getCacheKey(params)
+            return (0, query_1.query)(
+              'query',
+              store,
+              cache,
+              actions,
+              selectors,
+              queryKey,
+              cacheKey,
+              params,
+              options.secondsToLive,
+              options.onlyIfExpired,
+              options.mergeResults,
+              options.onCompleted,
+              options.onSuccess,
+              options.onError
+            )
+          },
+          mutate: (options) => {
+            return (0, mutate_1.mutate)(
+              'mutate',
+              store,
+              cache,
+              actions,
+              selectors,
+              options.mutation,
+              options.params,
+              abortControllers,
+              options.onCompleted,
+              options.onSuccess,
+              options.onError
+            )
+          },
+        }
+        return client
+      }
+      return {
+        cache,
+        reducer,
+        actions: {
+          updateQueryStateAndEntities,
+          updateMutationStateAndEntities,
+          mergeEntityChanges,
+          invalidateQuery,
+          clearQueryState,
+          clearMutationState,
+          clearCache,
+        },
+        selectors: {
+          selectCacheState,
+          selectQueryState,
+          selectQueryResult,
+          selectQueryLoading,
+          selectQueryError,
+          selectQueryParams,
+          selectQueryExpiresAt,
+          selectMutationState,
+          selectMutationResult,
+          selectMutationLoading,
+          selectMutationError,
+          selectMutationParams,
+          selectEntityById,
+          selectEntities,
+          selectEntitiesByTypename,
+        },
+        hooks: {
+          useClient: () => {
+            const store = cache.storeHooks.useStore()
+            return (0, react_1.useMemo)(() => createClient(store), [store])
+          },
+          useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, selectors, options),
+          useMutation: (options) =>
+            (0, useMutation_1.useMutation)(cache, actions, selectors, options, abortControllers),
+          useSelectEntityById: (id, typename) => {
+            return cache.storeHooks.useSelector((state) => selectEntityById(state, id, typename))
+          },
+        },
+        utils: {
+          createClient,
+          getInitialState: () => {
+            return reducer(undefined, utilsAndConstants_1.EMPTY_OBJECT)
+          },
+          applyEntityChanges: (entities, changes) => {
+            return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options)
+          },
+        },
+      }
+    },
+  }
+}
+exports.withTypenames = withTypenames
+exports.createCache = (0, exports.withTypenames)().createCache

package/dist/cjs/createCacheReducer.js

@@ -0,0 +1,285 @@
+'use strict'
+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]]
+        }
+      }
+    }
+    return t
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.createCacheReducer = void 0
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
+const optionalMutationKeys = ['error', 'result', 'params', 'loading']
+const createCacheReducer = (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({}),
+  })
+  cacheOptions.logsEnabled &&
+    (0, utilsAndConstants_1.log)('createCacheReducer', {
+      queryKeys,
+      initialState,
+    })
+  const deepEqual = cacheOptions.deepComparisonEnabled
+    ? utilsAndConstants_1.optionalUtils.deepEqual
+    : undefined
+  return (state = initialState, action) => {
+    switch (action.type) {
+      case actions.updateQueryStateAndEntities.type: {
+        const {queryKey, queryCacheKey, state: queryState, entityChanges} = action
+        const oldQueryState = state.queries[queryKey][queryCacheKey]
+        let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState)
+        if (newQueryState) {
+          if (oldQueryState && deepEqual) {
+            if (
+              newQueryState.params !== oldQueryState.params &&
+              deepEqual(newQueryState.params, oldQueryState.params)
+            ) {
+              newQueryState.params = oldQueryState.params
+            }
+            if (
+              newQueryState.result !== oldQueryState.result &&
+              deepEqual(newQueryState.result, oldQueryState.result)
+            ) {
+              newQueryState.result = oldQueryState.result
+            }
+          }
+          for (const key of optionalQueryKeys) {
+            if (key in newQueryState && newQueryState[key] === undefined) {
+              delete newQueryState[key]
+            }
+          }
+          if (
+            deepEqual === null || deepEqual === void 0
+              ? void 0
+              : deepEqual(
+                  oldQueryState !== null && oldQueryState !== void 0
+                    ? oldQueryState
+                    : utilsAndConstants_1.EMPTY_OBJECT,
+                  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) {
+          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 + ''])
+            newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state))
+            newState.queries = Object.assign(Object.assign({}, state.queries), {[queryKey]: withoutCacheKey})
+          }
+        }
+        return newState !== null && newState !== void 0 ? newState : state
+      }
+      case actions.updateMutationStateAndEntities.type: {
+        const {mutationKey, state: mutationState, entityChanges} = action
+        const oldMutationState = state.mutations[mutationKey]
+        let newMutationState =
+          mutationState && Object.assign(Object.assign({}, oldMutationState), mutationState)
+        if (newMutationState) {
+          if (oldMutationState && deepEqual) {
+            if (
+              newMutationState.params !== oldMutationState.params &&
+              deepEqual(newMutationState.params, oldMutationState.params)
+            ) {
+              newMutationState.params = oldMutationState.params
+            }
+            if (
+              newMutationState.result !== oldMutationState.result &&
+              deepEqual(newMutationState.result, oldMutationState.result)
+            ) {
+              newMutationState.result = oldMutationState.result
+            }
+          }
+          for (const key of optionalMutationKeys) {
+            if (key in newMutationState && newMutationState[key] === undefined) {
+              delete newMutationState[key]
+            }
+          }
+          if (
+            deepEqual === null || deepEqual === void 0
+              ? void 0
+              : deepEqual(
+                  oldMutationState !== null && oldMutationState !== void 0
+                    ? oldMutationState
+                    : utilsAndConstants_1.EMPTY_OBJECT,
+                  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
+        }
+        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 + ''])
+            newState !== null && newState !== void 0 ? newState : (newState = Object.assign({}, state))
+            newState.mutations = withoutMutationKey
+          }
+        }
+        return newState !== null && newState !== void 0 ? newState : state
+      }
+      case actions.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: {
+        const {queries: queriesToInvalidate} = action
+        if (queriesToInvalidate.length === 0) {
+          return state
+        }
+        const now = Date.now()
+        let newQueries = undefined
+        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
+                }
+              }
+            }
+          } 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
+                }
+              }
+            }
+          }
+        }
+        return newQueries === undefined
+          ? state
+          : Object.assign(Object.assign({}, state), {queries: newQueries})
+      }
+      case actions.clearQueryState.type: {
+        const {queries: queriesToClear} = action
+        if (queriesToClear.length === 0) {
+          return state
+        }
+        let newQueries = undefined
+        for (const {query: queryKey, cacheKey} of queriesToClear) {
+          const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : 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])
+              }
+              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
+          }
+        }
+        return newQueries === undefined
+          ? state
+          : Object.assign(Object.assign({}, state), {queries: newQueries})
+      }
+      case actions.clearMutationState.type: {
+        const {mutationKeys} = action
+        if (mutationKeys.length === 0) {
+          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]
+          }
+        }
+        return newMutations === undefined
+          ? state
+          : Object.assign(Object.assign({}, state), {mutations: newMutations})
+      }
+      case actions.clearCache.type: {
+        const {stateToKeep} = action
+        return stateToKeep ? Object.assign(Object.assign({}, initialState), stateToKeep) : initialState
+      }
+    }
+    return state
+  }
+}
+exports.createCacheReducer = createCacheReducer

package/dist/cjs/createSelectors.js

@@ -0,0 +1,68 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.createSelectors = void 0
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+const createSelectors = (cache) => {
+  const selectEntityById = (state, id, typename) => {
+    var _a
+    return id == null
+      ? undefined
+      : (_a = cache.cacheStateSelector(state).entities[typename]) === null || _a === void 0
+      ? void 0
+      : _a[id]
+  }
+  const selectQueryState = (state, query, cacheKey) => {
+    var _a
+    return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0
+      ? _a
+      : utilsAndConstants_1.EMPTY_OBJECT
+  }
+  const selectMutationState = (state, mutation) => {
+    var _a
+    return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0
+      ? _a
+      : utilsAndConstants_1.EMPTY_OBJECT
+  }
+  return {
+    selectQueryState,
+    selectQueryResult: (state, query, cacheKey) => {
+      return selectQueryState(state, query, cacheKey).result
+    },
+    selectQueryLoading: (state, query, cacheKey) => {
+      var _a
+      return (_a = selectQueryState(state, query, cacheKey).loading) !== null && _a !== void 0 ? _a : false
+    },
+    selectQueryError: (state, query, cacheKey) => {
+      return selectQueryState(state, query, cacheKey).error
+    },
+    selectQueryParams: (state, query, cacheKey) => {
+      return selectQueryState(state, query, cacheKey).params
+    },
+    selectQueryExpiresAt: (state, query, cacheKey) => {
+      return selectQueryState(state, query, cacheKey).expiresAt
+    },
+    selectMutationState,
+    selectMutationResult: (state, mutation) => {
+      return selectMutationState(state, mutation).result
+    },
+    selectMutationLoading: (state, mutation) => {
+      var _a
+      return (_a = selectMutationState(state, mutation).loading) !== null && _a !== void 0 ? _a : false
+    },
+    selectMutationError: (state, mutation) => {
+      return selectMutationState(state, mutation).error
+    },
+    selectMutationParams: (state, mutation) => {
+      return selectMutationState(state, mutation).params
+    },
+    selectEntityById,
+    selectEntities: (state) => {
+      return cache.cacheStateSelector(state).entities
+    },
+    selectEntitiesByTypename: (state, typename) => {
+      return cache.cacheStateSelector(state).entities[typename]
+    },
+  }
+}
+exports.createSelectors = createSelectors