react-redux-cache 0.12.0 → 0.13.0

package/dist/createCache.js

@@ -5,6 +5,7 @@ const react_1 = require("react");
 const react_redux_1 = require("react-redux");
 const createActions_1 = require("./createActions");
 const createCacheReducer_1 = require("./createCacheReducer");
+const createSelectors_1 = require("./createSelectors");
 const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const useMutation_1 = require("./useMutation");
@@ -24,20 +25,22 @@ const withTypenames = () => {
      */
     return {
         createCache: (partialCache) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-            var _k, _l, _m, _o;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+            var _m, _o, _p, _q, _r, _s;
             const abortControllers = new WeakMap();
             // provide all optional fields
             (_a = partialCache.options) !== null && _a !== void 0 ? _a : (partialCache.options = {});
-            (_b = (_k = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_k.logsEnabled = false);
-            (_c = (_l = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_l.additionalValidation = utilsAndConstants_1.IS_DEV);
-            (_d = (_m = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_m.deepComparisonEnabled = true);
+            (_b = (_m = partialCache.options).logsEnabled) !== null && _b !== void 0 ? _b : (_m.logsEnabled = false);
+            (_c = (_o = partialCache.options).additionalValidation) !== null && _c !== void 0 ? _c : (_o.additionalValidation = utilsAndConstants_1.IS_DEV);
+            (_d = (_p = partialCache.options).deepComparisonEnabled) !== null && _d !== void 0 ? _d : (_p.deepComparisonEnabled = true);
             (_e = partialCache.queries) !== null && _e !== void 0 ? _e : (partialCache.queries = {});
             (_f = partialCache.mutations) !== null && _f !== void 0 ? _f : (partialCache.mutations = {});
             (_g = partialCache.globals) !== null && _g !== void 0 ? _g : (partialCache.globals = {});
-            (_h = (_o = partialCache.globals).cachePolicy) !== null && _h !== void 0 ? _h : (_o.cachePolicy = 'cache-first');
+            (_h = (_q = partialCache.globals).queries) !== null && _h !== void 0 ? _h : (_q.queries = {});
+            (_j = (_r = partialCache.globals.queries).fetchPolicy) !== null && _j !== void 0 ? _j : (_r.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired);
+            (_k = (_s = partialCache.globals.queries).skipFetch) !== null && _k !== void 0 ? _k : (_s.skipFetch = false);
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (_j = partialCache.cacheStateSelector) !== null && _j !== void 0 ? _j : (partialCache.cacheStateSelector = (state) => state[cache.name]);
+            (_l = partialCache.cacheStateSelector) !== null && _l !== void 0 ? _l : (partialCache.cacheStateSelector = (state) => state[cache.name]);
             // @ts-expect-error private field for testing
             partialCache.abortControllers = abortControllers;
             const cache = partialCache;
@@ -45,81 +48,61 @@ const withTypenames = () => {
             if (cache.options.deepComparisonEnabled && !utilsAndConstants_1.optionalUtils.deepEqual) {
                 console.warn('react-redux-cache: optional dependency for fast-deep-equal was not provided, while deepComparisonEnabled option is true');
             }
-            // make selectors
-            const selectEntityById = (state, id, typename) => {
-                var _a;
-                return id == null ? undefined : (_a = cache.cacheStateSelector(state).entities[typename]) === null || _a === void 0 ? void 0 : _a[id];
-            };
-            const selectQueryState = (state, query, cacheKey) => {
-                var _a;
-                // @ts-expect-error fix later
-                return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
-            };
-            const selectMutationState = (state, mutation) => {
-                var _a;
-                // @ts-expect-error fix later
-                return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
-            };
+            // selectors
+            const selectors = (0, createSelectors_1.createSelectors)(cache);
+            const { selectQueryState, selectQueryResult, selectQueryLoading, selectQueryError, selectQueryParams, selectQueryExpiresAt, selectMutationState, selectMutationResult, selectMutationLoading, selectMutationError, selectMutationParams, selectEntityById, selectEntities, selectEntitiesByTypename, } = selectors;
+            // actions
             const actions = (0, createActions_1.createActions)(cache.name);
+            const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, } = actions;
             return {
                 /** Keeps all options, passed while creating the cache. */
                 cache,
                 /** Reducer of the cache, should be added to redux store. */
                 reducer: (0, createCacheReducer_1.createCacheReducer)(actions, Object.keys(cache.queries), cache.options),
-                actions,
+                actions: {
+                    /** Updates query state, and optionally merges entity changes in a single action. */
+                    updateQueryStateAndEntities,
+                    /** Updates mutation state, and optionally merges entity changes in a single action. */
+                    updateMutationStateAndEntities,
+                    /** Merge EntityChanges to the state. */
+                    mergeEntityChanges,
+                    /** Invalidates query states. */
+                    invalidateQuery,
+                    /** 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,
+                    /** Clear states for provided mutation keys. */
+                    clearMutationState,
+                },
                 selectors: {
                     /** Selects query state. */
                     selectQueryState,
                     /** Selects query latest result. */
-                    selectQueryResult: (state, query, cacheKey) => {
-                        return selectQueryState(state, query, cacheKey).result;
-                    },
+                    selectQueryResult,
                     /** Selects query loading state. */
-                    selectQueryLoading: (state, query, cacheKey) => {
-                        var _a;
-                        return (_a = selectQueryState(state, query, cacheKey).loading) !== null && _a !== void 0 ? _a : false;
-                    },
+                    selectQueryLoading,
                     /** Selects query latest error. */
-                    selectQueryError: (state, query, cacheKey) => {
-                        return selectQueryState(state, query, cacheKey).error;
-                    },
+                    selectQueryError,
                     /** Selects query latest params. */
-                    selectQueryParams: (state, query, cacheKey) => {
-                        return selectQueryState(state, query, cacheKey).params;
-                    },
+                    selectQueryParams,
                     /** Selects query latest expiresAt. */
-                    selectQueryExpiresAt: (state, query, cacheKey) => {
-                        return selectQueryState(state, query, cacheKey).expiresAt;
-                    },
+                    selectQueryExpiresAt,
                     /** Selects mutation state. */
                     selectMutationState,
                     /** Selects mutation latest result. */
-                    selectMutationResult: (state, mutation) => {
-                        return selectMutationState(state, mutation).result;
-                    },
+                    selectMutationResult,
                     /** Selects mutation loading state. */
-                    selectMutationLoading: (state, mutation) => {
-                        var _a;
-                        return (_a = selectMutationState(state, mutation).loading) !== null && _a !== void 0 ? _a : false;
-                    },
+                    selectMutationLoading,
                     /** Selects mutation latest error. */
-                    selectMutationError: (state, mutation) => {
-                        return selectMutationState(state, mutation).error;
-                    },
+                    selectMutationError,
                     /** Selects mutation latest params. */
-                    selectMutationParams: (state, mutation) => {
-                        return selectMutationState(state, mutation).params;
-                    },
+                    selectMutationParams,
                     /** Selects entity by id and typename. */
                     selectEntityById,
                     /** Selects all entities. */
-                    selectEntities: (state) => {
-                        return cache.cacheStateSelector(state).entities;
-                    },
+                    selectEntities,
                     /** Selects all entities of provided typename. */
-                    selectEntitiesByTypename: (state, typename) => {
-                        return cache.cacheStateSelector(state).entities[typename];
-                    },
+                    selectEntitiesByTypename,
                 },
                 hooks: {
                     /** Returns client object with query and mutate functions. */
@@ -133,12 +116,12 @@ const withTypenames = () => {
                                     const getCacheKey = (_a = cache.queries[queryKey].getCacheKey) !== null && _a !== void 0 ? _a : (utilsAndConstants_1.defaultGetCacheKey);
                                     // @ts-expect-error fix later
                                     const cacheKey = getCacheKey(params);
-                                    return (0, query_1.query)('query', store, cache, actions, queryKey, cacheKey, params, options.secondsToLive, options.onlyIfExpired, 
+                                    return (0, query_1.query)('query', store, cache, actions, selectors, queryKey, cacheKey, params, options.secondsToLive, options.onlyIfExpired, 
                                     // @ts-expect-error fix later
                                     options.mergeResults, options.onCompleted, options.onSuccess, options.onError);
                                 },
                                 mutate: (options) => {
-                                    return (0, mutate_1.mutate)('mutate', store, cache, actions, options.mutation, options.params, abortControllers, 
+                                    return (0, mutate_1.mutate)('mutate', store, cache, actions, selectors, options.mutation, options.params, abortControllers, 
                                     // @ts-expect-error fix later
                                     options.onCompleted, options.onSuccess, options.onError);
                                 },
@@ -147,21 +130,17 @@ const withTypenames = () => {
                         }, [store]);
                     },
                     /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
-                    useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, options),
+                    useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, selectors, options),
                     /** Subscribes to provided mutation state and provides mutate function. */
-                    useMutation: (options
-                    // @ts-expect-error cache type
-                    ) => (0, useMutation_1.useMutation)(cache, actions, options, abortControllers),
+                    useMutation: (options) => (0, useMutation_1.useMutation)(cache, actions, selectors, options, abortControllers),
                     /** useSelector + selectEntityById. */
                     useSelectEntityById: (id, typename) => {
                         return (0, react_redux_1.useSelector)((state) => selectEntityById(state, id, typename));
                     },
                 },
                 utils: {
-                    /**
-                     * Apply changes to the entities map.
-                     * @return `undefined` if nothing to change, otherwise new entities map with applied changes.
-                     */
+                    /** Apply changes to the entities map.
+                     * @returns `undefined` if nothing to change, otherwise new `EntitiesMap<T>` with applied changes. */
                     applyEntityChanges: (entities, changes) => {
                         return (0, utilsAndConstants_1.applyEntityChanges)(entities, changes, cache.options);
                     },

package/dist/createCacheReducer.d.ts

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

package/dist/createSelectors.d.ts

@@ -0,0 +1,18 @@
+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>;
+    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;
+    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>;
+    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;
+    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;
+    selectEntities: (state: unknown) => import("./types").EntitiesMap<T>;
+    selectEntitiesByTypename: <TN extends keyof T>(state: unknown, typename: TN) => import("./types").EntitiesMap<T>[TN];
+};

package/dist/createSelectors.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSelectors = void 0;
+const utilsAndConstants_1 = require("./utilsAndConstants");
+const createSelectors = (cache) => {
+    const selectEntityById = (state, id, typename) => {
+        var _a;
+        return id == null ? undefined : (_a = cache.cacheStateSelector(state).entities[typename]) === null || _a === void 0 ? void 0 : _a[id];
+    };
+    const selectQueryState = (state, query, cacheKey) => {
+        var _a;
+        // @ts-expect-error fix later
+        return (_a = cache.cacheStateSelector(state).queries[query][cacheKey]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
+    };
+    const selectMutationState = (state, mutation) => {
+        var _a;
+        // @ts-expect-error fix later
+        return (_a = cache.cacheStateSelector(state).mutations[mutation]) !== null && _a !== void 0 ? _a : utilsAndConstants_1.EMPTY_OBJECT;
+    };
+    return {
+        selectQueryState,
+        selectQueryResult: (state, query, cacheKey) => {
+            return selectQueryState(state, query, cacheKey).result;
+        },
+        selectQueryLoading: (state, query, cacheKey) => {
+            var _a;
+            return (_a = selectQueryState(state, query, cacheKey).loading) !== null && _a !== void 0 ? _a : false;
+        },
+        selectQueryError: (state, query, cacheKey) => {
+            return selectQueryState(state, query, cacheKey).error;
+        },
+        selectQueryParams: (state, query, cacheKey) => {
+            return selectQueryState(state, query, cacheKey).params;
+        },
+        selectQueryExpiresAt: (state, query, cacheKey) => {
+            return selectQueryState(state, query, cacheKey).expiresAt;
+        },
+        selectMutationState,
+        selectMutationResult: (state, mutation) => {
+            return selectMutationState(state, mutation).result;
+        },
+        selectMutationLoading: (state, mutation) => {
+            var _a;
+            return (_a = selectMutationState(state, mutation).loading) !== null && _a !== void 0 ? _a : false;
+        },
+        selectMutationError: (state, mutation) => {
+            return selectMutationState(state, mutation).error;
+        },
+        selectMutationParams: (state, mutation) => {
+            return selectMutationState(state, mutation).params;
+        },
+        selectEntityById,
+        selectEntities: (state) => {
+            return cache.cacheStateSelector(state).entities;
+        },
+        selectEntitiesByTypename: (state, typename) => {
+            return cache.cacheStateSelector(state).entities[typename];
+        },
+    };
+};
+exports.createSelectors = createSelectors;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { createCache, withTypenames } from './createCache';
-export type { ReduxCacheState } from './createCacheReducer';
 export * from './types';
-export { defaultGetCacheKey } from './utilsAndConstants';
+export { useQuerySelectorStateComparer } from './useQuery';
+export { defaultGetCacheKey, FetchPolicy, isEmptyObject } from './utilsAndConstants';

package/dist/index.js

@@ -14,25 +14,31 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultGetCacheKey = exports.withTypenames = exports.createCache = void 0;
+exports.isEmptyObject = exports.FetchPolicy = exports.defaultGetCacheKey = exports.useQuerySelectorStateComparer = exports.withTypenames = exports.createCache = void 0;
 var createCache_1 = require("./createCache");
 Object.defineProperty(exports, "createCache", { enumerable: true, get: function () { return createCache_1.createCache; } });
 Object.defineProperty(exports, "withTypenames", { enumerable: true, get: function () { return createCache_1.withTypenames; } });
 __exportStar(require("./types"), exports);
+var useQuery_1 = require("./useQuery");
+Object.defineProperty(exports, "useQuerySelectorStateComparer", { enumerable: true, get: function () { return useQuery_1.useQuerySelectorStateComparer; } });
 var utilsAndConstants_1 = require("./utilsAndConstants");
 Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: function () { return utilsAndConstants_1.defaultGetCacheKey; } });
+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
-// ! high (1.0.0)
-// remove cachePolicy? make skip/enabled a function? skip -> enabled/shouldFetch?
+// ! high (1.0.0-rc.0)
 // generate full api docs
 // ! medium
 // optimistic response
+// onCancel & onAbort
+// remove empty entities and queries from state
 // reset [whole] cache to initial / to provided state
 // globals for success, completions and loading states?
 // make query key / cache key difference more clear in the docs
 // check type of function arguments in dev
+// make skipFetch a function?
+// example -> playground with changable options
 // ! low
-// local cache policy to keep in component state?
 // make error type generic
 // allow multiple mutation with same keys?
 // custom useStore & useSelector to support multiple stores?

package/dist/mutate.d.ts

@@ -1,4 +1,5 @@
 import { Store } from 'redux';
-import type { ActionMap } from './createActions';
+import type { Actions } from './createActions';
+import { Selectors } from './createSelectors';
 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 & 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 | MR) ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof (MP | MR) ? MR[MK] : never>>;
+export declare const mutate: <N extends string, T extends Typenames, QP, QR, MP, MR, MK extends keyof (MP & MR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, mutationKey: MK, params: MK extends keyof (MP | MR) ? MP[MK] : never, abortControllers: WeakMap<Store, Record<Key, AbortController>>, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]> | undefined, error: unknown | undefined, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & string]>, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & number]>, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, MR[keyof MP & keyof MR & symbol]>, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: MP[keyof MP & keyof MR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: MP[keyof MP & keyof MR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<MutationResult<MK extends keyof (MP | MR) ? MR[MK] : never>>;

package/dist/mutate.js

@@ -11,8 +11,9 @@ 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_1, store_1, cache_1, _a, mutationKey_1, params_1, abortControllers_1, ...args_1) => __awaiter(void 0, [logTag_1, store_1, cache_1, _a, mutationKey_1, params_1, abortControllers_1, ...args_1], void 0, function* (logTag, store, cache, { updateMutationStateAndEntities, }, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) {
-    var _b, _c;
+const mutate = (logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_1, params_1, abortControllers_1, ...args_1) => __awaiter(void 0, [logTag_1, store_1, cache_1, actions_1, selectors_1, mutationKey_1, params_1, abortControllers_1, ...args_1], void 0, function* (logTag, store, cache, actions, selectors, mutationKey, params, abortControllers, onCompleted = cache.mutations[mutationKey].onCompleted, onSuccess = cache.mutations[mutationKey].onSuccess, onError = cache.mutations[mutationKey].onError) {
+    var _a, _b;
+    const { updateMutationStateAndEntities } = actions;
     let abortControllersOfStore = abortControllers.get(store);
     if (abortControllersOfStore === undefined) {
         abortControllersOfStore = {};
@@ -66,12 +67,14 @@ const mutate = (logTag_1, store_1, cache_1, _a, mutationKey_1, params_1, abortCo
             loading: false,
         }));
         // @ts-expect-error params
-        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
-            // @ts-expect-error queryKey
-            (_c = (_b = cache.globals).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, mutationKey, params, store);
+        if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store, actions, selectors))) {
+            (_b = (_a = cache.globals).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error, 
+            // @ts-expect-error mutationKey
+            mutationKey, params, store, actions, selectors);
         }
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
         // @ts-expect-error response
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);
+        response, error, params, store, actions, selectors);
         return { error };
     }
     if (response) {
@@ -81,10 +84,12 @@ const mutate = (logTag_1, store_1, cache_1, _a, mutationKey_1, params_1, abortCo
             result: response.result,
         };
         store.dispatch(updateMutationStateAndEntities(mutationKey, newState, response));
-        // @ts-expect-error params
-        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(response, params, store);
+        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(
+        // @ts-expect-error response
+        response, params, store, actions, selectors);
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
         // @ts-expect-error response
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, error, params, store);
+        response, error, params, store, actions, selectors);
         // @ts-expect-error fix later
         return { result: response.result };
     }

