react-redux-cache 0.2.0 → 0.3.0

package/README.md

@@ -13,6 +13,43 @@
 **Normalization** is the best way to keep the state of the app **consistent** between different views, reduces the number of fetches and allows to show cached data when navigating, which greatly improves **user experience**.
 
 Remains **full control** of redux state with ability to write custom selectors, actions and reducers to manage cached state.
+
+Here is example of redux state, generated by cache reducer from `/example` project:
+```js
+const state = {
+  entities: {
+    // each typename has its own map of entities, stored by id
+    users: {
+      "0": {id: 0, bankId: "0", name: "User 0 *"},
+      "1": {id: 1, bankId: "1", name: "User 1 *"},
+      "2": {id: 2, bankId: "2", name: "User 2"},
+      "3": {id: 3, bankId: "3", name: "User 3"}
+    },
+    banks: {
+      "0": {id: "0", name: "Bank 0"},
+      "1": {id: "1", name: "Bank 1"},
+      "2": {id: "2", name: "Bank 2"},
+      "3": {id: "3", name: "Bank 3"}
+    }
+  },
+  queries: {
+    // each query has its own map of query states, stored by cache key, which is generated from query params
+    getUser: {
+      "2": {loading: false, error: undefined, result: 2},
+      "3": {loading: true}
+    },
+    getUsers: {
+      // example of paginated state under custom cache key
+      "all-pages": {loading: false, result: {items: [0,1,2], page: 1}}
+    }
+  },
+  mutations: {
+    // each mutation has its own state as well
+    updateUser: {loading: false, result: 1} 
+  }
+}
+```
+
     
 ### Table of contents
 

package/dist/createCache.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import type { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryMutationState, QueryOptions, QueryResult, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 import { applyEntityChanges } from './utilsAndConstants';
@@ -10,18 +10,18 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
         entities: EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: import("./types").QueryMutationState<MR[MK]>; };
+        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
+        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
     } | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QR;
         queryCacheKey: Key;
-        state: Partial<import("./types").QueryMutationState<QR[keyof QR]>> | undefined;
+        state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
         mutationKey: keyof MR;
-        state: Partial<import("./types").QueryMutationState<MR[keyof MR]>> | undefined;
+        state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
@@ -34,28 +34,28 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         }[];
     } | {
         type: `@rrc/${N}/clearMutationState`;
-        mutationKeys: (keyof MR)[]; /** Select all entities of provided typename. */
+        mutationKeys: (keyof MR)[];
     }) => {
         entities: EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: import("./types").QueryMutationState<MR[MK]>; };
