react-redux-cache 0.19.3 → 0.19.4

package/dist/cjs/index.js

@@ -0,0 +1,83 @@
+'use strict'
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) {
+          k2 = k
+        }
+        var desc = Object.getOwnPropertyDescriptor(m, k)
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get() {
+              return m[k]
+            },
+          }
+        }
+        Object.defineProperty(o, k2, desc)
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) {
+          k2 = k
+        }
+        o[k2] = m[k]
+      })
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m) {
+      if (p !== 'default' && !Object.prototype.hasOwnProperty.call(exports, p)) {
+        __createBinding(exports, m, p)
+      }
+    }
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.isEmptyObject =
+  exports.FetchPolicy =
+  exports.defaultGetCacheKey =
+  exports.createStateComparer =
+  exports.withTypenames =
+  exports.createCache =
+    void 0
+var createCache_1 = require('./createCache')
+
+Object.defineProperty(exports, 'createCache', {
+  enumerable: true,
+  get() {
+    return createCache_1.createCache
+  },
+})
+Object.defineProperty(exports, 'withTypenames', {
+  enumerable: true,
+  get() {
+    return createCache_1.withTypenames
+  },
+})
+__exportStar(require('./types'), exports)
+var utilsAndConstants_1 = require('./utilsAndConstants')
+
+Object.defineProperty(exports, 'createStateComparer', {
+  enumerable: true,
+  get() {
+    return utilsAndConstants_1.createStateComparer
+  },
+})
+Object.defineProperty(exports, 'defaultGetCacheKey', {
+  enumerable: true,
+  get() {
+    return utilsAndConstants_1.defaultGetCacheKey
+  },
+})
+Object.defineProperty(exports, 'FetchPolicy', {
+  enumerable: true,
+  get() {
+    return utilsAndConstants_1.FetchPolicy
+  },
+})
+Object.defineProperty(exports, 'isEmptyObject', {
+  enumerable: true,
+  get() {
+    return utilsAndConstants_1.isEmptyObject
+  },
+})

package/dist/cjs/mutate.js

@@ -0,0 +1,161 @@
+'use strict'
+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())
+    })
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.mutate = void 0
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+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 &&
+          (0, utilsAndConstants_1.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 &&
+        (0, utilsAndConstants_1.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`)
+    }
+  )
+exports.mutate = mutate
+const ABORTED_RESULT = Object.freeze({aborted: true})

package/dist/cjs/query.js

@@ -0,0 +1,180 @@
+'use strict'
+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())
+    })
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.query = void 0
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+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 &&
+        (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: already loading`, {
+          queryStateOnStart,
+          params,
+          cacheKey,
+        })
+      const error = yield queryStateOnStart.loading.then(utilsAndConstants_1.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 &&
+        (0, utilsAndConstants_1.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 &&
+      (0, utilsAndConstants_1.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,
+    }
+  })
+exports.query = query
+const catchAndReturn = (x) => x

package/dist/cjs/types.js

@@ -0,0 +1,2 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', {value: true})

package/dist/cjs/useMutation.js

@@ -0,0 +1,82 @@
+'use strict'
+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())
+    })
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.useMutation = void 0
+const react_1 = require('react')
+const mutate_1 = require('./mutate')
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+const useMutation = (cache, actions, selectors, options, abortControllers) => {
+  var _a
+  const {mutation: mutationKey, onCompleted, onSuccess, onError} = options
+  const store = cache.storeHooks.useStore()
+  const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
+    return [
+      (state) => {
+        cache.options.logsEnabled &&
+          (0, utilsAndConstants_1.log)('mutationStateSelector', {
+            state,
+            cacheState: cache.cacheStateSelector(state),
+          })
+        return cache.cacheStateSelector(state).mutations[mutationKey]
+      },
+      (params) =>
+        __awaiter(void 0, void 0, void 0, function* () {
+          return yield (0,
+          mutate_1.mutate)('useMutation.mutate', store, cache, actions, selectors, mutationKey, params, abortControllers, onCompleted, onSuccess, onError)
+        }),
+      () => {
+        var _a
+        const abortController =
+          (_a = abortControllers.get(store)) === null || _a === void 0 ? void 0 : _a[mutationKey]
+        if (abortController === undefined || abortController.signal.aborted) {
+          return false
+        }
+        abortController.abort()
+        store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {loading: undefined}))
+        return true
+      },
+    ]
+  }, [mutationKey, store])
+  const mutationState =
+    (_a = cache.storeHooks.useSelector(mutationStateSelector)) !== null && _a !== void 0
+      ? _a
+      : utilsAndConstants_1.EMPTY_OBJECT
+  cache.options.logsEnabled &&
+    (0, utilsAndConstants_1.log)('useMutation', {
+      options,
+      mutationState,
+    })
+  return [mutate, mutationState, abort]
+}
+exports.useMutation = useMutation

