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

package/dist/esm/createCacheReducer.js

@@ -0,0 +1,271 @@
+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
+  }
+import {applyEntityChanges, EMPTY_OBJECT, isEmptyObject, log, optionalUtils} from './utilsAndConstants'
+
+const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params', 'loading']
+const optionalMutationKeys = ['error', 'result', 'params', 'loading']
+export 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 &&
+    log('createCacheReducer', {
+      queryKeys,
+      initialState,
+    })
+  const deepEqual = cacheOptions.deepComparisonEnabled ? 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 : EMPTY_OBJECT,
+                  newQueryState
+                )
+          ) {
+            newQueryState = undefined
+          }
+        }
+        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
+        }
+        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 + ''])
+            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 : EMPTY_OBJECT,
+                  newMutationState
+                )
+          ) {
+            newMutationState = undefined
+          }
+        }
+        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
+        }
+        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 + ''])
+            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 = 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 !== EMPTY_OBJECT) {
+            newQueries !== null && newQueries !== void 0
+              ? newQueries
+              : (newQueries = Object.assign({}, state.queries))
+            newQueries[queryKey] = 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
+  }
+}

package/dist/esm/createSelectors.js

@@ -0,0 +1,64 @@
+import {EMPTY_OBJECT} from './utilsAndConstants'
+
+export 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
+      : EMPTY_OBJECT
+  }
+  const selectMutationState = (state, mutation) => {
+    var _a
+    return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0
+      ? _a
+      : 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]
+    },
+  }
+}

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export {createCache, withTypenames} from './createCache'
+export * from './types'
+export {createStateComparer, defaultGetCacheKey, FetchPolicy, isEmptyObject} from './utilsAndConstants'

package/dist/esm/mutate.js

@@ -0,0 +1,157 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value)
+          })
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next())
+    })
+  }
+import {log} from './utilsAndConstants'
+
+export const mutate = (
+  logTag_1,
+  store_1,
+  cache_1,
+  actions_1,
+  selectors_1,
+  mutationKey_1,
+  params_1,
+  abortControllers_1,
+  ...args_1
+) =>
+  __awaiter(
+    void 0,
+    [
+      logTag_1,
+      store_1,
+      cache_1,
+      actions_1,
+      selectors_1,
+      mutationKey_1,
+      params_1,
+      abortControllers_1,
+      ...args_1,
+    ],
+    void 0,
+    function* (
+      logTag,
+      store,
+      cache,
+      actions,
+      selectors,
+      mutationKey,
+      params,
+      abortControllers,
+      onCompleted = cache.mutations[mutationKey].onCompleted,
+      onSuccess = cache.mutations[mutationKey].onSuccess,
+      onError = cache.mutations[mutationKey].onError
+    ) {
+      var _a, _b
+      const {updateMutationStateAndEntities} = actions
+      let abortControllersOfStore = abortControllers.get(store)
+      if (abortControllersOfStore === undefined) {
+        abortControllersOfStore = {}
+        abortControllers.set(store, abortControllersOfStore)
+      }
+      {
+        const abortController = abortControllersOfStore[mutationKey]
+        cache.options.logsEnabled &&
+          log(logTag, {
+            mutationKey,
+            params,
+            previousAborted: abortController !== undefined,
+          })
+        if (abortController !== undefined) {
+          abortController.abort()
+        }
+      }
+      const abortController = new AbortController()
+      abortControllersOfStore[mutationKey] = abortController
+      const mutatePromise = cache.mutations[mutationKey].mutation(params, store, abortController.signal)
+      store.dispatch(
+        updateMutationStateAndEntities(mutationKey, {
+          loading: mutatePromise,
+          params,
+          result: undefined,
+        })
+      )
+      let response
+      let error
+      try {
+        response = yield mutatePromise
+      } catch (e) {
+        error = e
+      }
+      cache.options.logsEnabled &&
+        log(`${logTag} finished`, {
+          response,
+          error,
+          aborted: abortController.signal.aborted,
+        })
+      if (abortController.signal.aborted) {
+        return ABORTED_RESULT
+      }
+      delete abortControllersOfStore[mutationKey]
+      if (error) {
+        store.dispatch(
+          updateMutationStateAndEntities(mutationKey, {
+            error,
+            loading: undefined,
+          })
+        )
+        if (
+          !(onError === null || onError === void 0
+            ? void 0
+            : onError(error, params, store, actions, selectors))
+        ) {
+          ;(_b = (_a = cache.globals).onError) === null || _b === void 0
+            ? void 0
+            : _b.call(_a, error, mutationKey, params, store, actions, selectors)
+        }
+        onCompleted === null || onCompleted === void 0
+          ? void 0
+          : onCompleted(response, error, params, store, actions, selectors)
+        return {error}
+      }
+      if (response) {
+        const newState = {
+          error: undefined,
+          loading: undefined,
+          result: response.result,
+        }
+        store.dispatch(updateMutationStateAndEntities(mutationKey, newState, response))
+        onSuccess === null || onSuccess === void 0
+          ? void 0
+          : onSuccess(response, params, store, actions, selectors)
+        onCompleted === null || onCompleted === void 0
+          ? void 0
+          : onCompleted(response, error, params, store, actions, selectors)
+        return {result: response.result}
+      }
+      throw new Error(`${logTag}: both error and response are not defined`)
+    }
+  )
+const ABORTED_RESULT = Object.freeze({aborted: true})

