react-redux-cache 0.0.12 → 0.2.0

package/README.md

@@ -1,3 +1,11 @@
+### Donations 🙌
+
+**BTC:** bc1qs0sq7agz5j30qnqz9m60xj4tt8th6aazgw7kxr \
+**ETH:** 0x1D834755b5e889703930AC9b784CB625B3cd833E \
+**USDT(Tron):** TPrCq8LxGykQ4as3o1oB8V7x1w2YPU2o5n \
+**TON:** EQAtBuFWI3H_LpHfEToil4iYemtfmyzlaJpahM3tFSoxojvV \
+**DOGE:** D7GMQdKhKC9ymbT9PtcetSFTQjyPRRfkwT
+
 # react-redux-cache
 
 **Powerful** yet **lightweight** data fetching and caching library that supports **normalization** unlike `react-query` and `rtk-query`, while having similar but very simple interface. Built on top of `redux`, fully typed and written on Typescript. Can be considered as `ApolloClient` for protocols other than `GraphQL`.
@@ -6,8 +14,6 @@
 
 Remains **full control** of redux state with ability to write custom selectors, actions and reducers to manage cached state.
     
-Usage example can be found in `example/` folder and run by `npm run example` command from the root folder.
-    
 ### Table of contents
 
  - [Installation](https://github.com/gentlee/react-redux-cache#Installation)
@@ -21,7 +27,8 @@ Usage example can be found in `example/` folder and run by `npm run example` com
    - [Infinite scroll pagination](https://github.com/gentlee/react-redux-cache#infinite-scroll-pagination)
    - [redux-persist](https://github.com/gentlee/react-redux-cache#redux-persist)
  - [FAQ](https://github.com/gentlee/react-redux-cache#faq)
-   - [What is cache key?](https://github.com/gentlee/react-redux-cache#what-is-cache-key)
+   - [What is a query cache key?](https://github.com/gentlee/react-redux-cache#what-is-a-query-cache-key)
+   - [How mutation fetching differs from queries?](https://github.com/gentlee/react-redux-cache#how-mutation-fetching-differs-from-queries)
 
 ### Installation
 `react`, `redux` and `react-redux` are peer dependencies.
@@ -29,21 +36,28 @@ Usage example can be found in `example/` folder and run by `npm run example` com
 npm add react-redux-cache react redux react-redux
 ```
 ### Initialization
-The only function that needs to be imported is `createCache`, which creates fully typed reducer, hooks, actions, selectors and utils to be used in the app.
+The only function that needs to be imported is `createCache`, which creates fully typed reducer, hooks, actions, selectors and utils to be used in the app. You can create as many caches as needed, but keep in mind that normalization is not shared between them.
 All typenames, queries and mutations should be passed while initializing the cache for proper typing.
 #### cache.ts
 ```typescript
 export const {
+  cache,
   reducer,
   hooks: {useClient, useMutation, useQuery, useSelectEntityById},
   // Actions, selectors and utils may be not used at all
   selectors: {entitiesSelector, entitiesByTypenameSelector},
-  actions: {setQueryStateAndEntities, setMutationStateAndEntities, mergeEntityChanges},
+  actions: {
+    updateQueryStateAndEntities,
+    updateMutationStateAndEntities,
+    mergeEntityChanges,
+    clearQueryState,
+    clearMutationState,
+  },
   utils: {applyEntityChanges},
 } = createCache({
-  // This selector should return the cache state based on the path to its reducer.
-  cacheStateSelector: (state) => state.cache,
-  // Typenames provide a mapping of all typenames to their entity types, which is needed for normalization.
+  // Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state.
+  name: 'cache',
+  // Typenames provide a 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.
   typenames: {
     users: {} as User, // here `users` entities will have type `User`
@@ -61,11 +75,12 @@ export const {
 ```
 #### store.ts
 ```typescript
-// Create store as usual, passing the new cache reducer
-// under the key, previously used in cacheStateSelector
+// Create store as usual, passing the new cache reducer under the name of the cache.
+// If some other redux structure is needed, provide custom cacheStateSelector when creating cache.
 const store = configureStore({
   reducer: {
-    cache: reducer,
+    [cache.name]: reducer,
+    ...
   }
 })
 ```
@@ -111,6 +126,9 @@ export const removeUser = async (id: number) => {
 ```
 
 ### Usage
+
+Please check `example/` folder (`npm run example` to run).
+
 #### UserScreen.tsx
 ```typescript
 export const UserScreen = () => {
@@ -271,7 +289,7 @@ const persistedReducer = persistReducer(
 
 ### FAQ
 
-#### What is cache key?
+#### What is a query cache key?
 
 **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.
 
@@ -293,3 +311,9 @@ export const defaultGetCacheKey = <P = unknown>(params: P): Key => {
 It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order.
 
 As example, can be overriden when implementing pagination.
+
+#### How mutation fetching differs from queries?
+
+**Queries:** For each cache key (= unique params by default) of each query fetch is running in parallel. If fetch is already running for specific cache key, all next fetches are cancelled until it finishes.
+
+**Mutations:** Only one mutation can be run for each mutation key at a time. If another one called, previous is aborted.

package/dist/createActions.d.ts

@@ -0,0 +1,50 @@
+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) => {
+    updateQueryStateAndEntities: {
+        <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+            type: `@rrc/${N}/updateQueryStateAndEntities`;
+            queryKey: K;
+            queryCacheKey: Key;
+            state: Partial<QueryMutationState<QR[K]>> | undefined;
+            entityChagnes: EntityChanges<T> | undefined;
+        };
+        type: `@rrc/${N}/updateQueryStateAndEntities`;
+    };
+    updateMutationStateAndEntities: {
+        <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+            type: `@rrc/${N}/updateMutationStateAndEntities`;
+            mutationKey: K_1;
+            state: Partial<QueryMutationState<MR[K_1]>> | undefined;
+            entityChagnes: EntityChanges<T> | undefined;
+        };
+        type: `@rrc/${N}/updateMutationStateAndEntities`;
+    };
+    mergeEntityChanges: {
+        (changes: EntityChanges<T>): {
+            type: `@rrc/${N}/mergeEntityChanges`;
+            changes: EntityChanges<T>;
+        };
+        type: `@rrc/${N}/mergeEntityChanges`;
+    };
+    clearQueryState: {
+        <K_2 extends keyof QR>(queryKeys: {
+            key: K_2;
+            cacheKey?: Key | undefined;
+        }[]): {
+            type: `@rrc/${N}/clearQueryState`;
+            queryKeys: {
+                key: K_2;
+                cacheKey?: Key | undefined;
+            }[];
+        };
+        type: `@rrc/${N}/clearQueryState`;
+    };
+    clearMutationState: {
+        <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+            type: `@rrc/${N}/clearMutationState`;
+            mutationKeys: K_3[];
+        };
+        type: `@rrc/${N}/clearMutationState`;
+    };
+};

package/dist/createActions.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActions = void 0;
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const createActions = (name) => {
+    const actionPrefix = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/${name}/`;
+    const updateQueryStateAndEntitiesType = `${actionPrefix}updateQueryStateAndEntities`;
+    /** Updates query state, and optionally merges entity changes in a single action. */
+    const updateQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
+        type: updateQueryStateAndEntitiesType,
+        queryKey,
+        queryCacheKey,
+        state,
+        entityChagnes,
+    });
+    updateQueryStateAndEntities.type = updateQueryStateAndEntitiesType;
+    const updateMutationStateAndEntitiesType = `${actionPrefix}updateMutationStateAndEntities`;
+    /** Updates mutation state, and optionally merges entity changes in a single action. */
+    const updateMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
+        type: updateMutationStateAndEntitiesType,
+        mutationKey,
+        state,
+        entityChagnes,
+    });
+    updateMutationStateAndEntities.type = updateMutationStateAndEntitiesType;
+    const mergeEntityChangesType = `${actionPrefix}mergeEntityChanges`;
+    /** Merge EntityChanges to the state. */
+    const mergeEntityChanges = (changes) => ({
+        type: mergeEntityChangesType,
+        changes,
+    });
+    mergeEntityChanges.type = mergeEntityChangesType;
+    const clearQueryStateType = `${actionPrefix}clearQueryState`;
+    /** 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. */
+    const clearQueryState = (queryKeys) => ({
+        type: clearQueryStateType,
+        queryKeys,
+    });
+    clearQueryState.type = clearQueryStateType;
+    const clearMutationStateType = `${actionPrefix}clearMutationState`;
+    /** Clear states for provided mutation keys. */
+    const clearMutationState = (mutationKeys) => ({
+        type: clearMutationStateType,
+        mutationKeys,
+    });
+    clearMutationState.type = clearMutationStateType;
+    return {
+        updateQueryStateAndEntities,
+        updateMutationStateAndEntities,
+        mergeEntityChanges,
+        clearQueryState,
+        clearMutationState,
+    };
+};
+exports.createActions = createActions;

package/dist/createCache.d.ts

@@ -1,80 +1,116 @@
-import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import type { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 import { applyEntityChanges } from './utilsAndConstants';
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
-export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: OptionalPartial<Cache<T, QP, QR, MP, MR>, "queries" | "mutations" | "options">) => {
-    cache: Cache<T, QP, QR, MP, MR>;
+export declare const createCache: <N extends string, T extends Typenames, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "options" | "queries" | "mutations" | "cacheStateSelector">) => {
+    cache: Cache<N, T, QP, QR, MP, MR>;
     /** 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]>; };
     } | undefined, action: {
-        type: `${string}MERGE_ENTITY_CHANGES`;
-        changes: import("./types").EntityChanges<T>;
-    } | {
-        type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+        type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QR;
         queryCacheKey: Key;
         state: Partial<import("./types").QueryMutationState<QR[keyof QR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
-        type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+        type: `@rrc/${N}/updateMutationStateAndEntities`;
         mutationKey: keyof MR;
         state: Partial<import("./types").QueryMutationState<MR[keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
+    } | {
+        type: `@rrc/${N}/mergeEntityChanges`;
+        changes: import("./types").EntityChanges<T>;
+    } | {
+        type: `@rrc/${N}/clearQueryState`;
+        queryKeys: {
+            key: keyof QR;
+            cacheKey?: Key | undefined;
+        }[];
+    } | {
+        type: `@rrc/${N}/clearMutationState`;
+        mutationKeys: (keyof MR)[]; /** Select all entities of provided typename. */
     }) => {
         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]>; };
     };
     actions: {
-        /** Updates query state, and optionally merges entity changes in a single action. */
-        setQueryStateAndEntities: <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
-            type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
-            queryKey: K;
-            queryCacheKey: Key;
-            state: Partial<import("./types").QueryMutationState<QR[K]>> | undefined;
-            entityChagnes: import("./types").EntityChanges<T> | undefined;
+        updateQueryStateAndEntities: {
+            <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").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;
+                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): {
+                type: `@rrc/${N}/updateMutationStateAndEntities`;
+                mutationKey: K_1;
+                state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
+                entityChagnes: import("./types").EntityChanges<T> | undefined;
+            };
+            type: `@rrc/${N}/updateMutationStateAndEntities`;
+        };
+        mergeEntityChanges: {
+            (changes: import("./types").EntityChanges<T>): {
+                type: `@rrc/${N}/mergeEntityChanges`;
+                changes: import("./types").EntityChanges<T>;
+            };
+            type: `@rrc/${N}/mergeEntityChanges`;
         };
-        /** Updates mutation state, and optionally merges entity changes in a single action. */
-        setMutationStateAndEntities: <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
-            type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
-            mutationKey: K_1;
-            state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
-            entityChagnes: import("./types").EntityChanges<T> | undefined;
+        clearQueryState: {
+            <K_2 extends keyof QR>(queryKeys: {
+                key: K_2;
+                cacheKey?: Key | undefined;
+            }[]): {
+                type: `@rrc/${N}/clearQueryState`;
+                queryKeys: {
+                    key: K_2;
+                    cacheKey?: Key | undefined;
+                }[];
+            };
+            type: `@rrc/${N}/clearQueryState`;
         };
-        /** Merge EntityChanges to the state. */
-        mergeEntityChanges: (changes: import("./types").EntityChanges<T>) => {
-            type: `${string}MERGE_ENTITY_CHANGES`;
-            changes: import("./types").EntityChanges<T>;
+        clearMutationState: {
+            <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+                type: `@rrc/${N}/clearMutationState`;
+                mutationKeys: K_3[]; /** Select all entities of provided typename. */
+            };
+            type: `@rrc/${N}/clearMutationState`;
         };
     };
     selectors: {
+        /** Select all entities from the state. */
         entitiesSelector: (state: unknown) => EntitiesMap<T>;
-        entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_2 in keyof T]: (state: unknown) => EntitiesMap<T>[K_2]; }[TN];
+        /** Select all entities of provided typename. */
+        entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_4 in keyof T]: (state: unknown) => EntitiesMap<T>[K_4]; }[TN];
     };
     hooks: {
         /** Returns client object with query function */
         useClient: () => {
-            query: <QK_1 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, MP, MR, QK_1>) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>;
+            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>>;
         };
         /** Fetches query when params change and subscribes to query state. */
