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

package/dist/cjs/utilsAndConstants.js

@@ -0,0 +1,189 @@
+'use strict'
+Object.defineProperty(exports, '__esModule', {value: true})
+exports.createStateComparer =
+  exports.isEmptyObject =
+  exports.applyEntityChanges =
+  exports.FetchPolicy =
+  exports.log =
+  exports.defaultGetCacheKey =
+  exports.NOOP =
+  exports.EMPTY_ARRAY =
+  exports.EMPTY_OBJECT =
+  exports.IS_DEV =
+  exports.optionalUtils =
+  exports.PACKAGE_SHORT_NAME =
+    void 0
+exports.PACKAGE_SHORT_NAME = 'rrc'
+exports.optionalUtils = {
+  deepEqual: undefined,
+}
+try {
+  exports.optionalUtils.deepEqual = require('fast-deep-equal/es6')
+} catch (_a) {
+  console.debug(exports.PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed')
+}
+exports.IS_DEV = (() => {
+  try {
+    return __DEV__
+  } catch (e) {
+    return process.env.NODE_ENV === 'development'
+  }
+})()
+exports.EMPTY_OBJECT = Object.freeze({})
+exports.EMPTY_ARRAY = Object.freeze([])
+const NOOP = () => {}
+exports.NOOP = NOOP
+const defaultGetCacheKey = (params) => {
+  switch (typeof params) {
+    case 'string':
+    case 'symbol':
+      return params
+    case 'object':
+      return JSON.stringify(params)
+    default:
+      return String(params)
+  }
+}
+exports.defaultGetCacheKey = defaultGetCacheKey
+const log = (tag, data) => {
+  console.debug(`@${exports.PACKAGE_SHORT_NAME} [${tag}]`, data)
+}
+exports.log = log
+exports.FetchPolicy = {
+  NoCacheOrExpired: (expired, _params, state) => {
+    return expired || state.result === undefined
+  },
+  Always: () => true,
+}
+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 ? exports.optionalUtils.deepEqual : undefined
+  let result
+  const typenames = new Set([
+    ...(changes.entities ? Object.keys(changes.entities) : exports.EMPTY_ARRAY),
+    ...(changes.merge ? Object.keys(changes.merge) : exports.EMPTY_ARRAY),
+    ...(changes.remove ? Object.keys(changes.remove) : exports.EMPTY_ARRAY),
+    ...(changes.replace ? Object.keys(changes.replace) : exports.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 : exports.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 &&
+    (0, exports.log)('applyEntityChanges', {
+      entities,
+      changes,
+      options,
+      result,
+    })
+  return result
+}
+exports.applyEntityChanges = applyEntityChanges
+const isEmptyObject = (o) => {
+  for (const _ in o) {
+    return false
+  }
+  return true
+}
+exports.isEmptyObject = isEmptyObject
+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
+  }
+}
+exports.createStateComparer = createStateComparer

package/dist/esm/createActions.js

@@ -0,0 +1,61 @@
+import {PACKAGE_SHORT_NAME} from './utilsAndConstants'
+
+export const createActions = (name) => {
+  const actionPrefix = `@${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,
+  }
+}

package/dist/esm/createCache.js

@@ -0,0 +1,203 @@
+import {useMemo} from 'react'
+
+import {createActions} from './createActions'
+import {createCacheReducer} from './createCacheReducer'
+import {createSelectors} from './createSelectors'
+import {mutate as mutateImpl} from './mutate'
+import {query as queryImpl} from './query'
+import {useMutation} from './useMutation'
+import {useQuery} from './useQuery'
+import {
+  applyEntityChanges,
+  createStateComparer,
+  defaultGetCacheKey,
+  EMPTY_OBJECT,
+  FetchPolicy,
+  IS_DEV,
+  optionalUtils,
+} from './utilsAndConstants'
+
+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
+      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 = 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 = 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 && !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 = createStateComparer(target.selectorComparer)
+        }
+      }
+      setDefaultComparer(cache.globals.queries)
+      for (const queryKey in partialCache.queries) {
+        setDefaultComparer(partialCache.queries[queryKey])
+      }
+      const selectors = Object.assign({selectCacheState: cache.cacheStateSelector}, createSelectors(cache))
+      const {
+        selectCacheState,
+        selectQueryState,
+        selectQueryResult,
+        selectQueryLoading,
+        selectQueryError,
+        selectQueryParams,
+        selectQueryExpiresAt,
+        selectMutationState,
+        selectMutationResult,
+        selectMutationLoading,
+        selectMutationError,
+        selectMutationParams,
+        selectEntityById,
+        selectEntities,
+        selectEntitiesByTypename,
+      } = selectors
+      const actions = createActions(cache.name)
+      const {
+        updateQueryStateAndEntities,
+        updateMutationStateAndEntities,
+        mergeEntityChanges,
+        invalidateQuery,
+        clearQueryState,
+        clearMutationState,
+        clearCache,
+      } = actions
+      const reducer = 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 : defaultGetCacheKey
+            const cacheKey = getCacheKey(params)
+            return queryImpl(
+              'query',
+              store,
+              cache,
+              actions,
+              selectors,
+              queryKey,
+              cacheKey,
+              params,
+              options.secondsToLive,
+              options.onlyIfExpired,
+              options.mergeResults,
+              options.onCompleted,
+              options.onSuccess,
+              options.onError
+            )
+          },
+          mutate: (options) => {
+            return mutateImpl(
+              '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 useMemo(() => createClient(store), [store])
+          },
+          useQuery: (options) => useQuery(cache, actions, selectors, options),
+          useMutation: (options) => useMutation(cache, actions, selectors, options, abortControllers),
+          useSelectEntityById: (id, typename) => {
+            return cache.storeHooks.useSelector((state) => selectEntityById(state, id, typename))
+          },
+        },
+        utils: {
+          createClient,
+          getInitialState: () => {
+            return reducer(undefined, EMPTY_OBJECT)
+          },
+          applyEntityChanges: (entities, changes) => {
+            return applyEntityChanges(entities, changes, cache.options)
+          },
+        },
+      }
+    },
+  }
+}
+export const createCache = withTypenames().createCache