+        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
+        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
     };
     actions: {
         updateQueryStateAndEntities: {
-            <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
-                state: Partial<import("./types").QueryMutationState<QR[K]>> | undefined;
+                state: Partial<QueryMutationState<QR[K]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K_1;
-                state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
+                state: Partial<QueryMutationState<MR[K_1]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -83,12 +83,20 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         clearMutationState: {
             <K_3 extends keyof MR>(mutationKeys: K_3[]): {
                 type: `@rrc/${N}/clearMutationState`;
-                mutationKeys: K_3[]; /** Select all entities of provided typename. */
+                mutationKeys: K_3[];
             };
             type: `@rrc/${N}/clearMutationState`;
         };
     };
     selectors: {
+        selectQueryState: <QK_1 extends keyof QR | keyof QP>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never> | undefined;
+        selectQueryResult: <QK_2 extends keyof QR | keyof QP>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
+        selectQueryLoading: <QK_3 extends keyof QR | keyof QP>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
+        selectQueryError: <QK_4 extends keyof QR | keyof QP>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => QueryMutationState<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+        selectMutationResult: <MK_2 extends keyof MP | keyof MR>(state: unknown, mutation: MK_2) => (MK_2 extends keyof MP & keyof MR ? MR[MK_2] : never) | undefined;
+        selectMutationLoading: <MK_3 extends keyof MP | keyof MR>(state: unknown, mutation: MK_3) => boolean;
+        selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
         /** Select all entities from the state. */
         entitiesSelector: (state: unknown) => EntitiesMap<T>;
         /** Select all entities of provided typename. */
@@ -97,18 +105,18 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     hooks: {
         /** Returns client object with query function */
         useClient: () => {
-            query: <QK_1 extends keyof QR | keyof QP>(options: QueryOptions<T, QP, QR, MR, QK_1>) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>;
-            mutate: <MK_1 extends keyof MP | keyof MR>(options: {
-                mutation: MK_1;
-                params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never;
-            }) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
+            query: <QK_5 extends keyof QR | keyof QP>(options: Omit<QueryOptions<T, QP, QR, MR, QK_5>, "cachePolicy">) => Promise<QueryResult<QK_5 extends keyof QP & keyof QR ? QR[QK_5] : never>>;
+            mutate: <MK_5 extends keyof MP | keyof MR>(options: {
+                mutation: MK_5;
+                params: MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never;
+            }) => Promise<MutationResult<MK_5 extends keyof MP & keyof MR ? MR[MK_5] : never>>;
         };
         /** Fetches query when params change and subscribes to query state. */
-        useQuery: <QK_2 extends keyof QR | keyof QP>(options: import("./types").UseQueryOptions<T, QP, QR, MR, QK_2>) => readonly [import("./types").QueryMutationState<QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never>, () => Promise<void>];
+        useQuery: <QK_6 extends keyof QR | keyof QP>(options: import("./types").UseQueryOptions<T, QP, QR, MR, QK_6>) => readonly [QueryMutationState<QK_6 extends keyof QP & keyof QR ? QR[QK_6] : never>, () => Promise<QueryResult<QK_6 extends infer T_1 ? T_1 extends QK_6 ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_2 extends keyof MP | keyof MR>(options: {
-            mutation: MK_2;
-        }) => readonly [(params: MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never) => Promise<void>, import("./types").QueryMutationState<MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never>, () => boolean];
+        useMutation: <MK_6 extends keyof MP | keyof MR>(options: {
+            mutation: MK_6;
+        }) => readonly [(params: MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never) => Promise<MutationResult<MK_6 extends infer T_2 ? T_2 extends MK_6 ? T_2 extends keyof MP & keyof MR ? MR[T_2] : never : never : never>>, QueryMutationState<MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never>, () => boolean];
         /** Selects entity by id and subscribes to the changes. */
         useSelectEntityById: <TN_1 extends keyof T>(id: Key | null | undefined, typename: TN_1) => T[TN_1] | undefined;
     };

package/dist/createCache.js

@@ -36,6 +36,14 @@ const createCache = (partialCache) => {
         result[x] = (state) => cache.cacheStateSelector(state).entities[x];
         return result;
     }, {});
+    const selectQueryState = (state, query, cacheKey) => {
+        // @ts-expect-error fix later
+        return cache.cacheStateSelector(state).queries[query][cacheKey];
+    };
+    const selectMutationState = (state, mutation) => {
+        // @ts-expect-error fix later
+        return cache.cacheStateSelector(state).mutations[mutation];
+    };
     const actions = (0, createActions_1.createActions)(cache.name);
     return {
         cache,
@@ -43,6 +51,29 @@ const createCache = (partialCache) => {
         reducer: (0, reducer_1.createCacheReducer)(actions, cache.typenames, Object.keys(cache.queries), cache.options),
         actions,
         selectors: {
+            selectQueryState,
+            selectQueryResult: (state, query, cacheKey) => {
+                var _a;
+                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.result;
+            },
+            selectQueryLoading: (state, query, cacheKey) => {
+                var _a;
+                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.loading;
+            },
+            selectQueryError: (state, query, cacheKey) => {
+                var _a;
+                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.error;
+            },
+            selectMutationState,
+            selectMutationResult: (state, mutation) => {
+                return selectMutationState(state, mutation).result;
+            },
+            selectMutationLoading: (state, mutation) => {
+                return selectMutationState(state, mutation).loading;
+            },
+            selectMutationError: (state, mutation) => {
+                return selectMutationState(state, mutation).error;
+            },
             /** Select all entities from the state. */
             entitiesSelector,
             /** Select all entities of provided typename. */
@@ -62,10 +93,10 @@ const createCache = (partialCache) => {
                             const getCacheKey = (_a = cache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
                             // @ts-expect-error fix later
                             const cacheKey = getCacheKey(params);
-                            return (0, query_1.query)('query', true, store, cache, actions, queryKey, cacheKey, params);
+                            return (0, query_1.query)('query', store, cache, actions, queryKey, cacheKey, params);
                         },
                         mutate: (options) => {
-                            return (0, mutate_1.mutate)('mutate', true, store, cache, actions, options.mutation, options.params, abortControllers);
+                            return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers);
                         },
                     };
                     return client;

package/dist/index.js

@@ -23,13 +23,10 @@ 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
-// screenshot of redux state to README
-// optimistic response
-// cover with tests
-// try use skip for refreshing strategy?
 // add example without normalization
-// make query key / cache key difference more clear in the docs
-// support multiple caches = reducers
+// try use skip for refreshing strategy?
+// optimistic response
+// make query key / cache key difference more clear in the docs, or remove queryKey at all?
 // ! medium
 // make named caches to produce named hooks, actions etc (same as slices in RTK)?
 // allow multiple mutation with same keys?

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, returnResult: boolean, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities }: Pick<ActionMap<N, T, QR, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => Promise<void | 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, QR, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;

package/dist/mutate.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const mutate = (logTag, returnResult, store, cache, { updateMutationStateAndEntities }, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
+const mutate = (logTag, store, cache, { updateMutationStateAndEntities }, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -55,7 +55,7 @@ const mutate = (logTag, returnResult, store, cache, { updateMutationStateAndEnti
             aborted: abortController.signal.aborted,
         });
     if (abortController.signal.aborted) {
-        return returnResult ? { aborted: true } : undefined;
+        return ABORTED_RESULT;
     }
     delete abortControllersOfStore[mutationKey];
     if (error) {
@@ -73,8 +73,9 @@ const mutate = (logTag, returnResult, store, cache, { updateMutationStateAndEnti
             result: response.result,
         }, response));
         // @ts-expect-error fix later
-        return returnResult ? { result: response.result } : undefined;
+        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/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, returnResult: boolean, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities }: Pick<ActionMap<N, T, QR, MR>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<void | 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, QR, MR>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -11,7 +11,7 @@ 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, returnResult, store, cache, { updateQueryStateAndEntities }, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
+const query = (logTag, store, cache, { updateQueryStateAndEntities }, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const logsEnabled = cache.options.logsEnabled;
     const cacheStateSelector = cache.cacheStateSelector;
@@ -25,7 +25,7 @@ const query = (logTag, returnResult, store, cache, { updateQueryStateAndEntities
                 params,
                 cacheKey,
             });
-        return returnResult ? { cancelled: true } : undefined;
+        return CANCELLED_RESULT;
     }
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
         loading: true,
@@ -43,7 +43,7 @@ const query = (logTag, returnResult, store, cache, { updateQueryStateAndEntities
             error: error,
             loading: false,
         }));
-        return returnResult ? { error } : undefined;
+        return { error };
     }
     const newState = {
         error: undefined,
@@ -53,19 +53,18 @@ const query = (logTag, returnResult, store, cache, { updateQueryStateAndEntities
             : mergeResults
                 ? mergeResults(
                 // @ts-expect-error fix later
-                (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params)
+                (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params, store)
                 : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
-    // @ts-expect-error fix types
-    return returnResult
-        ? {
-            result: cacheResultSelector
-                ? cacheResultSelector(cacheStateSelector(store.getState()), 
-                // @ts-expect-error fix types
-                params)
-                : newState === null || newState === void 0 ? void 0 : newState.result,
-        }
-        : undefined;
+    return {
+        // @ts-expect-error fix types
+        result: cacheResultSelector
+            ? cacheResultSelector(cacheStateSelector(store.getState()), 
+            // @ts-expect-error fix types
+            params)
+            : newState === null || newState === void 0 ? void 0 : newState.result,
+    };
 });
 exports.query = query;
+const CANCELLED_RESULT = Object.freeze({ cancelled: true });

package/dist/types.d.ts

@@ -1,3 +1,4 @@
+import { Store } from 'redux';
 import type { ReduxCacheState } from './reducer';
 export type Key = string | number | symbol;
 export type Dict<T> = Record<Key, T>;
@@ -73,8 +74,8 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
      * Needed when query result may already be in the cache, e.g. for single entity query by id.
      * */
     resultSelector?: (state: S, params: P) => R | undefined;
-    /** Merges results before saving to the store. */
-    mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined) => 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;
     /**
      * Cache key is used for storing the query state and for performing a fetch when it changes. Queries with the same cache key share their state.
      * Default implementation uses `JSON.stringify` or `String()` depending on type.
@@ -86,7 +87,7 @@ export type UseQueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (Q
     query: QK;
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
     skip?: boolean;
-} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never, 'cachePolicy' | 'mergeResults' | 'getCacheKey'>;
+} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never, 'cachePolicy'>;
 /**
  * @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.

package/dist/useMutation.d.ts

@@ -3,4 +3,4 @@ import { ActionMap } from './createActions';
 import { Cache, Key, QueryMutationState, Typenames } from './types';
 export declare const useMutation: <N extends string, T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<N, T, unknown, unknown, MP, MR>, actions: Pick<ActionMap<N, T, unknown, MR>, "updateMutationStateAndEntities">, options: {
     mutation: MK;
-}, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+}, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<import("./types").MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -32,7 +32,7 @@ const useMutation = (cache, actions, options, abortControllers) => {
             },
             // mutate
             (params) => __awaiter(void 0, void 0, void 0, function* () {
-                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, actions, mutationKey, params, abortControllers);
+                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, mutationKey, params, abortControllers);
             }),
             // abort
             () => {

package/dist/useQuery.d.ts

@@ -1,3 +1,3 @@
 import { ActionMap } from './createActions';
 import { Cache, QueryMutationState, Typenames, UseQueryOptions } from './types';
-export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QR, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<void>];
+export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QR, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<import("./types").QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];

package/dist/useQuery.js

@@ -16,8 +16,9 @@ const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey), } = options;
+    const { query: queryKey, skip, params, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', } = options;
     const logsEnabled = cache.options.logsEnabled;
+    const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheResultSelector = cache.queries[queryKey].resultSelector;
     const cacheStateSelector = cache.cacheStateSelector;
     const store = (0, react_redux_1.useStore)();
@@ -34,7 +35,7 @@ const useQuery = (cache, actions, options) => {
     const resultFromSelector = (resultSelector && (0, react_redux_1.useSelector)(resultSelector));
     const hasResultFromSelector = resultFromSelector !== undefined;
     const fetch = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
-        yield (0, query_1.query)('useQuery.fetch', false, store, cache, actions, queryKey, cacheKey, params);
+        return yield (0, query_1.query)('useQuery.fetch', store, cache, actions, queryKey, cacheKey, params);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }), [store, queryKey, cacheKey]);
     const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.2.0",
+  "version": "0.3.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",