react-redux-cache 0.1.1 → 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`.
@@ -28,21 +36,28 @@ Remains **full control** of redux state with ability to write custom selectors,
 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. Only **single** cache reducer per store is supported currenlty.
+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: {updateQueryStateAndEntities, updateMutationStateAndEntities, 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`
@@ -60,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,
+    ...
   }
 })
 ```

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,4 +1,3 @@
-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';
@@ -6,78 +5,87 @@ 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>(partialCache: 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}UPDATE_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}UPDATE_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: `${string}CLEAR_QUERY_STATE`;
+        type: `@rrc/${N}/mergeEntityChanges`;
+        changes: import("./types").EntityChanges<T>;
+    } | {
+        type: `@rrc/${N}/clearQueryState`;
         queryKeys: {
             key: keyof QR;
             cacheKey?: Key | undefined;
         }[];
     } | {
-        type: `${string}CLEAR_MUTATION_STATE`;
-        mutationKeys: (keyof MR)[];
+        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. */
-        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;
+        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`;
         };
-        /** Updates mutation state, and optionally merges entity changes in a single action. */
-        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;
+        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`;
         };
-        /** Merge EntityChanges to the state. */
-        mergeEntityChanges: (changes: import("./types").EntityChanges<T>) => {
-            type: `${string}MERGE_ENTITY_CHANGES`;
-            changes: import("./types").EntityChanges<T>;
+        mergeEntityChanges: {
+            (changes: import("./types").EntityChanges<T>): {
+                type: `@rrc/${N}/mergeEntityChanges`;
+                changes: import("./types").EntityChanges<T>;
+            };
+            type: `@rrc/${N}/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: <K_2 extends keyof QR>(queryKeys: {
-            key: K_2;
-            cacheKey?: Key | undefined;
-        }[]) => {
-            type: `${string}CLEAR_QUERY_STATE`;
-            queryKeys: {
+        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`;
         };
-        /** Clear states for provided mutation keys. */
-        clearMutationState: <K_3 extends keyof MR>(mutationKeys: K_3[]) => {
-            type: `${string}CLEAR_MUTATION_STATE`;
-            mutationKeys: K_3[];
+        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: {
@@ -89,20 +97,20 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(partialC
     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_5 extends keyof T>(id: Key | null | undefined, typename: K_5) => T[K_5] | 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,7 +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 createActions_1 = require("./createActions");
 const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const reducer_1 = require("./reducer");
@@ -14,16 +14,18 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
 const createCache = (partialCache) => {
-    var _a, _b, _c, _d, _e;
-    var _f, _g;
+    var _a, _b, _c, _d, _e, _f;
+    var _g, _h;
     const abortControllers = new WeakMap();
     // provide all optional fields
     (_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);
+    (_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 = {});
-    // @ts-expect-error for testing
+    // 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
@@ -34,23 +36,12 @@ const createCache = (partialCache) => {
         result[x] = (state) => cache.cacheStateSelector(state).entities[x];
         return result;
     }, {});
+    const actions = (0, createActions_1.createActions)(cache.name);
     return {
         cache,
         /** Reducer of the cache, should be added to redux store. */
-        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. */
-            updateQueryStateAndEntities: actions_1.updateQueryStateAndEntities,
-            /** Updates mutation state, and optionally merges entity changes in a single action. */
-            updateMutationStateAndEntities: actions_1.updateMutationStateAndEntities,
-            /** Merge EntityChanges to the state. */
-            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,
-        },
+        reducer: (0, reducer_1.createCacheReducer)(actions, cache.typenames, Object.keys(cache.queries), cache.options),
+        actions,
         selectors: {
             /** Select all entities from the state. */
             entitiesSelector,
@@ -71,22 +62,24 @@ const createCache = (partialCache) => {
                             const getCacheKey = (_a = cache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
                             // @ts-expect-error fix later
                             const cacheKey = getCacheKey(params);
-                            return (0, query_1.query)('query', true, store, cache, 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, cache, 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)(cache, 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)(cache, 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 : cache.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: {

package/dist/index.js

@@ -29,6 +29,7 @@ Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true,
 // 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
 // make named caches to produce named hooks, actions etc (same as slices in RTK)?
 // allow multiple mutation with same keys?

package/dist/mutate.d.ts

@@ -1,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 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* () {
+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, actions_1.updateMutationStateAndEntities)(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, actions_1.updateMutationStateAndEntities)(mutationKey, {
+        store.dispatch(updateMutationStateAndEntities(mutationKey, {
             error: error,
             loading: false,
         }));
         return { error };
     }
     if (response) {
-        store.dispatch((0, actions_1.updateMutationStateAndEntities)(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 type { ActionMap } from './createActions';
 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>>;
+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 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* () {
+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, actions_1.updateQueryStateAndEntities)(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, actions_1.updateQueryStateAndEntities)(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, actions_1.updateQueryStateAndEntities)(queryKey, cacheKey, newState, response));
+    store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
     // @ts-expect-error fix types
     return returnResult
         ? {

package/dist/reducer.d.ts

@@ -1,39 +1,35 @@
-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], {
+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}UPDATE_QUERY_STATE_AND_ENTITIES`;
+    type: `@rrc/${N}/updateQueryStateAndEntities`;
     queryKey: keyof QR;
     queryCacheKey: import("./types").Key;
     state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
-    type: `${string}UPDATE_MUTATION_STATE_AND_ENTITIES`;
+    type: `@rrc/${N}/updateMutationStateAndEntities`;
     mutationKey: keyof MR;
     state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
-    type: `${string}MERGE_ENTITY_CHANGES`;
+    type: `@rrc/${N}/mergeEntityChanges`;
     changes: import("./types").EntityChanges<T>;
 } | {
-    type: `${string}CLEAR_QUERY_STATE`;
+    type: `@rrc/${N}/clearQueryState`;
     queryKeys: {
         key: keyof QR;
         cacheKey?: import("./types").Key | undefined;
     }[];
 } | {
-    type: `${string}CLEAR_MUTATION_STATE`;
+    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]>; };
 };