-        useQuery: <QK_2 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_2>) => readonly [import("./types").QueryMutationState<QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never>, () => Promise<void>];
+        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>];
         /** 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];
         /** Selects entity by id and subscribes to the changes. */
-        useSelectEntityById: <K_3 extends keyof T>(id: Key | null | undefined, typename: K_3) => T[K_3] | undefined;
+        useSelectEntityById: <TN_1 extends keyof T>(id: Key | null | undefined, typename: TN_1) => T[TN_1] | undefined;
     };
     utils: {
         applyEntityChanges: (entities: EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => EntitiesMap<T> | undefined;

package/dist/createCache.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const createActions_1 = require("./createActions");
 const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const reducer_1 = require("./reducer");
@@ -12,41 +13,39 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
-const createCache = (cache) => {
-    var _a, _b, _c, _d, _e;
-    var _f, _g;
+const createCache = (partialCache) => {
+    var _a, _b, _c, _d, _e, _f;
+    var _g, _h;
     const abortControllers = new WeakMap();
     // provide all optional fields
-    (_a = cache.options) !== null && _a !== void 0 ? _a : (cache.options = {});
-    (_b = (_f = cache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_f.logsEnabled = false);
-    (_c = (_g = cache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_g.validateFunctionArguments = utilsAndConstants_1.isDev);
-    (_d = cache.queries) !== null && _d !== void 0 ? _d : (cache.queries = {});
-    (_e = cache.mutations) !== null && _e !== void 0 ? _e : (cache.mutations = {});
-    // @ts-expect-error for testing
-    cache.abortControllers = abortControllers;
-    const nonPartialCache = cache;
+    (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
+    (_b = (_g = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_g.logsEnabled = false);
+    (_c = (_h = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_h.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
+    (_d = partialCache.queries) !== null && _d !== void 0 ? _d : (partialCache.queries = {});
+    (_e = partialCache.mutations) !== null && _e !== void 0 ? _e : (partialCache.mutations = {});
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (_f = partialCache.cacheStateSelector) !== null && _f !== void 0 ? _f : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+    // @ts-expect-error private field for testing
+    partialCache.abortControllers = abortControllers;
+    const cache = partialCache;
     // make selectors
     const entitiesSelector = (state) => {
-        return nonPartialCache.cacheStateSelector(state).entities;
+        return cache.cacheStateSelector(state).entities;
     };
-    const enitityMapSelectorByTypename = Object.keys(cache.typenames).reduce((result, x) => {
-        result[x] = (state) => nonPartialCache.cacheStateSelector(state).entities[x];
+    const enitityMapSelectorByTypename = Object.keys(partialCache.typenames).reduce((result, x) => {
+        result[x] = (state) => cache.cacheStateSelector(state).entities[x];
         return result;
     }, {});
+    const actions = (0, createActions_1.createActions)(cache.name);
     return {
-        cache: nonPartialCache,
+        cache,
         /** Reducer of the cache, should be added to redux store. */
-        reducer: (0, reducer_1.createCacheReducer)(nonPartialCache.typenames, nonPartialCache.queries, nonPartialCache.mutations, nonPartialCache.options),
-        actions: {
-            /** Updates query state, and optionally merges entity changes in a single action. */
-            setQueryStateAndEntities: reducer_1.setQueryStateAndEntities,
-            /** Updates mutation state, and optionally merges entity changes in a single action. */
-            setMutationStateAndEntities: reducer_1.setMutationStateAndEntities,
-            /** Merge EntityChanges to the state. */
-            mergeEntityChanges: reducer_1.mergeEntityChanges,
-        },
+        reducer: (0, reducer_1.createCacheReducer)(actions, cache.typenames, Object.keys(cache.queries), cache.options),
+        actions,
         selectors: {
+            /** Select all entities from the state. */
             entitiesSelector,
+            /** Select all entities of provided typename. */
             entitiesByTypenameSelector: (typename) => {
                 return enitityMapSelectorByTypename[typename];
             },
@@ -60,30 +59,32 @@ const createCache = (cache) => {
                         query: (options) => {
                             var _a;
                             const { query: queryKey, params } = options;
-                            const getCacheKey = (_a = nonPartialCache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
+                            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, nonPartialCache, queryKey, cacheKey, params);
+                            return (0, query_1.query)('query', true, store, cache, actions, queryKey, cacheKey, params);
                         },
                         mutate: (options) => {
-                            return (0, mutate_1.mutate)('mutate', true, store, nonPartialCache, options.mutation, options.params, abortControllers);
+                            return (0, mutate_1.mutate)('mutate', true, store, cache, actions, options.mutation, options.params, abortControllers);
                         },
                     };
                     return client;
                 }, [store]);
             },
             /** Fetches query when params change and subscribes to query state. */
-            useQuery: (options) => (0, useQuery_1.useQuery)(nonPartialCache, options),
+            useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, options),
             /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: (options) => (0, useMutation_1.useMutation)(nonPartialCache, options, abortControllers),
+            useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
             /** Selects entity by id and subscribes to the changes. */
             useSelectEntityById: (id, typename) => {
-                return (0, react_redux_1.useSelector)((state) => id == null ? undefined : nonPartialCache.cacheStateSelector(state).entities[typename][id]);
+                return (0, react_redux_1.useSelector)((state) => 
+                // TODO move to selectors?
+                id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id]);
             },
         },
         utils: {
             applyEntityChanges: (entities, changes) => {
-                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, nonPartialCache.options);
+                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options);
             },
         },
     };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createCache } from './createCache';
 export type { ReduxCacheState } from './reducer';
 export * from './types';
-export { defaultGetCacheKey, defaultQueryMutationState } from './utilsAndConstants';
+export { defaultGetCacheKey, DEFAULT_QUERY_MUTATION_STATE as defaultQueryMutationState, } from './utilsAndConstants';

package/dist/index.js

@@ -20,45 +20,38 @@ Object.defineProperty(exports, "createCache", { enumerable: true, get: function
 __exportStar(require("./types"), exports);
 var utilsAndConstants_1 = require("./utilsAndConstants");
 Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
-Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.defaultQueryMutationState; } });
+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
 // ! medium
-// allow multiple mutation with sam keys?
+// make named caches to produce named hooks, actions etc (same as slices in RTK)?
+// allow multiple mutation with same keys?
 // type extractors from cache
 // custom useStore
 // return back deserialize selector?
-// resultSelector - return also boolean that result is full enough
+// resultSelector - return also boolean that result is full enough or make cache policy as a function
 // selector for entities by typename
-// provide call query/mutation function to call them without hooks, but with all state updates
-// get typenames from schema? (useSelectDenormalized)
 // callback option on error / success?
-// cache policy as function? needsRefetch
-// add verbose debug logs
-// refetch queries on query / mutation success?
-// remove state when it finished without errors
-// set default options like getParams
-// selectors for loading state of similar query or mutation (wihout using params as key)
+// refetch queries on mutation success
+// remove query/mutation state when it finished without errors
 // deep equal entities while merging state
-// support multiple stores
-// add validation if entity is full enough
-// optimistic response
 // make error type generic
-// proper types, remove as, any, todo
+// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?
 // ! low
-// make types readonly
-// support changing query key?
-// remove defaultState and keep values undefined?
 // add params to the state?
 // cancellation to queries
 // if mutation & query alrady loading - make options: last, throttle, debounce, parallel?
 // add time-to-live option, and/or time-to-refresh
-// add getUpdateTime option to check entities while merging
-// useLocalMutation - uses local component state, or make store option - redux or component state or context? 1 version: redux only
+// add refresh interval for queries that are mounted
 // replace try/catch with returned error
 // support any store, not only redux
-// QueryInfo.defaultOptions
-// set options in refresh/mutate functions
-// multiple reducers instead of 1?
-// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?
+// readonly types?
+// proper types, remove as, any, todo
+// add number of retries param?

package/dist/mutate.d.ts

@@ -1,3 +1,4 @@
 import { Store } from 'redux';
-import { Cache, Key, MutationResult, Typenames } from './types';
-export declare const mutate: <T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, 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>>;
+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>>;

package/dist/mutate.js

@@ -10,9 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
-const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
+const mutate = (logTag, returnResult, store, cache, { updateMutationStateAndEntities }, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -30,7 +29,7 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
             abortController.abort();
         }
         else {
-            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+            store.dispatch(updateMutationStateAndEntities(mutationKey, {
                 loading: true,
                 result: undefined,
             }));
@@ -60,14 +59,14 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
     }
     delete abortControllersOfStore[mutationKey];
     if (error) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch(updateMutationStateAndEntities(mutationKey, {
             error: error,
             loading: false,
         }));
         return { error };
     }
     if (response) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch(updateMutationStateAndEntities(mutationKey, {
             error: undefined,
             loading: false,
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/dist/query.d.ts

@@ -1,3 +1,4 @@
 import { Store } from 'redux';
-import { Cache, Key, QueryResult, Typenames } from './types';
-export declare const query: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, 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>>;
+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>>;

package/dist/query.js

@@ -10,9 +10,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
-const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
+const query = (logTag, returnResult, 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;
@@ -28,7 +27,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
             });
         return returnResult ? { cancelled: true } : undefined;
     }
-    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
         loading: true,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
@@ -40,7 +39,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
         params);
     }
     catch (error) {
-        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+        store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
             error: error,
             loading: false,
         }));