package/dist/esm/query.js

@@ -0,0 +1,169 @@
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value)
+          })
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value))
+        } catch (e) {
+          reject(e)
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected)
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next())
+    })
+  }
+import {log, NOOP} from './utilsAndConstants'
+
+export const query = (
+  logTag,
+  store,
+  cache,
+  actions,
+  selectors,
+  queryKey,
+  cacheKey,
+  params,
+  secondsToLive,
+  onlyIfExpired,
+  mergeResults,
+  onCompleted,
+  onSuccess,
+  onError
+) =>
+  __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d
+    if (secondsToLive === void 0) {
+      secondsToLive =
+        (_a = cache.queries[queryKey].secondsToLive) !== null && _a !== void 0
+          ? _a
+          : cache.globals.queries.secondsToLive
+    }
+    if (mergeResults === void 0) {
+      mergeResults = cache.queries[queryKey].mergeResults
+    }
+    if (onCompleted === void 0) {
+      onCompleted = cache.queries[queryKey].onCompleted
+    }
+    if (onSuccess === void 0) {
+      onSuccess = cache.queries[queryKey].onSuccess
+    }
+    if (onError === void 0) {
+      onError = cache.queries[queryKey].onError
+    }
+    const {selectQueryResult, selectQueryState} = selectors
+    const logsEnabled = cache.options.logsEnabled
+    const queryStateOnStart = selectQueryState(store.getState(), queryKey, cacheKey)
+    if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
+      logsEnabled &&
+        log(`${logTag} fetch cancelled: already loading`, {
+          queryStateOnStart,
+          params,
+          cacheKey,
+        })
+      const error = yield queryStateOnStart.loading.then(NOOP).catch(catchAndReturn)
+      return error
+        ? {
+            cancelled: 'loading',
+            error,
+          }
+        : {
+            cancelled: 'loading',
+            result: selectQueryResult(store.getState(), queryKey, cacheKey),
+          }
+    }
+    if (
+      onlyIfExpired &&
+      (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.expiresAt) !=
+        null &&
+      queryStateOnStart.expiresAt > Date.now()
+    ) {
+      logsEnabled &&
+        log(`${logTag} fetch cancelled: not expired yet`, {
+          queryStateOnStart,
+          params,
+          cacheKey,
+          onlyIfExpired,
+        })
+      return {
+        cancelled: 'not-expired',
+        result: queryStateOnStart.result,
+      }
+    }
+    const {updateQueryStateAndEntities} = actions
+    const fetchPromise = cache.queries[queryKey].query(params, store)
+    store.dispatch(
+      updateQueryStateAndEntities(queryKey, cacheKey, {
+        loading: fetchPromise,
+        params,
+      })
+    )
+    logsEnabled && log(`${logTag} started`, {queryKey, params, cacheKey, queryStateOnStart, onlyIfExpired})
+    let response
+    try {
+      response = yield fetchPromise
+    } catch (error) {
+      store.dispatch(
+        updateQueryStateAndEntities(queryKey, cacheKey, {
+          error,
+          loading: undefined,
+        })
+      )
+      if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
+        ;(_c = (_b = cache.globals).onError) === null || _c === void 0
+          ? void 0
+          : _c.call(_b, error, queryKey, params, store, actions, selectors)
+      }
+      onCompleted === null || onCompleted === void 0
+        ? void 0
+        : onCompleted(undefined, error, params, store, actions, selectors)
+      return {error}
+    }
+    const newState = {
+      error: undefined,
+      loading: undefined,
+      expiresAt:
+        (_d = response.expiresAt) !== null && _d !== void 0
+          ? _d
+          : secondsToLive != null
+          ? Date.now() + secondsToLive * 1000
+          : undefined,
+      result: mergeResults
+        ? mergeResults(
+            selectQueryResult(store.getState(), queryKey, cacheKey),
+            response,
+            params,
+            store,
+            actions,
+            selectors
+          )
+        : response.result,
+    }
+    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response))
+    onSuccess === null || onSuccess === void 0
+      ? void 0
+      : onSuccess(response, params, store, actions, selectors)
+    onCompleted === null || onCompleted === void 0
+      ? void 0
+      : onCompleted(response, undefined, params, store, actions, selectors)
+    return {
+      result: newState === null || newState === void 0 ? void 0 : newState.result,
+    }
+  })
+const catchAndReturn = (x) => x

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {}