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

package/dist/esm/useMutation.js

@@ -0,0 +1,88 @@
+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 {useMemo} from 'react'
+
+import {mutate as mutateImpl} from './mutate'
+import {EMPTY_OBJECT, log} from './utilsAndConstants'
+
+export 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] = useMemo(() => {
+    return [
+      (state) => {
+        cache.options.logsEnabled &&
+          log('mutationStateSelector', {
+            state,
+            cacheState: cache.cacheStateSelector(state),
+          })
+        return cache.cacheStateSelector(state).mutations[mutationKey]
+      },
+      (params) =>
+        __awaiter(void 0, void 0, void 0, function* () {
+          return yield mutateImpl(
+            '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 : EMPTY_OBJECT
+  cache.options.logsEnabled &&
+    log('useMutation', {
+      options,
+      mutationState,
+    })
+  return [mutate, mutationState, abort]
+}

package/dist/esm/useQuery.js

@@ -0,0 +1,125 @@
+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 {useCallback, useEffect} from 'react'
+
+import {query as queryImpl} from './query'
+import {createStateComparer, defaultGetCacheKey, EMPTY_OBJECT, log} from './utilsAndConstants'
+
+export 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 : 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
+      : createStateComparer(selectorComparer)
+  const store = cache.storeHooks.useStore()
+  const cacheKey = getCacheKey(params)
+  const performFetch = useCallback(
+    (options) =>
+      __awaiter(void 0, void 0, void 0, function* () {
+        const paramsPassed = options && 'params' in options
+        return yield queryImpl(
+          '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
+      : EMPTY_OBJECT
+  useEffect(() => {
+    if (skipFetch) {
+      logsEnabled && 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 &&
+        log('useQuery.useEffect skip fetch due to fetch policy', {
+          queryState,
+          expired,
+          queryKey,
+          cacheKey,
+        })
+      return
+    }
+    performFetch()
+  }, [cacheKey, skipFetch])
+  logsEnabled &&
+    log('useQuery', {
+      cacheKey,
+      options,
+      queryState,
+    })
+  return [queryState, performFetch]
+}
+const defaultStateComparer = createStateComparer(['result', 'loading', 'params', 'error'])

package/dist/esm/utilsAndConstants.js

@@ -0,0 +1,168 @@
+export const PACKAGE_SHORT_NAME = 'rrc'
+export const optionalUtils = {
+  deepEqual: undefined,
+}
+try {
+  optionalUtils.deepEqual = require('fast-deep-equal/es6')
+} catch (_a) {
+  console.debug(PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed')
+}
+export const IS_DEV = (() => {
+  try {
+    return __DEV__
+  } catch (e) {
+    return process.env.NODE_ENV === 'development'
+  }
+})()
+export const EMPTY_OBJECT = Object.freeze({})
+export const EMPTY_ARRAY = Object.freeze([])
+export const NOOP = () => {}
+export const defaultGetCacheKey = (params) => {
+  switch (typeof params) {
+    case 'string':
+    case 'symbol':
+      return params
+    case 'object':
+      return JSON.stringify(params)
+    default:
+      return String(params)
+  }
+}
+export const log = (tag, data) => {
+  console.debug(`@${PACKAGE_SHORT_NAME} [${tag}]`, data)
+}
+export const FetchPolicy = {
+  NoCacheOrExpired: (expired, _params, state) => {
+    return expired || state.result === undefined
+  },
+  Always: () => true,
+}
+export const applyEntityChanges = (entities, changes, options) => {
+  var _a, _b, _c, _d
+  if (changes.merge && changes.entities) {
+    console.warn('react-redux-cache.applyEntityChanges: merge and entities should not be both set')
+  }
+  const {merge = changes.entities, replace, remove} = changes
+  if (!merge && !replace && !remove) {
+    return undefined
+  }
+  const deepEqual = options.deepComparisonEnabled ? optionalUtils.deepEqual : undefined
+  let result
+  const typenames = new Set([
+    ...(changes.entities ? Object.keys(changes.entities) : EMPTY_ARRAY),
+    ...(changes.merge ? Object.keys(changes.merge) : EMPTY_ARRAY),
+    ...(changes.remove ? Object.keys(changes.remove) : EMPTY_ARRAY),
+    ...(changes.replace ? Object.keys(changes.replace) : EMPTY_ARRAY),
+  ])
+  for (const typename of typenames) {
+    const entitiesToMerge = merge === null || merge === void 0 ? void 0 : merge[typename]
+    const entitiesToReplace = replace === null || replace === void 0 ? void 0 : replace[typename]
+    const entitiesToRemove = remove === null || remove === void 0 ? void 0 : remove[typename]
+    if (
+      !entitiesToMerge &&
+      !entitiesToReplace &&
+      !(entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length)
+    ) {
+      continue
+    }
+    if (options.additionalValidation) {
+      const mergeIds = entitiesToMerge && Object.keys(entitiesToMerge)
+      const replaceIds = entitiesToReplace && Object.keys(entitiesToReplace)
+      const idsSet = new Set(mergeIds)
+      replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.forEach((id) => idsSet.add(id))
+      entitiesToRemove === null || entitiesToRemove === void 0
+        ? void 0
+        : entitiesToRemove.forEach((id) => idsSet.add(String(id)))
+      const totalKeysInResponse =
+        ((_a = mergeIds === null || mergeIds === void 0 ? void 0 : mergeIds.length) !== null && _a !== void 0
+          ? _a
+          : 0) +
+        ((_b = replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.length) !== null &&
+        _b !== void 0
+          ? _b
+          : 0) +
+        ((_c =
+          entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length) !==
+          null && _c !== void 0
+          ? _c
+          : 0)
+      if (totalKeysInResponse !== 0 && idsSet.size !== totalKeysInResponse) {
+        console.warn(
+          'react-redux-cache.applyEntityChanges: merge, replace and remove changes have intersections for: ' +
+            typename
+        )
+      }
+    }
+    const oldEntities = (_d = entities[typename]) !== null && _d !== void 0 ? _d : EMPTY_OBJECT
+    let newEntities
+    entitiesToRemove === null || entitiesToRemove === void 0
+      ? void 0
+      : entitiesToRemove.forEach((id) => {
+          if (oldEntities[id]) {
+            newEntities !== null && newEntities !== void 0
+              ? newEntities
+              : (newEntities = 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))) {
+          newEntities !== null && newEntities !== void 0
+            ? newEntities
+            : (newEntities = Object.assign({}, oldEntities))
+          newEntities[id] = newEntity
+        }
+      }
+    }
+    if (entitiesToMerge) {
+      for (const id in entitiesToMerge) {
+        const oldEntity = 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[id] = newEntity
+        }
+      }
+    }
+    if (!newEntities) {
+      continue
+    }
+    result !== null && result !== void 0 ? result : (result = Object.assign({}, entities))
+    result[typename] = newEntities
+  }
+  options.logsEnabled &&
+    log('applyEntityChanges', {
+      entities,
+      changes,
+      options,
+      result,
+    })
+  return result
+}
+export const isEmptyObject = (o) => {
+  for (const _ in o) {
+    return false
+  }
+  return true
+}
+export const createStateComparer = (fields) => {
+  return (x, y) => {
+    if (x === y) {
+      return true
+    }
+    if (x === undefined || y === undefined) {
+      return false
+    }
+    for (let i = 0; i < fields.length; i += 1) {
+      const key = fields[i]
+      if (x[key] !== y[key]) {
+        return false
+      }
+    }
+    return true
+  }
+}

package/dist/types/createActions.d.ts

@@ -0,0 +1,106 @@
+import type {EntityChanges, Key, MutationState, QueryState, Typenames} from './types'
+import {CacheState} from './types'
+
+export type Actions<
+  N extends string = string,
+  T extends Typenames = Typenames,
+  QP = unknown,
+  QR = unknown,
+  MP = unknown,
+  MR = unknown
+> = ReturnType<typeof createActions<N, T, QP, QR, MP, MR>>
+export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(
+  name: N
+) => {
+  updateQueryStateAndEntities: {
+    <K extends keyof (QP | QR)>(
+      queryKey: K,
+      queryCacheKey: Key,
+      state?: Partial<QueryState<T, QP[K], QR[K]>>,
+      entityChanges?: EntityChanges<T>
+    ): {
+      type: `@rrc/${N}/updateQueryStateAndEntities`
+      queryKey: K
+      queryCacheKey: Key
+      state: Partial<QueryState<T, QP[K], QR[K]>> | undefined
+      entityChanges: EntityChanges<T> | undefined
+    }
+    type: `@rrc/${N}/updateQueryStateAndEntities`
+  }
+  updateMutationStateAndEntities: {
+    <K extends keyof (MP | MR)>(
+      mutationKey: K,
+      state?: Partial<MutationState<T, MP[K], MR[K]>>,
+      entityChanges?: EntityChanges<T>
+    ): {
+      type: `@rrc/${N}/updateMutationStateAndEntities`
+      mutationKey: K
+      state: Partial<MutationState<T, MP[K], MR[K]>> | undefined
+      entityChanges: EntityChanges<T> | undefined
+    }
+    type: `@rrc/${N}/updateMutationStateAndEntities`
+  }
+  mergeEntityChanges: {
+    (changes: EntityChanges<T>): {
+      type: `@rrc/${N}/mergeEntityChanges`
+      changes: EntityChanges<T>
+    }
+    type: `@rrc/${N}/mergeEntityChanges`
+  }
+  invalidateQuery: {
+    <K extends keyof (QP | QR)>(
+      queries: {
+        /** Query key */
+        query: K
+        /** Query cache key */
+        cacheKey?: Key
+        /** Unix timestamp at which query expires. Is set to the query state. @Default Date.now() */
+        expiresAt?: number
+      }[]
+    ): {
+      type: `@rrc/${N}/invalidateQuery`
+      queries: {
+        /** Query key */
+        query: K
+        /** Query cache key */
+        cacheKey?: Key
+        /** Unix timestamp at which query expires. Is set to the query state. @Default Date.now() */
+        expiresAt?: number
+      }[]
+    }
+    type: `@rrc/${N}/invalidateQuery`
+  }
+  clearQueryState: {
+    <K extends keyof (QP | QR)>(
+      queries: {
+        /** Query key */
+        query: K
+        /** Query cache key */
+        cacheKey?: Key
+      }[]
+    ): {
+      type: `@rrc/${N}/clearQueryState`
+      queries: {
+        /** Query key */
+        query: K
+        /** Query cache key */
+        cacheKey?: Key
+      }[]
+    }
+    type: `@rrc/${N}/clearQueryState`
+  }
+  clearMutationState: {
+    <K extends keyof (MP | MR)>(mutationKeys: K[]): {
+      type: `@rrc/${N}/clearMutationState`
+      mutationKeys: K[]
+    }
+    type: `@rrc/${N}/clearMutationState`
+  }
+  clearCache: {
+    (stateToKeep?: Partial<CacheState<T, QP, QR, MP, MR>>): {
+      type: `@rrc/${N}/clearCache`
+      stateToKeep: Partial<CacheState<T, QP, QR, MP, MR>> | undefined
+    }
+    type: `@rrc/${N}/clearCache`
+  }
+}