react-redux-cache 0.7.1 → 0.8.1

package/README.md

@@ -139,23 +139,26 @@ Examples of states, generated by cache reducer from `/example` project:
 npm add react-redux-cache react redux react-redux fast-deep-equal
 ```
 ### 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. 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.
+The only function that needs to be imported is either `withTypenames`, which is needed for normalization, or directly `createCache` if it is not needed. `createCache` 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 queries and mutations should be passed while initializing the cache for proper typing.
 #### cache.ts
 ```typescript
+// Mapping of all typenames to their entity types, which is needed for proper normalization typing.
+// Not needed if normalization is not used.
+export type CacheTypenames = {
+  users: User, // here `users` entities will have type `User`
+  banks: Bank,
+}
+
 export const {
   cache,
   reducer,
   hooks: {useClient, useMutation, useQuery},
-} = createCache({
+  // `withTypenames` is only needed to provide proper Typenames for normalization - limitation of Typescript.
+  // `createCache` can be imported directly without `withTypenames`.
+} = withTypenames<CacheTypenames>().createCache({
   // Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state.
   name: 'cache',
-  // Mapping of all typenames to their entity types, which is needed for proper normalization. Should be empty if normalization is not needed.
-  // Empty objects with type casting can be used as values.
-  typenames: {
-    users: {} as User, // here `users` entities will have type `User`
-    banks: {} as Bank,
-  },
   queries: {
     getUsers: { query: getUsers },
     getUser: {
@@ -174,7 +177,7 @@ export const {
 
 For normalization two things are required:
 - Set proper typenames while creating the cache - mapping of all entities and their corresponding TS types.
-- Return an object from queries and mutations, that contains the following fields (besides `result`):
+- Return an object from queries and mutations that contains the following fields (besides `result`):
 
 ```typescript
 type EntityChanges<T extends Typenames> = {  

package/dist/createCache.d.ts

@@ -2,31 +2,198 @@ import type { Cache, Key, MutateOptions, MutationResult, MutationState, Optional
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 import { applyEntityChanges } from './utilsAndConstants';
+/**
+ * Function to provide generic Typenames if normalization is needed - this is a Typescript limitation.
+ * Returns object with createCache function with provided typenames.
+ * @example
+ * const cache = withTypenames<MyTypenames>().createCache({
+ *   ...
+ * })
+ */
+export declare const withTypenames: <T extends Typenames = Typenames>() => {
+    createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector">) => {
+        /** Keeps all options, passed while creating the cache. */
+        cache: Cache<N, T, QP, QR, MP, MR>;
+        /** Reducer of the cache, should be added to redux store. */
+        reducer: (state: {
+            entities: import("./types").EntitiesMap<T>;
+            queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
+            mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;
+        } | undefined, action: {
+            type: `@rrc/${N}/updateQueryStateAndEntities`;
+            queryKey: keyof QP & keyof QR;
+            queryCacheKey: Key;
+            state: Partial<QueryState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
+            entityChanges: import("./types").EntityChanges<T> | undefined;
+        } | {
+            type: `@rrc/${N}/updateMutationStateAndEntities`;
+            mutationKey: keyof MP & keyof MR;
+            state: Partial<MutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
+            entityChanges: import("./types").EntityChanges<T> | undefined;
+        } | {
+            type: `@rrc/${N}/mergeEntityChanges`;
+            changes: import("./types").EntityChanges<T>;
+        } | {
+            type: `@rrc/${N}/invalidateQuery`;
+            queries: {
+                query: keyof QP & keyof QR;
+                cacheKey?: Key | undefined;
+                expiresAt?: number | undefined;
+            }[];
+        } | {
+            type: `@rrc/${N}/clearQueryState`;
+            queries: {
+                query: keyof QP & keyof QR;
+                cacheKey?: Key | undefined;
+            }[];
+        } | {
+            type: `@rrc/${N}/clearMutationState`;
+            mutationKeys: (keyof MP & keyof MR)[];
+        }) => {
+            entities: import("./types").EntitiesMap<T>;
+            queries: QP | QR extends infer T_3 ? { [QK in keyof T_3]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
+            mutations: MP | MR extends infer T_4 ? { [MK in keyof T_4]: MutationState<MP[MK], MR[MK]>; } : never;
+        };
+        actions: {
+            updateQueryStateAndEntities: {
+                <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+                    type: `@rrc/${N}/updateQueryStateAndEntities`;
+                    queryKey: K;
+                    queryCacheKey: Key;
+                    state: Partial<QueryState<QP[K], QR[K]>> | undefined;
+                    entityChanges: import("./types").EntityChanges<T> | undefined;
+                };
+                type: `@rrc/${N}/updateQueryStateAndEntities`;
+            };
+            updateMutationStateAndEntities: {
+                <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+                    type: `@rrc/${N}/updateMutationStateAndEntities`;
+                    mutationKey: K_1;
+                    state: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined;
+                    entityChanges: import("./types").EntityChanges<T> | undefined;
+                };
+                type: `@rrc/${N}/updateMutationStateAndEntities`;
+            };
+            mergeEntityChanges: {
+                (changes: import("./types").EntityChanges<T>): {
+                    type: `@rrc/${N}/mergeEntityChanges`;
+                    changes: import("./types").EntityChanges<T>;
+                };
+                type: `@rrc/${N}/mergeEntityChanges`;
+            };
+            invalidateQuery: {
+                <K_2 extends keyof QP & keyof QR>(queries: {
+                    query: K_2;
+                    cacheKey?: Key | undefined;
+                    expiresAt?: number | undefined;
+                }[]): {
+                    type: `@rrc/${N}/invalidateQuery`;
+                    queries: {
+                        query: K_2;
+                        cacheKey?: Key | undefined;
+                        expiresAt?: number | undefined;
+                    }[];
+                };
+                type: `@rrc/${N}/invalidateQuery`;
+            };
+            clearQueryState: {
+                <K_3 extends keyof QP & keyof QR>(queries: {
+                    query: K_3;
+                    cacheKey?: Key | undefined;
+                }[]): {
+                    type: `@rrc/${N}/clearQueryState`;
+                    queries: {
+                        query: K_3;
+                        cacheKey?: Key | undefined;
+                    }[];
+                };
+                type: `@rrc/${N}/clearQueryState`;
+            };
+            clearMutationState: {
+                <K_4 extends keyof MP & keyof MR>(mutationKeys: K_4[]): {
+                    type: `@rrc/${N}/clearMutationState`;
+                    mutationKeys: K_4[];
+                };
+                type: `@rrc/${N}/clearMutationState`;
+            };
+        };
+        selectors: {
+            /** Selects query state. */
+            selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
+            /** Selects query latest result. */
+            selectQueryResult: <QK_2 extends keyof QP | keyof QR>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
+            /** Selects query loading state. */
+            selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean;
+            /** Selects query latest error. */
+            selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+            /** Selects query latest params. */
+            selectQueryParams: <QK_5 extends keyof QP | keyof QR>(state: unknown, query: QK_5, cacheKey: Key) => (QK_5 extends keyof QP & keyof QR ? QP[QK_5] : never) | undefined;
+            /** Selects query latest expiresAt. */
+            selectQueryExpiresAt: <QK_6 extends keyof QP | keyof QR>(state: unknown, query: QK_6, cacheKey: Key) => number | undefined;
+            /** Selects mutation state. */
+            selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+            /** Selects mutation latest result. */
+            selectMutationResult: <MK_2 extends keyof MP | keyof MR>(state: unknown, mutation: MK_2) => (MK_2 extends keyof MP & keyof MR ? MR[MK_2] : never) | undefined;
+            /** Selects mutation loading state. */
+            selectMutationLoading: <MK_3 extends keyof MP | keyof MR>(state: unknown, mutation: MK_3) => boolean;
+            /** Selects mutation latest error. */
+            selectMutationError: <MK_4 extends keyof MP | keyof MR>(state: unknown, mutation: MK_4) => Error | undefined;
+            /** Selects mutation latest params. */
+            selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => (MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never) | undefined;
+            /** Selects entity by id and typename. */
+            selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
+            /** Selects all entities. */
+            selectEntities: (state: unknown) => import("./types").EntitiesMap<T>;
+            /** Selects all entities of provided typename. */
+            selectEntitiesByTypename: <TN_1 extends keyof T>(state: unknown, typename: TN_1) => import("./types").EntitiesMap<T>[TN_1];
+        };
+        hooks: {
+            /** Returns client object with query and mutate functions. */
+            useClient: () => {
+                query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
+                mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<T, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
+            };
+            /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
+            useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_5 ? T_5 extends QK_8 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
+            /** Subscribes to provided mutation state and provides mutate function. */
+            useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<T, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_6 ? T_6 extends MK_7 ? T_6 extends keyof MP & keyof MR ? MR[T_6] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+            /** useSelector + selectEntityById. */
+            useSelectEntityById: <TN_2 extends keyof T>(id: Key | null | undefined, typename: TN_2) => T[TN_2] | undefined;
+        };
+        utils: {
+            /**
+             * Apply changes to the entities map.
+             * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
+             */
+            applyEntityChanges: (entities: import("./types").EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => import("./types").EntitiesMap<T> | undefined;
+        };
+    };
+};
 /**
  * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
  */
-export declare const createCache: <N extends string, T extends Typenames, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, T, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector">) => {
+export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCache: OptionalPartial<Cache<N, Typenames, QP, QR, MP, MR>, "queries" | "options" | "mutations" | "cacheStateSelector">) => {
     /** Keeps all options, passed while creating the cache. */
-    cache: Cache<N, T, QP, QR, MP, MR>;
+    cache: Cache<N, Typenames, QP, QR, MP, MR>;
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
-        entities: import("./types").EntitiesMap<T>;
-        queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-        mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;
+        entities: import("./types").EntitiesMap<Typenames>;
+        queries: QP | QR extends infer T ? { [QK in keyof T]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
+        mutations: MP | MR extends infer T_1 ? { [MK in keyof T_1]: MutationState<MP[MK], MR[MK]>; } : never;
     } | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
         state: Partial<QueryState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
-        entityChanges: import("./types").EntityChanges<T> | undefined;
+        entityChanges: import("./types").EntityChanges<Typenames> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
         mutationKey: keyof MP & keyof MR;
         state: Partial<MutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
-        entityChanges: import("./types").EntityChanges<T> | undefined;
+        entityChanges: import("./types").EntityChanges<Typenames> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
-        changes: import("./types").EntityChanges<T>;
+        changes: import("./types").EntityChanges<Typenames>;
     } | {
         type: `@rrc/${N}/invalidateQuery`;
         queries: {
@@ -44,34 +211,34 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         type: `@rrc/${N}/clearMutationState`;
         mutationKeys: (keyof MP & keyof MR)[];
     }) => {
-        entities: import("./types").EntitiesMap<T>;
-        queries: QP | QR extends infer T_3 ? { [QK in keyof T_3]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
-        mutations: MP | MR extends infer T_4 ? { [MK in keyof T_4]: MutationState<MP[MK], MR[MK]>; } : never;
+        entities: import("./types").EntitiesMap<Typenames>;
+        queries: QP | QR extends infer T_2 ? { [QK in keyof T_2]: import("./types").Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
+        mutations: MP | MR extends infer T_3 ? { [MK in keyof T_3]: MutationState<MP[MK], MR[MK]>; } : never;
     };
     actions: {
         updateQueryStateAndEntities: {
-            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
                 state: Partial<QueryState<QP[K], QR[K]>> | undefined;
-                entityChanges: import("./types").EntityChanges<T> | undefined;
+                entityChanges: import("./types").EntityChanges<Typenames> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K_1;
                 state: Partial<MutationState<MP[K_1], MR[K_1]>> | undefined;
-                entityChanges: import("./types").EntityChanges<T> | undefined;
+                entityChanges: import("./types").EntityChanges<Typenames> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
         };
         mergeEntityChanges: {
-            (changes: import("./types").EntityChanges<T>): {
+            (changes: import("./types").EntityChanges<Typenames>): {
                 type: `@rrc/${N}/mergeEntityChanges`;
-                changes: import("./types").EntityChanges<T>;
+                changes: import("./types").EntityChanges<Typenames>;
             };
             type: `@rrc/${N}/mergeEntityChanges`;
         };
@@ -122,7 +289,7 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         selectQueryError: <QK_4 extends keyof QP | keyof QR>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
         /** Selects query latest params. */
         selectQueryParams: <QK_5 extends keyof QP | keyof QR>(state: unknown, query: QK_5, cacheKey: Key) => (QK_5 extends keyof QP & keyof QR ? QP[QK_5] : never) | undefined;
-        /** Selects query expiresAt value. */
+        /** Selects query latest expiresAt. */
         selectQueryExpiresAt: <QK_6 extends keyof QP | keyof QR>(state: unknown, query: QK_6, cacheKey: Key) => number | undefined;
         /** Selects mutation state. */
         selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
@@ -135,30 +302,30 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         /** Selects mutation latest params. */
         selectMutationParams: <MK_5 extends keyof MP | keyof MR>(state: unknown, mutation: MK_5) => (MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never) | undefined;
         /** Selects entity by id and typename. */
-        selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;
+        selectEntityById: <TN extends string>(state: unknown, id: Key | null | undefined, typename: TN) => object | undefined;
         /** Selects all entities. */
-        selectEntities: (state: unknown) => import("./types").EntitiesMap<T>;
+        selectEntities: (state: unknown) => import("./types").EntitiesMap<Typenames>;
         /** Selects all entities of provided typename. */
-        selectEntitiesByTypename: <TN_1 extends keyof T>(state: unknown, typename: TN_1) => import("./types").EntitiesMap<T>[TN_1];
+        selectEntitiesByTypename: <TN_1 extends string>(state: unknown, typename: TN_1) => import("./types").Dict<object> | undefined;
     };
     hooks: {
         /** Returns client object with query and mutate functions. */
         useClient: () => {
-            query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
-            mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<T, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
+            query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<Typenames, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
+            mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<Typenames, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
         };
         /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-        useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_5 ? T_5 extends QK_8 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
+        useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<Typenames, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<Typenames, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_4 ? T_4 extends QK_8 ? T_4 extends keyof QP & keyof QR ? QR[T_4] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<T, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_6 ? T_6 extends MK_7 ? T_6 extends keyof MP & keyof MR ? MR[T_6] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+        useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<Typenames, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_5 ? T_5 extends MK_7 ? T_5 extends keyof MP & keyof MR ? MR[T_5] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
         /** useSelector + selectEntityById. */
-        useSelectEntityById: <TN_2 extends keyof T>(id: Key | null | undefined, typename: TN_2) => T[TN_2] | undefined;
+        useSelectEntityById: <TN_2 extends string>(id: Key | null | undefined, typename: TN_2) => object | undefined;
     };
     utils: {
         /**
          * Apply changes to the entities map.
          * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
          */
-        applyEntityChanges: (entities: import("./types").EntitiesMap<T>, changes: import("./types").EntityChanges<T>) => import("./types").EntitiesMap<T> | undefined;
+        applyEntityChanges: (entities: import("./types").EntitiesMap<Typenames>, changes: import("./types").EntityChanges<Typenames>) => import("./types").EntitiesMap<Typenames> | undefined;
     };
 };

package/dist/createCache.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCache = void 0;
+exports.createCache = exports.withTypenames = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const createActions_1 = require("./createActions");
@@ -11,140 +11,161 @@ const useMutation_1 = require("./useMutation");
 const useQuery_1 = require("./useQuery");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 /**
- * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
+ * Function to provide generic Typenames if normalization is needed - this is a Typescript limitation.
+ * Returns object with createCache function with provided typenames.
+ * @example
+ * const cache = withTypenames<MyTypenames>().createCache({
+ *   ...
+ * })
  */
-const createCache = (partialCache) => {
-    var _a, _b, _c, _d, _e, _f, _g;
-    var _h, _j, _k;
-    const abortControllers = new WeakMap();
-    // provide all optional fields
-    (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
-    (_b = (_h = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_h.logsEnabled = false);
-    (_c = (_j = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_j.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
-    (_d = (_k = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_k.deepComparisonEnabled = true);
-    (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
-    (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (_g = partialCache.cacheStateSelector) !== null && _g !== void 0 ? _g : (partialCache.cacheStateSelector = (state) => state[cache.name]);
-    // @ts-expect-error private field for testing
-    partialCache.abortControllers = abortControllers;
-    const cache = partialCache;
-    // make selectors
-    const selectEntityById = (state, id, typename) => {
-        return id == null ? undefined : cache.cacheStateSelector(state).entities[typename][id];
-    };
-    const selectQueryState = (state, query, cacheKey) => {
-        var _a;
-        // @ts-expect-error fix later
-        return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
-    };
-    const selectMutationState = (state, mutation) => {
-        var _a;
-        // @ts-expect-error fix later
-        return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
-    };
-    const actions = (0, createActions_1.createActions)(cache.name);
+const withTypenames = () => {
+    /**
+     * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
+     */
     return {
-        /** Keeps all options, passed while creating the cache. */
-        cache,
-        /** Reducer of the cache, should be added to redux store. */
-        reducer: (0, createCacheReducer_1.createCacheReducer)(actions, cache.typenames, Object.keys(cache.queries), cache.options),
-        actions,
-        selectors: {
-            /** Selects query state. */
-            selectQueryState,
-            /** Selects query latest result. */
-            selectQueryResult: (state, query, cacheKey) => {
-                return selectQueryState(state, query, cacheKey).result;
-            },
-            /** Selects query loading state. */
-            selectQueryLoading: (state, query, cacheKey) => {
-                return selectQueryState(state, query, cacheKey).loading;
-            },
-            /** Selects query latest error. */
-            selectQueryError: (state, query, cacheKey) => {
-                return selectQueryState(state, query, cacheKey).error;
-            },
-            /** Selects query latest params. */
-            selectQueryParams: (state, query, cacheKey) => {
-                return selectQueryState(state, query, cacheKey).params;
-            },
-            /** Selects query expiresAt value. */
-            selectQueryExpiresAt: (state, query, cacheKey) => {
-                return selectQueryState(state, query, cacheKey).expiresAt;
-            },
-            /** Selects mutation state. */
-            selectMutationState,
-            /** Selects mutation latest result. */
-            selectMutationResult: (state, mutation) => {
-                return selectMutationState(state, mutation).result;
-            },
-            /** Selects mutation loading state. */
-            selectMutationLoading: (state, mutation) => {
-                return selectMutationState(state, mutation).loading;
-            },
-            /** Selects mutation latest error. */
-            selectMutationError: (state, mutation) => {
-                return selectMutationState(state, mutation).error;
-            },
-            /** Selects mutation latest params. */
-            selectMutationParams: (state, mutation) => {
-                return selectMutationState(state, mutation).params;
-            },
-            /** Selects entity by id and typename. */
-            selectEntityById,
-            /** Selects all entities. */
-            selectEntities: (state) => {
-                return cache.cacheStateSelector(state).entities;
-            },
-            /** Selects all entities of provided typename. */
-            selectEntitiesByTypename: (state, typename) => {
-                return cache.cacheStateSelector(state).entities[typename];
-            },
-        },
-        hooks: {
-            /** Returns client object with query and mutate functions. */
-            useClient: () => {
-                const store = (0, react_redux_1.useStore)();
-                return (0, react_1.useMemo)(() => {
-                    const client = {
-                        query: (options) => {
-                            var _a;
-                            const { query: queryKey, params } = options;
-                            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', store, cache, actions, queryKey, cacheKey, params, options.secondsToLive, options.onlyIfExpired, 
-                            // @ts-expect-error fix later
-                            options.mergeResults, options.onCompleted, options.onSuccess, options.onError);
-                        },
-                        mutate: (options) => {
-                            return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers, 
-                            // @ts-expect-error fix later
-                            options.onCompleted, options.onSuccess, options.onError);
-                        },
-                    };
-                    return client;
-                }, [store]);
-            },
-            /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-            useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, options),
-            /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
-            /** useSelector + selectEntityById. */
-            useSelectEntityById: (id, typename) => {
-                return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));
-            },
-        },
-        utils: {
-            /**
-             * Apply changes to the entities map.
-             * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
-             */
-            applyEntityChanges: (entities, changes) => {
-                return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options);
-            },
+        createCache: (partialCache) => {
+            var _a, _b, _c, _d, _e, _f, _g;
+            var _h, _j, _k;
+            const abortControllers = new WeakMap();
+            // provide all optional fields
+            (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
+            (_b = (_h = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_h.logsEnabled = false);
+            (_c = (_j = partialCache.options).validateFunctionArguments) !== null && _c !== void 0 ? _c : (_j.validateFunctionArguments = utilsAndConstants_1.IS_DEV);
+            (_d = (_k = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_k.deepComparisonEnabled = true);
+            (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
+            (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (_g = partialCache.cacheStateSelector) !== null && _g !== void 0 ? _g : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+            // @ts-expect-error private field for testing
+            partialCache.abortControllers = abortControllers;
+            const cache = partialCache;
+            // validate options
+            if (cache.options.deepComparisonEnabled && !utilsAndConstants_1.optionalUtils.deepEqual) {
+                console.warn('react-redux-cache: optional dependency for fast-deep-equal was not provided, while deepComparisonEnabled option is true');
+            }
+            // make selectors
+            const selectEntityById = (state, id, typename) => {
+                var _a;
+                return id == null ? undefined : (_a = cache.cacheStateSelector(state).entities[typename]) === null || _a === void 0 ? void 0 : _a[id];
+            };
+            const selectQueryState = (state, query, cacheKey) => {
+                var _a;
+                // @ts-expect-error fix later
+                return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+            };
+            const selectMutationState = (state, mutation) => {
+                var _a;
+                // @ts-expect-error fix later
+                return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
+            };
+            const actions = (0, createActions_1.createActions)(cache.name);
+            return {
+                /** Keeps all options, passed while creating the cache. */
+                cache,
+                /** Reducer of the cache, should be added to redux store. */
+                reducer: (0, createCacheReducer_1.createCacheReducer)(actions, Object.keys(cache.queries), cache.options),
+                actions,
+                selectors: {
+                    /** Selects query state. */
+                    selectQueryState,
+                    /** Selects query latest result. */
+                    selectQueryResult: (state, query, cacheKey) => {
+                        return selectQueryState(state, query, cacheKey).result;
+                    },
+                    /** Selects query loading state. */
+                    selectQueryLoading: (state, query, cacheKey) => {
+                        return selectQueryState(state, query, cacheKey).loading;
+                    },
+                    /** Selects query latest error. */
+                    selectQueryError: (state, query, cacheKey) => {
+                        return selectQueryState(state, query, cacheKey).error;
+                    },
+                    /** Selects query latest params. */
+                    selectQueryParams: (state, query, cacheKey) => {
+                        return selectQueryState(state, query, cacheKey).params;
+                    },
+                    /** Selects query latest expiresAt. */
+                    selectQueryExpiresAt: (state, query, cacheKey) => {
+                        return selectQueryState(state, query, cacheKey).expiresAt;
+                    },
+                    /** Selects mutation state. */
+                    selectMutationState,
+                    /** Selects mutation latest result. */
+                    selectMutationResult: (state, mutation) => {
+                        return selectMutationState(state, mutation).result;
+                    },
+                    /** Selects mutation loading state. */
+                    selectMutationLoading: (state, mutation) => {
+                        return selectMutationState(state, mutation).loading;
+                    },
+                    /** Selects mutation latest error. */
+                    selectMutationError: (state, mutation) => {
+                        return selectMutationState(state, mutation).error;
+                    },
+                    /** Selects mutation latest params. */
+                    selectMutationParams: (state, mutation) => {
+                        return selectMutationState(state, mutation).params;
+                    },
+                    /** Selects entity by id and typename. */
+                    selectEntityById,
+                    /** Selects all entities. */
+                    selectEntities: (state) => {
+                        return cache.cacheStateSelector(state).entities;
+                    },
+                    /** Selects all entities of provided typename. */
+                    selectEntitiesByTypename: (state, typename) => {
+                        return cache.cacheStateSelector(state).entities[typename];
+                    },
+                },
+                hooks: {
+                    /** Returns client object with query and mutate functions. */
+                    useClient: () => {
+                        const store = (0, react_redux_1.useStore)();
+                        return (0, react_1.useMemo)(() => {
+                            const client = {
+                                query: (options) => {
+                                    var _a;
+                                    const { query: queryKey, params } = options;
+                                    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', store, cache, actions, queryKey, cacheKey, params, options.secondsToLive, options.onlyIfExpired, 
+                                    // @ts-expect-error fix later
+                                    options.mergeResults, options.onCompleted, options.onSuccess, options.onError);
+                                },
+                                mutate: (options) => {
+                                    return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers, 
+                                    // @ts-expect-error fix later
+                                    options.onCompleted, options.onSuccess, options.onError);
+                                },
+                            };
+                            return client;
+                        }, [store]);
+                    },
+                    /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
+                    useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, options),
+                    /** Subscribes to provided mutation state and provides mutate function. */
+                    useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
+                    /** useSelector + selectEntityById. */
+                    useSelectEntityById: (id, typename) => {
+                        return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));
+                    },
+                },
+                utils: {
+                    /**
+                     * Apply changes to the entities map.
+                     * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
+                     */
+                    applyEntityChanges: (entities, changes) => {
+                        return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options);
+                    },
+                },
+            };
         },
     };
 };
-exports.createCache = createCache;
+exports.withTypenames = withTypenames;
+/**
+ * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
+ */
+exports.createCache = (0, exports.withTypenames)().createCache;

package/dist/createCacheReducer.d.ts

@@ -1,7 +1,7 @@
 import type { ActionMap } from './createActions';
 import type { CacheOptions, Dict, EntitiesMap, MutationState, QueryState, Typenames } from './types';
 export type ReduxCacheState<T extends Typenames, QP, QR, MP, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QP, QR, MP, MR>>>;
-export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: ActionMap<N, T, QP, QR, MP, MR>, typenames: T, queryKeys: (keyof QP & keyof QR)[], cacheOptions: CacheOptions) => (state: {
+export declare const createCacheReducer: <N extends string, T extends Typenames, QP, QR, MP, MR>(actions: ActionMap<N, T, QP, QR, MP, MR>, queryKeys: (keyof QP & keyof QR)[], cacheOptions: CacheOptions) => (state: {
     entities: EntitiesMap<T>;
     queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryState<QP[QK], QR[QK]> | undefined>; } : never;
     mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: MutationState<MP[MK], MR[MK]>; } : never;

package/dist/createCacheReducer.js

@@ -2,14 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const EMPTY_QUERY_STATE = Object.freeze({});
 const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params'];
 const optionalMutationKeys = ['error', 'result', 'params'];
-const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
+const createCacheReducer = (actions, queryKeys, cacheOptions) => {
     const entitiesMap = {};
-    for (const key in typenames) {
-        entitiesMap[key] = EMPTY_QUERY_STATE;
-    }
     const queryStateMap = {};
     for (const key of queryKeys) {
         queryStateMap[key] = {};
@@ -22,7 +18,6 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
     };
     cacheOptions.logsEnabled &&
         (0, utilsAndConstants_1.log)('createCacheReducer', {
-            typenames,
             queryKeys,
             initialState,
         });
@@ -151,9 +146,9 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                             delete newQueries[queryKey][cacheKey];
                         }
                     }
-                    else if (queryStates !== EMPTY_QUERY_STATE) {
+                    else if (queryStates !== utilsAndConstants_1.EMPTY_OBJECT) {
                         newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                        newQueries[queryKey] = EMPTY_QUERY_STATE;
+                        newQueries[queryKey] = utilsAndConstants_1.EMPTY_OBJECT;
                     }
                 }
                 return !newQueries

package/dist/index.d.ts

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

package/dist/index.js

@@ -14,9 +14,10 @@ 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.defaultQueryMutationState = exports.defaultGetCacheKey = exports.createCache = void 0;
+exports.defaultQueryMutationState = exports.defaultGetCacheKey = exports.withTypenames = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
+Object.defineProperty(exports, "withTypenames", { enumerable: true, get: function () { return createCache_1.withTypenames; } });
 __exportStar(require("./types"), exports);
 var utilsAndConstants_1 = require("./utilsAndConstants");
 Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
@@ -26,8 +27,6 @@ Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true,
 // rca -> vite
 // defaults
 // remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?
-// optional typenames: {} as Typenames
-// remove mergeResults? bcs store is passed to queries/mutations
 // remove undefined optional fields & emtpy states
 // generate full api docs
 // ! medium

package/dist/types.d.ts

@@ -21,16 +21,6 @@ export type Typenames = Record<string, object>;
 export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     /** Used as prefix for actions and in default cacheStateSelector for selecting cache state from redux state. */
     name: N;
-    /**
-     * Mapping of all typenames to their entity types, which is needed for proper normalization. Should be empty if normalization is not needed.
-     * @key Typename.
-     * @value Object with proper type of the typename. Empty objects with type casting can be used.
-     * @example
-     * typenames: {
-        users: {} as User, // here `users` entities will have type `User`
-        banks: {} as Bank,
-    } */
-    typenames: T;
     queries: {
         [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK]> : never;
     };
@@ -64,7 +54,7 @@ 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]>;
+    [K in keyof T]?: Dict<T[K]>;
 };
 export type EntityIds<T extends Typenames> = {
     [K in keyof T]?: Key[];

package/dist/utilsAndConstants.d.ts

@@ -7,6 +7,8 @@ export declare const IS_DEV: boolean;
 export declare const DEFAULT_QUERY_MUTATION_STATE: Readonly<{
     loading: false;
 }>;
+export declare const EMPTY_OBJECT: Readonly<{}>;
+export declare const EMPTY_ARRAY: readonly never[];
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key;
 export declare const log: (tag: string, data?: unknown) => void;
 export declare const applyEntityChanges: <T extends Typenames>(entities: EntitiesMap<T>, changes: EntityChanges<T>, options: CacheOptions) => EntitiesMap<T> | undefined;

package/dist/utilsAndConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
+exports.applyEntityChanges = exports.log = exports.defaultGetCacheKey = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.DEFAULT_QUERY_MUTATION_STATE = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'rrc';
 exports.optionalUtils = {
     deepEqual: undefined,
@@ -21,6 +21,8 @@ exports.IS_DEV = (() => {
     }
 })();
 exports.DEFAULT_QUERY_MUTATION_STATE = Object.freeze({ loading: false });
+exports.EMPTY_OBJECT = Object.freeze({});
+exports.EMPTY_ARRAY = Object.freeze([]);
 const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':
@@ -38,12 +40,9 @@ const log = (tag, data) => {
 };
 exports.log = log;
 const applyEntityChanges = (entities, changes, options) => {
-    var _a, _b, _c;
-    if (options.validateFunctionArguments) {
-        // check for merge and entities both set
-        if (changes.merge && changes.entities) {
-            throw new Error('Merge and entities should not be both set');
-        }
+    var _a, _b, _c, _d;
+    if (changes.merge && changes.entities) {
+        console.warn('react-redux-cache.applyEntityChanges: merge and entities should not be both set');
     }
     const { merge = changes.entities, replace, remove } = changes;
     if (!merge && !replace && !remove) {
@@ -51,7 +50,14 @@ const applyEntityChanges = (entities, changes, options) => {
     }
     const deepEqual = options.deepComparisonEnabled ? exports.optionalUtils.deepEqual : undefined;
     let result;
-    for (const typename in entities) {
+    // TODO refactor to remove this Set
+    const typenames = new Set([
+        ...(changes.entities ? Object.keys(changes.entities) : exports.EMPTY_ARRAY),
+        ...(changes.merge ? Object.keys(changes.merge) : exports.EMPTY_ARRAY),
+        ...(changes.remove ? Object.keys(changes.remove) : exports.EMPTY_ARRAY),
+        ...(changes.replace ? Object.keys(changes.replace) : exports.EMPTY_ARRAY),
+    ]);
+    for (const typename of typenames) {
         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];
@@ -67,10 +73,11 @@ const applyEntityChanges = (entities, changes, options) => {
             entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => idsSet.add(String(id))); // String() because Object.keys always returns strings
             const totalKeysInResponse = ((_a = mergeIds === null || mergeIds === void 0 ? void 0 : mergeIds.length) !== null && _a !== void 0 ? _a : 0) + ((_b = replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.length) !== null && _b !== void 0 ? _b : 0) + ((_c = entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length) !== null && _c !== void 0 ? _c : 0);
             if (totalKeysInResponse !== 0 && idsSet.size !== totalKeysInResponse) {
-                throw new Error('Merge, replace and remove changes have intersections for: ' + typename);
+                console.warn('react-redux-cache.applyEntityChanges: merge, replace and remove changes have intersections for: ' +
+                    typename);
             }
         }
-        const oldEntities = entities[typename];
+        const oldEntities = (_d = entities[typename]) !== null && _d !== void 0 ? _d : exports.EMPTY_OBJECT;
         let newEntities;
         // remove
         entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => {
@@ -104,6 +111,7 @@ const applyEntityChanges = (entities, changes, options) => {
             continue;
         }
         result !== null && result !== void 0 ? result : (result = Object.assign({}, entities));
+        // @ts-expect-error fix later
         result[typename] = newEntities;
     }
     options.logsEnabled &&

package/package.json

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