react-redux-cache 0.0.1 → 0.0.3

package/README.md

@@ -1,6 +1,6 @@
 # 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`.
+**Powerful** yet **lightweight** data fetching and caching library that supports **normalization** unlike `react-query` and `rtk-query`, while having similar interface. 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**.
 
@@ -65,7 +65,7 @@ For normalization `normalizr` package is used in this example, but any other too
 Perfect implementation is when the backend already returns normalized data.
 ```typescript
 export const getUser = async (id: number) => {
-  const result: User = await ...
+  const result = await ...
   
   const normalizedResult: {
     result: number
@@ -105,13 +105,13 @@ export const UserScreen = () => {
 
   // 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')
+  const bank = useSelectEntityById(user?.bankId, 'banks')
 
   if (loading) {
-    return ... // loading state
+    return ...
   }
 
-  return ... // loaded state
+  return ...
 }
 ```
 

package/dist/createCache.d.ts

@@ -0,0 +1,71 @@
+import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
+import { Cache, EntitiesMap, Key, OptionalPartial, Typenames } from './types';
+import { useMutation } from './useMutation';
+import { useQuery } from './useQuery';
+/**
+ * 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/createCache.js

@@ -0,0 +1,61 @@
+"use strict";
+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");
+/**
+ * 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/index.d.ts

@@ -1,74 +1,6 @@
-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 { createCache } from './createCache';
+export type { ReduxCacheState } 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;
-    };
-};
+export { defaultMutationCacheOptions } from './useMutation';
+export { defaultQueryCacheOptions, queryCacheOptionsByPolicy } from './useQuery';
+export { defaultGetParamsKey, defaultQueryMutationState, processEntityChanges, } from './utilsAndConstants';

package/dist/index.js

@@ -14,18 +14,26 @@ 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");
+exports.processEntityChanges = exports.defaultQueryMutationState = exports.defaultGetParamsKey = exports.queryCacheOptionsByPolicy = exports.defaultQueryCacheOptions = exports.defaultMutationCacheOptions = exports.createCache = void 0;
+var createCache_1 = require("./createCache");
+Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
+__exportStar(require("./types"), exports);
+var useMutation_1 = require("./useMutation");
+Object.defineProperty(exports, "defaultMutationCacheOptions", { enumerable: true, get: function () { return useMutation_1.defaultMutationCacheOptions; } });
+var useQuery_1 = require("./useQuery");
+Object.defineProperty(exports, "defaultQueryCacheOptions", { enumerable: true, get: function () { return useQuery_1.defaultQueryCacheOptions; } });
+Object.defineProperty(exports, "queryCacheOptionsByPolicy", { enumerable: true, get: function () { return useQuery_1.queryCacheOptionsByPolicy; } });
+var utilsAndConstants_1 = require("./utilsAndConstants");
+Object.defineProperty(exports, "defaultGetParamsKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetParamsKey; } });
+Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.defaultQueryMutationState; } });
+Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get: function () { return utilsAndConstants_1.processEntityChanges; } });
 // Backlog
 // ! high
-// create package with README
+// package.json exports
 // cover with tests
 // ! medium
-// add params to the state
+// return back deserialize selector?
+// resultSelector - return also boolean that result is full enough
 // 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)
@@ -43,6 +51,7 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 // make error type generic
 // proper types, remove as, any, todo
 // ! low
+// add params to the state?
 // cancellation to queries
 // if mutation & query alrady loading - make options: last, throttle, debounce, parallel?
 // add time-to-live option, and/or time-to-refresh
@@ -54,59 +63,3 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 // 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.js

@@ -26,7 +26,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
         });
     return (state = initialState, action) => {
         switch (action.type) {
-            case '@RRQN/SET_QUERY_STATE_AND_ENTITIES': {
+            case '@RRC/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) {
@@ -34,7 +34,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
                 }
                 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': {
+            case '@RRC/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) {
@@ -42,7 +42,7 @@ const createCacheReducer = (typenames, queries, mutations, cacheOptions) => {
                 }
                 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': {
+            case '@RRC/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;

package/dist/types.d.ts

@@ -7,11 +7,11 @@ export type OptionalPartial<T, K extends keyof T> = Partial<{
 /** 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>>;
+    merge?: PartialEntitiesMap<T>;
     /** Entities that will replace existing. */
     replace?: Partial<EntitiesMap<T>>;
