react-redux-cache 0.16.1 → 0.18.0

package/README.md

@@ -9,7 +9,7 @@
 
 # react-redux-cache (RRC)
 
-### Supports both `Redux` and `Zustand`
+### Supports both `Redux` and `Zustand` (check /example)
 
 **Powerful**, **performant** yet **lightweight** data fetching and caching library that supports **normalization** unlike `React Query` and `RTK-Query`, while having similar but not over-engineered, simple interface. Another advantage over `RTK-Query` is that it **doesn't use Immer** ([perf issue](https://github.com/reduxjs/redux-toolkit/issues/4793)). Covered with tests, fully typed and written on Typescript.
 
@@ -44,11 +44,11 @@ Examples of states, generated by cache reducer from `/example` project:
       // each query has its own map of query states, stored by cache key, which is generated from query params
       getUser: {
         "2": {result: 2, params: 2, expiresAt: 1727217298025},
-        "3": {loading: true, params: 3}
+        "3": {loading: Promise<...>, params: 3}
       },
       getUsers: {
         // example of paginated state under custom cache key
-        "all-pages": {
+        "feed": {
           result: {items: [0,1,2], page: 1},
           params: {page: 1}
         }
@@ -82,11 +82,11 @@ Examples of states, generated by cache reducer from `/example` project:
           params: 2,
           expiresAt: 1727217298025
         },
-        "3": {loading: true, params: 3}
+        "3": {loading: Promise<...>, params: 3}
       },
       getUsers: {
         // example of paginated state under custom cache key
-        "all-pages": {
+        "feed": {
           result: {
             items: [
               {id: 0, bank: {id: "0", name: "Bank 0"}, name: "User 0 *"},
@@ -137,13 +137,13 @@ Examples of states, generated by cache reducer from `/example` project:
 
 ```sh
 # required
-npm add react-redux-cache react
+npm i react-redux-cache react
 
 # without react-redux
-npm add react-redux-cache react fast-deep-equal
+npm i react-redux-cache react fast-deep-equal
 
 # all required and optional peers
-npm add react-redux-cache react react-redux fast-deep-equal
+npm i react-redux-cache react react-redux fast-deep-equal
 ```
 
 ### Initialization
@@ -221,15 +221,13 @@ const store = configureStore({
 Zustand:
 ```typescript
 type State = {[cache.name]: ReturnType<typeof reducer>}
-type Actions = {dispatch: (action: CacheAction) => void}
-type CacheAction = Parameters<typeof reducer>[1]
+type Actions = {dispatch: (action: Parameters<typeof reducer>[1]) => void}
+
+const initialState = {[cache.name]: getInitialState()}
 
 export const useStore = create<State & Actions>((set, get) => ({
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  [cache.name]: reducer(undefined, {} as any),
-  dispatch: (action: CacheAction) => {
-    set({cache: reducer(get().cache, action)})
-  },
+  ...initialState,
+  dispatch: (action) => set({[cache.name]: reducer(get()[cache.name], action)}),
 }))
 
 const store = {dispatch: useStore.getState().dispatch, getState: useStore.getState}
@@ -272,7 +270,7 @@ export const removeUser = (async (id, _, abortSignal) => {
 
 ### Usage
 
-Please check `example/` folder (`npm run example` to run).
+Please check `example/` folder (`npm run example` to run). There are examples for both Redux and Zustand.
 
 #### UserScreen.tsx
 ```typescript
@@ -306,7 +304,7 @@ export const UserScreen = () => {
 
 #### Error handling
 
-Queries and mutations are wrapped in try/catch, so any error will lead to cancelling of any updates to the state except `loading: false` and the caught error. If you still want to make some state updates, or just want to use thrown errors only for unexpected cases, consider returning expected errors as a part of the result:
+Queries and mutations are wrapped in try/catch, so any error will lead to cancelling of any updates to the state except loading state and the caught error. If you still want to make some state updates, or just want to use thrown errors only for unexpected cases, consider returning expected errors as a part of the result:
 
 ```typescript
 export const updateBank = (async (bank) => {
@@ -433,7 +431,7 @@ Here is an example of `getUsers` query configuration with pagination support. Yo
   queries: {
     getUsers: {
       query: getUsers,
-      getCacheKey: () => 'all-pages', // single cache key is used for all pages
+      getCacheKey: () => 'feed', // single cache key is used for all pages
       mergeResults: (oldResult, {result: newResult}) => {
         if (!oldResult || newResult.page === 1) {
           return newResult
@@ -441,7 +439,7 @@ Here is an example of `getUsers` query configuration with pagination support. Yo
         if (newResult.page === oldResult.page + 1) {
           return {
             ...newResult,
-            items: [...oldResult.items, ...newResult.items],
+            items: oldResult.items.concat(newResult.items),
           }
         }
         return oldResult

package/dist/createActions.d.ts

@@ -3,20 +3,20 @@ import { CacheState } from './types';
 export type Actions<N extends string = string, T extends Typenames = Typenames, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = 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) => {
     updateQueryStateAndEntities: {
-        <K extends keyof (QP | QR)>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<QP[K], QR[K]>>, entityChanges?: EntityChanges<T>): {
+        <K extends keyof (QP | QR)>(queryKey: K, queryCacheKey: Key, state?: Partial<QueryState<T, QP[K], QR[K]>>, entityChanges?: EntityChanges<T>): {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: K;
             queryCacheKey: Key;
-            state: Partial<QueryState<QP[K], QR[K]>> | undefined;
+            state: Partial<QueryState<T, QP[K], QR[K]>> | undefined;
             entityChanges: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateQueryStateAndEntities`;
     };
     updateMutationStateAndEntities: {
-        <K extends keyof (MP | MR)>(mutationKey: K, state?: Partial<MutationState<MP[K], MR[K]>>, entityChanges?: EntityChanges<T>): {
+        <K extends keyof (MP | MR)>(mutationKey: K, state?: Partial<MutationState<T, MP[K], MR[K]>>, entityChanges?: EntityChanges<T>): {
             type: `@rrc/${N}/updateMutationStateAndEntities`;
             mutationKey: K;
-            state: Partial<MutationState<MP[K], MR[K]>> | undefined;
+            state: Partial<MutationState<T, MP[K], MR[K]>> | undefined;
             entityChanges: EntityChanges<T> | undefined;
         };
         type: `@rrc/${N}/updateMutationStateAndEntities`;

package/dist/createCache.d.ts

@@ -21,12 +21,12 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             type: `@rrc/${N}/updateQueryStateAndEntities`;
             queryKey: keyof QP & keyof QR;
             queryCacheKey: Key;
-            state: Partial<import("./types").QueryState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
+            state: Partial<import("./types").QueryState<T, 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<import("./types").MutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
+            state: Partial<import("./types").MutationState<T, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
             entityChanges: import("./types").EntityChanges<T> | undefined;
         } | {
             type: `@rrc/${N}/mergeEntityChanges`;
@@ -54,21 +54,21 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
         actions: {
             /** Updates query state, and optionally merges entity changes in a single action. */
             updateQueryStateAndEntities: {
-                <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+                <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryState<T, QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
                     type: `@rrc/${N}/updateQueryStateAndEntities`;
                     queryKey: K;
                     queryCacheKey: Key;
-                    state: Partial<import("./types").QueryState<QP[K], QR[K]>> | undefined;
+                    state: Partial<import("./types").QueryState<T, QP[K], QR[K]>> | undefined;
                     entityChanges: import("./types").EntityChanges<T> | undefined;
                 };
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
             };
             /** Updates mutation state, and optionally merges entity changes in a single action. */
             updateMutationStateAndEntities: {
-                <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<import("./types").MutationState<MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
+                <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<import("./types").MutationState<T, MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<T> | undefined): {
                     type: `@rrc/${N}/updateMutationStateAndEntities`;
                     mutationKey: K;
-                    state: Partial<import("./types").MutationState<MP[K], MR[K]>> | undefined;
+                    state: Partial<import("./types").MutationState<T, MP[K], MR[K]>> | undefined;
                     entityChanges: import("./types").EntityChanges<T> | undefined;
                 };
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -133,11 +133,11 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
             selectCacheState: (state: any) => import("./types").CacheState<T, QP, QR, MP, MR>;
             /** Selects query state. */
-            selectQueryState: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => import("./types").QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>;
+            selectQueryState: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => import("./types").QueryState<T, QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>;
             /** Selects query latest result. */
             selectQueryResult: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined;
             /** Selects query loading state. */
-            selectQueryLoading: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => boolean;
+            selectQueryLoading: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => false | Promise<import("./types").NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>;
             /** Selects query latest error. */
             selectQueryError: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => Error | undefined;
             /** Selects query latest params. */
@@ -145,11 +145,11 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             /** Selects query latest expiresAt. */
             selectQueryExpiresAt: <QK extends keyof QP | keyof QR>(state: unknown, query: QK, cacheKey: Key) => number | undefined;
             /** Selects mutation state. */
-            selectMutationState: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => import("./types").MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MR[MK] : never>;
+            selectMutationState: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => import("./types").MutationState<T, MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MR[MK] : never>;
             /** Selects mutation latest result. */
             selectMutationResult: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined;
             /** Selects mutation loading state. */
-            selectMutationLoading: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => boolean;
+            selectMutationLoading: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => false | Promise<import("./types").NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>;
             /** Selects mutation latest error. */
             selectMutationError: <MK extends keyof MP | keyof MR>(state: unknown, mutation: MK) => Error | undefined;
             /** Selects mutation latest params. */
@@ -168,13 +168,15 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
                 mutate: <MK extends keyof (MP & MR)>(options: MutateOptions<N, T, QP, QR, MP, MR, MK>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
             };
             /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-            useQuery: <QK extends keyof (QP & QR)>(options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[3]) => readonly [Omit<import("./types").QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, T, QP, QR, QK, MP, MR>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
+            useQuery: <QK extends keyof (QP & QR)>(options: Parameters<typeof useQuery<N, T, QP, QR, MP, MR, QK>>[3]) => readonly [Omit<import("./types").QueryState<T, QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, T, QP, QR, QK, MP, MR>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK extends infer T_1 ? T_1 extends QK ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>];
             /** Subscribes to provided mutation state and provides mutate function. */
-            useMutation: <MK extends keyof (MP & MR)>(options: Parameters<typeof useMutation<N, T, QP, QR, MP, MR, MK>>[3]) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, import("./types").MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+            useMutation: <MK extends keyof (MP & MR)>(options: Parameters<typeof useMutation<N, T, QP, QR, MP, MR, MK>>[3]) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<MutationResult<MK extends infer T_1 ? T_1 extends MK ? T_1 extends keyof MP & keyof MR ? MR[T_1] : never : never : never>>, import("./types").MutationState<T, MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
             /** useSelector + selectEntityById. */
             useSelectEntityById: <TN extends keyof T>(id: Key | null | undefined, typename: TN) => T[TN] | undefined;
         };
         utils: {
+            /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
+            getInitialState: () => import("./types").CacheState<T, QP, QR, MP, MR>;
             /** Apply changes to the entities map.
              * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
             applyEntityChanges: (entities: Parameters<typeof applyEntityChanges<T>>[0], changes: Parameters<typeof applyEntityChanges<T>>[1]) => import("./types").EntitiesMap<T> | undefined;
@@ -203,12 +205,12 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
         type: `@rrc/${N}/updateQueryStateAndEntities`;
         queryKey: keyof QP & keyof QR;
         queryCacheKey: Key;
-        state: Partial<import("./types").QueryState<QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
+        state: Partial<import("./types").QueryState<Typenames, QP[keyof QP & keyof QR], QR[keyof QP & keyof QR]>> | undefined;
         entityChanges: import("./types").EntityChanges<Typenames> | undefined;
     } | {
         type: `@rrc/${N}/updateMutationStateAndEntities`;
         mutationKey: keyof MP & keyof MR;
-        state: Partial<import("./types").MutationState<MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
+        state: Partial<import("./types").MutationState<Typenames, MP[keyof MP & keyof MR], MR[keyof MP & keyof MR]>> | undefined;
         entityChanges: import("./types").EntityChanges<Typenames> | undefined;
     } | {
         type: `@rrc/${N}/mergeEntityChanges`;
@@ -236,21 +238,21 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
     actions: {
         /** Updates query state, and optionally merges entity changes in a single action. */
         updateQueryStateAndEntities: {
-            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryState<QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
+            <K extends keyof QP & keyof QR>(queryKey: K, queryCacheKey: Key, state?: Partial<import("./types").QueryState<Typenames, QP[K], QR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
                 type: `@rrc/${N}/updateQueryStateAndEntities`;
                 queryKey: K;
                 queryCacheKey: Key;
-                state: Partial<import("./types").QueryState<QP[K], QR[K]>> | undefined;
+                state: Partial<import("./types").QueryState<Typenames, QP[K], QR[K]>> | undefined;
                 entityChanges: import("./types").EntityChanges<Typenames> | undefined;
             };
             type: `@rrc/${N}/updateQueryStateAndEntities`;
         };
         /** Updates mutation state, and optionally merges entity changes in a single action. */
         updateMutationStateAndEntities: {
-            <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<import("./types").MutationState<MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
+            <K extends keyof MP & keyof MR>(mutationKey: K, state?: Partial<import("./types").MutationState<Typenames, MP[K], MR[K]>> | undefined, entityChanges?: import("./types").EntityChanges<Typenames> | undefined): {
                 type: `@rrc/${N}/updateMutationStateAndEntities`;
                 mutationKey: K;
-                state: Partial<import("./types").MutationState<MP[K], MR[K]>> | undefined;
+                state: Partial<import("./types").MutationState<Typenames, MP[K], MR[K]>> | undefined;
                 entityChanges: import("./types").EntityChanges<Typenames> | undefined;
             };
             type: `@rrc/${N}/updateMutationStateAndEntities`;
@@ -315,11 +317,11 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
         /** This is a cacheStateSelector from createCache options, or default one if was not provided. */
         selectCacheState: (state: any) => import("./types").CacheState<Typenames, QP, QR, MP, MR>;
         /** Selects query state. */
-        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => import("./types").QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>;
+        selectQueryState: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => import("./types").QueryState<Typenames, 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_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => (QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never) | undefined;
         /** Selects query loading state. */
-        selectQueryLoading: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => boolean;
+        selectQueryLoading: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => false | Promise<import("./types").NormalizedQueryResponse<Typenames, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>;
         /** Selects query latest error. */
         selectQueryError: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => Error | undefined;
         /** Selects query latest params. */
@@ -327,11 +329,11 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
         /** Selects query latest expiresAt. */
         selectQueryExpiresAt: <QK_1 extends keyof QP | keyof QR>(state: unknown, query: QK_1, cacheKey: Key) => number | undefined;
         /** Selects mutation state. */
-        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => import("./types").MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>;
+        selectMutationState: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => import("./types").MutationState<Typenames, 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_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => (MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never) | undefined;
         /** Selects mutation loading state. */
-        selectMutationLoading: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => boolean;
+        selectMutationLoading: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => false | Promise<import("./types").NormalizedQueryResponse<Typenames, MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
         /** Selects mutation latest error. */
         selectMutationError: <MK_1 extends keyof MP | keyof MR>(state: unknown, mutation: MK_1) => Error | undefined;
         /** Selects mutation latest params. */
@@ -350,13 +352,15 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
             mutate: <MK_1 extends keyof MP | keyof MR>(options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
         };
         /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-        useQuery: <QK_1 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>) => readonly [Omit<import("./types").QueryState<QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_1 extends infer T ? T extends QK_1 ? T extends keyof QP & keyof QR ? QR[T] : never : never : never>>];
+        useQuery: <QK_1 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<N, Typenames, QK_1, QP, QR, MP, MR>) => readonly [Omit<import("./types").QueryState<Typenames, QK_1 extends keyof QP & keyof QR ? QP[QK_1] : never, QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_1 extends infer T ? T extends QK_1 ? T extends keyof QP & keyof QR ? QR[T] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_1 extends keyof MP | keyof MR>(options: Omit<MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>, "params">) => readonly [(params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) => Promise<MutationResult<MK_1 extends infer T ? T extends MK_1 ? T extends keyof MP & keyof MR ? MR[T] : never : never : never>>, import("./types").MutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never>, () => boolean];
+        useMutation: <MK_1 extends keyof MP | keyof MR>(options: Omit<MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>, "params">) => readonly [(params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) => Promise<MutationResult<MK_1 extends infer T ? T extends MK_1 ? T extends keyof MP & keyof MR ? MR[T] : never : never : never>>, import("./types").MutationState<Typenames, MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never, MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never>, () => boolean];
         /** useSelector + selectEntityById. */
         useSelectEntityById: <TN extends string>(id: Key | null | undefined, typename: TN) => object | undefined;
     };
     utils: {
+        /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
+        getInitialState: () => import("./types").CacheState<Typenames, QP, QR, MP, MR>;
         /** Apply changes to the entities map.
          * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
         applyEntityChanges: (entities: import("./types").EntitiesMap<Typenames>, changes: import("./types").EntityChanges<Typenames>) => import("./types").EntitiesMap<Typenames> | undefined;

package/dist/createCache.js

@@ -58,11 +58,13 @@ const withTypenames = () => {
             // actions
             const actions = (0, createActions_1.createActions)(cache.name);
             const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, clearCache, } = actions;
+            // reducer
+            const reducer = (0, createCacheReducer_1.createCacheReducer)(actions, Object.keys(cache.queries), cache.options);
             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),
+                reducer,
                 actions: {
                     /** Updates query state, and optionally merges entity changes in a single action. */
                     updateQueryStateAndEntities,
@@ -147,6 +149,11 @@ const withTypenames = () => {
                     },
                 },
                 utils: {
+                    /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
+                    getInitialState: () => {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        return reducer(undefined, utilsAndConstants_1.EMPTY_OBJECT);
+                    },
                     /** Apply changes to the entities map.
                      * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
                     applyEntityChanges: (entities, changes) => {

package/dist/createCacheReducer.js

@@ -13,8 +13,19 @@ var __rest = (this && this.__rest) || function (s, e) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCacheReducer = void 0;
 const utilsAndConstants_1 = require("./utilsAndConstants");
-const optionalQueryKeys = ['error', 'expiresAt', 'result', 'params'];
-const optionalMutationKeys = ['error', 'result', 'params'];
+const optionalQueryKeys = [
+    'error',
+    'expiresAt',
+    'result',
+    'params',
+    'loading',
+];
+const optionalMutationKeys = [
+    'error',
+    'result',
+    'params',
+    'loading',
+];
 const createCacheReducer = (actions, queryKeys, cacheOptions) => {
     const initialState = Object.freeze({
         entities: Object.freeze({}),
@@ -82,9 +93,6 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                             delete newMutationState[key];
                         }
                     }
-                    if ('loading' in newMutationState && !newMutationState.loading) {
-                        delete newMutationState.loading;
-                    }
                     // skip if new state deep equals to the old state
                     if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldMutationState !== null && oldMutationState !== void 0 ? oldMutationState : utilsAndConstants_1.EMPTY_OBJECT, newMutationState)) {
                         newMutationState = undefined;

package/dist/createSelectors.d.ts

@@ -1,15 +1,15 @@
 import { Cache, Key, MutationState, QueryState, Typenames } from './types';
 export type Selectors<N extends string = string, T extends Typenames = Typenames, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = ReturnType<typeof createSelectors<N, T, QP, QR, MP, MR>>;
 export declare const createSelectors: <N extends string, T extends Typenames, QP, QR, MP, MR>(cache: Cache<N, T, QP, QR, MP, MR>) => {
-    selectQueryState: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => QueryState<QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>;
+    selectQueryState: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => QueryState<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>;
     selectQueryResult: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QR[QK] : never) | undefined;
-    selectQueryLoading: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => boolean;
+    selectQueryLoading: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => false | Promise<import("./types").NormalizedQueryResponse<T, QK extends keyof QP & keyof QR ? QR[QK] : never>>;
     selectQueryError: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => Error | undefined;
     selectQueryParams: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => (QK extends keyof QP & keyof QR ? QP[QK] : never) | undefined;
     selectQueryExpiresAt: <QK extends keyof (QP & QR)>(state: unknown, query: QK, cacheKey: Key) => number | undefined;
-    selectMutationState: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => MutationState<MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>;
+    selectMutationState: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => MutationState<T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>;
     selectMutationResult: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MR[MK] : never) | undefined;
-    selectMutationLoading: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => boolean;
+    selectMutationLoading: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => false | Promise<import("./types").NormalizedQueryResponse<T, MK extends keyof MP & keyof MR ? MR[MK] : never>>;
     selectMutationError: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => Error | undefined;
     selectMutationParams: <MK extends keyof (MP & MR)>(state: unknown, mutation: MK) => (MK extends keyof MP & keyof MR ? MP[MK] : never) | undefined;
     selectEntityById: <TN extends keyof T>(state: unknown, id: Key | null | undefined, typename: TN) => T[TN] | undefined;

package/dist/index.js

@@ -26,9 +26,13 @@ Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: fu
 Object.defineProperty(exports, "FetchPolicy", { enumerable: true, get: function () { return utilsAndConstants_1.FetchPolicy; } });
 Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: function () { return utilsAndConstants_1.isEmptyObject; } });
 // Backlog
+// highest
+// generate full api docs
+// cancel all queries / mutations
+// selectors optional cache key
 // ! high (1.0.0-rc.0)
 // optimistic response
-// generate full api docs
+// features list
 // ! medium
 // onCancel & onAbort
 // remove empty entities and queries from state

package/dist/mutate.js

@@ -30,23 +30,22 @@ const mutate = (logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_
         if (abortController !== undefined) {
             abortController.abort();
         }
-        else {
-            store.dispatch(updateMutationStateAndEntities(mutationKey, {
-                loading: true,
-                params,
-                result: undefined,
-            }));
-        }
     }
     const abortController = new AbortController();
     abortControllersOfStore[mutationKey] = abortController;
+    const mutatePromise = cache.mutations[mutationKey].mutation(
+    // @ts-expect-error fix later
+    params, store, abortController.signal);
+    store.dispatch(updateMutationStateAndEntities(mutationKey, {
+        // @ts-expect-error TODO fix types
+        loading: mutatePromise,
+        params,
+        result: undefined,
+    }));
     let response;
     let error;
-    const fetchFn = cache.mutations[mutationKey].mutation;
     try {
-        response = yield fetchFn(
-        // @ts-expect-error fix later
-        params, store, abortController.signal);
+        response = yield mutatePromise;
     }
     catch (e) {
         error = e;
@@ -64,7 +63,7 @@ const mutate = (logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_
     if (error) {
         store.dispatch(updateMutationStateAndEntities(mutationKey, {
             error: error,
-            loading: false,
+            loading: undefined,
         }));
         // @ts-expect-error params
         if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store, actions, selectors))) {
@@ -80,7 +79,7 @@ const mutate = (logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_
     if (response) {
         const newState = {
             error: undefined,
-            loading: false,
+            loading: undefined,
             result: response.result,
         };
         store.dispatch(updateMutationStateAndEntities(mutationKey, newState, response));

package/dist/query.js

@@ -10,53 +10,69 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
+const cache_1 = require("./testing/redux/cache");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const query = (logTag, store, cache, actions, selectors, queryKey, cacheKey, params, secondsToLive, onlyIfExpired, mergeResults, onCompleted, onSuccess, onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d;
     if (secondsToLive === void 0) { secondsToLive = (_a = cache.queries[queryKey].secondsToLive) !== null && _a !== void 0 ? _a : cache.globals.queries.secondsToLive; }
     if (mergeResults === void 0) { mergeResults = cache.queries[queryKey].mergeResults; }
     if (onCompleted === void 0) { onCompleted = cache.queries[queryKey].onCompleted; }
     if (onSuccess === void 0) { onSuccess = cache.queries[queryKey].onSuccess; }
     if (onError === void 0) { onError = cache.queries[queryKey].onError; }
+    const { selectQueryResult } = selectors;
     const logsEnabled = cache.options.logsEnabled;
-    const cacheStateSelector = cache.cacheStateSelector;
-    const queryStateOnStart = cacheStateSelector(store.getState()).queries[queryKey][cacheKey];
+    const queryStateOnStart = (0, cache_1.selectQueryState)(store.getState(), 
+    // @ts-expect-error TODO fix types
+    queryKey, cacheKey);
     if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
         logsEnabled &&
-            (0, utilsAndConstants_1.log)(`${logTag} cancelled: already loading`, {
+            (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: already loading`, {
                 queryStateOnStart,
                 params,
                 cacheKey,
             });
-        return CANCELLED_RESULT;
+        const error = yield queryStateOnStart.loading.then(utilsAndConstants_1.NOOP).catch(catchAndReturn);
+        return error
+            ? {
+                cancelled: 'loading',
+                error,
+            }
+            : {
+                cancelled: 'loading',
+                result: selectQueryResult(store.getState(), queryKey, cacheKey),
+            };
     }
     if (onlyIfExpired && (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.expiresAt) != null && queryStateOnStart.expiresAt > Date.now()) {
         logsEnabled &&
-            (0, utilsAndConstants_1.log)(`${logTag} cancelled: not expired yet`, {
+            (0, utilsAndConstants_1.log)(`${logTag} fetch cancelled: not expired yet`, {
                 queryStateOnStart,
                 params,
                 cacheKey,
                 onlyIfExpired,
             });
-        return CANCELLED_RESULT;
+        return {
+            cancelled: 'not-expired',
+            // @ts-expect-error TODO fix types
+            result: queryStateOnStart.result,
+        };
     }
     const { updateQueryStateAndEntities } = actions;
+    const fetchPromise = cache.queries[queryKey].query(
+    // @ts-expect-error fix later
+    params, store);
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
-        loading: true,
+        loading: fetchPromise,
         params,
     }));
     logsEnabled && (0, utilsAndConstants_1.log)(`${logTag} started`, { queryKey, params, cacheKey, queryStateOnStart, onlyIfExpired });
     let response;
-    const fetchFn = cache.queries[queryKey].query;
     try {
-        response = yield fetchFn(
-        // @ts-expect-error fix later
-        params, store);
+        response = yield fetchPromise;
     }
     catch (error) {
         store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
             error: error,
-            loading: false,
+            loading: undefined,
         }));
         // @ts-expect-error params
         if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
@@ -71,12 +87,12 @@ const query = (logTag, store, cache, actions, selectors, queryKey, cacheKey, par
     }
     const newState = {
         error: undefined,
-        loading: false,
+        loading: undefined,
         expiresAt: (_d = response.expiresAt) !== null && _d !== void 0 ? _d : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : undefined),
         result: mergeResults
             ? mergeResults(
             // @ts-expect-error fix later
-            (_e = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _e === void 0 ? void 0 : _e.result, response, params, store, actions, selectors)
+            selectQueryResult(store.getState(), queryKey, cacheKey), response, params, store, actions, selectors)
             : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
@@ -92,4 +108,4 @@ const query = (logTag, store, cache, actions, selectors, queryKey, cacheKey, par
     };
 });
 exports.query = query;
-const CANCELLED_RESULT = Object.freeze({ cancelled: true });
+const catchAndReturn = (x) => x;

package/dist/types.d.ts

@@ -53,7 +53,7 @@ export type Globals<N extends string, T extends Typenames, QP, QR, MP, MR> = {
         /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
          * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
          * @Default FetchPolicy.NoCacheOrExpired */
-        fetchPolicy: (expired: boolean, params: unknown, state: QueryState<unknown, unknown>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
+        fetchPolicy: (expired: boolean, params: unknown, state: QueryState<T, unknown, unknown>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
         /** Disables any fetches when set to true. Triggers fetch when changed to false. @Default false */
         skipFetch: boolean;
         /** If set, this value updates expiresAt value of query state when query result is received. @Default undefined */
@@ -85,10 +85,10 @@ export type EntityIds<T extends Typenames> = {
 export type CacheState<T extends Typenames, QP, QR, MP, MR> = {
     entities: EntitiesMap<T>;
     queries: {
-        [QK in keyof (QP | QR)]: Dict<QueryState<QP[QK], QR[QK]> | undefined>;
+        [QK in keyof (QP | QR)]: Dict<QueryState<T, QP[QK], QR[QK]> | undefined>;
     };
     mutations: {
-        [MK in keyof (MP | MR)]: MutationState<MP[MK], MR[MK]>;
+        [MK in keyof (MP | MR)]: MutationState<T, MP[MK], MR[MK]>;
     };
 };
 export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Partial<Pick<Globals<N, T, QP, QR, MP, MR>['queries'], 'skipFetch' | 'secondsToLive'>> & {
@@ -96,7 +96,7 @@ export type QueryInfo<N extends string, T extends Typenames = Typenames, P = unk
     /** Determines when useQuery fetch triggers should start fetching. Fetch is performed if function returns true.
      * Fetch triggers are: 1) mount 2) cache key change 3) skipFetch value change to false.
      * @Default FetchPolicy.NoCacheOrExpired */
-    fetchPolicy?: (expired: boolean, params: P, queryState: QueryState<P, R>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
+    fetchPolicy?: (expired: boolean, params: P, queryState: QueryState<T, P, R>, store: Store, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean;
     /** Merges results before saving to the store. Default implementation is using the latest result. */
     mergeResults?: (oldResult: R | undefined, response: NormalizedQueryResponse<T, R>, params: P | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => R;
     /**
@@ -118,7 +118,12 @@ params: P,
 /** Store */
 store: Store) => Promise<QueryResponse<R>>;
 export type NormalizedQuery<T extends Typenames = Typenames, P = unknown, R = unknown> = (...args: Parameters<Query<P, R>>) => Promise<NormalizedQueryResponse<T, R>>;
-export type QueryState<P, R> = MutationState<P, R> & {
+export type QueryState<T extends Typenames, P, R> = MutationState<T, P, R> & {
+    /**
+     * Timestamp in milliseconds, after which state is considered expired.
+     * Hooks may refetch the query again when component mounts, cache key or skip option change, depending on the fetch policy.
+     * Client query calls also start making fetch if onlyIfExpired argument is truthy.
+     * */
     expiresAt?: number;
 };
 export type UseQueryOptions<N extends string, T extends Typenames, QK extends keyof (QP & QR), QP, QR, MP, MR> = {
@@ -137,7 +142,8 @@ export type QueryResponse<R = unknown> = {
 export type NormalizedQueryResponse<T extends Typenames = Typenames, R = unknown> = EntityChanges<T> & QueryResponse<R>;
 export type QueryResult<R = unknown> = {
     error?: unknown;
-    cancelled?: true;
+    /** Fetch cancelled reason. */
+    cancelled?: 'loading' | 'not-expired';
     result?: R;
 };
 export type MutationInfo<N extends string, T extends Typenames = Typenames, P = unknown, R = unknown, QP = unknown, QR = unknown, MP = unknown, MR = unknown> = Pick<QueryInfo<N, T, P, R, QP, QR, MP, MR>, 'onCompleted' | 'onSuccess' | 'onError'> & {
@@ -164,9 +170,9 @@ export type MutationResult<R = unknown> = {
     aborted?: true;
     result?: R;
 };
-export type MutationState<P, R> = {
-    /** `true` when fetch is currently in progress. */
-    loading?: boolean;
+export type MutationState<T extends Typenames, P, R> = {
+    /** Set when fetch is currently in progress. */
+    loading?: Promise<NormalizedQueryResponse<T, R>>;
     /** Result of the latest successfull response. */
     result?: R;
     /** Error of the latest response. */

package/dist/useMutation.d.ts

@@ -1,4 +1,4 @@
 import { Actions } from './createActions';
 import { Selectors } from './createSelectors';
 import { Cache, Key, MutateOptions, MutationState, Store, Typenames } from './types';
-export declare const useMutation: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: Omit<MutateOptions<N, T, QP, QR, MP, MR, MK>, "params">, 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>>, MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+export declare const useMutation: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: Omit<MutateOptions<N, T, QP, QR, MP, MR, MK>, "params">, 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>>, MutationState<T, MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -43,9 +43,7 @@ const useMutation = (cache, actions, selectors, options, abortControllers) => {
                     return false;
                 }
                 abortController.abort();
-                store.dispatch(actions.updateMutationStateAndEntities(mutationKey, {
-                    loading: false,
-                }));
+                store.dispatch(actions.updateMutationStateAndEntities(mutationKey, { loading: undefined }));
                 return true;
             },
         ];

package/dist/useQuery.d.ts

@@ -1,6 +1,6 @@
 import { Actions } from './createActions';
 import { Selectors } from './createSelectors';
 import { Cache, QueryOptions, QueryState, Typenames, UseQueryOptions } from './types';
-export declare const useQuery: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: UseQueryOptions<N, T, QK, QP, QR, MP, MR>) => readonly [Omit<QueryState<QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, T, QP, QR, QK, MP, MR>, "params" | "onlyIfExpired">>) => 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 & QR)>(cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, options: UseQueryOptions<N, T, QK, QP, QR, MP, MR>) => readonly [Omit<QueryState<T, QK extends keyof QP & keyof QR ? QP[QK] : never, QK extends keyof QP & keyof QR ? QR[QK] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<N, T, QP, QR, QK, MP, MR>, "params" | "onlyIfExpired">>) => 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>>];
 /** Omit `expiresAt` from comparison */
-export declare const useQuerySelectorStateComparer: <P, R>(state1: QueryState<P, R> | undefined, state2: QueryState<P, R> | undefined) => boolean;
+export declare const useQuerySelectorStateComparer: <T extends Typenames, P, R>(state1: QueryState<T, P, R> | undefined, state2: QueryState<T, P, R> | undefined) => boolean;

package/dist/useQuery.js

@@ -16,9 +16,9 @@ const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, selectors, options) => {
     var _a, _b, _c;
     const { query: queryKey, skipFetch = false, params, secondsToLive, fetchPolicy = (_a = cache.queries[queryKey].fetchPolicy) !== null && _a !== void 0 ? _a : cache.globals.queries.fetchPolicy, mergeResults, onCompleted, onSuccess, onError, } = options;
+    const { selectQueryState } = selectors;
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
-    const cacheStateSelector = cache.cacheStateSelector;
     const store = cache.storeHooks.useStore();
     // @ts-expect-error fix types later
     const cacheKey = getCacheKey(params);
@@ -36,8 +36,7 @@ const useQuery = (cache, actions, selectors, options) => {
     [store, queryKey, cacheKey]);
     /** Query state */
     const queryState = (_c = cache.storeHooks.useSelector((state) => {
-        const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
-        return queryState; // TODO proper type
+        return selectQueryState(state, queryKey, cacheKey); // TODO proper type
     }, (exports.useQuerySelectorStateComparer))) !== null && _c !== void 0 ? _c : utilsAndConstants_1.EMPTY_OBJECT;
     (0, react_1.useEffect)(() => {
         if (skipFetch) {

package/dist/utilsAndConstants.d.ts

@@ -6,11 +6,12 @@ export declare const optionalUtils: {
 export declare const IS_DEV: boolean;
 export declare const EMPTY_OBJECT: Readonly<{}>;
 export declare const EMPTY_ARRAY: readonly never[];
+export declare const NOOP: () => void;
 export declare const defaultGetCacheKey: <P = unknown>(params: P) => Key;
 export declare const log: (tag: string, data?: unknown) => void;
 export declare const FetchPolicy: {
     /** Only if cache does not exist (result is undefined) or expired. */
-    NoCacheOrExpired: (expired: boolean, _: unknown, state: QueryState<unknown, unknown>) => boolean;
+    NoCacheOrExpired: <T extends Typenames = Typenames, P = unknown, R = unknown>(expired: boolean, _params: P, state: QueryState<T, P, R>) => boolean;
     /** Every fetch trigger. */
     Always: () => boolean;
 };

package/dist/utilsAndConstants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isEmptyObject = exports.applyEntityChanges = exports.FetchPolicy = exports.log = exports.defaultGetCacheKey = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
+exports.isEmptyObject = exports.applyEntityChanges = exports.FetchPolicy = exports.log = exports.defaultGetCacheKey = exports.NOOP = exports.EMPTY_ARRAY = exports.EMPTY_OBJECT = exports.IS_DEV = exports.optionalUtils = exports.PACKAGE_SHORT_NAME = void 0;
 exports.PACKAGE_SHORT_NAME = 'rrc';
 exports.optionalUtils = {
     deepEqual: undefined,
@@ -22,6 +22,9 @@ exports.IS_DEV = (() => {
 })();
 exports.EMPTY_OBJECT = Object.freeze({});
 exports.EMPTY_ARRAY = Object.freeze([]);
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const NOOP = () => { };
+exports.NOOP = NOOP;
 const defaultGetCacheKey = (params) => {
     switch (typeof params) {
         case 'string':
@@ -40,7 +43,7 @@ const log = (tag, data) => {
 exports.log = log;
 exports.FetchPolicy = {
     /** Only if cache does not exist (result is undefined) or expired. */
-    NoCacheOrExpired: (expired, _, state) => {
+    NoCacheOrExpired: (expired, _params, state) => {
         return expired || state.result === undefined;
     },
     /** Every fetch trigger. */

package/package.json

@@ -2,14 +2,15 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.16.1",
+  "version": "0.18.0",
   "description": "Powerful data fetching and caching library for Redux and Zustand that supports normalization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "example": "(cd example && yarn && yarn start)",
+    "example": "(cd example && yarn && yarn dev)",
     "clean": "rm -rf dist",
     "lint": "yarn eslint src",
+    "lint-fix": "yarn eslint --fix src",
     "build": "yarn clean && yarn lint && tsc && rm -rf dist/testing && rm -rf dist/__tests__",
     "test": "node node_modules/jest/bin/jest.js",
     "preminor-rc": "yarn build && npm version preminor --preid rc",