package/dist/cjs/useQuery.js

@@ -0,0 +1,121 @@
+'use strict'
+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())
+    })
+  }
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.useQuery = void 0
+const react_1 = require('react')
+const query_1 = require('./query')
+const utilsAndConstants_1 = require('./utilsAndConstants')
+
+const useQuery = (cache, actions, selectors, options) => {
+  var _a, _b, _c, _d, _e
+  const {
+    query: queryKey,
+    skipFetch = false,
+    params,
+    secondsToLive,
+    selectorComparer,
+    fetchPolicy = (_a = cache.queries[queryKey].fetchPolicy) !== null && _a !== void 0
+      ? _a
+      : cache.globals.queries.fetchPolicy,
+    mergeResults,
+    onCompleted,
+    onSuccess,
+    onError,
+  } = options
+  const {selectQueryState} = selectors
+  const queryInfo = cache.queries[queryKey]
+  const logsEnabled = cache.options.logsEnabled
+  const getCacheKey =
+    (_b = queryInfo.getCacheKey) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultGetCacheKey
+  const comparer =
+    selectorComparer === undefined
+      ? (_d =
+          (_c = queryInfo.selectorComparer) !== null && _c !== void 0
+            ? _c
+            : cache.globals.queries.selectorComparer) !== null && _d !== void 0
+        ? _d
+        : defaultStateComparer
+      : typeof selectorComparer === 'function'
+      ? selectorComparer
+      : (0, utilsAndConstants_1.createStateComparer)(selectorComparer)
+  const store = cache.storeHooks.useStore()
+  const cacheKey = getCacheKey(params)
+  const performFetch = (0, react_1.useCallback)(
+    (options) =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        const paramsPassed = options && 'params' in options
+        return yield (0,
+        query_1.query)('useQuery.fetch', store, cache, actions, selectors, queryKey, paramsPassed ? getCacheKey(options.params) : cacheKey, paramsPassed ? options.params : params, secondsToLive, options === null || options === void 0 ? void 0 : options.onlyIfExpired, mergeResults, onCompleted, onSuccess, onError)
+      }),
+    [store, queryKey, cacheKey]
+  )
+  const queryState =
+    (_e = cache.storeHooks.useSelector((state) => {
+      return selectQueryState(state, queryKey, cacheKey)
+    }, comparer)) !== null && _e !== void 0
+      ? _e
+      : utilsAndConstants_1.EMPTY_OBJECT
+  ;(0, react_1.useEffect)(() => {
+    if (skipFetch) {
+      logsEnabled &&
+        (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', {skipFetch, queryKey, cacheKey})
+      return
+    }
+    const expired = queryState.expiresAt != null && queryState.expiresAt <= Date.now()
+    if (!fetchPolicy(expired, params, queryState, store, selectors)) {
+      logsEnabled &&
+        (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch due to fetch policy', {
+          queryState,
+          expired,
+          queryKey,
+          cacheKey,
+        })
+      return
+    }
+    performFetch()
+  }, [cacheKey, skipFetch])
+  logsEnabled &&
+    (0, utilsAndConstants_1.log)('useQuery', {
+      cacheKey,
+      options,
+      queryState,
+    })
+  return [queryState, performFetch]
+}
+exports.useQuery = useQuery
+const defaultStateComparer = (0, utilsAndConstants_1.createStateComparer)([
+  'result',
+  'loading',
+  'params',
+  'error',
+])