package/dist/query.d.ts

@@ -1,4 +1,5 @@
 import { Store } from 'redux';
-import type { ActionMap } from './createActions';
+import type { Actions } from './createActions';
+import { Selectors } from './createSelectors';
 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 & 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 | QR) ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof (QP | QR) ? QR[QK] : never>>;
+export declare const query: <N extends string, T extends Typenames, QP, QR, MP, MR, QK extends keyof (QP & QR)>(logTag: string, store: Store, cache: Cache<N, T, QP, QR, MP, MR>, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>, queryKey: QK, cacheKey: Key, params: QK extends keyof (QP | QR) ? QP[QK] : never, secondsToLive: number | undefined, onlyIfExpired: boolean | undefined, mergeResults?: ((oldResult: QR[keyof QP & keyof QR & string] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & string]) | ((oldResult: QR[keyof QP & keyof QR & number] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & number]) | ((oldResult: QR[keyof QP & keyof QR & symbol] | undefined, response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => QR[keyof QP & keyof QR & symbol]) | undefined, onCompleted?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]> | undefined, error: unknown | undefined, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onSuccess?: ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & string]>, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & number]>, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | ((response: import("./types").NormalizedQueryResponse<T, QR[keyof QP & keyof QR & symbol]>, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => void) | undefined, onError?: ((error: unknown, params: QP[keyof QP & keyof QR & string] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & number] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | ((error: unknown, params: QP[keyof QP & keyof QR & symbol] | undefined, store: Store, actions: Actions<N, T, QP, QR, MP, MR>, selectors: Selectors<N, T, QP, QR, MP, MR>) => boolean | void | null | undefined) | undefined) => Promise<QueryResult<QK extends keyof (QP | QR) ? QR[QK] : never>>;

package/dist/query.js

@@ -11,10 +11,9 @@ 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, _a, queryKey, cacheKey, params, secondsToLive, onlyIfExpired, mergeResults, onCompleted, onSuccess, onError) => __awaiter(void 0, void 0, void 0, function* () {
-    var _b, _c, _d, _e, _f;
-    var { updateQueryStateAndEntities, } = _a;
-    if (secondsToLive === void 0) { secondsToLive = (_b = cache.queries[queryKey].secondsToLive) !== null && _b !== void 0 ? _b : cache.globals.secondsToLive; }
+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;
+    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; }
@@ -41,6 +40,7 @@ const query = (logTag, store, cache, _a, queryKey, cacheKey, params, secondsToLi
             });
         return CANCELLED_RESULT;
     }
