react-redux-cache 0.8.2 → 0.10.0

package/README.md

@@ -165,6 +165,7 @@ export const {
       query: getUser,
       // For each query `secondsToLive` option can be set, which is used to set expiration date of a cached result when query response is received.
       // After expiration query result is considered invalidated and will be refetched on the next useQuery mount.
+      // Can also be set globally in `globals`.
       secondsToLive: 5 * 60 // Here cached result is valid for 5 minutes.
     },
   },
@@ -289,7 +290,23 @@ export const updateBank = (bank) => {
     }
   }
 } satisfies Mutation<Partial<Bank>>
+```
+
+If global error handling is needed for errors, not handled by query / mutation `onError` callback, global `onError` can be used:
 
+```typescript
+export const cache = createCache({
+  name: 'cache',
+  globals: {
+    onError: (error, key) {
+      console.log('Not handled error', { error, key })
+    }
+  },
+  queries: {
+    getUsers: { query: getUsers },
+  },
+  ...
+})
 ```
 
 #### Invalidation

package/dist/createCache.d.ts

@@ -11,7 +11,7 @@ import { applyEntityChanges } from './utilsAndConstants';
  * })
  */
 export declare const withTypenames: <T extends Typenames = Typenames>() => {
-    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "defaults">) => {
+    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "globals">) => {
         /** Keeps all options, passed while creating the cache. */
         cache: Cache<N, T, QP, QR, MP, MR>;
         /** Reducer of the cache, should be added to redux store. */
@@ -172,7 +172,7 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
-export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, Typenames, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "defaults">) => {
+export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, Typenames, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "globals">) => {
     /** Keeps all options, passed while creating the cache. */
     cache: Cache<N, Typenames, QP, QR, MP, MR>;
     /** Reducer of the cache, should be added to redux store. */

package/dist/createCache.js

@@ -30,12 +30,12 @@ const withTypenames = () => {
             // provide all optional fields
             (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
             (_b = (_k = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_k.logsEnabled = false);
-            (_c = (_l = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_l.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
+            (_c = (_l = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_l.additionalValidation = utilsAndConstants_1.IS_DEV);
             (_d = (_m = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_m.deepComparisonEnabled = true);
             (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
             (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
-            (_g = partialCache.defaults) !== null && _g !== void 0 ? _g : (partialCache.defaults = {});
-            (_h = (_o = partialCache.defaults).cachePolicy) !== null && _h !== void 0 ? _h : (_o.cachePolicy = 'cache-first');
+            (_g = partialCache.globals) !== null && _g !== void 0 ? _g : (partialCache.globals = {});
+            (_h = (_o = partialCache.globals).cachePolicy) !== null && _h !== void 0 ? _h : (_o.cachePolicy = 'cache-first');
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             (_j = partialCache.cacheStateSelector) !== null && _j !== void 0 ? _j : (partialCache.cacheStateSelector = (state) => state[cache.name]);
             // @ts-expect-error private field for testing
@@ -147,7 +147,9 @@ const withTypenames = () => {
                     /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
                     useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, options),
                     /** Subscribes to provided mutation state and provides mutate function. */
-                    useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
+                    useMutation: (options
+                    // @ts-expect-error cache type
+                    ) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
                     /** useSelector + selectEntityById. */
                     useSelectEntityById: (id, typename) => {
                         return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));

package/dist/index.js

@@ -24,22 +24,25 @@ Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: fu
 Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE; } });
 // Backlog
 // ! high (1.0.0)
-// rca -> vite
 // remove undefined optional fields & emtpy states. remove mutation state when it finished without errors
 // remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?
 // generate full api docs
 // ! medium
+// example rca -> vite
 // optimistic response
+// reset [whole] cache to initial / to provided state
+// globals for success, completions and loading states?
 // make query key / cache key difference more clear in the docs
 // check type of function arguments in dev
 // ! low
+// local cache policy to keep in component state?
 // make error type generic
 // allow multiple mutation with same keys?
 // custom useStore & useSelector to support multiple stores?
 // easy access to all currently loading queries and mutations?
 // cancellation to queries
 // if mutation & query already loading - make options: last, throttle, debounce, parallel?
-// add refresh interval for queries that are mounted
+// add refresh interval for queries that are mounted?
 // readonly types?
 // proper types, remove as, any, todo
 // add number of retries param?

package/dist/mutate.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, MutationResult, Typenames } from './types';
-export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities, }: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
+export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities, }: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;

package/dist/mutate.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -65,7 +66,10 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutat
             loading: false,
         }));
         // @ts-expect-error params
-        onError === null || onError === void 0 ? void 0 : onError(error, params, store);
+        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
+            // @ts-expect-error queryKey
+            (_b = (_a = cache.globals).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error, mutationKey, params, store);
+        }
         // @ts-expect-error response
         onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);
         return { error };

package/dist/query.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, QueryResult, Typenames } from './types';
-export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities, }: Pick<ActionMap<N, T, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities, }: Pick<ActionMap<N, T, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -12,9 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const query = (logTag, store, cache, _a, queryKey, cacheKey, params, secondsToLive, onlyIfExpired, mergeResults, onCompleted, onSuccess, onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b, _c, _d;
+    var _b, _c, _d, _e, _f;
     var { updateQueryStateAndEntities, } = _a;
-    if (secondsToLive === void 0) { secondsToLive = (_b = cache.queries[queryKey].secondsToLive) !== null && _b !== void 0 ? _b : cache.defaults.secondsToLive; }
+    if (secondsToLive === void 0) { secondsToLive = (_b = cache.queries[queryKey].secondsToLive) !== null && _b !== void 0 ? _b : cache.globals.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; }
@@ -59,7 +59,10 @@ const query = (logTag, store, cache, _a, queryKey, cacheKey, params, secondsToLi
             loading: false,
         }));
         // @ts-expect-error params
-        onError === null || onError === void 0 ? void 0 : onError(error, params, store);
+        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
+            // @ts-expect-error queryKey
+            (_d = (_c = cache.globals).onError) === null || _d === void 0 ? void 0 : _d.call(_c, error, queryKey, params, store);
+        }
         // @ts-expect-error params
         onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(undefined, error, params, store);
         return { error };
@@ -67,11 +70,11 @@ const query = (logTag, store, cache, _a, queryKey, cacheKey, params, secondsToLi
     const newState = {
         error: undefined,
         loading: false,
-        expiresAt: (_c = response.expiresAt) !== null && _c !== void 0 ? _c : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
+        expiresAt: (_e = response.expiresAt) !== null && _e !== void 0 ? _e : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
         result: mergeResults
             ? mergeResults(
             // @ts-expect-error fix later
-            (_d = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _d === void 0 ? void 0 : _d.result, response, params, store)
+            (_f = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _f === void 0 ? void 0 : _f.result, response, params, store)
             : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));

package/dist/types.d.ts

@@ -27,14 +27,14 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     mutations: {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
     };
-    /** Default options for queries.
-     * @default { cachePolicy: 'cache-first', sedondsToLive: undefined } */
-    defaults: Defaults;
+    /** Default options for queries and mutations.
+     * @default { cachePolicy: 'cache-first', sedondsToLive: undefined, onError: undefined } */
+    globals: Globals<QP, MP>;
     options: CacheOptions;
     /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
     cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
 };
-export type Defaults = {
+export type Globals<QP, MP> = {
     /**
      * Cache policy.
      * @cache-first fetch only if cache either does not exist or is expired on useQuery mount.
@@ -44,15 +44,18 @@ export type Defaults = {
     cachePolicy: QueryCachePolicy;
     /** If set, this value updates expiresAt value of query state when query result is received. */
     secondsToLive?: number;
+    /** Handles errors, not handled by onError from queries and mutations. */
+    onError?: <K extends keyof QP | keyof MP>(error: unknown, key: K, params: QP[keyof QP] | MP[keyof MP], // TODO proper type
+    store: Store) => void;
 };
 export type CacheOptions = {
     /**
-     * Enables validation of package function arguments. Recommened to enable in dev/testing mode.
+     * Enables additional validation with logging to console.warn. Recommened to enable in dev/testing mode.
      * @default true in dev mode.
      * */
-    validateFunctionArguments: boolean;
+    additionalValidation: boolean;
     /**
-     * Enables console logs.
+     * Enables debug logs.
      * @default false
      */
     logsEnabled: boolean;
@@ -78,7 +81,7 @@ export type Query<P, T extends Typenames = Typenames, R = unknown> = (
 params: P, 
 /** Redux store */
 store: Store) => Promise<QueryResponse<T, R>>;
-export type QueryInfo<T extends Typenames, P, R> = Partial<Defaults> & {
+export type QueryInfo<T extends Typenames, P, R> = Partial<Pick<Globals<unknown, unknown>, 'cachePolicy' | 'secondsToLive'>> & {
     query: Query<P, T, R>;
     /** Merges results before saving to the store. Default implementation is using the latest result. */
     mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined, store: Store) => R;
@@ -92,8 +95,8 @@ export type QueryInfo<T extends Typenames, P, R> = Partial<Defaults> & {
     onCompleted?: (response: QueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store) => void;
     /** Called after fetch finished without error. */
     onSuccess?: (response: QueryResponse<T, R>, params: P | undefined, store: Store) => void;
-    /** Called after fetch finished with error. */
-    onError?: (error: unknown, params: P | undefined, store: Store) => void;
+    /** Called after fetch finished with error. Should return true if error was handled and does not require global onError handling. */
+    onError?: (error: unknown, params: P | undefined, store: Store) => boolean | void | null | undefined;
 };
 export type QueryState<P, R> = MutationState<P, R> & {
     expiresAt?: number;

package/dist/useQuery.js

@@ -16,7 +16,7 @@ const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, secondsToLive, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : cache.defaults.cachePolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
+    const { query: queryKey, skip, params, secondsToLive, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : cache.globals.cachePolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheStateSelector = cache.cacheStateSelector;

package/dist/utilsAndConstants.js

@@ -65,7 +65,7 @@ const applyEntityChanges = (entities, changes, options) => {
             continue;
         }
         // check for key intersection
-        if (options.validateFunctionArguments) {
+        if (options.additionalValidation) {
             const mergeIds = entitiesToMerge && Object.keys(entitiesToMerge);
             const replaceIds = entitiesToReplace && Object.keys(entitiesToReplace);
             const idsSet = new Set(mergeIds);

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.8.2",
+  "version": "0.10.0",
   "description": "Powerful data fetching and caching library that supports normalization, built on top of redux",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",