@@ -57,7 +56,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
                 (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params)
                 : response.result,
     };
-    store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, newState, response));
+    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
     // @ts-expect-error fix types
     return returnResult
         ? {

package/dist/reducer.d.ts

@@ -1,46 +1,35 @@
-import { Cache, Dict, EntitiesMap, EntityChanges, Key, QueryMutationState, Typenames } from './types';
-export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<T, QP, QR, MP, MR>>>;
-export declare const createCacheReducer: <T extends Typenames, QP, QR, MP, MR>(typenames: T, queries: QP & QR extends infer T_1 ? { [QK in keyof T_1]: QK extends keyof QP & keyof QR ? import("./types").QueryInfo<T, QP[QK], QR[QK], {
+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: {
     entities: EntitiesMap<T>;
-    queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
-    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
-}> : never; } : never, mutations: MP & MR extends infer T_2 ? { [MK_1 in keyof T_2]: MK_1 extends keyof MP & keyof MR ? import("./types").MutationInfo<T, MP[MK_1], MR[MK_1]> : never; } : never, cacheOptions: import("./types").CacheOptions) => (state: {
-    entities: EntitiesMap<T>;
-    queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
+    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
     mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
 } | undefined, action: {
-    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+    type: `@rrc/${N}/updateQueryStateAndEntities`;
     queryKey: keyof QR;
-    queryCacheKey: Key;
+    queryCacheKey: import("./types").Key;
     state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
+    entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
-    type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+    type: `@rrc/${N}/updateMutationStateAndEntities`;
     mutationKey: keyof MR;
     state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
+    entityChagnes: import("./types").EntityChanges<T> | undefined;
+} | {
+    type: `@rrc/${N}/mergeEntityChanges`;
+    changes: import("./types").EntityChanges<T>;
+} | {
+    type: `@rrc/${N}/clearQueryState`;
+    queryKeys: {
+        key: keyof QR;
+        cacheKey?: import("./types").Key | undefined;
+    }[];
 } | {
-    type: `${string}MERGE_ENTITY_CHANGES`;
-    changes: EntityChanges<T>;
+    type: `@rrc/${N}/clearMutationState`;
+    mutationKeys: (keyof MR)[];
 }) => {
     entities: EntitiesMap<T>;
-    queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
+    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
     mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
 };
-export declare const setQueryStateAndEntities: <T extends Typenames, QR, K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
-    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
-    queryKey: K;
-    queryCacheKey: Key;
-    state: Partial<QueryMutationState<QR[K]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
-};
-export declare const setMutationStateAndEntities: <T extends Typenames, MR, K extends keyof MR>(mutationKey: K, state?: Partial<QueryMutationState<MR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
-    type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
-    mutationKey: K;
-    state: Partial<QueryMutationState<MR[K]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
-};
-export declare const mergeEntityChanges: <T extends Typenames>(changes: EntityChanges<T>) => {
-    type: `${string}MERGE_ENTITY_CHANGES`;
-    changes: EntityChanges<T>;
-};

package/dist/reducer.js

@@ -1,75 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeEntityChanges = exports.setMutationStateAndEntities = exports.setQueryStateAndEntities = exports.createCacheReducer = void 0;
+exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
+const EMPTY_QUERY_STATE = Object.freeze({});
+const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
     const entitiesMap = {};
     for (const key in typenames) {
-        entitiesMap[key] = {};
+        entitiesMap[key] = EMPTY_QUERY_STATE;
     }
-    const queriesMap = {};
-    for (const key in queries) {
-        queriesMap[key] = {};
+    const queryStateMap = {};
+    for (const key of queryKeys) {
+        queryStateMap[key] = {};
     }
-    const mutationsMap = {};
+    const mutationStateMap = {};
     const initialState = {
         entities: entitiesMap,
-        queries: queriesMap,
-        mutations: mutationsMap,
+        queries: queryStateMap,
+        mutations: mutationStateMap,
     };
     cacheOptions.logsEnabled &&
         (0, utilsAndConstants_1.log)('createCacheReducer', {
             typenames,
-            queries,
-            mutations,
+            queryKeys,
             initialState,
         });
     return (state = initialState, action) => {
+        var _a, _b;
         switch (action.type) {
-            case '@RRC/SET_QUERY_STATE_AND_ENTITIES': {
-                const { queryKey, queryCacheKey, state: queryState, entityChagnes } = action;
+            case actions.updateQueryStateAndEntities.type: {
+                const { queryKey, queryCacheKey, state: queryState, entityChagnes, } = action;
                 const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!queryState && !newEntities) {
                     return state;
                 }
-                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { queries: Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: Object.assign(Object.assign({}, state.queries[queryKey][queryCacheKey]), queryState) }) }) });
+                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { queries: Object.assign(Object.assign({}, state.queries), { [queryKey]: Object.assign(Object.assign({}, state.queries[queryKey]), { [queryCacheKey]: Object.assign(Object.assign({}, ((_a = state.queries[queryKey][queryCacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE)), queryState) }) }) });
             }