package/dist/reducer.js

@@ -3,59 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const EMPTY_QUERY_STATE = Object.freeze({});
-const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
+const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
     const entitiesMap = {};
     for (const key in typenames) {
         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/UPDATE_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({}, ((_a = state.queries[queryKey][queryCacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE)), queryState) }) }) });
             }
-            case '@RRC/UPDATE_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({}, ((_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 '@RRC/CLEAR_QUERY_STATE': {
-                const { queryKeys } = action;
-                if (!queryKeys.length) {
+            case actions.clearQueryState.type: {
+                const { queryKeys: queryKeysToClear } = action;
+                if (!queryKeysToClear.length) {
                     return state;
                 }
                 let newQueries = undefined;
-                for (const query of queryKeys) {
+                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));
@@ -73,7 +72,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
                 }
                 return Object.assign(Object.assign({}, state), { queries: newQueries });
             }
-            case '@RRC/CLEAR_MUTATION_STATE': {
+            case actions.clearMutationState.type: {
                 const { mutationKeys } = action;
                 if (!mutationKeys.length) {
                     return state;

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { 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

@@ -12,10 +12,9 @@ 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 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, actions_1.updateMutationStateAndEntities)(mutationKey, {
+                store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {
                     loading: false,
                 }));
                 return true;

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,7 +34,7 @@ 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) => {

package/dist/utilsAndConstants.d.ts

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

package/dist/utilsAndConstants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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.PACKAGE_SHORT_NAME = 'rrc';
 exports.IS_DEV = (() => {
     try {
         // @ts-expect-error __DEV__ is only for React Native

package/package.json

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

package/dist/actions.d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,35 +0,0 @@
-"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;