react-redux-cache 0.0.12 → 0.1.1

package/README.md

@@ -6,8 +6,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 +19,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,7 +28,7 @@ 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. Only **single** cache reducer per store is supported currenlty.
 All typenames, queries and mutations should be passed while initializing the cache for proper typing.
 #### cache.ts
 ```typescript
@@ -38,7 +37,7 @@ export const {
   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},
   utils: {applyEntityChanges},
 } = createCache({
   // This selector should return the cache state based on the path to its reducer.
@@ -111,6 +110,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 +273,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 +295,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/actions.d.ts

@@ -0,0 +1,32 @@
+import type { EntityChanges, Key, QueryMutationState, Typenames } from './types';
+export declare const updateQueryStateAndEntities: <T extends Typenames, QR, K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
+    type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
+    queryKey: K;
+    queryCacheKey: Key;
+    state: Partial<QueryMutationState<QR[K]>> | undefined;
+    entityChagnes: EntityChanges<T> | undefined;
+};
+export declare const updateMutationStateAndEntities: <T extends Typenames, MR, K extends keyof MR>(mutationKey: K, state?: Partial<QueryMutationState<MR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined) => {
+    type: `${string}UPDATE_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>;
+};
+export declare const clearQueryState: <QR, K extends keyof QR>(queryKeys: {
+    key: K;
+    cacheKey?: Key | undefined;
+}[]) => {
+    type: `${string}CLEAR_QUERY_STATE`;
+    queryKeys: {
+        key: K;
+        cacheKey?: Key | undefined;
+    }[];
+};
+export declare const clearMutationState: <MR, K extends keyof MR>(mutationKeys: K[]) => {
+    type: `${string}CLEAR_MUTATION_STATE`;
+    mutationKeys: K[];
+};

package/dist/actions.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearMutationState = exports.clearQueryState = exports.mergeEntityChanges = exports.updateMutationStateAndEntities = exports.updateQueryStateAndEntities = void 0;
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const ACTION_PREFIX = `@${utilsAndConstants_1.PACKAGE_SHORT_NAME}/`;
+const updateQueryStateAndEntities = (queryKey, queryCacheKey, state, entityChagnes) => ({
+    type: `${ACTION_PREFIX}UPDATE_QUERY_STATE_AND_ENTITIES`,
+    queryKey,
+    queryCacheKey,
+    state,
+    entityChagnes,
+});
+exports.updateQueryStateAndEntities = updateQueryStateAndEntities;
+const updateMutationStateAndEntities = (mutationKey, state, entityChagnes) => ({
+    type: `${ACTION_PREFIX}UPDATE_MUTATION_STATE_AND_ENTITIES`,
+    mutationKey,
+    state,
+    entityChagnes,
+});
+exports.updateMutationStateAndEntities = updateMutationStateAndEntities;
+const mergeEntityChanges = (changes) => ({
+    type: `${ACTION_PREFIX}MERGE_ENTITY_CHANGES`,
+    changes,
+});
+exports.mergeEntityChanges = mergeEntityChanges;
+const clearQueryState = (queryKeys) => ({
+    type: `${ACTION_PREFIX}CLEAR_QUERY_STATE`,
+    queryKeys,
+});
+exports.clearQueryState = clearQueryState;
+const clearMutationState = (mutationKeys) => ({
+    type: `${ACTION_PREFIX}CLEAR_MUTATION_STATE`,
+    mutationKeys,
+});
+exports.clearMutationState = clearMutationState;

package/dist/createCache.d.ts

@@ -1,12 +1,12 @@
-import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
+import { clearMutationState, clearQueryState, mergeEntityChanges, updateMutationStateAndEntities, updateQueryStateAndEntities } from './actions';
+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">) => {
+export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<T, QP, QR, MP, MR>, "queries" | "mutations" | "options">) => {
     cache: Cache<T, QP, QR, MP, MR>;
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
@@ -17,16 +17,25 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
         type: `${string}MERGE_ENTITY_CHANGES`;
         changes: import("./types").EntityChanges<T>;
     } | {
-        type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+        type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
         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: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
         mutationKey: keyof MR;
         state: Partial<import("./types").QueryMutationState<MR[keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
+    } | {
+        type: `${string}CLEAR_QUERY_STATE`;
+        queryKeys: {
+            key: keyof QR;
+            cacheKey?: Key | undefined;
+        }[];
+    } | {
+        type: `${string}CLEAR_MUTATION_STATE`;
+        mutationKeys: (keyof MR)[];
     }) => {
         entities: EntitiesMap<T>;
         queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
@@ -34,16 +43,16 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
     };
     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`;
+        updateQueryStateAndEntities: <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
+            type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
             queryKey: K;
             queryCacheKey: Key;
             state: Partial<import("./types").QueryMutationState<QR[K]>> | undefined;
             entityChagnes: import("./types").EntityChanges<T> | undefined;
         };
         /** 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`;