-            case '@RRC/SET_MUTATION_STATE_AND_ENTITIES': {
-                const { mutationKey, state: mutationState, entityChagnes } = action;
+            case actions.updateMutationStateAndEntities.type: {
+                const { mutationKey, state: mutationState, entityChagnes, } = action;
                 const newEntities = entityChagnes && (0, utilsAndConstants_1.applyEntityChanges)(state.entities, entityChagnes, cacheOptions);
                 if (!mutationState && !newEntities) {
                     return state;
                 }
-                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { mutations: Object.assign(Object.assign({}, state.mutations), { [mutationKey]: Object.assign(Object.assign({}, state.mutations[mutationKey]), mutationState) }) });
+                return Object.assign(Object.assign(Object.assign({}, state), (newEntities ? { entities: newEntities } : null)), { mutations: Object.assign(Object.assign({}, state.mutations), { [mutationKey]: Object.assign(Object.assign({}, ((_b = state.mutations[mutationKey]) !== null && _b !== void 0 ? _b : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE)), mutationState) }) });
             }
-            case '@RRC/MERGE_ENTITY_CHANGES': {
+            case actions.mergeEntityChanges.type: {
                 const { changes } = action;
                 const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions);
                 return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
             }
+            case actions.clearQueryState.type: {
+                const { queryKeys: queryKeysToClear } = action;
+                if (!queryKeysToClear.length) {
+                    return state;
+                }
+                let newQueries = undefined;
+                for (const query of queryKeysToClear) {
+                    if (query.cacheKey != null) {
+                        if ((newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key][query.cacheKey]) {
+                            newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
+                            newQueries[query.key] = Object.assign({}, newQueries[query.key]);
+                            delete newQueries[query.key][query.cacheKey];
+                        }
+                    }
+                    else if ((newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[query.key] !== EMPTY_QUERY_STATE) {
+                        newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
+                        newQueries[query.key] = EMPTY_QUERY_STATE;
+                    }
+                }
+                if (!newQueries) {
+                    return state;
+                }
+                return Object.assign(Object.assign({}, state), { queries: newQueries });
+            }
+            case actions.clearMutationState.type: {
+                const { mutationKeys } = action;
+                if (!mutationKeys.length) {
+                    return state;
+                }
+                let newMutations = undefined;
+                for (const mutation of mutationKeys) {
+                    if (state.mutations[mutation]) {
+                        newMutations !== null && newMutations !== void 0 ? newMutations : (newMutations = Object.assign({}, state.mutations));
+                        delete newMutations[mutation];
+                    }
+                }
+                if (!newMutations) {
+                    return state;
+                }
+                return Object.assign(Object.assign({}, state), { mutations: newMutations });
+            }
         }
         return state;
     };
 };
 exports.createCacheReducer = createCacheReducer;
