react-redux-cache 0.0.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Alexander Danilov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,119 @@
+# react-redux-cache
+
+**Powerfull** and **customizable** data fetching and caching library that supports **normalization** (unlike `react-query` and `rtk-query`), built on top of `redux`.
+
+**Normalization** is the only way to keep the state of the app **consistent** between different views, reduces the number of fetches and allows to show cached data when navigating, which greatly improves **user experience**.
+
+Hooks, reducer, actions and selectors are fully typed and written on Typescript, so redux store will be properly typed and you will remain a **full control** of its 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)
+ - [Initialization](https://github.com/gentlee/react-redux-cache#Initialization)
+   - [cache.ts](https://github.com/gentlee/react-redux-cache#cachets) 
+   - [store.ts](https://github.com/gentlee/react-redux-cache#storets) 
+   - [api.ts](https://github.com/gentlee/react-redux-cache#apits) 
+ - [Usage](https://github.com/gentlee/react-redux-cache#usage)
+ - [Advanced](https://github.com/gentlee/react-redux-cache#advanced)
+
+### Installation
+`react` and `redux` are peer dependencies.
+```sh
+npm add react-redux-cache react redux
+```
+### Initialization
+Create reducer, hooks, actions and selectors with `createCache`.
+All queries and mutations should be passed while initializing the cache, for proper typing and later access by key.
+In this example we omit usage of actions and selectors.
+#### cache.ts
+```typescript
+export const {
+  reducer,
+  hooks: {useMutation, useQuery, useSelectEntityById},
+} = createCache({
+  // This selector should select cache state from redux store state, based on the path to its reducer.
+  cacheStateSelector: (state) => state.cache,
+  // Typenames provide a mapping of all typenames to their entity types.
+  // Empty objects with type casting can be used as values.
+  typenames: {
+    users: {} as User,
+    banks: {} as Bank,
+  },
+  queries: {
+    getUsers: { query: getUsers },
+    getUser: { query: getUser },
+  },
+  mutations: {
+    updateUser: { mutation: updateUser },
+    removeUser: { mutation: removeUser },
+  },
+})
+```
+#### store.ts
+```typescript
+const store = configureStore({
+  reducer: {
+    cache: reducer,
+  }
+})
+```
+#### api.ts
+Query result should be of type `QueryResponse`, mutation result should be of type `MutationResponse`.
+For normalization `normalizr` package is used in this example, but any other tool can be used if query result is of proper type.
+Perfect implementation is when the backend already returns normalized data.
+```typescript
+export const getUser = async (id: number) => {
+  const result: User = await ...
+  
+  const normalizedResult: {
+    result: number
+    entities: {
+      users: Record<number, User>
+      banks: Record<string, Bank>
+    }
+  } = normalize(result, getUserSchema)
+
+  return normalizedResult
+}
+
+export const removeUser = async (id: number) => {
+  await ...
+  return {
+    remove: { users: [id] },
+  }
+}
+```
+
+### Usage
+#### UserScreen.tsx
+```typescript
+export const UserScreen = () => {
+  const {id} = useParams()
+
+  // useQuery will infer all types from created cache,
+  // telling you that params and result here are of type `number`.
+  const [{result: userId, loading, error}] = useQuery({
+    query: 'getUser',
+    params: Number(id),
+  })
+
+  const [updateUser, {loading: updatingUser}] = useMutation({
+    mutation: 'updateUser',
+  })
+
+  // This selector is created by createCache and also returns proper types - User and Bank
+  const user = useSelectEntityById(userId, 'users')
+  const bank = useSelectEntityById(user?.bank, 'banks')
+
+  if (loading) {
+    return ... // loading state
+  }
+
+  return ... // loaded state
+}
+```
+
+### Advanced
+To be done...

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
+import { Cache, EntitiesMap, Key, OptionalPartial, Typenames } from './types';
+import { useMutation } from './useMutation';
+import { useQuery } from './useQuery';
+export * from './reducer';
+export * from './types';
+export * from './useMutation';
+export * from './useQuery';
+export * 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>, "options">) => {
+    cache: Cache<T, QP, QR, MP, MR>;
+    /** Reducer of the cache, should be added to redux store. */
+    reducer: (state: {
+        entities: EntitiesMap<T>;
+        queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
+        mutations: { [MK in keyof MR]: import("./types").QueryMutationState<MR[MK]>; };
+    } | undefined, action: {
+        type: `${string}MERGE_ENTITY_CHANGES`;
+        changes: import("./types").EntityChanges<T>;
+    } | {
+        type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+        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`;
+        mutationKey: keyof MR;
+        state: Partial<import("./types").QueryMutationState<MR[keyof MR]>> | undefined;
+        entityChagnes: import("./types").EntityChanges<T> | undefined;
+    }) => {
+        entities: EntitiesMap<T>;
+        queries: { [QK in keyof QR]: import("./types").Dict<import("./types").QueryMutationState<QR[QK]>>; };
+        mutations: { [MK in keyof MR]: import("./types").QueryMutationState<MR[MK]>; };
+    };
+    actions: {
+        /** Updates query state, and optionally merges entity changes in a single action. */
+        setQueryStateAndEntities: <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
+            type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+            queryKey: K;
+            queryCacheKey: Key;
+            state: Partial<import("./types").QueryMutationState<QR[K]>> | undefined;
+            entityChagnes: import("./types").EntityChanges<T> | undefined;
+        };
+        /** Updates mutation state, and optionally merges entity changes in a single action. */
+        setMutationStateAndEntities: <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined) => {
+            type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+            mutationKey: K_1;
+            state: Partial<import("./types").QueryMutationState<MR[K_1]>> | undefined;
+            entityChagnes: import("./types").EntityChanges<T> | undefined;
+        };
+        /** Merge EntityChanges to the state. */
+        mergeEntityChanges: (changes: import("./types").EntityChanges<T>) => {
+            type: `${string}MERGE_ENTITY_CHANGES`;
+            changes: import("./types").EntityChanges<T>;
+        };
+    };
+    selectors: {
+        entitiesSelector: (state: unknown) => EntitiesMap<T>;
+        entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_2 in keyof T]: (state: unknown) => EntitiesMap<T>[K_2]; }[TN];
+    };
+    hooks: {
+        /** Fetches query when params change and subscribes to query state. */
+        useQuery: <QK_1 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_1>) => readonly [import("./types").QueryMutationState<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>, (params?: (QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never) | undefined) => Promise<void>];
+        /** Subscribes to provided mutation state and provides mutate function. */
+        useMutation: <MK_1 extends keyof MP | keyof MR>(options: {
+            mutation: MK_1;
+            cacheOptions?: import("./types").MutationCacheOptions | undefined;
+        }) => readonly [(params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) => Promise<void>, import("./types").QueryMutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never>, AbortController | undefined];
+        /** 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;
+    };
+};

package/dist/index.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCache = void 0;
+const react_redux_1 = require("react-redux");
+const reducer_1 = require("./reducer");
+const useMutation_1 = require("./useMutation");
+const useQuery_1 = require("./useQuery");
+const utilsAndConstants_1 = require("./utilsAndConstants");
+// Backlog
+// ! high
+// create package with README
+// cover with tests
+// ! medium
+// add params to the state
+// 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)
+// 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
+// ! low
+// 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
+// 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?
+__exportStar(require("./reducer"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./useMutation"), exports);
+__exportStar(require("./useQuery"), exports);
+__exportStar(require("./utilsAndConstants"), exports);
+/** Creates reducer, actions and hooks for managing queries and mutations through redux cache. */
+const createCache = (cache) => {
+    var _a, _b, _c, _d;
+    var _e, _f, _g;
+    // @ts-expect-error hot
+    const hotReloadEnabled = Boolean(module === null || module === void 0 ? void 0 : module.hot);
+    // provide all optional fields
+    (_a = cache.options) !== null && _a !== void 0 ? _a : (cache.options = {});
+    (_b = (_e = cache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_e.logsEnabled = false);
+    (_c = (_f = cache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_f.validateFunctionArguments = utilsAndConstants_1.isDev);
+    (_d = (_g = cache.options).validateHookArguments) !== null && _d !== void 0 ? _d : (_g.validateHookArguments = utilsAndConstants_1.isDev && !hotReloadEnabled);
+    const nonPartialCache = cache;
+    // make selectors
+    const entitiesSelector = (state) => {
+        return nonPartialCache.cacheStateSelector(state).entities;
+    };
+    const enitityMapSelectorByTypename = Object.keys(cache.typenames).reduce((result, x) => {
+        result[x] = (state) => nonPartialCache.cacheStateSelector(state).entities[x];
+        return result;
+    }, {});
+    return {
+        cache: nonPartialCache,
+        /** Reducer of the cache, should be added to redux store. */
+        reducer: (0, reducer_1.createCacheReducer)(nonPartialCache.typenames, nonPartialCache.queries, nonPartialCache.mutations, nonPartialCache.options),
+        actions: {
+            /** Updates query state, and optionally merges entity changes in a single action. */
+            setQueryStateAndEntities: reducer_1.setQueryStateAndEntities,
+            /** Updates mutation state, and optionally merges entity changes in a single action. */
+            setMutationStateAndEntities: reducer_1.setMutationStateAndEntities,
+            /** Merge EntityChanges to the state. */
+            mergeEntityChanges: reducer_1.mergeEntityChanges,
+        },
+        selectors: {
+            entitiesSelector,
+            entitiesByTypenameSelector: (typename) => {
+                return enitityMapSelectorByTypename[typename];
+            },
+        },
+        hooks: {
+            /** Fetches query when params change and subscribes to query state. */
+            useQuery: (options) => (0, useQuery_1.useQuery)(nonPartialCache, options),
+            /** Subscribes to provided mutation state and provides mutate function. */
+            useMutation: (options) => (0, useMutation_1.useMutation)(nonPartialCache, options),
+            /** 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]);
+            },
+        },
+    };
+};
+exports.createCache = createCache;

package/dist/reducer.d.ts

@@ -0,0 +1,46 @@
+import { Cache, Dict, EntitiesMap, EntityChanges, Key, QueryMutationState, Typenames } from './types';
+export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<T, QP, QR, MP, MR>>>;
+export declare const createCacheReducer: <T extends Typenames, QP, QR, MP, MR>(typenames: T, queries: QP & QR extends infer T_1 ? { [QK in keyof T_1]: QK extends keyof QP & keyof QR ? import("./types").QueryInfo<T, QP[QK], QR[QK], {
+    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]>>; };
+    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+} | undefined, action: {
+    type: `${string}SET_QUERY_STATE_AND_ENTITIES`;
+    queryKey: keyof QR;
+    queryCacheKey: Key;
+    state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
+    entityChagnes: EntityChanges<T> | undefined;
+} | {
+    type: `${string}SET_MUTATION_STATE_AND_ENTITIES`;
+    mutationKey: keyof MR;
+    state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
+    entityChagnes: EntityChanges<T> | undefined;
+} | {
+    type: `${string}MERGE_ENTITY_CHANGES`;
+    changes: EntityChanges<T>;
+}) => {
+    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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEntityChanges = exports.setMutationStateAndEntities = exports.setQueryStateAndEntities = exports.createCacheReducer = void 0;
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
+    const entitiesMap = {};
+    for (const key in typenames) {
+        entitiesMap[key] = {};
+    }
+    const queriesMap = {};
+    for (const key in queries) {
+        queriesMap[key] = {};
+    }
+    const mutationsMap = {};
+    const initialState = {
+        entities: entitiesMap,
+        queries: queriesMap,
+        mutations: mutationsMap,
+    };
+    cacheOptions.logsEnabled &&
+        (0, utilsAndConstants_1.log)('createCacheReducer', {
+            typenames,
+            queries,
+            mutations,
+            initialState,
+        });
+    return (state = initialState, action) => {
+        switch (action.type) {
+            case '@RRQN/SET_QUERY_STATE_AND_ENTITIES': {
+                const { queryKey, queryCacheKey, state: queryState, entityChagnes } = action;
+                const newEntities = entityChagnes && (0, utilsAndConstants_1.processEntityChanges)(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) }) }) });
+            }
+            case '@RRQN/SET_MUTATION_STATE_AND_ENTITIES': {
+                const { mutationKey, state: mutationState, entityChagnes } = action;
+                const newEntities = entityChagnes && (0, utilsAndConstants_1.processEntityChanges)(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) }) });
+            }
+            case '@RRQN/MERGE_ENTITY_CHANGES': {
+                const { changes } = action;
+                const newEntities = (0, utilsAndConstants_1.processEntityChanges)(state.entities, changes, cacheOptions);
+                return newEntities ? Object.assign(Object.assign({}, state), { entities: newEntities }) : state;
+            }
+        }
+        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

@@ -0,0 +1,137 @@
+import type { 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<{
+    [A in K]: Partial<T[A]>;
+}> & Omit<T, K>;
+/** Entity changes to be merged to redux state. */
+export type EntityChanges<T extends Typenames> = {
+    /** Entities that will be merged with existing. */
+    merge?: Partial<PartialEntitiesMap<T>>;
+    /** Entities that will replace existing. */
+    replace?: Partial<EntitiesMap<T>>;
+    /** Ids of entities that will be removed.  */
+    remove?: Partial<EntityIds<T>>;
+    /** Alias for `merge` to support normalizr. */
+    entities?: EntityChanges<T>['merge'];
+};
+/** Record of typename and its corresponding entity type */
+export type Typenames = Record<string, object>;
+export type Cache<T extends Typenames, QP, QR, MP, MR> = {
+    typenames: T;
+    queries: {
+        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReturnType<ReturnType<typeof createCacheReducer<T, QP, QR, MP, MR>>>> : never;
+    };
+    mutations: {
+        [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
+    };
+    options: CacheOptions;
+    /** Returns cache state from redux root state. */
+    cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
+};
+export type CacheOptions = {
+    /**
+     * Enables validation of package function arguments. Recommened to enable in dev/testing mode.
+     * Default is true in dev mode.
+     * */
+    validateFunctionArguments: boolean;
+    /**
+     * Enables validation of package hook arguments. Recommened to enable in dev/testing mode and disable in production.
+     * Should be disabled with hot reloading.
+     * Default is true in dev mode without hot reloading.
+     * */
+    validateHookArguments: boolean;
+    /**
+     * Enable console logs.
+     * Default is false.
+     */
+    logsEnabled: boolean;
+};
+export type PartialEntitiesMap<T extends Typenames> = {
+    [K in keyof T]: Dict<Partial<T[K]>>;
+};
+export type EntitiesMap<T extends Typenames> = {
+    [K in keyof T]: Dict<T[K] | undefined>;
+};
+export type EntityIds<T extends Typenames> = {
+    [K in keyof T]: Key[];
+};
+export type Query<T extends Typenames, P, R> = (params: P) => Promise<QueryResponse<T, R>>;
+export type QueryInfo<T extends Typenames, P, R, S> = {
+    query: Query<T, P, R>;
+    /**
+     * Cache policy string or cache options object.
+     * Default is { policy: 'cache-first', cacheQueryState: true, cacheEntities: true }
+     * @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.
+     */
+    cacheOptions?: QueryCacheOptions | QueryCachePolicy;
+    /**
+     * Selector for query result from redux state.
+     * Can prevent hook from doing unnecessary fetches.
+     * Needed when query result may already be in the cache, e.g. for single entity query by id.
+     * */
+    resultSelector?: (state: S, params: P) => R | undefined;
+    /** Merges results before saving to the store. */
+    mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined) => R;
+    /**
+     * Params key is used for determining if parameters were changed and fetch is needed.
+     * Also used as cache key, of `getCacheKey` wasn't provided.
+     * Default implementation uses `JSON.stringify` of parameters.
+     * */
+    getParamsKey?: (params?: P) => Key;
+    /**
+     * Cache key is a key in redux state for caching query state.
+     * Queries with equal cache keys have the same state.
+     * Default implementation is equal to `getParamsKey`.
+     * */
+    getCacheKey?: (params?: P) => Key;
+};
+export type UseQueryOptions<T extends Typenames, QP, QR, MP, 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, 'cacheOptions' | '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.
+ */
+export type QueryCachePolicy = 'cache-first' | 'cache-and-fetch';
+export type QueryCacheOptions = {
+    /**
+     * @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.
+     */
+    policy: QueryCachePolicy;
+    /** If `false`, query state is not saved in the store. Default is `true`. */
+    cacheQueryState: boolean;
+    /** If `false`, entities from response are not saved to the store. Default is `true`. */
+    cacheEntities: boolean;
+};
+export type QueryResponse<T extends Typenames, R> = EntityChanges<T> & {
+    /** Normalized result of a query. */
+    result: R;
+};
+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>>;
+export type MutationInfo<T extends Typenames, P, R> = {
+    mutation: Mutation<T, P, R>;
+    cacheOptions?: MutationCacheOptions;
+};
+export type MutationCacheOptions = Pick<QueryCacheOptions, 'cacheEntities'> & {
+    /** If `false`, mutation state is not saved in the store. Default is `true`. */
+    cacheMutationState: boolean;
+};
+export type MutationResponse<T extends Typenames, R> = EntityChanges<T> & {
+    /** Normalized result of a mutation. */
+    result?: R;
+};
+export type QueryMutationState<R> = {
+    /** `true` when query or mutation is currently in progress. */
+    loading: boolean;
+    /** Result of the latest successfull query response. */
+    result?: R;
+    /** Error of the latest response. */
+    error?: Error;
+};

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Common
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/useMutation.d.ts

@@ -0,0 +1,6 @@
+import { Cache, MutationCacheOptions, QueryMutationState, Typenames } from './types';
+export declare const DEFAULT_MUTATION_CACHE_OPTIONS: MutationCacheOptions;
+export declare const useMutation: <T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<T, unknown, unknown, MP, MR>, options: {
+    mutation: MK;
+    cacheOptions?: MutationCacheOptions | undefined;
+}) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, AbortController | undefined];

package/dist/useMutation.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMutation = exports.DEFAULT_MUTATION_CACHE_OPTIONS = void 0;
+const react_1 = require("react");
+const react_redux_1 = require("react-redux");
+const reducer_1 = require("./reducer");
+const utilsAndConstants_1 = require("./utilsAndConstants");
+exports.DEFAULT_MUTATION_CACHE_OPTIONS = {
+    cacheMutationState: true,
+    cacheEntities: true,
+};
+const useMutation = (cache, options) => {
+    var _a, _b;
+    const { mutation: mutationKey, cacheOptions = (_a = cache.mutations[mutationKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.DEFAULT_MUTATION_CACHE_OPTIONS, } = options;
+    const dispatch = (0, react_redux_1.useDispatch)();
+    cache.options.logsEnabled &&
+        (0, utilsAndConstants_1.log)('useMutation', {
+            cacheOptions,
+        });
+    // Check values that should be set once.
+    // Can be removed from deps.
+    cache.options.validateHookArguments &&
+        (() => {
+            ;
+            [
+                ['cache', cache],
+                ['cache.options', cache.options],
+                ['cache.options.logsEnabled', cache.options.logsEnabled],
+                ['cacheStateSelector', cache.cacheStateSelector],
+                ['mutationKey', mutationKey],
+                ['cacheOptions.cacheEntities', cacheOptions.cacheEntities],
+                ['cacheOptions.cacheMutationState', cacheOptions.cacheMutationState],
+            ]
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
+        })();
+    const abortControllerRef = (0, react_1.useRef)();
+    const mutationStateSelector = (0, react_1.useCallback)((state) => {
+        cache.options.logsEnabled &&
+            (0, utilsAndConstants_1.log)('mutationStateSelector', {
+                state,
+                cacheState: cache.cacheStateSelector(state),
+            });
+        return cache.cacheStateSelector(state).mutations[mutationKey];
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // @ts-expect-error fix later
+    const mutationState = (_b = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultEndpointState;
+    const mutate = (0, react_1.useCallback)((params) => __awaiter(void 0, void 0, void 0, function* () {
+        cache.options.logsEnabled &&
+            (0, utilsAndConstants_1.log)('mutate', {
+                mutationKey,
+                params,
+                abortController: abortControllerRef.current,
+            });
+        if (abortControllerRef.current) {
+            abortControllerRef.current.abort();
+        }
+        else {
+            cacheOptions.cacheMutationState &&
+                dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, { loading: true }));
+        }
+        const abortController = new AbortController();
+        abortControllerRef.current = abortController;
+        let response;
+        let error;
+        const fetchFn = cache.mutations[mutationKey].mutation;
+        try {
+            response = yield fetchFn(
+            // @ts-expect-error fix later
+            params, abortController.signal);
+        }
+        catch (e) {
+            error = e;
+        }
+        cache.options.logsEnabled &&
+            (0, utilsAndConstants_1.log)('mutate finished', {
+                response,
+                error,
+                aborted: abortController.signal.aborted,
+            });
+        if (abortController.signal.aborted) {
+            return;
+        }
+        abortControllerRef.current = undefined;
+        if (response) {
+            dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, cacheOptions.cacheMutationState
+                ? {
+                    error: undefined,
+                    loading: false,
+                    result: response.result,
+                }
+                : undefined, cacheOptions.cacheEntities ? response : undefined));
+        }
+        else if (error && cacheOptions.cacheMutationState) {
+            dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                error: error,
+                loading: false,
+            }));
+        }
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    return [mutate, mutationState, abortControllerRef.current];
+};
+exports.useMutation = useMutation;

package/dist/useQuery.d.ts

@@ -0,0 +1,8 @@
+import { Cache, QueryCacheOptions, QueryCachePolicy, QueryMutationState, Typenames, UseQueryOptions } from './types';
+export declare const QUERY_CACHE_OPTIONS_BY_POLICY: Record<QueryCachePolicy, QueryCacheOptions>;
+export declare const DEFAULT_QUERY_CACHE_OPTIONS: {
+    readonly policy: "cache-first";
+    readonly cacheQueryState: true;
+    readonly cacheEntities: true;
+};
+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>, (params?: (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined) => Promise<void>];

package/dist/useQuery.js

@@ -0,0 +1,173 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQuery = exports.DEFAULT_QUERY_CACHE_OPTIONS = exports.QUERY_CACHE_OPTIONS_BY_POLICY = void 0;
+const react_1 = require("react");
+const react_redux_1 = require("react-redux");
+const reducer_1 = require("./reducer");
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const CACHE_FIRST_OPTIONS = {
+    policy: 'cache-first',
+    cacheQueryState: true,
+    cacheEntities: true,
+};
+exports.QUERY_CACHE_OPTIONS_BY_POLICY = {
+    'cache-first': CACHE_FIRST_OPTIONS,
+    'cache-and-fetch': Object.assign(Object.assign({}, CACHE_FIRST_OPTIONS), { policy: 'cache-and-fetch' }),
+};
+exports.DEFAULT_QUERY_CACHE_OPTIONS = CACHE_FIRST_OPTIONS;
+const useQuery = (cache, options) => {
+    var _a, _b, _c, _d;
+    const getParamsKey = (_a = cache.queries[options.query].getParamsKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetParamsKey);
+    const { query: queryKey, skip, params: hookParams, cacheOptions: cacheOptionsOrPolicy = (_b = cache.queries[queryKey].cacheOptions) !== null && _b !== void 0 ? _b : exports.DEFAULT_QUERY_CACHE_OPTIONS, mergeResults = cache.queries[queryKey].mergeResults, getCacheKey = (_c = cache.queries[queryKey].getCacheKey) !== null && _c !== void 0 ? _c : getParamsKey, } = options;
+    const hookParamsKey = getParamsKey(
+    // @ts-expect-error fix later
+    hookParams);
+    const cacheOptions = typeof cacheOptionsOrPolicy === 'string'
+        ? exports.QUERY_CACHE_OPTIONS_BY_POLICY[cacheOptionsOrPolicy]
+        : cacheOptionsOrPolicy;
+    const store = (0, react_redux_1.useStore)();
+    // Check values that should be set once.
+    cache.options.validateHookArguments &&
+        (() => {
+            ;
+            [
+                ['store', store],
+                ['cache', cache],
+                ['cache.queries', cache.queries],
+                ['cacheStateSelector', cache.cacheStateSelector],
+                ['cacheOptions.cacheEntities', cacheOptions.cacheEntities],
+                ['cacheOptions.cacheQueryState', cacheOptions.cacheQueryState],
+                ['options.query', options.query],
+                ['queryKey', queryKey],
+                ['resultSelector', cache.queries[queryKey].resultSelector],
+            ]
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
+        })();
+    const forceUpdate = (0, utilsAndConstants_1.useForceUpdate)();
+    // Keeps most of local state.
+    // Reference because state is changed not only by changing hook arguments, but also by calling fetch, and it should be done synchronously.
+    const stateRef = (0, react_1.useRef)({});
+    (0, react_1.useMemo)(() => {
+        if (skip || stateRef.current.paramsKey === hookParamsKey) {
+            return;
+        }
+        const resultSelectorImpl = cache.queries[queryKey].resultSelector;
+        const state = stateRef.current;
+        state.params = hookParams;
+        state.paramsKey = hookParamsKey;
+        state.latestHookParamsKey = state.paramsKey;
+        // @ts-expect-error fix later
+        state.cacheKey = getCacheKey(hookParams);
+        state.resultSelector = createResultSelector(
+        // @ts-expect-error fix later
+        resultSelectorImpl, cache.cacheStateSelector, hookParams);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [hookParamsKey, skip]);
+    const resultFromSelector = 
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    stateRef.current.resultSelector && (0, react_redux_1.useSelector)(stateRef.current.resultSelector);
+    const hasResultFromSelector = resultFromSelector !== undefined;
+    const queryStateSelector = (0, react_1.useCallback)((state) => {
+        cache.options.logsEnabled &&
+            (0, utilsAndConstants_1.log)('queryStateSelector', {
+                state,
+                queryKey,
+                cacheKey: stateRef.current.cacheKey,
+                cacheState: cache.cacheStateSelector(state),
+            });
+        const queryState = cache.cacheStateSelector(state).queries[queryKey][stateRef.current.cacheKey];
+        return queryState; // TODO proper type
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    const queryStateFromSelector = (_d = (0, react_redux_1.useSelector)(queryStateSelector)) !== null && _d !== void 0 ? _d : utilsAndConstants_1.defaultEndpointState;
+    const queryState = hasResultFromSelector
+        ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
+        : queryStateFromSelector;
+    const fetchImpl = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _e;
+        cache.options.logsEnabled && (0, utilsAndConstants_1.log)('useQuery.fetchImpl', { queryState });
+        if (queryState.loading) {
+            return;
+        }
+        cacheOptions.cacheQueryState &&
+            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, {
+                loading: true,
+            }));
+        const { paramsKey, params } = stateRef.current;
+        let response;
+        const fetchFn = cache.queries[queryKey].query;
+        try {
+            response = yield fetchFn(
+            // @ts-expect-error fix later
+            params);
+        }
+        catch (error) {
+            if (stateRef.current.paramsKey === paramsKey && cacheOptions.cacheQueryState) {
+                store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, {
+                    error: error,
+                    loading: false,
+                }));
+            }
+        }
+        if (response && stateRef.current.paramsKey === paramsKey) {
+            store.dispatch((0, reducer_1.setQueryStateAndEntities)(queryKey, stateRef.current.cacheKey, !cacheOptions.cacheQueryState
+                ? undefined
+                : {
+                    error: undefined,
+                    loading: false,
+                    result: hasResultFromSelector
+                        ? undefined
+                        : mergeResults
+                            ? mergeResults(
+                            // @ts-expect-error fix later
+                            (_e = queryStateSelector(store.getState())) === null || _e === void 0 ? void 0 : _e.result, response, params)
+                            : response.result,
+                }, cacheOptions.cacheEntities ? response : undefined));
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }), [mergeResults, queryState.loading, hasResultFromSelector]);
+    (0, react_1.useEffect)(() => {
+        if (queryState.result != null && cacheOptions.policy === 'cache-first') {
+            return;
+        }
+        fetchImpl();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [stateRef.current.latestHookParamsKey]);
+    const fetch = (0, react_1.useCallback)((params) => {
+        cache.options.logsEnabled && (0, utilsAndConstants_1.log)('useQuery.fetch', params);
+        if (params !== undefined) {
+            const state = stateRef.current;
+            // @ts-expect-error fix later
+            const paramsKey = getParamsKey(params);
+            if (state.paramsKey !== paramsKey) {
+                const resultSelectorImpl = cache.queries[queryKey].resultSelector;
+                state.params = params;
+                state.paramsKey = paramsKey;
+                // @ts-expect-error fix later
+                state.cacheKey = getCacheKey(params);
+                state.resultSelector = createResultSelector(
+                // @ts-expect-error fix later
+                resultSelectorImpl, cache.cacheStateSelector, hookParams);
+                forceUpdate();
+            }
+        }
+        return fetchImpl();
+    }, 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [fetchImpl, getCacheKey]);
+    return [queryState, fetch];
+};
+exports.useQuery = useQuery;
+const createResultSelector = (resultSelector, cacheStateSelector, params) => {
+    return (resultSelector && ((state) => resultSelector(cacheStateSelector(state), params)));
+};

package/dist/utilsAndConstants.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { CacheOptions, EntitiesMap, EntityChanges, Typenames } from './types';
+export declare const PACKAGE_SHORT_NAME = "RRC";
+export declare const isDev: boolean;
+export declare const defaultEndpointState: {
+    readonly loading: false;
+};
+export declare const defaultGetParamsKey: <P = unknown>(params: P) => string;
+/**
+ * @returns function to force update a function component.
+ */
+export declare const useForceUpdate: () => import("react").DispatchWithoutAction;
+export declare const useAssertValueNotChanged: (name: string, value: unknown) => void;
+export declare const log: (tag: string, data: unknown) => void;
+/**
+ * Process changes to entities map.
+ * @return `undefined` if nothing to change, otherwise processed entities map.
+ */
+export declare const processEntityChanges: <T extends Typenames>(entities: EntitiesMap<T>, changes: EntityChanges<T>, options: CacheOptions) => EntitiesMap<T> | undefined;

package/dist/utilsAndConstants.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.useForceUpdate = exports.defaultGetParamsKey = exports.defaultEndpointState = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
+const react_1 = require("react");
+const react_2 = require("react");
+exports.PACKAGE_SHORT_NAME = 'RRC';
+exports.isDev = (() => {
+    try {
+        // @ts-expect-error __DEV__ is only for React Native
+        return __DEV__;
+    }
+    catch (e) {
+        return process.env.NODE_ENV === 'development';
+    }
+})();
+exports.defaultEndpointState = { loading: false };
+const defaultGetParamsKey = (params) => !params ? '' : JSON.stringify(params);
+exports.defaultGetParamsKey = defaultGetParamsKey;
+const forceUpdateReducer = (i) => i + 1;
+/**
+ * @returns function to force update a function component.
+ */
+const useForceUpdate = () => {
+    return (0, react_2.useReducer)(forceUpdateReducer, 0)[1];
+};
+exports.useForceUpdate = useForceUpdate;
+const useAssertValueNotChanged = (name, value) => {
+    const firstMountRef = (0, react_1.useRef)(false);
+    (0, react_1.useMemo)(() => {
+        if (firstMountRef.current) {
+            throw new Error(`${name} should not be modified`);
+        }
+        firstMountRef.current = true;
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [value]);
+};
+exports.useAssertValueNotChanged = useAssertValueNotChanged;
+const log = (tag, data) => {
+    console.debug(`@${exports.PACKAGE_SHORT_NAME} [${tag}]`, data);
+};
+exports.log = log;
+/**
+ * Process changes to entities map.
+ * @return `undefined` if nothing to change, otherwise processed entities map.
+ */
+const processEntityChanges = (entities, changes, options) => {
+    var _a, _b, _c;
+    const { merge = changes.entities, replace, remove } = changes;
+    if (!merge && !replace && !remove) {
+        return undefined;
+    }
+    if (options.validateFunctionArguments) {
+        // check for merge and entities both set
+        if (changes.merge && changes.entities) {
+            throw new Error('Response merge and entities should not be both set');
+        }
+        // check for key intersection
+        const mergeKeys = merge && Object.keys(merge);
+        const replaceKeys = replace && Object.keys(replace);
+        const removeKeys = remove && Object.keys(remove);
+        const keysSet = new Set(mergeKeys);
+        replaceKeys === null || replaceKeys === void 0 ? void 0 : replaceKeys.forEach((key) => keysSet.add(key));
+        removeKeys === null || removeKeys === void 0 ? void 0 : removeKeys.forEach((key) => keysSet.add(key));
+        const totalKeysInResponse = ((_a = mergeKeys === null || mergeKeys === void 0 ? void 0 : mergeKeys.length) !== null && _a !== void 0 ? _a : 0) + ((_b = replaceKeys === null || replaceKeys === void 0 ? void 0 : replaceKeys.length) !== null && _b !== void 0 ? _b : 0) + ((_c = removeKeys === null || removeKeys === void 0 ? void 0 : removeKeys.length) !== null && _c !== void 0 ? _c : 0);
+        if (keysSet.size !== totalKeysInResponse) {
+            throw new Error('Merge, replace and remove keys should not intersect');
+        }
+    }
+    let result;
+    for (const typename in entities) {
+        const entitiesToMerge = merge === null || merge === void 0 ? void 0 : merge[typename];
+        const entitiesToReplace = replace === null || replace === void 0 ? void 0 : replace[typename];
+        const entitiesToRemove = remove === null || remove === void 0 ? void 0 : remove[typename];
+        if (!entitiesToMerge && !entitiesToReplace && !entitiesToRemove) {
+            continue;
+        }
+        const newEntities = Object.assign({}, entities[typename]);
+        // remove
+        entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => delete newEntities[id]);
+        // replace
+        if (entitiesToReplace) {
+            for (const id in entitiesToReplace) {
+                newEntities[id] = entitiesToReplace[id];
+            }
+        }
+        // merge
+        if (entitiesToMerge) {
+            for (const id in entitiesToMerge) {
+                newEntities[id] = Object.assign(Object.assign({}, newEntities[id]), entitiesToMerge[id]);
+            }
+        }
+        result !== null && result !== void 0 ? result : (result = Object.assign({}, entities));
+        result[typename] = newEntities;
+    }
+    (0, exports.log)('processEntityChanges', {
+        entities,
+        changes,
+        result,
+    });
+    return result;
+};
+exports.processEntityChanges = processEntityChanges;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "react-redux-cache",
+  "author": "Alexander Danilov",
+  "license": "MIT",
+  "version": "0.0.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",
+  "scripts": {
+    "example": "yarn build && (cd example && yarn && yarn start)",
+    "clean": "rm -rf dist package.tgz",
+    "build": "yarn clean && tsc && yarn pack -f package.tgz",
+    "test": "yarn build && node node_modules/jest/bin/jest.js",
+    "prepublishOnly": "yarn test"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "devDependencies": {
+    "@types/jest": "29.5.1",
+    "@types/node": "20.1.2",
+    "@types/redux-logger": "3.0.9",
+    "@typescript-eslint/eslint-plugin": "5.59.5",
+    "@typescript-eslint/parser": "5.59.5",
+    "eslint": "8.40.0",
+    "eslint-config-prettier": "8.8.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-react": "7.33.2",
+    "eslint-plugin-react-hooks": "4.6.0",
+    "eslint-plugin-simple-import-sort": "10.0.0",
+    "jest": "29.5.0",
+    "prettier": "2.8.8",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-redux": "8.0.5",
+    "redux": "4.2.1",
+    "redux-logger": "3.0.6",
+    "ts-jest": "29.1.0",
+    "typescript": "5.0.4"
+  },
+  "peerDependencies": {
+    "react": "^16",
+    "react-redux": "^4",
+    "redux": "^4"
+  },
+  "dependencies": {
+    "redux-persist": "6.0.0"
+  },
+  "keywords": [
+    "react",
+    "redux",
+    "cache",
+    "query",
+    "normalization"
+  ]
+}