+        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: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
             mutationKey: K_1;
             state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
             entityChagnes: import("./types").EntityChanges<T> | undefined;
@@ -53,10 +62,29 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
             type: `${string}MERGE_ENTITY_CHANGES`;
             changes: import("./types").EntityChanges<T>;
         };
+        /** 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: {
+            key: K_2;
+            cacheKey?: Key | undefined;
+        }[]) => {
+            type: `${string}CLEAR_QUERY_STATE`;
+            queryKeys: {
+                key: K_2;
+                cacheKey?: Key | undefined;
+            }[];
+        };
+        /** Clear states for provided mutation keys. */
+        clearMutationState: <K_3 extends keyof MR>(mutationKeys: K_3[]) => {
+            type: `${string}CLEAR_MUTATION_STATE`;
+            mutationKeys: K_3[];
+        };
     };
     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 */
@@ -74,7 +102,7 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
             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: <K_5 extends keyof T>(id: Key | null | undefined, typename: K_5) => T[K_5] | 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 actions_1 = require("./actions");
 const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const reducer_1 = require("./reducer");
@@ -12,41 +13,48 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
-const createCache = (cache) => {
+const createCache = (partialCache) => {
     var _a, _b, _c, _d, _e;
     var _f, _g;
     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 = {});
+    (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
+    (_b = (_f = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_f.logsEnabled = false);
+    (_c = (_g = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_g.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 = {});
     // @ts-expect-error for testing
-    cache.abortControllers = abortControllers;
-    const nonPartialCache = cache;
+    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;
     }, {});
     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),
+        reducer: (0, reducer_1.createCacheReducer)(cache.typenames, cache.queries, cache.mutations, cache.options),
         actions: {
             /** Updates query state, and optionally merges entity changes in a single action. */
-            setQueryStateAndEntities: reducer_1.setQueryStateAndEntities,
+            updateQueryStateAndEntities: actions_1.updateQueryStateAndEntities,
             /** Updates mutation state, and optionally merges entity changes in a single action. */
-            setMutationStateAndEntities: reducer_1.setMutationStateAndEntities,
+            updateMutationStateAndEntities: actions_1.updateMutationStateAndEntities,
             /** Merge EntityChanges to the state. */
-            mergeEntityChanges: reducer_1.mergeEntityChanges,
+            mergeEntityChanges: actions_1.mergeEntityChanges,
+            /** 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: actions_1.clearQueryState,
+            /** Clear states for provided mutation keys. */
+            clearMutationState: actions_1.clearMutationState,
         },
         selectors: {
+            /** Select all entities from the state. */
             entitiesSelector,
+            /** Select all entities of provided typename. */
             entitiesByTypenameSelector: (typename) => {
                 return enitityMapSelectorByTypename[typename];
             },
@@ -60,30 +68,30 @@ 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, 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, 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, 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, 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) => 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,37 @@ 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
 // ! 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.js

@@ -10,7 +10,7 @@ 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 actions_1 = require("./actions");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
@@ -30,7 +30,7 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
             abortController.abort();
         }
         else {
-            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+            store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
                 loading: true,
                 result: undefined,
             }));
