react-redux-cache 0.7.0-rc.0 → 0.7.1

package/README.md

@@ -291,17 +291,22 @@ export const updateBank = (bank) => {
 
 #### Invalidation
 
-`cache-first` cache policy (default) skips fetching on component mount if result is already cached, but we can invalidate cached query results using `invalidateQuery` action to make it run again on a next mount. Also, we can return this action as a part of query or mutation response, to perform it in one batch update.
+`cache-first` cache policy (default) skips fetching on component mount if result is already cached, but we can invalidate cached query results using `invalidateQuery` action to make it run again on a next mount.
 
 ```typescript
-const updateUser = (user: Partial<User>) => {
-  const response = ...
-  return {
-    result: response.result,
-    expiresAt: Date.now() + 10000, // optional, expiration time of current response
-    actions: [invalidateQuery([{ key: 'getUsers' }])] // optional, this action sets `expiresAt` field of `getUsers` states to Date.now()
-  }
-}
+
+export const cache = createCache({
+  ...
+  mutations: {
+    updateUser: {
+      mutation: updateUser,
+      onSuccess(_, __, {dispatch}) {
+        // we invalidate getUsers after a single user update (can be done better by updating getUsers state with updateQueryStateAndEntities)
+        dispatch(cache.actions.invalidateQuery([{query: 'getUsers'}]))
+      },
+    },
+  },
+})
 ```
 
 #### Extended cache policy

package/dist/createActions.d.ts

@@ -34,7 +34,7 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     invalidateQuery: {
         <K_2 extends keyof QP & keyof QR>(queries: {
             /** Query key */
-            key: K_2;
+            query: K_2;
             /** Query cache key */
             cacheKey?: Key | undefined;
             /** Unix timestamp at which query expires. Is set to the query state. @default Date.now() */
@@ -43,7 +43,7 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
             type: `@rrc/${N}/invalidateQuery`;
             queries: {
                 /** Query key */
-                key: K_2;
+                query: K_2;
                 /** Query cache key */
                 cacheKey?: Key | undefined;
                 /** Unix timestamp at which query expires. Is set to the query state. @default Date.now() */
@@ -57,14 +57,14 @@ export declare const createActions: <N extends string, T extends Typenames, QP,
     clearQueryState: {
         <K_3 extends keyof QP & keyof QR>(queries: {
             /** Query key */
-            key: K_3;
+            query: K_3;
             /** Query cache key */
             cacheKey?: Key | undefined;
         }[]): {
             type: `@rrc/${N}/clearQueryState`;
             queries: {
                 /** Query key */
-                key: K_3;
+                query: K_3;
                 /** Query cache key */
                 cacheKey?: Key | undefined;
             }[];

package/dist/createCache.d.ts

@@ -1,4 +1,4 @@
-import type { Cache, Key, MutationResult, MutationState, OptionalPartial, QueryOptions, QueryResult, QueryState, Typenames } from './types';
+import type { Cache, Key, MutateOptions, MutationResult, MutationState, OptionalPartial, QueryOptions, QueryResult, QueryState, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 import { applyEntityChanges } from './utilsAndConstants';
@@ -30,14 +30,14 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
     } | {
         type: `@rrc/${N}/invalidateQuery`;
         queries: {
-            key: keyof QP & keyof QR;
+            query: keyof QP & keyof QR;
             cacheKey?: Key | undefined;
             expiresAt?: number | undefined;
         }[];
     } | {
         type: `@rrc/${N}/clearQueryState`;
         queries: {
-            key: keyof QP & keyof QR;
+            query: keyof QP & keyof QR;
             cacheKey?: Key | undefined;
         }[];
     } | {
@@ -77,13 +77,13 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         };
         invalidateQuery: {
             <K_2 extends keyof QP & keyof QR>(queries: {
-                key: K_2;
+                query: K_2;
                 cacheKey?: Key | undefined;
                 expiresAt?: number | undefined;
             }[]): {
                 type: `@rrc/${N}/invalidateQuery`;
                 queries: {
-                    key: K_2;
+                    query: K_2;
                     cacheKey?: Key | undefined;
                     expiresAt?: number | undefined;
                 }[];
@@ -92,12 +92,12 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         };
         clearQueryState: {
             <K_3 extends keyof QP & keyof QR>(queries: {
-                key: K_3;
+                query: K_3;
                 cacheKey?: Key | undefined;
             }[]): {
                 type: `@rrc/${N}/clearQueryState`;
                 queries: {
-                    key: K_3;
+                    query: K_3;
                     cacheKey?: Key | undefined;
                 }[];
             };
@@ -145,17 +145,12 @@ export declare const createCache: <N extends string, T extends Typenames, QP, QR
         /** Returns client object with query and mutate functions. */
         useClient: () => {
             query: <QK_7 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, QK_7>) => Promise<QueryResult<QK_7 extends keyof QP & keyof QR ? QR[QK_7] : never>>;
-            mutate: <MK_6 extends keyof MP | keyof MR>(options: {
-                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>>;
+            mutate: <MK_6 extends keyof MP | keyof MR>(options: MutateOptions<T, MP, MR, MK_6>) => Promise<MutationResult<MK_6 extends keyof MP & keyof MR ? MR[MK_6] : never>>;
         };
         /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
         useQuery: <QK_8 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, QK_8>) => readonly [Omit<QueryState<QK_8 extends keyof QP & keyof QR ? QP[QK_8] : never, QK_8 extends keyof QP & keyof QR ? QR[QK_8] : never>, "expiresAt">, (options?: Partial<Pick<QueryOptions<T, QP, QR, QK_8>, "params" | "onlyIfExpired">> | undefined) => Promise<QueryResult<QK_8 extends infer T_5 ? T_5 extends QK_8 ? T_5 extends keyof QP & keyof QR ? QR[T_5] : never : never : never>>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_7 extends keyof MP | keyof MR>(options: {
-            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>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
+        useMutation: <MK_7 extends keyof MP | keyof MR>(options: Omit<MutateOptions<T, MP, MR, MK_7>, "params">) => readonly [(params: MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never) => Promise<MutationResult<MK_7 extends infer T_6 ? T_6 extends MK_7 ? T_6 extends keyof MP & keyof MR ? MR[T_6] : never : never : never>>, MutationState<MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never, MK_7 extends keyof MP & keyof MR ? MP[MK_7] : never>, () => boolean];
         /** useSelector + selectEntityById. */
         useSelectEntityById: <TN_2 extends keyof T>(id: Key | null | undefined, typename: TN_2) => T[TN_2] | undefined;
     };

package/dist/createCache.js

@@ -110,16 +110,18 @@ const createCache = (partialCache) => {
                     const client = {
                         query: (options) => {
                             var _a;
-                            const { query: queryKey, params, onlyIfExpired, secondsToLive, mergeResults } = options;
+                            const { query: queryKey, params } = options;
                             const getCacheKey = (_a = cache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
                             // @ts-expect-error fix later
                             const cacheKey = getCacheKey(params);
-                            return (0, query_1.query)('query', store, cache, actions, queryKey, cacheKey, params, secondsToLive, onlyIfExpired, 
+                            return (0, query_1.query)('query', store, cache, actions, queryKey, cacheKey, params, options.secondsToLive, options.onlyIfExpired, 
                             // @ts-expect-error fix later
-                            mergeResults);
+                            options.mergeResults, options.onCompleted, options.onSuccess, options.onError);
                         },
                         mutate: (options) => {
-                            return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers);
+                            return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers, 
+                            // @ts-expect-error fix later
+                            options.onCompleted, options.onSuccess, options.onError);
                         },
                     };
                     return client;

package/dist/createCacheReducer.d.ts

@@ -22,14 +22,14 @@ export declare const createCacheReducer: <N extends string, T extends Typenames,
 } | {
     type: `@rrc/${N}/invalidateQuery`;
     queries: {
-        key: keyof QP & keyof QR;
+        query: keyof QP & keyof QR;
         cacheKey?: import("./types").Key | undefined;
         expiresAt?: number | undefined;
     }[];
 } | {
     type: `@rrc/${N}/clearQueryState`;
     queries: {
-        key: keyof QP & keyof QR;
+        query: keyof QP & keyof QR;
         cacheKey?: import("./types").Key | undefined;
     }[];
 } | {

package/dist/createCacheReducer.js

@@ -96,20 +96,20 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                 }
                 const now = Date.now();
                 let newQueries = undefined;
-                for (const { key, cacheKey, expiresAt = now } of queriesToInvalidate) {
-                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[key];
+                for (const { query: queryKey, cacheKey, expiresAt = now } of queriesToInvalidate) {
+                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[queryKey];
                     if (cacheKey != null) {
                         if (queryStates[cacheKey]) {
                             const queryState = queryStates[cacheKey];
                             if (queryState && queryState.expiresAt !== expiresAt) {
                                 newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                                if (state.queries[key] === newQueries[key]) {
-                                    newQueries[key] = Object.assign({}, newQueries[key]);
+                                if (state.queries[queryKey] === newQueries[queryKey]) {
+                                    newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
                                 }
                                 // @ts-expect-error fix type later
-                                newQueries[key][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
+                                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
                                 if (expiresAt === undefined) {
-                                    delete newQueries[key][cacheKey].expiresAt;
+                                    delete newQueries[queryKey][cacheKey].expiresAt;
                                 }
                             }
                         }
@@ -119,12 +119,12 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                             const queryState = queryStates[cacheKey];
                             if (queryState && queryState.expiresAt !== expiresAt) {
                                 newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                                if (state.queries[key] === newQueries[key]) {
-                                    newQueries[key] = Object.assign({}, newQueries[key]);
+                                if (state.queries[queryKey] === newQueries[queryKey]) {
+                                    newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
                                 }
-                                newQueries[key][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
+                                newQueries[queryKey][cacheKey] = Object.assign(Object.assign({}, queryState), { expiresAt });
                                 if (expiresAt === undefined) {
-                                    delete newQueries[key][cacheKey].expiresAt;
+                                    delete newQueries[queryKey][cacheKey].expiresAt;
                                 }
                             }
                         }
@@ -140,20 +140,20 @@ const createCacheReducer = (actions, typenames, queryKeys, cacheOptions) => {
                     return state;
                 }
                 let newQueries = undefined;
-                for (const { key, cacheKey } of queriesToClear) {
-                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[key];
+                for (const { query: queryKey, cacheKey } of queriesToClear) {
+                    const queryStates = (newQueries !== null && newQueries !== void 0 ? newQueries : state.queries)[queryKey];
                     if (cacheKey != null) {
                         if (queryStates[cacheKey]) {
                             newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                            if (state.queries[key] === newQueries[key]) {
-                                newQueries[key] = Object.assign({}, newQueries[key]);
+                            if (state.queries[queryKey] === newQueries[queryKey]) {
+                                newQueries[queryKey] = Object.assign({}, newQueries[queryKey]);
                             }
-                            delete newQueries[key][cacheKey];
+                            delete newQueries[queryKey][cacheKey];
                         }
                     }
                     else if (queryStates !== EMPTY_QUERY_STATE) {
                         newQueries !== null && newQueries !== void 0 ? newQueries : (newQueries = Object.assign({}, state.queries));
-                        newQueries[key] = EMPTY_QUERY_STATE;
+                        newQueries[queryKey] = EMPTY_QUERY_STATE;
                     }
                 }
                 return !newQueries

package/dist/index.js

@@ -23,7 +23,6 @@ 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 (1.0.0)
-// key -> query
 // rca -> vite
 // defaults
 // remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?

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, 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>>;
+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>>, onCompleted?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined) => 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, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) => __awaiter(void 0, void 0, void 0, function* () {
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -64,6 +64,10 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutat
             error: error,
             loading: false,
         }));
+        // @ts-expect-error params
+        onError === null || onError === void 0 ? void 0 : onError(error, params, store);
+        // @ts-expect-error response
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);
         return { error };
     }
     if (response) {
@@ -73,6 +77,10 @@ const mutate = (logTag, store, cache, { updateMutationStateAndEntities, }, mutat
             result: response.result,
         };
         store.dispatch(updateMutationStateAndEntities(mutationKey, newState, response));
+        // @ts-expect-error params
+        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(response, params, store);
+        // @ts-expect-error response
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);
         // @ts-expect-error fix later
         return { result: response.result };
     }

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, QP, QR, unknown, unknown>, "updateQueryStateAndEntities">, queryKey: QK, cacheKey: Key, params: QK extends keyof QP & keyof QR ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & symbol]) | undefined) => 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, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onSuccess?: ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((response: import("./types").QueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store<any, import("redux").AnyAction>) => void) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store<any, import("redux").AnyAction>) => void) | undefined) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;

package/dist/query.js

@@ -11,7 +11,7 @@ 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, secondsToLive = cache.queries[queryKey].secondsToLive, onlyIfExpired, mergeResults = cache.queries[queryKey].mergeResults) => __awaiter(void 0, void 0, void 0, function* () {
+const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey, cacheKey, params, secondsToLive = cache.queries[queryKey].secondsToLive, onlyIfExpired, mergeResults = cache.queries[queryKey].mergeResults, onCompleted = cache.queries[queryKey].onCompleted, onSuccess = cache.queries[queryKey].onSuccess, onError = cache.queries[queryKey].onError) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const logsEnabled = cache.options.logsEnabled;
     const cacheStateSelector = cache.cacheStateSelector;
@@ -52,6 +52,10 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey,
             error: error,
             loading: false,
         }));
+        // @ts-expect-error params
+        onError === null || onError === void 0 ? void 0 : onError(error, params, store);
+        // @ts-expect-error params
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(undefined, error, params, store);
         return { error };
     }
     const newState = {
@@ -65,6 +69,10 @@ const query = (logTag, store, cache, { updateQueryStateAndEntities, }, queryKey,
             : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
+    // @ts-expect-error response
+    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(response, params, store);
+    // @ts-expect-error response
+    onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, undefined, params, store);
     return {
         // @ts-expect-error fix types
         result: newState === null || newState === void 0 ? void 0 : newState.result,

package/dist/types.d.ts

@@ -91,6 +91,12 @@ export type QueryInfo<T extends Typenames, P, R> = {
      * It is recommended to override it when default implementation is not optimal or when keys in params object can be sorted in random order etc.
      * */
     getCacheKey?: (params?: P) => Key;
+    /** Called after fetch finished either successfully or not. */
+    onCompleted?: (response: QueryResponse<T, R> | undefined, error: unknown | undefined, params: P | undefined, store: Store) => void;
+    /** Called after fetch finished without error. */
+    onSuccess?: (response: QueryResponse<T, R>, params: P | undefined, store: Store) => void;
+    /** Called after fetch finished with error. */
+    onError?: (error: unknown, params: P | undefined, store: Store) => void;
 };
 export type QueryState<P, R> = MutationState<P, R> & {
     expiresAt?: number;
@@ -100,7 +106,11 @@ export type UseQueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP &
     params: QK extends keyof (QP | QR) ? QP[QK] : never;
     /** When true fetch is not performed. When switches to false fetch is performed depending on cache policy. */
     skip?: boolean;
-} & Pick<QueryInfo<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>, 'cachePolicy' | 'secondsToLive' | 'mergeResults'>;
+} & Pick<QueryInfo<T, QK extends keyof (QP | QR) ? QP[QK] : never, QK extends keyof (QP | QR) ? QR[QK] : never>, 'cachePolicy' | 'secondsToLive' | 'mergeResults' | 'onCompleted' | 'onSuccess' | 'onError'>;
+export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, QK>, 'skip' | 'cachePolicy'> & {
+    /** If set to true, query will run only if it is expired or result not yet cached. */
+    onlyIfExpired?: boolean;
+};
 /**
  * @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.
@@ -116,10 +126,6 @@ export type QueryResult<R> = {
     cancelled?: true;
     result?: R;
 };
-export type QueryOptions<T extends Typenames, QP, QR, QK extends keyof (QP & QR)> = Omit<UseQueryOptions<T, QP, QR, QK>, 'skip' | 'cachePolicy'> & {
-    /** If set to true, query will run only if it is expired or result not yet cached. */
-    onlyIfExpired?: boolean;
-};
 export type Mutation<P, T extends Typenames = Typenames, R = unknown> = (
 /** Mutation parameters */
 params: P, 
@@ -127,9 +133,13 @@ params: P,
 store: Store, 
 /** Signal is aborted for current mutation when the same mutation was called once again. */
 abortSignal: AbortSignal) => Promise<MutationResponse<T, R>>;
-export type MutationInfo<T extends Typenames, P, R> = {
+export type MutationInfo<T extends Typenames, P, R> = Pick<QueryInfo<T, P, R>, 'onCompleted' | 'onSuccess' | 'onError'> & {
     mutation: Mutation<P, T, R>;
 };
+export type MutateOptions<T extends Typenames, MP, MR, MK extends keyof (MP & MR)> = Pick<MutationInfo<T, MK extends keyof (MP | MR) ? MP[MK] : never, MK extends keyof (MP | MR) ? MR[MK] : never>, 'onCompleted' | 'onSuccess' | 'onError'> & {
+    mutation: MK;
+    params: MK extends keyof (MP | MR) ? MP[MK] : never;
+};
 export type MutationResponse<T extends Typenames, R> = EntityChanges<T> & {
     result?: R;
 };

package/dist/useMutation.d.ts

@@ -1,6 +1,4 @@
 import { Store } from 'redux';
 import { ActionMap } from './createActions';
-import { Cache, Key, MutationState, 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, 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>>, MutationState<MK extends keyof MP & keyof MR ? MP[MK] : never, MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];
+import { Cache, Key, MutateOptions, MutationState, 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, unknown, MP, MR>, "updateMutationStateAndEntities">, options: Omit<MutateOptions<T, 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];

package/dist/useMutation.js

@@ -16,7 +16,7 @@ const mutate_1 = require("./mutate");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useMutation = (cache, actions, options, abortControllers) => {
     var _a;
-    const { mutation: mutationKey } = options;
+    const { mutation: mutationKey, onCompleted, onSuccess, onError } = options;
     const store = (0, react_redux_1.useStore)();
     // Using single useMemo for performance reasons
     const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
@@ -32,7 +32,9 @@ const useMutation = (cache, actions, options, abortControllers) => {
             },
             // mutate
             (params) => __awaiter(void 0, void 0, void 0, function* () {
-                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, mutationKey, params, abortControllers);
+                return yield (0, mutate_1.mutate)('useMutation.mutate', store, cache, actions, mutationKey, params, abortControllers, 
+                // @ts-expect-error fix later
+                onCompleted, onSuccess, onError);
             }),
             // abort
             () => {

package/dist/useQuery.js

@@ -16,7 +16,7 @@ const query_1 = require("./query");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 const useQuery = (cache, actions, options) => {
     var _a, _b, _c;
-    const { query: queryKey, skip, params, secondsToLive, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', mergeResults, } = options;
+    const { query: queryKey, skip, params, secondsToLive, cachePolicy = (_a = cache.queries[queryKey].cachePolicy) !== null && _a !== void 0 ? _a : 'cache-first', mergeResults, onCompleted, onSuccess, onError, } = options;
     const logsEnabled = cache.options.logsEnabled;
     const getCacheKey = (_b = cache.queries[queryKey].getCacheKey) !== null && _b !== void 0 ? _b : (utilsAndConstants_1.defaultGetCacheKey);
     const cacheStateSelector = cache.cacheStateSelector;
@@ -31,7 +31,7 @@ const useQuery = (cache, actions, options) => {
         paramsPassed ? getCacheKey(options.params) : cacheKey, paramsPassed ? options.params : params, // params type can also have null | undefined, thats why we don't check for it here
         secondsToLive, options === null || options === void 0 ? void 0 : options.onlyIfExpired, 
         // @ts-expect-error fix later
-        mergeResults);
+        mergeResults, onCompleted, onSuccess, onError);
     }), 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [store, queryKey, cacheKey]);

package/package.json

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