react-redux-cache 0.4.1 → 0.4.3

package/dist/createActions.d.ts

@@ -1,23 +1,23 @@
 import type { EntityChanges, Key, QueryMutationState, Typenames } from './types';
-export type ActionMap<N extends string, T extends Typenames, QR, MR> = ReturnType<typeof createActions<N, T, QR, MR>>;
-export declare const createActions: <N extends string, T extends Typenames, QR, MR>(name: N) => {
+export type ActionMap<N extends string, T extends Typenames, QP, QR, MP, MR> = 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) => {
     /** Updates query state, and optionally merges entity changes in a single action. */
     updateQueryStateAndEntities: {
-        <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: K;
             queryCacheKey: Key;
-            state: Partial<QueryMutationState<QR[K]>> | undefined;
+            state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
             entityChagnes: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateQueryStateAndEntities`;
     };
     /** Updates mutation state, and optionally merges entity changes in a single action. */
     updateMutationStateAndEntities: {
-        <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateMutationStateAndEntities`;
             mutationKey: K_1;
-            state: Partial<QueryMutationState<MR[K_1]>> | undefined;
+            state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
             entityChagnes: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -33,7 +33,7 @@ export declare const createActions: <N extends string, T extends Typenames, QR,
     /** Clear states for provided query keys and cache keys.
      * If cache key for query key is not provided, the whole state for query key is cleared. */
     clearQueryState: {
-        <K_2 extends keyof QR>(queryKeys: {
+        <K_2 extends keyof QP & keyof QR>(queryKeys: {
             key: K_2;
             cacheKey?: Key | undefined;
         }[]): {
@@ -47,7 +47,7 @@ export declare const createActions: <N extends string, T extends Typenames, QR,
     };
     /** Clear states for provided mutation keys. */
     clearMutationState: {
-        <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+        <K_3 extends keyof MP & keyof MR>(mutationKeys: K_3[]): {
             type: `@rrc/${N}/clearMutationState`;
             mutationKeys: K_3[];
         };

package/dist/createCache.d.ts

@@ -11,18 +11,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: import("./types").EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+        queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: import("./types").Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+        mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
     } | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
-        queryKey: keyof QR;
+        queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
-        state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
+        state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
-        mutationKey: keyof MR;
-        state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
+        mutationKey: keyof MP & keyof MR;
+        state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
@@ -30,33 +30,33 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     } | {
         type: `@rrc/${N}/clearQueryState`;
         queryKeys: {
-            key: keyof QR;
+            key: keyof QP & keyof QR;
             cacheKey?: Key | undefined;
         }[];
     } | {
         type: `@rrc/${N}/clearMutationState`;
-        mutationKeys: (keyof MR)[];
+        mutationKeys: (keyof MP & keyof MR)[];
     }) => {
         entities: import("./types").EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+        queries: QP | QR extends infer T_3 ? { [QK in keyof T_3]: import("./types").Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+        mutations: MP | MR extends infer T_4 ? { [MK in keyof T_4]: QueryMutationState<MP[MK], MR[MK]>; } : never;
     };
     actions: {
         updateQueryStateAndEntities: {
-            <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
-                state: Partial<QueryMutationState<QR[K]>> | undefined;
+                state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K_1;
-                state: Partial<QueryMutationState<MR[K_1]>> | undefined;
+                state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -69,7 +69,7 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
             type: `@rrc/${N}/mergeEntityChanges`;
         };
         clearQueryState: {
-            <K_2 extends keyof QR>(queryKeys: {
+            <K_2 extends keyof QP & keyof QR>(queryKeys: {
                 key: K_2;
                 cacheKey?: Key | undefined;
             }[]): {
@@ -82,30 +82,34 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
             type: `@rrc/${N}/clearQueryState`;
         };
         clearMutationState: {
-            <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+            <K_3 extends keyof MP & keyof MR>(mutationKeys: K_3[]): {
                 type: `@rrc/${N}/clearMutationState`;
                 mutationKeys: K_3[];
             };
             type: `@rrc/${N}/clearMutationState`;
-        }; /** Selects query latest result. */
+        };
     };
     selectors: {
         /** Selects query state. */
-        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;
+        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never> | undefined;
         /** Selects query latest result. */
-        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;
+        selectQueryResult: <QK_2 extends keyof QP | keyof QR>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
         /** Selects query loading state. */
-        selectQueryLoading: <QK_3 extends keyof QR | keyof QP>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
+        selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
         /** Selects query latest error. */
-        selectQueryError: <QK_4 extends keyof QR | keyof QP>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+        selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+        /** Selects query latest params. */
+        selectQueryParams: <QK_5 extends keyof QP | keyof QR>(state: unknown, query: QK_5, cacheKey: Key) => (QK_5 extends keyof QP & keyof QR ? QP[QK_5] : never) | undefined;
         /** Selects mutation state. */
-        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>;
+        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => QueryMutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
         /** Selects mutation latest result. */
         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;
         /** Selects mutation loading state. */
         selectMutationLoading: <MK_3 extends keyof MP | keyof MR>(state: unknown, mutation: MK_3) => boolean;
         /** Selects mutation latest error. */
         selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
+        /** Selects mutation latest params. */
+        selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never;
         /** Selects entity by id and typename. */
         selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
         /** Selects all entities. */
@@ -116,18 +120,20 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     hooks: {
         /** Returns client object with query and mutate functions. */
         useClient: () => {
-            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>>;
+            query: <QK_6 extends keyof QP | keyof QR>(options: Omit<QueryOptions<T, QP, QR, QK_6>, "cachePolicy">) => Promise<QueryResult<QK_6 extends keyof QP & keyof QR ? QR[QK_6] : never>>;
+            mutate: <MK_6 extends keyof MP | keyof MR>(options: {
+                mutation: MK_6;
+                params: MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never;
+            }) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
         };
         /** Fetches query when params change and subscribes to query state. */
-        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>>];
+        useQuery: <QK_7 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_7>) => readonly [QueryMutationState<QK_7 extends keyof QP & keyof QR ? QP[QK_7] : never, QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>, () => Promise<QueryResult<QK_7 extends infer T_5 ? T_5 extends QK_7 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        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];
+        useMutation: <MK_7 extends keyof MP | keyof MR>(options: {
+            mutation: MK_7;
+        }) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_6 ? T_6 extends MK_7 ? T_6 extends keyof MP & keyof MR ? MR[T_6] : never : never : never>>, QueryMutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+        /** useSelector + selectEntityById. */
+        useSelectEntityById: <TN_2 extends keyof T>(id: Key | null | undefined, typename: TN_2) => T[TN_2] | undefined;
     };
     utils: {
         /**

package/dist/createCache.js

@@ -29,6 +29,9 @@ const createCache = (partialCache) => {
     partialCache.abortControllers = abortControllers;
     const cache = partialCache;
     // make selectors
+    const selectEntityById = (state, id, typename) => {
+        return id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id];
+    };
     const selectQueryState = (state, query, cacheKey) => {
         // @ts-expect-error fix later
         return cache.cacheStateSelector(state).queries[query][cacheKey];
@@ -62,6 +65,11 @@ const createCache = (partialCache) => {
                 var _a;
                 return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.error;
             },
+            /** Selects query latest params. */
+            selectQueryParams: (state, query, cacheKey) => {
+                var _a;
+                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.params;
+            },
             /** Selects mutation state. */
             selectMutationState,
             /** Selects mutation latest result. */
@@ -76,10 +84,12 @@ const createCache = (partialCache) => {
             selectMutationError: (state, mutation) => {
                 return selectMutationState(state, mutation).error;
             },
-            /** Selects entity by id and typename. */
-            selectEntityById: (state, id, typename) => {
-                return id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id];
+            /** Selects mutation latest params. */
+            selectMutationParams: (state, mutation) => {
+                return selectMutationState(state, mutation).params;
             },
+            /** Selects entity by id and typename. */
+            selectEntityById,
             /** Selects all entities. */
             selectEntities: (state) => {
                 return cache.cacheStateSelector(state).entities;
@@ -114,6 +124,10 @@ const createCache = (partialCache) => {
             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),
+            /** useSelector + selectEntityById. */
+            useSelectEntityById: (id, typename) => {
+                return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));
+            },
         },
         utils: {
             /**

package/dist/index.js

@@ -23,7 +23,8 @@ 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
-// add not optimized not normalized example, and not normalized state example to readme
+// determine refresh vs load next page
+// update readme with how to use mergeResults for invalidating / updating caches
 // try use skip for refreshing strategy?
 // optimistic response
 // make query key / cache key difference more clear in the docs, and/or rename queryKey -> query

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, 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>>;
+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>>) => 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, 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 = {};
@@ -31,6 +31,7 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities }, mutati
         else {
             store.dispatch(updateMutationStateAndEntities(mutationKey, {
                 loading: true,
+                params,
                 result: undefined,
             }));
         }

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, 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>>;
+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) => 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, 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;
@@ -29,6 +29,7 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities }, queryKey,
     }
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
         loading: true,
+        params,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
     let response;

package/dist/reducer.d.ts

@@ -1,20 +1,20 @@
 import type { ActionMap } from './createActions';
 import type { CacheOptions, Dict, EntitiesMap, QueryMutationState, Typenames } from './types';
-export type ReduxCacheState<T extends Typenames, QR, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QR, MR>>>;
-export declare const createCacheReducer: <N extends string, T extends Typenames, QR, MR>(actions: ActionMap<N, T, QR, MR>, typenames: T, queryKeys: (keyof QR)[], cacheOptions: CacheOptions) => (state: {
+export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QP, QR, MP, MR>>>;
+export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: ActionMap<N, T, QP, QR, MP, MR>, typenames: T, queryKeys: (keyof QP & keyof QR)[], cacheOptions: CacheOptions) => (state: {
     entities: EntitiesMap<T>;
-    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
-    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
 } | undefined, action: {
     type: `@rrc/${N}/updateQueryStateAndEntities`;
-    queryKey: keyof QR;
+    queryKey: keyof QP & keyof QR;
     queryCacheKey: import("./types").Key;
-    state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
+    state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/updateMutationStateAndEntities`;
-    mutationKey: keyof MR;
-    state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
+    mutationKey: keyof MP & keyof MR;
+    state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/mergeEntityChanges`;
@@ -22,14 +22,14 @@ export declare const createCacheReducer: <N extends string, T extends Typenames,
 } | {
     type: `@rrc/${N}/clearQueryState`;
     queryKeys: {
-        key: keyof QR;
+        key: keyof QP & keyof QR;
         cacheKey?: import("./types").Key | undefined;
     }[];
 } | {
     type: `@rrc/${N}/clearMutationState`;
-    mutationKeys: (keyof MR)[];
+    mutationKeys: (keyof MP & keyof MR)[];
 }) => {
     entities: EntitiesMap<T>;
-    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
-    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
 };

package/dist/types.d.ts

@@ -21,8 +21,10 @@ export type Typenames = Record<string, object>;
 export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state. */
     name: N;
-    /** Mapping of all typenames to their entity types, which is needed for proper typing and normalization.
-     * Empty objects with type casting can be used as values.
+    /**
+     * Mapping of all typenames to their entity types, which is needed for proper normalization. Can be empty If normalization not needed.
+     * @key Typename.
+     * @value Object with proper type of the typename. Empty objects with type casting can be used.
      * @example
      * typenames: {
         users: {} as User, // here `users` entities will have type `User`
@@ -30,14 +32,14 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     } */
     typenames: T;
     queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never;
+        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QP, QR, MP, MR>> : never;
     };
     mutations: {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
     };
     options: CacheOptions;
     /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
-    cacheStateSelector: (state: any) => ReduxCacheState<T, QR, MR>;
+    cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
 };
 export type CacheOptions = {
     /**
@@ -83,11 +85,11 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
      * */
     getCacheKey?: (params?: P) => Key;
 };
-export type UseQueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (QP & QR)> = {
+export type UseQueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = {
     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'>;
+} & Pick<QueryInfo<T, unknown, unknown, unknown>, '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.
@@ -102,7 +104,7 @@ export type QueryResult<R> = {
     cancelled?: true;
     result?: R;
 };
-export type QueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, MR, QK>, 'skip'>;
+export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, QK>, 'skip'>;
 export type Mutation<T extends Typenames, P, R> = (params: P, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;
@@ -118,11 +120,13 @@ export type MutationResult<R> = {
     aborted?: true;
     result?: R;
 };
-export type QueryMutationState<R> = {
+export type QueryMutationState<P, R> = {
     /** `true` when query or mutation is currently in progress. */
     loading: boolean;
     /** Result of the latest successfull response. */
     result?: R;
     /** Error of the latest response. */
     error?: Error;
+    /** Parameters of the latest request. */
+    params: P;
 };

package/dist/useMutation.d.ts

@@ -1,6 +1,6 @@
 import { Store } from 'redux';
 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: {
+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, unknown, MP, MR>, "updateMutationStateAndEntities">, options: {
     mutation: MK;
-}, 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];
+}, 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, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

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<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>>];
+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, QP, QR, MP, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QP[QK] : never, 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/package.json

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