+    const { updateQueryStateAndEntities } = actions;
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, {
         loading: true,
         params,
@@ -60,28 +60,32 @@ const query = (logTag, store, cache, _a, queryKey, cacheKey, params, secondsToLi
         }));
         // @ts-expect-error params
         if (!(onError === null || onError === void 0 ? void 0 : onError(error, params, store))) {
+            (_c = (_b = cache.globals).onError) === null || _c === void 0 ? void 0 : _c.call(_b, error, 
             // @ts-expect-error queryKey
-            (_d = (_c = cache.globals).onError) === null || _d === void 0 ? void 0 : _d.call(_c, error, queryKey, params, store);
+            queryKey, params, store, actions, selectors);
         }
+        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(undefined, error, 
         // @ts-expect-error params
-        onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(undefined, error, params, store);
+        params, store, actions, selectors);
         return { error };
     }
     const newState = {
         error: undefined,
         loading: false,
-        expiresAt: (_e = response.expiresAt) !== null && _e !== void 0 ? _e : (secondsToLive != null ? Date.now() + secondsToLive * 1000 : 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
-            (_f = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _f === void 0 ? void 0 : _f.result, response, params, store)
+            (_e = cacheStateSelector(store.getState()).queries[queryKey][cacheKey]) === null || _e === void 0 ? void 0 : _e.result, response, params, store, actions, selectors)
             : response.result,
     };
     store.dispatch(updateQueryStateAndEntities(queryKey, cacheKey, newState, response));
+    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(
     // @ts-expect-error response
-    onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(response, params, store);
+    response, params, store, actions, selectors);
+    onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(
     // @ts-expect-error response
-    onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response, undefined, params, store);
+    response, undefined, params, store, actions, selectors);
     return {
         // @ts-expect-error fix types
         result: newState === null || newState === void 0 ? void 0 : newState.result,