react-redux-cache 0.4.2 → 0.5.0

package/README.md

@@ -15,74 +15,103 @@
 
 Can be considered as `ApolloClient` for protocols other than `GraphQL`, but with **full control** over its storage - redux store, with ability to write custom selectors, actions and reducers to manage cached state.
 
-Example of **normalized** redux state, generated by cache reducer from `/example` project:
-```js
-{
-  entities: {
-    // each typename has its own map of entities, stored by id
-    users: {
-      "0": {id: 0, bankId: "0", name: "User 0 *"},
-      "1": {id: 1, bankId: "1", name: "User 1 *"},
-      "2": {id: 2, bankId: "2", name: "User 2"},
-      "3": {id: 3, bankId: "3", name: "User 3"}
+Examples of states, generated by cache reducer from `/example` project:
+<details>
+  <summary>
+    Normalized
+  </summary>
+  
+  ```js
+  {
+    entities: {
+      // each typename has its own map of entities, stored by id
+      users: {
+        "0": {id: 0, bankId: "0", name: "User 0 *"},
+        "1": {id: 1, bankId: "1", name: "User 1 *"},
+        "2": {id: 2, bankId: "2", name: "User 2"},
+        "3": {id: 3, bankId: "3", name: "User 3"}
+      },
+      banks: {
+        "0": {id: "0", name: "Bank 0"},
+        "1": {id: "1", name: "Bank 1"},
+        "2": {id: "2", name: "Bank 2"},
+        "3": {id: "3", name: "Bank 3"}
+      }
     },
-    banks: {
-      "0": {id: "0", name: "Bank 0"},
-      "1": {id: "1", name: "Bank 1"},
-      "2": {id: "2", name: "Bank 2"},
-      "3": {id: "3", name: "Bank 3"}
-    }
-  },
-  queries: {
-    // each query has its own map of query states, stored by cache key, which is generated from query params
-    getUser: {
-      "2": {loading: false, error: undefined, result: 2},
-      "3": {loading: true}
+    queries: {
+      // each query has its own map of query states, stored by cache key, which is generated from query params
+      getUser: {
+        "2": {loading: false, error: undefined, result: 2, params: 2},
+        "3": {loading: true, params: 3}
+      },
+      getUsers: {
+        // example of paginated state under custom cache key
+        "all-pages": {
+          loading: false,
+          result: {items: [0,1,2], page: 1},
+          params: {page: 1}
+        }
+      }
     },
-    getUsers: {
-      // example of paginated state under custom cache key
-      "all-pages": {loading: false, result: {items: [0,1,2], page: 1}}
+    mutations: {
+      // each mutation has its own state as well
+      updateUser: {
+        loading: false,
+        result: 1,
+        params: {id: 1, name: "User 1 *"}
+      } 
     }
-  },
-  mutations: {
-    // each mutation has its own state as well
-    updateUser: {loading: false, result: 1} 
   }
-}
-```
+  ```
+</details>
 
-Example of **not normalized** redux state, generated by cache reducer from `/example` project:
-```js
-{
-  // entities map is used for normalization and is empty here
-  entities: {},
-  queries: {
-    // each query has its own map of query states, stored by cache key, which is generated from query params
-    getUser: {
-      "2": {loading: false, error: undefined, result: {id: 2, bank: {id: "2", name: "Bank 2"}, name: "User 2"}},
-      "3": {loading: true}
-    },
-    getUsers: {
-      // example of paginated state under custom cache key
-      "all-pages": {
-        loading: false,
-        result: {
-          items: [
-            {id: 0, bank: {id: "0", name: "Bank 0"}, name: "User 0 *"},
-            {id: 1, bank: {id: "1", name: "Bank 1"}, name: "User 1 *"},
-            {id: 2, bank: {id: "2", name: "Bank 2"}, name: "User 2"}
-          ],
-          page: 1
+<details>
+  <summary>
+    Not normalized
+  </summary>
+  
+  ```js
+  {
+    // entities map is used for normalization and is empty here
+    entities: {},
+    queries: {
+      // each query has its own map of query states, stored by cache key, which is generated from query params
+      getUser: {
+        "2": {
+          loading: false,
+          error: undefined,
+          result: {id: 2, bank: {id: "2", name: "Bank 2"}, name: "User 2"},
+          params: 2
+        },
+        "3": {loading: true, params: 3}
+      },
+      getUsers: {
+        // example of paginated state under custom cache key
+        "all-pages": {
+          loading: false,
+          result: {
+            items: [
+              {id: 0, bank: {id: "0", name: "Bank 0"}, name: "User 0 *"},
+              {id: 1, bank: {id: "1", name: "Bank 1"}, name: "User 1 *"},
+              {id: 2, bank: {id: "2", name: "Bank 2"}, name: "User 2"}
+            ],
+            page: 1
+          },
+          params: {page: 1}
         }
       }
+    },
+    mutations: {
+      // each mutation has its own state as well
+      updateUser: {
+        loading: false,
+        result: {id: 1, bank: {id: "1", name: "Bank 1"}, name: "User 1 *"},
+        params: {id: 1, name: "User 1 *"}
+      } 
     }
-  },
-  mutations: {
-    // each mutation has its own state as well
-    updateUser: {loading: false, result: {id: 1, bank: {id: "1", name: "Bank 1"}, name: "User 1 *"}} 
   }
-}
-```
+  ```
+</details>
     
 ### Table of contents
 