@@ -60,14 +60,14 @@ const mutate = (logTag, returnResult, store, cache, mutationKey, params, abortCo
     }
     delete abortControllersOfStore[mutationKey];
     if (error) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
             error: error,
             loading: false,
         }));
         return { error };
     }
     if (response) {
-        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+        store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
             error: undefined,
             loading: false,
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion

package/dist/query.d.ts

@@ -1,3 +1,3 @@
 import { Store } from 'redux';
-import { Cache, Key, QueryResult, Typenames } from './types';
+import type { 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>>;

package/dist/query.js

@@ -10,7 +10,7 @@ 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 actions_1 = require("./actions");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
@@ -28,7 +28,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((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, {
         loading: true,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
@@ -40,7 +40,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, params) =
         params);
     }
     catch (error) {
-        store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, cacheKey, {
+        store.dispatch((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, {
             error: error,
             loading: false,
         }));
@@ -57,7 +57,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((0, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, newState, response));
     // @ts-expect-error fix types
     return returnResult
         ? {

package/dist/reducer.d.ts

@@ -1,4 +1,5 @@
-import { Cache, Dict, EntitiesMap, EntityChanges, Key, QueryMutationState, Typenames } from './types';
+import { clearMutationState, clearQueryState, mergeEntityChanges, updateMutationStateAndEntities, updateQueryStateAndEntities } from './actions';
+import type { Cache, Dict, EntitiesMap, 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], {
     entities: EntitiesMap<T>;
@@ -9,38 +10,30 @@ export declare const createCacheReducer: <T extends Typenames, QP, QR, MP, MR>(t
     queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
     mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
 } | undefined, action: {
-    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+    type: `${string}UPDATE_QUERY_STATE_AND_ENTITIES`;
     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: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
     mutationKey: keyof MR;
     state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
-    entityChagnes: EntityChanges<T> | undefined;
+    entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `${string}MERGE_ENTITY_CHANGES`;
-    changes: EntityChanges<T>;
+    changes: import("./types").EntityChanges<T>;
+} | {
+    type: `${string}CLEAR_QUERY_STATE`;
+    queryKeys: {
+        key: keyof QR;
+        cacheKey?: import("./types").Key | undefined;
+    }[];
+} | {
+    type: `${string}CLEAR_MUTATION_STATE`;
+    mutationKeys: (keyof MR)[];
 }) => {
     entities: EntitiesMap<T>;
     queries: { [QK_1 in keyof QR]: Dict<QueryMutationState<QR[QK_1]>>; };
     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,11 +1,12 @@
 "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 EMPTY_QUERY_STATE = Object.freeze({});
 const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
     const entitiesMap = {};
     for (const key in typenames) {
-        entitiesMap[key] = {};
+        entitiesMap[key] = EMPTY_QUERY_STATE;
     }
     const queriesMap = {};
     for (const key in queries) {
@@ -25,51 +26,72 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
             initialState,
         });
     return (state = initialState, action) => {
+        var _a, _b;
         switch (action.type) {
-            case '@RRC/SET_QUERY_STATE_AND_ENTITIES': {
+            case '@RRC/UPDATE_QUERY_STATE_AND_ENTITIES': {
                 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': {
+            case '@RRC/UPDATE_MUTATION_STATE_AND_ENTITIES': {
                 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': {
                 const { changes } = action;
                 const newEntities = (0, utilsAndConstants_1.applyEntityChanges)(state.entities, changes, cacheOptions);
                 return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
             }
+            case '@RRC/CLEAR_QUERY_STATE': {
+                const { queryKeys } = action;
+                if (!queryKeys.length) {
+                    return state;
+                }
+                let newQueries = undefined;
+                for (const query of queryKeys) {
+                    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 '@RRC/CLEAR_MUTATION_STATE': {
+                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 { createCacheReducer, 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<{

package/dist/useMutation.js

@@ -12,8 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMutation = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const actions_1 = require("./actions");
 const mutate_1 = require("./mutate");
-const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useMutation = (cache, options, abortControllers) => {
     var _a;
@@ -43,7 +43,7 @@ const useMutation = (cache, options, abortControllers) => {
                     return false;
                 }
                 abortController.abort();
-                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                store.dispatch((0, actions_1.updateMutationStateAndEntities)(mutationKey, {
                     loading: false,
                 }));
                 return true;
@@ -52,7 +52,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.js

@@ -40,7 +40,7 @@ const useQuery = (cache, options) => {
     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';
+import type { CacheOptions, EntitiesMap, EntityChanges, Key, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "RRC";
-export declare const isDev: boolean;
-export declare const defaultQueryMutationState: {
+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.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.isDev = (() => {
+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.1.1",
   "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"
   },