react-redux-cache 0.8.1 → 0.8.2

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">) => {
+    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector" | "defaults">) => {
         /** 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">) => {
+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">) => {
     /** 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

@@ -24,18 +24,20 @@ const withTypenames = () => {
      */
     return {
         createCache: (partialCache) => {
-            var _a, _b, _c, _d, _e, _f, _g;
-            var _h, _j, _k;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _k, _l, _m, _o;
             const abortControllers = new WeakMap();
             // provide all optional fields
             (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
-            (_b = (_h = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_h.logsEnabled = false);
-            (_c = (_j = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_j.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
-            (_d = (_k = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_k.deepComparisonEnabled = true);
+            (_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);
+            (_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');
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (_g = partialCache.cacheStateSelector) !== null && _g !== void 0 ? _g : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+            (_j = partialCache.cacheStateSelector) !== null && _j !== void 0 ? _j : (partialCache.cacheStateSelector = (state) => state[cache.name]);
             // @ts-expect-error private field for testing
             partialCache.abortControllers = abortControllers;
             const cache = partialCache;

package/dist/index.js

@@ -25,32 +25,21 @@ Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true,
 // Backlog
 // ! high (1.0.0)
 // rca -> vite
-// defaults
+// remove undefined optional fields & emtpy states. remove mutation state when it finished without errors
 // remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?
-// remove undefined optional fields & emtpy states
 // generate full api docs
 // ! medium
 // optimistic response
 // make query key / cache key difference more clear in the docs
 // check type of function arguments in dev
-// allow multiple mutation with same keys?
-// return back deserialize selector?
-// selector for entities by typename
-// callback option on error / success?
-// refetch queries on mutation success
-// remove query/mutation state when it finished without errors
-// deep equal entities while merging state
-// make error type generic
 // ! low
+// make error type generic
+// allow multiple mutation with same keys?
 // custom useStore & useSelector to support multiple stores?
-// access to currently loading queries and mutations?
-// add params to the state?
+// easy access to all currently loading queries and mutations?
 // cancellation to queries
-// if mutation & query alrady loading - make options: last, throttle, debounce, parallel?
-// add time-to-live option, and/or time-to-refresh
+// if mutation & query already loading - make options: last, throttle, debounce, parallel?
 // add refresh interval for queries that are mounted
-// replace try/catch with returned error
-// support any store, not only redux
 // readonly types?
 // proper types, remove as, any, todo
 // add number of retries param?

package/dist/query.js

@@ -11,8 +11,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey, cacheKey, params, secondsToLive = cache.queries[queryKey].secondsToLive, onlyIfExpired, mergeResults = cache.queries[queryKey].mergeResults, onCompleted = cache.queries[queryKey].onCompleted, onSuccess = cache.queries[queryKey].onSuccess, onError = cache.queries[queryKey].onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
+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 { updateQueryStateAndEntities, } = _a;
+    if (secondsToLive === void 0) { secondsToLive = (_b = cache.queries[queryKey].secondsToLive) !== null && _b !== void 0 ? _b : cache.defaults.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 logsEnabled = cache.options.logsEnabled;
     const cacheStateSelector = cache.cacheStateSelector;
     const queryStateOnStart = cacheStateSelector(store.getState()).queries[queryKey][cacheKey];
@@ -61,11 +67,11 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey,
     const newState = {
         error: undefined,
         loading: false,
-        expiresAt: (_a = response.expiresAt) !== null && _a !== void 0 ? _a : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
+        expiresAt: (_c = response.expiresAt) !== null && _c !== void 0 ? _c : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
         result: mergeResults
             ? mergeResults(
             // @ts-expect-error fix later
-            (_b = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _b === void 0 ? void 0 : _b.result, response, params, store)
+            (_d = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _d === void 0 ? void 0 : _d.result, response, params, store)
             : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));

package/dist/types.d.ts

@@ -27,10 +27,24 @@ 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;
     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 = {
+    /**
+     * Cache policy.
+     * @cache-first fetch only if cache either does not exist or is expired on useQuery mount.
+     * @cache-and-fetch fetch on every useQuery mount.
+     * @default cache-first
+     */
+    cachePolicy: QueryCachePolicy;
+    /** If set, this value updates expiresAt value of query state when query result is received. */
+    secondsToLive?: number;
+};
 export type CacheOptions = {
     /**
      * Enables validation of package function arguments. Recommened to enable in dev/testing mode.
@@ -64,15 +78,8 @@ 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> = {
+export type QueryInfo<T extends Typenames, P, R> = Partial<Defaults> & {
     query: Query<P, T, R>;
-    /**
-     * Cache policy.
-     * @default cache-first
-     */
-    cachePolicy?: QueryCachePolicy;
-    /** If set, this value updates expiresAt value of query state when query resut is received. */
-    secondsToLive?: number;
     /** 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;
     /**
@@ -101,10 +108,6 @@ export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)
     /** If set to true, query will run only if it is expired or result not yet cached. */
     onlyIfExpired?: boolean;
 };
-/**
- * @param cache-first for each params key fetch is not called if cache exists.
- * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
- */
 export type QueryCachePolicy = 'cache-first' | 'cache-and-fetch';
 export type QueryResponse<T extends Typenames, R> = EntityChanges<T> & {
     result: R;

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-first', mergeResults, onCompleted, onSuccess, onError, } = options;
+    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 logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheStateSelector = cache.cacheStateSelector;

package/package.json

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