@@ -219,44 +248,49 @@ export const UserScreen = () => {
 
 ### Advanced
 
-#### resultSelector
-
-By default result of a query is stored under its **cache key**, but sometimes it makes sense to take result from other queries or normalized entities.
+#### Advanced cache policy & skip / fetch usage
 
-For example when single `User` entity is requested by `userId` for the first time, the entity can already be in the cache after `getUsers` query finished.
-
-For that case `resultSelector` can be used:
+`cache-first` cache policy skips fetching if result is already cached, but sometimes it can't determine that we already have result in some other's query result or in normalized entities cache. In that case we can use `skip` parameter of a query:
 
 ```typescript
+export const UserScreen = () => {
+  const user = useSelectEntityById(userId, 'users')
 
-// createCache
+  const [{loading, error}] = useQuery({
+    query: 'getUser',
+    params: userId,
+    skip: !!user // we skip fetching if we already have user cached by some other query, e.g. getUsers
+  })
 
-... = createCache({
   ...
-  queries: {
-    ...
-    getUser: {
-      query: getUser,
-      resultSelector: (state, id) => state.entities.users[id]?.id, // <-- Result is selected from cached entities
-    },
-  },
-})
+}
+```
+
+We can additional check that entity is full enough:
+
+```typescript
+  skip: !!user && isFullUser(user)
+```
 
-// component
+Other approach is to set `skip: true` and manually run `fetch` when needed:
 
+```typescript
 export const UserScreen = () => {
-  ...
+  const screenIsVisible = useScreenIsVisible()
 
-  // When screen mounts for the first time, query is not fetched
-  // and cached value is returned if user entity was already in the cache
-  const [{result, loading, error}] = useQuery({
+  const [{result, loading, error}, fetchUser] = useQuery({
     query: 'getUser',
     params: userId,
+    skip: true
   })
 
+  useEffect(() => {
+    if (screenIsVisible) {
+      fetchUser()
+    }
+  }, [screenIsVisible])
   ...
 }
-
 ```
 
 #### Infinite scroll pagination
@@ -295,11 +329,14 @@ Here is an example of `getUsers` query configuration with pagination support. Yo
 export const GetUsersScreen = () => {
   const {query} = useClient()
 
-  const [{result: usersResult, loading, error}, refetch] = useQuery({
+  const [{result: usersResult, loading, error, params}, refetch] = useQuery({
     query: 'getUsers',
     params: 1 // page
   })
 
+  const refreshing = loading && params === 1
+  const loadingNextPage = loading && !refreshing
+
   const onLoadNextPage = () => {
     const lastLoadedPage = usersResult?.page ?? 0
     query({
@@ -316,9 +353,14 @@ export const GetUsersScreen = () => {
 
   return (
     <div>
+      {refreshing && <div className="spinner" />}
       {usersResult?.items.map(renderUser)}
       <button onClick={refetch}>Refresh</button>
-      <button onClick={onLoadNextPage}>Load next page</button>
+      {loadingNextPage ? (
+        <div className="spinner" />
+      ) : (
+        <button onClick={loadNextPage}>Load next page</button>
+      )}
     </div>
   )
 }

package/dist/createActions.d.ts

@@ -1,23 +1,23 @@
 import type { EntityChanges, Key, QueryMutationState, Typenames } from './types';
-export type ActionMap<N extends string, T extends Typenames, QR, MR> = ReturnType<typeof createActions<N, T, QR, MR>>;
-export declare const createActions: <N extends string, T extends Typenames, QR, MR>(name: N) => {
+export type ActionMap<N extends string, T extends Typenames, QP, QR, MP, MR> = ReturnType<typeof createActions<N, T, QP, QR, MP, MR>>;
+export declare const createActions: <N extends string, T extends Typenames, QP, QR, MP, MR>(name: N) => {
     /** Updates query state, and optionally merges entity changes in a single action. */
     updateQueryStateAndEntities: {
-        <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: K;
             queryCacheKey: Key;
-            state: Partial<QueryMutationState<QR[K]>> | undefined;
+            state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
             entityChagnes: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateQueryStateAndEntities`;
     };
     /** Updates mutation state, and optionally merges entity changes in a single action. */
     updateMutationStateAndEntities: {
-        <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
+        <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: EntityChanges<T> | undefined): {
             type: `@rrc/${N}/updateMutationStateAndEntities`;
             mutationKey: K_1;
-            state: Partial<QueryMutationState<MR[K_1]>> | undefined;
+            state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
             entityChagnes: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -33,7 +33,7 @@ export declare const createActions: <N extends string, T extends Typenames, QR,
     /** Clear states for provided query keys and cache keys.
      * If cache key for query key is not provided, the whole state for query key is cleared. */
     clearQueryState: {
-        <K_2 extends keyof QR>(queryKeys: {
+        <K_2 extends keyof QP & keyof QR>(queryKeys: {
             key: K_2;
             cacheKey?: Key | undefined;
         }[]): {
@@ -47,7 +47,7 @@ export declare const createActions: <N extends string, T extends Typenames, QR,
     };
     /** Clear states for provided mutation keys. */
     clearMutationState: {
-        <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+        <K_3 extends keyof MP & keyof MR>(mutationKeys: K_3[]): {
             type: `@rrc/${N}/clearMutationState`;
             mutationKeys: K_3[];
         };

package/dist/createCache.d.ts

@@ -11,18 +11,18 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     /** Reducer of the cache, should be added to redux store. */
     reducer: (state: {
         entities: import("./types").EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+        queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: import("./types").Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+        mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
     } | undefined, action: {
         type: `@rrc/${N}/updateQueryStateAndEntities`;
-        queryKey: keyof QR;
+        queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
-        state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
+        state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
-        mutationKey: keyof MR;
-        state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
+        mutationKey: keyof MP & keyof MR;
+        state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
         entityChagnes: import("./types").EntityChanges<T> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
@@ -30,33 +30,33 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     } | {
         type: `@rrc/${N}/clearQueryState`;
         queryKeys: {
-            key: keyof QR;
+            key: keyof QP & keyof QR;
             cacheKey?: Key | undefined;
         }[];
     } | {
         type: `@rrc/${N}/clearMutationState`;
-        mutationKeys: (keyof MR)[];
+        mutationKeys: (keyof MP & keyof MR)[];
     }) => {
         entities: import("./types").EntitiesMap<T>;
-        queries: { [QK in keyof QR]: import("./types").Dict<QueryMutationState<QR[QK]>>; };
-        mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+        queries: QP | QR extends infer T_3 ? { [QK in keyof T_3]: import("./types").Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+        mutations: MP | MR extends infer T_4 ? { [MK in keyof T_4]: QueryMutationState<MP[MK], MR[MK]>; } : never;
     };
     actions: {
         updateQueryStateAndEntities: {
-            <K extends keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryMutationState<QP[K], QR[K]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
-                state: Partial<QueryMutationState<QR[K]>> | undefined;
+                state: Partial<QueryMutationState<QP[K], QR[K]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         updateMutationStateAndEntities: {
-            <K_1 extends keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
+            <K_1 extends keyof MP & keyof MR>(mutationKey: K_1, state?: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined, entityChagnes?: import("./types").EntityChanges<T> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K_1;
-                state: Partial<QueryMutationState<MR[K_1]>> | undefined;
+                state: Partial<QueryMutationState<MP[K_1], MR[K_1]>> | undefined;
                 entityChagnes: import("./types").EntityChanges<T> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -69,7 +69,7 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
             type: `@rrc/${N}/mergeEntityChanges`;
         };
         clearQueryState: {
-            <K_2 extends keyof QR>(queryKeys: {
+            <K_2 extends keyof QP & keyof QR>(queryKeys: {
                 key: K_2;
                 cacheKey?: Key | undefined;
             }[]): {
@@ -82,7 +82,7 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
             type: `@rrc/${N}/clearQueryState`;
         };
         clearMutationState: {
-            <K_3 extends keyof MR>(mutationKeys: K_3[]): {
+            <K_3 extends keyof MP & keyof MR>(mutationKeys: K_3[]): {
                 type: `@rrc/${N}/clearMutationState`;
                 mutationKeys: K_3[];
             };
@@ -91,21 +91,25 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     };
     selectors: {
         /** Selects query state. */
-        selectQueryState: <QK_1 extends keyof QR | keyof QP>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never> | undefined;
+        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => QueryMutationState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never> | undefined;
         /** Selects query latest result. */
-        selectQueryResult: <QK_2 extends keyof QR | keyof QP>(state: unknown, query: QK_2, cacheKey: Key) => (QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never) | undefined;
+        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 QR | keyof QP>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
+        selectQueryLoading: <QK_3 extends keyof QP | keyof QR>(state: unknown, query: QK_3, cacheKey: Key) => boolean | undefined;
         /** Selects query latest error. */
-        selectQueryError: <QK_4 extends keyof QR | keyof QP>(state: unknown, query: QK_4, cacheKey: Key) => Error | undefined;
+        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 mutation state. */
-        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => QueryMutationState<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => QueryMutationState<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;
         /** 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. */
@@ -116,18 +120,18 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     hooks: {
         /** Returns client object with query and mutate functions. */
         useClient: () => {
-            query: <QK_5 extends keyof QR | keyof QP>(options: Omit<QueryOptions<T, QP, QR, MR, QK_5>, "cachePolicy">) => Promise<QueryResult<QK_5 extends keyof QP & keyof QR ? QR[QK_5] : never>>;
-            mutate: <MK_5 extends keyof MP | keyof MR>(options: {
-                mutation: MK_5;
-                params: MK_5 extends keyof MP & keyof MR ? MP[MK_5] : never;
-            }) => Promise<MutationResult<MK_5 extends keyof MP & keyof MR ? MR[MK_5] : never>>;
+            query: <QK_6 extends keyof QP | keyof QR>(options: Omit<QueryOptions<T, QP, QR, QK_6>, "cachePolicy">) => Promise<QueryResult<QK_6 extends keyof QP & keyof QR ? QR[QK_6] : never>>;
+            mutate: <MK_6 extends keyof MP | keyof MR>(options: {
+                mutation: MK_6;
+                params: MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never;
+            }) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
         };
         /** Fetches query when params change and subscribes to query state. */
-        useQuery: <QK_6 extends keyof QR | keyof QP>(options: import("./types").UseQueryOptions<T, QP, QR, MR, QK_6>) => readonly [QueryMutationState<QK_6 extends keyof QP & keyof QR ? QR[QK_6] : never>, () => Promise<QueryResult<QK_6 extends infer T_1 ? T_1 extends QK_6 ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
+        useQuery: <QK_7 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_7>) => readonly [QueryMutationState<QK_7 extends keyof QP & keyof QR ? QP[QK_7] : never, QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>, () => Promise<QueryResult<QK_7 extends infer T_5 ? T_5 extends QK_7 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_6 extends keyof MP | keyof MR>(options: {
-            mutation: MK_6;
-        }) => readonly [(params: MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never) => Promise<MutationResult<MK_6 extends infer T_2 ? T_2 extends MK_6 ? T_2 extends keyof MP & keyof MR ? MR[T_2] : never : never : never>>, QueryMutationState<MK_6 extends keyof MP & keyof MR ? MP[MK_6] : never>, () => boolean];
+        useMutation: <MK_7 extends keyof MP | keyof MR>(options: {
+            mutation: MK_7;
+        }) => 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>>, QueryMutationState<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;
     };

package/dist/createCache.js

@@ -65,6 +65,11 @@ const createCache = (partialCache) => {
                 var _a;
                 return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.error;
             },
+            /** Selects query latest params. */
+            selectQueryParams: (state, query, cacheKey) => {
+                var _a;
+                return (_a = selectQueryState(state, query, cacheKey)) === null || _a === void 0 ? void 0 : _a.params;
+            },
             /** Selects mutation state. */
             selectMutationState,
             /** Selects mutation latest result. */
@@ -79,6 +84,10 @@ const createCache = (partialCache) => {
             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. */

package/dist/index.js

@@ -23,8 +23,8 @@ Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: fu
 Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true, get: function () { return utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE; } });
 // Backlog
 // ! high
-// add not optimized not normalized example, and not normalized state example to readme
-// try use skip for refreshing strategy?
+// useQuery refresh with params use as client.query?
+// update readme with how to use mergeResults for invalidating / updating caches?
 // optimistic response
 // make query key / cache key difference more clear in the docs, and/or rename queryKey -> query
 // ! medium
@@ -32,14 +32,12 @@ Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true,
 // type extractors from cache
 // custom useStore
 // return back deserialize selector?
-// resultSelector - return also boolean that result is full enough or make cache policy as a function
 // selector for entities by typename
 // callback option on error / success?
 // refetch queries on mutation success
 // remove query/mutation state when it finished without errors
 // deep equal entities while merging state
 // make error type generic
-// don't cache result if resultSelector set? throw error if mergeResult set with resultSelector?
 // ! low
 // access to currently loading queries and mutations?
 // add params to the state?

package/dist/mutate.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, MutationResult, Typenames } from './types';
-export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities }: Pick<ActionMap<N, T, QR, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
+export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateMutationStateAndEntities, }: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, mutationKey: MK, params: MK extends keyof MP & keyof MR ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;

package/dist/mutate.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mutate = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const mutate = (logTag, store, cache, { updateMutationStateAndEntities }, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
+const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutationKey, params, abortControllers) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -31,6 +31,7 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities }, mutati
         else {
             store.dispatch(updateMutationStateAndEntities(mutationKey, {
                 loading: true,
+                params,
                 result: undefined,
             }));
         }

package/dist/query.d.ts

@@ -1,4 +1,4 @@
 import { Store } from 'redux';
 import type { ActionMap } from './createActions';
 import type { Cache, Key, QueryResult, Typenames } from './types';
-export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities }: Pick<ActionMap<N, T, QR, MR>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, { updateQueryStateAndEntities, }: Pick<ActionMap<N, T, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -11,11 +11,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const query = (logTag, store, cache, { updateQueryStateAndEntities }, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
+const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey, cacheKey, params) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
     const logsEnabled = cache.options.logsEnabled;
     const cacheStateSelector = cache.cacheStateSelector;
-    const cacheResultSelector = cache.queries[queryKey].resultSelector;
     const mergeResults = cache.queries[queryKey].mergeResults;
     const queryStateOnStart = cacheStateSelector(store.getState()).queries[queryKey][cacheKey];
     if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
@@ -29,6 +28,7 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities }, queryKey,
     }
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
         loading: true,
+        params,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryStateOnStart, params, cacheKey });
     let response;
@@ -48,22 +48,16 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities }, queryKey,
     const newState = {
         error: undefined,
         loading: false,
-        result: cacheResultSelector
-            ? undefined
-            : mergeResults
-                ? mergeResults(
-                // @ts-expect-error fix later
-                (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params, store)
-                : response.result,
+        result: mergeResults
+            ? mergeResults(
+            // @ts-expect-error fix later
+            (_a = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _a === void 0 ? void 0 : _a.result, response, params, store)
+            : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
     return {
         // @ts-expect-error fix types
-        result: cacheResultSelector
-            ? cacheResultSelector(cacheStateSelector(store.getState()), 
-            // @ts-expect-error fix types
-            params)
-            : newState === null || newState === void 0 ? void 0 : newState.result,
+        result: newState === null || newState === void 0 ? void 0 : newState.result,
     };
 });
 exports.query = query;

package/dist/reducer.d.ts

@@ -1,20 +1,20 @@
 import type { ActionMap } from './createActions';
 import type { CacheOptions, Dict, EntitiesMap, QueryMutationState, Typenames } from './types';
-export type ReduxCacheState<T extends Typenames, QR, MR> = ReturnType<ReturnType<typeof createCacheReducer<string, T, QR, MR>>>;
-export declare const createCacheReducer: <N extends string, T extends Typenames, QR, MR>(actions: ActionMap<N, T, QR, MR>, typenames: T, queryKeys: (keyof QR)[], cacheOptions: CacheOptions) => (state: {
+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: {
     entities: EntitiesMap<T>;
-    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
-    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
 } | undefined, action: {
     type: `@rrc/${N}/updateQueryStateAndEntities`;
-    queryKey: keyof QR;
+    queryKey: keyof QP & keyof QR;
     queryCacheKey: import("./types").Key;
-    state: Partial<QueryMutationState<QR[keyof QR]>> | undefined;
+    state: Partial<QueryMutationState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/updateMutationStateAndEntities`;
-    mutationKey: keyof MR;
-    state: Partial<QueryMutationState<MR[keyof MR]>> | undefined;
+    mutationKey: keyof MP & keyof MR;
+    state: Partial<QueryMutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
     entityChagnes: import("./types").EntityChanges<T> | undefined;
 } | {
     type: `@rrc/${N}/mergeEntityChanges`;
@@ -22,14 +22,14 @@ export declare const createCacheReducer: <N extends string, T extends Typenames,
 } | {
     type: `@rrc/${N}/clearQueryState`;
     queryKeys: {
-        key: keyof QR;
+        key: keyof QP & keyof QR;
         cacheKey?: import("./types").Key | undefined;
     }[];
 } | {
     type: `@rrc/${N}/clearMutationState`;
-    mutationKeys: (keyof MR)[];
+    mutationKeys: (keyof MP & keyof MR)[];
 }) => {
     entities: EntitiesMap<T>;
-    queries: { [QK in keyof QR]: Dict<QueryMutationState<QR[QK]>>; };
-    mutations: { [MK in keyof MR]: QueryMutationState<MR[MK]>; };
+    queries: QP | QR extends infer T_1 ? { [QK in keyof T_1]: Dict<QueryMutationState<QP[QK], QR[QK]>>; } : never;
+    mutations: MP | MR extends infer T_2 ? { [MK in keyof T_2]: QueryMutationState<MP[MK], MR[MK]>; } : never;
 };

package/dist/types.d.ts

@@ -21,8 +21,10 @@ 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 typing and normalization.
-     * Empty objects with type casting can be used as values.
+    /**
+     * Mapping of all typenames to their entity types, which is needed for proper normalization. Can be empty If normalization 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`
@@ -30,14 +32,14 @@ export type Cache<N extends string, T extends Typenames, QP, QR, MP, MR> = {
     } */
     typenames: T;
     queries: {
-        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never;
+        [QK in keyof (QP & QR)]: QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK]> : never;
     };
     mutations: {
         [MK in keyof (MP & MR)]: MK extends keyof (MP | MR) ? MutationInfo<T, MP[MK], MR[MK]> : never;
     };
     options: CacheOptions;
     /** Should return cache state from redux root state. Default implementation returns `state[name]`. */
-    cacheStateSelector: (state: any) => ReduxCacheState<T, QR, MR>;
+    cacheStateSelector: (state: any) => ReduxCacheState<T, QP, QR, MP, MR>;
 };
 export type CacheOptions = {
     /**
@@ -61,19 +63,13 @@ export type EntityIds<T extends Typenames> = {
     [K in keyof T]?: Key[];
 };
 export type Query<T extends Typenames, P, R> = (params: P) => Promise<QueryResponse<T, R>>;
-export type QueryInfo<T extends Typenames, P, R, S> = {
+export type QueryInfo<T extends Typenames, P, R> = {
     query: Query<T, P, R>;
     /**
      * Cache policy.
      * @default cache-first
      */
     cachePolicy?: QueryCachePolicy;
-    /**
-     * Selector for query result from redux state.
-     * Can prevent hook from doing unnecessary fetches.
-     * Needed when query result may already be in the cache, e.g. for single entity query by id.
-     * */
-    resultSelector?: (state: S, params: P) => R | undefined;
     /** Merges results before saving to the store. Default implementation is using the latest result. */
     mergeResults?: (oldResult: R | undefined, response: QueryResponse<T, R>, params: P | undefined, store: Store) => R;
     /**
@@ -83,11 +79,11 @@ export type QueryInfo<T extends Typenames, P, R, S> = {
      * */
     getCacheKey?: (params?: P) => Key;
 };
-export type UseQueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (QP & QR)> = {
+export type UseQueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = {
     query: QK;
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
     skip?: boolean;
-} & Pick<QK extends keyof (QP | QR) ? QueryInfo<T, QP[QK], QR[QK], ReduxCacheState<T, QR, MR>> : never, 'cachePolicy'>;
+} & Pick<QueryInfo<T, unknown, unknown>, 'cachePolicy'>;
 /**
  * @param cache-first for each params key fetch is not called if cache exists.
  * @param cache-and-fetch for each params key result is taken from cache and fetch is called.
@@ -102,7 +98,7 @@ export type QueryResult<R> = {
     cancelled?: true;
     result?: R;
 };
-export type QueryOptions<T extends Typenames, QP, QR, MR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, MR, QK>, 'skip'>;
+export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, QK>, 'skip'>;
 export type Mutation<T extends Typenames, P, R> = (params: P, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;
@@ -118,11 +114,13 @@ export type MutationResult<R> = {
     aborted?: true;
     result?: R;
 };
-export type QueryMutationState<R> = {
+export type QueryMutationState<P, R> = {
     /** `true` when query or mutation is currently in progress. */
     loading: boolean;
     /** Result of the latest successfull response. */
     result?: R;
     /** Error of the latest response. */
     error?: Error;
+    /** Parameters of the latest request. */
+    params: P;
 };

package/dist/useMutation.d.ts

@@ -1,6 +1,6 @@
 import { Store } from 'redux';
 import { ActionMap } from './createActions';
 import { Cache, Key, QueryMutationState, Typenames } from './types';
-export declare const useMutation: <N extends string, T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<N, T, unknown, unknown, MP, MR>, actions: Pick<ActionMap<N, T, unknown, MR>, "updateMutationStateAndEntities">, options: {
+export declare const useMutation: <N extends string, T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<N, T, unknown, unknown, MP, MR>, actions: Pick<ActionMap<N, T, unknown, unknown, MP, MR>, "updateMutationStateAndEntities">, options: {
     mutation: MK;
-}, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<import("./types").MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+}, abortControllers: WeakMap<Store, Record<Key, AbortController>>) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<import("./types").MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useQuery.d.ts

@@ -1,3 +1,3 @@
 import { ActionMap } from './createActions';
 import { Cache, QueryMutationState, Typenames, UseQueryOptions } from './types';
-export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QR, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<import("./types").QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
+export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Pick<ActionMap<N, T, QP, QR, MP, MR>, "updateQueryStateAndEntities">, options: UseQueryOptions<T, QP, QR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<import("./types").QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];

package/dist/useQuery.js

@@ -19,32 +19,18 @@ const useQuery = (cache, actions, options) => {
     const { query: queryKey, skip, params, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', } = options;
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
-    const cacheResultSelector = cache.queries[queryKey].resultSelector;
     const cacheStateSelector = cache.cacheStateSelector;
     const store = (0, react_redux_1.useStore)();
     // @ts-expect-error fix types later
     const cacheKey = getCacheKey(params);
-    const resultSelector = (0, react_1.useMemo)(() => {
-        return (cacheResultSelector &&
-            ((state) => cacheResultSelector(cacheStateSelector(state), 
-            // @ts-expect-error fix types later
-            params)));
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [cacheKey]);
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    const resultFromSelector = (resultSelector && (0, react_redux_1.useSelector)(resultSelector));
-    const hasResultFromSelector = resultFromSelector !== undefined;
     const fetch = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
         return yield (0, query_1.query)('useQuery.fetch', store, cache, actions, queryKey, cacheKey, params);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }), [store, queryKey, cacheKey]);
-    const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {
+    const queryState = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
     })) !== null && _c !== void 0 ? _c : utilsAndConstants_1.DEFAULT_QUERY_MUTATION_STATE;
-    const queryState = hasResultFromSelector
-        ? (Object.assign(Object.assign({}, queryStateFromSelector), { result: resultFromSelector }))
-        : queryStateFromSelector;
     (0, react_1.useEffect)(() => {
         if (skip) {
             logsEnabled && (0, utilsAndConstants_1.log)('useQuery.useEffect skip fetch', { skip, cacheKey });
@@ -65,7 +51,6 @@ const useQuery = (cache, actions, options) => {
         (0, utilsAndConstants_1.log)('useQuery', {
             cacheKey,
             options,
-            resultFromSelector,
             queryState,
         });
     return [

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Powerful data fetching and caching library that supports normalization, built on top of redux",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",