-    /** Ids of entities that will be removed.  */
-    remove?: Partial<EntityIds<T>>;
+    /** Ids of entities that will be removed. */
+    remove?: EntityIds<T>;
     /** Alias for `merge` to support normalizr. */
     entities?: EntityChanges<T>['merge'];
 };
@@ -48,13 +48,13 @@ export type CacheOptions = {
     logsEnabled: boolean;
 };
 export type PartialEntitiesMap<T extends Typenames> = {
-    [K in keyof T]: Dict<Partial<T[K]>>;
+    [K in keyof T]?: Dict<Partial<T[K]>>;
 };
 export type EntitiesMap<T extends Typenames> = {
-    [K in keyof T]: Dict<T[K] | undefined>;
+    [K in keyof T]: Dict<T[K]>;
 };
 export type EntityIds<T extends Typenames> = {
-    [K in keyof T]: Key[];
+    [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> = {
@@ -77,7 +77,7 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
     /**
      * 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.
+     * Default implementation uses `JSON.stringify` or `String()` depending on type.
      * */
     getParamsKey?: (params?: P) => Key;
     /**

package/dist/useMutation.d.ts

@@ -1,5 +1,5 @@
 import { Cache, MutationCacheOptions, QueryMutationState, Typenames } from './types';
-export declare const DEFAULT_MUTATION_CACHE_OPTIONS: MutationCacheOptions;
+export declare const defaultMutationCacheOptions: 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;

package/dist/useMutation.js

@@ -9,18 +9,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMutation = exports.DEFAULT_MUTATION_CACHE_OPTIONS = void 0;
+exports.useMutation = exports.defaultMutationCacheOptions = 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 = {
+exports.defaultMutationCacheOptions = {
     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 { mutation: mutationKey, cacheOptions = (_a = cache.mutations[mutationKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.defaultMutationCacheOptions, } = options;
     const dispatch = (0, react_redux_1.useDispatch)();
     cache.options.logsEnabled &&
         (0, utilsAndConstants_1.log)('useMutation', {
@@ -54,7 +54,7 @@ const useMutation = (cache, options) => {
         // 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 mutationState = (_b = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultQueryMutationState;
     const mutate = (0, react_1.useCallback)((params) => __awaiter(void 0, void 0, void 0, function* () {
         cache.options.logsEnabled &&
             (0, utilsAndConstants_1.log)('mutate', {

package/dist/useQuery.d.ts

@@ -1,6 +1,6 @@
 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: {
+export declare const queryCacheOptionsByPolicy: Record<QueryCachePolicy, QueryCacheOptions>;
+export declare const defaultQueryCacheOptions: {
     readonly policy: "cache-first";
     readonly cacheQueryState: true;
     readonly cacheEntities: true;

package/dist/useQuery.js

@@ -9,30 +9,30 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useQuery = exports.DEFAULT_QUERY_CACHE_OPTIONS = exports.QUERY_CACHE_OPTIONS_BY_POLICY = void 0;
+exports.useQuery = exports.defaultQueryCacheOptions = exports.queryCacheOptionsByPolicy = 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 = {
+const cacheFirstOptions = {
     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.queryCacheOptionsByPolicy = {
+    'cache-first': cacheFirstOptions,
+    'cache-and-fetch': Object.assign(Object.assign({}, cacheFirstOptions), { policy: 'cache-and-fetch' }),
 };
-exports.DEFAULT_QUERY_CACHE_OPTIONS = CACHE_FIRST_OPTIONS;
+exports.defaultQueryCacheOptions = cacheFirstOptions;
 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 { query: queryKey, skip, params: hookParams, cacheOptions: cacheOptionsOrPolicy = (_b = cache.queries[queryKey].cacheOptions) !== null && _b !== void 0 ? _b : exports.defaultQueryCacheOptions, 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]
+        ? exports.queryCacheOptionsByPolicy[cacheOptionsOrPolicy]
         : cacheOptionsOrPolicy;
     const store = (0, react_redux_1.useStore)();
     // Check values that should be set once.
@@ -89,7 +89,7 @@ const useQuery = (cache, options) => {
         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 queryStateFromSelector = (_d = (0, react_redux_1.useSelector)(queryStateSelector)) !== null && _d !== void 0 ? _d : utilsAndConstants_1.defaultQueryMutationState;
     const queryState = hasResultFromSelector
         ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
         : queryStateFromSelector;

package/dist/utilsAndConstants.d.ts

@@ -2,7 +2,7 @@
 import { CacheOptions, EntitiesMap, EntityChanges, Typenames } from './types';
 export declare const PACKAGE_SHORT_NAME = "RRC";
 export declare const isDev: boolean;
-export declare const defaultEndpointState: {
+export declare const defaultQueryMutationState: {
     readonly loading: false;
 };
 export declare const defaultGetParamsKey: <P = unknown>(params: P) => string;

package/dist/utilsAndConstants.js

@@ -1,6 +1,6 @@
 "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;
+exports.processEntityChanges = exports.log = exports.useAssertValueNotChanged = exports.useForceUpdate = exports.defaultGetParamsKey = exports.defaultQueryMutationState = exports.isDev = exports.PACKAGE_SHORT_NAME = void 0;
 const react_1 = require("react");
 const react_2 = require("react");
 exports.PACKAGE_SHORT_NAME = 'RRC';
@@ -13,8 +13,17 @@ exports.isDev = (() => {
         return process.env.NODE_ENV === 'development';
     }
 })();
-exports.defaultEndpointState = { loading: false };
-const defaultGetParamsKey = (params) => !params ? '' : JSON.stringify(params);
+exports.defaultQueryMutationState = { loading: false };
+const defaultGetParamsKey = (params) => {
+    switch (typeof params) {
+        case 'string':
+            return params;
+        case 'object':
+            return JSON.stringify(params);
+        default:
+            return String(params);
+    }
+};
 exports.defaultGetParamsKey = defaultGetParamsKey;
 const forceUpdateReducer = (i) => i + 1;
 /**
@@ -45,35 +54,43 @@ exports.log = log;
  */
 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');
+            throw new Error('Merge and entities should not be both set');
         }
     }
+    const { merge = changes.entities, replace, remove } = changes;
+    if (!merge && !replace && !remove) {
+        return undefined;
+    }
     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) {
+        if (!entitiesToMerge && !entitiesToReplace && !(entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.length)) {
             continue;
         }
+        // check for key intersection
+        if (options.validateFunctionArguments) {
+            const mergeIds = entitiesToMerge && Object.keys(entitiesToMerge);
+            const replaceIds = entitiesToReplace && Object.keys(entitiesToReplace);
+            const idsSet = new Set(mergeIds);
+            replaceIds === null || replaceIds === void 0 ? void 0 : replaceIds.forEach((id) => idsSet.add(id));
+            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.log('[VALIDATe]', {
+                totalKeysInResponse,
+                idsSet,
+                mergeIds,
+                replaceIds,
+                entitiesToRemove,
+            });
+        }
         const newEntities = Object.assign({}, entities[typename]);
         // remove
         entitiesToRemove === null || entitiesToRemove === void 0 ? void 0 : entitiesToRemove.forEach((id) => delete newEntities[id]);

package/package.json

@@ -2,21 +2,19 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "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)",
+    "example": "yarn build && (cd example && yarn cache clean && yarn add ../package.tgz && 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"
+    "test": "node node_modules/jest/bin/jest.js",
+    "prepublishOnly": "yarn build && yarn test"
   },
-  "files": [
-    "dist/*"
-  ],
   "devDependencies": {
+    "@testing-library/react": "14.0.0",
     "@types/jest": "29.5.1",
     "@types/node": "20.1.2",
     "@types/redux-logger": "3.0.9",
@@ -43,8 +41,11 @@
     "react-redux": "^4",
     "redux": "^4"
   },
-  "dependencies": {
-    "redux-persist": "6.0.0"
+  "files": [
+    "dist/*"
+  ],
+  "exports": {
+    ".": "./dist/index.js"
   },
   "keywords": [
     "react",
@@ -52,5 +53,9 @@
     "cache",
     "query",
     "normalization"
-  ]
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gentlee/react-redux-cache.git"
+  }
 }