-const actionPrefix = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/`;
-const setQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
-    type: `${actionPrefix}SET_QUERY_STATE_AND_ENTITIES`,
-    queryKey,
-    queryCacheKey,
-    state,
-    entityChagnes,
-});
-exports.setQueryStateAndEntities = setQueryStateAndEntities;
-const setMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
-    type: `${actionPrefix}SET_MUTATION_STATE_AND_ENTITIES`,
-    mutationKey,
-    state,
-    entityChagnes,
-});
-exports.setMutationStateAndEntities = setMutationStateAndEntities;
-const mergeEntityChanges = (changes) => ({
-    type: `${actionPrefix}MERGE_ENTITY_CHANGES`,
-    changes,
-});
-exports.mergeEntityChanges = mergeEntityChanges;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { createCacheReducer, ReduxCacheState } from './reducer';
+import type { ReduxCacheState } from './reducer';
 export type Key = string | number | symbol;
 export type Dict<T> = Record<Key, T>;
 export type OptionalPartial<T, K extends keyof T> = Partial<{
@@ -17,17 +17,26 @@ export type EntityChanges<T extends Typenames> = {
 };
 /** Record of typename and its corresponding entity type */
 export type Typenames = Record<string, object>;
-export type Cache<T extends Typenames, QP, QR, MP, MR> = {
+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.
+     * @example
+     * typenames: {
+        users: {} as User, // here `users` entities will have type `User`
+        banks: {} as Bank,
+    } */
     typenames: T;
     queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReturnType<ReturnType<typeof createCacheReducer<T, QP, QR, MP, MR>>>> : never;
+        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never;
     };
     mutations: {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
     };
     options: CacheOptions;
-    /** Returns cache state from redux root state. */
-    cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
+    /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
+    cacheStateSelector: (state: any) => ReduxCacheState<T, QR, MR>;
 };
 export type CacheOptions = {
     /**
@@ -73,11 +82,11 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
      * */
     getCacheKey?: (params?: P) => Key;
 };
-export type UseQueryOptions<T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)> = {
+export type UseQueryOptions<T extends Typenames, QP, QR, MR, 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, QP, QR, MP, MR>> : never, 'cachePolicy' | 'mergeResults' | 'getCacheKey'>;
+} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never, 'cachePolicy' | 'mergeResults' | 'getCacheKey'>;
 /**
  * @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.
@@ -92,7 +101,7 @@ export type QueryResult<R> = {
     cancelled?: true;
     result?: R;
 };
-export type QueryOptions<T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, MP, MR, QK>, 'skip'>;
+export type QueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, MR, 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>>;

package/dist/useMutation.d.ts

@@ -1,5 +1,6 @@
 import { Store } from 'redux';
+import { ActionMap } from './createActions';
 import { Cache, Key, QueryMutationState, Typenames } from './types';
-export declare const useMutation: <T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<T, unknown, unknown, MP, MR>, 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, 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];

package/dist/useMutation.js

@@ -13,9 +13,8 @@ exports.useMutation = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const mutate_1 = require("./mutate");
-const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const useMutation = (cache, options, abortControllers) => {
+const useMutation = (cache, actions, options, abortControllers) => {
     var _a;
     const { mutation: mutationKey } = options;
     const store = (0, react_redux_1.useStore)();
@@ -33,7 +32,7 @@ const useMutation = (cache, options, abortControllers) => {
             },
             // mutate
             (params) => __awaiter(void 0, void 0, void 0, function* () {
-                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, mutationKey, params, abortControllers);
+                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, actions, mutationKey, params, abortControllers);
             }),
             // abort
             () => {
@@ -43,7 +42,7 @@ const useMutation = (cache, options, abortControllers) => {
                     return false;
                 }
                 abortController.abort();
-                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {
                     loading: false,
                 }));
                 return true;
@@ -52,7 +51,7 @@ const useMutation = (cache, options, abortControllers) => {
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [mutationKey, store]);
     // @ts-expect-error fix later
-    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.defaultQueryMutationState;
+    const mutationState = (_a = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
             options,

package/dist/useQuery.d.ts

@@ -1,2 +1,3 @@
+import { ActionMap } from './createActions';
 import { Cache, QueryMutationState, Typenames, UseQueryOptions } from './types';
-export declare const useQuery: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, 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<void>];

package/dist/useQuery.js

@@ -14,7 +14,7 @@ const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const useQuery = (cache, options) => {
+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 logsEnabled = cache.options.logsEnabled;
@@ -34,13 +34,13 @@ const useQuery = (cache, 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, queryKey, cacheKey, params);
+        yield (0, query_1.query)('useQuery.fetch', false, 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) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
-    })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.defaultQueryMutationState;
+    })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
     const queryState = hasResultFromSelector
         ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
         : queryStateFromSelector;

package/dist/utilsAndConstants.d.ts

@@ -1,7 +1,7 @@
-import { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
-export declare const PACKAGE_SHORT_NAME = "RRC";
-export declare const isDev: boolean;
-export declare const defaultQueryMutationState: {
+import type { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
+export declare const PACKAGE_SHORT_NAME = "rrc";
+export declare const IS_DEV: boolean;
+export declare const DEFAULT_QUERY_MUTATION_STATE: {
     readonly loading: false;
     readonly error: undefined;
 };

package/dist/utilsAndConstants.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.defaultQueryMutationState = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
-exports.PACKAGE_SHORT_NAME = 'RRC';
-exports.isDev = (() => {
+exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.PACKAGE_SHORT_NAME = void 0;
+exports.PACKAGE_SHORT_NAME = 'rrc';
+exports.IS_DEV = (() => {
     try {
         // @ts-expect-error __DEV__ is only for React Native
         return __DEV__;
@@ -11,7 +11,7 @@ exports.isDev = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.defaultQueryMutationState = { loading: false, error: undefined };
+exports.DEFAULT_QUERY_MUTATION_STATE = { loading: false, error: undefined };
 const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.0.12",
+  "version": "0.2.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",
@@ -10,7 +10,7 @@
     "example": "(cd example && yarn && yarn start)",
     "clean": "rm -rf dist",
     "lint": "yarn eslint src",
-    "build": "yarn clean && yarn lint && tsc && yarn pack -f package.tgz",
+    "build": "yarn clean && yarn lint && tsc",
     "test": "node node_modules/jest/bin/jest.js",
     "prepublishOnly": "yarn build && yarn test"
   },
@@ -38,7 +38,7 @@
     "redux": "4.2.1",
     "redux-logger": "3.0.6",
     "ts-jest": "29.1.0",
-    "typescript": "5.0.4"
+    "typescript": "5.0"
   },
   "peerDependencies": {
     "react": "^16",