react-redux-cache 0.0.8 → 0.0.9

package/dist/createCache.d.ts

@@ -1,5 +1,5 @@
 import { mergeEntityChanges, setMutationStateAndEntities, setQueryStateAndEntities } from './reducer';
-import { Cache, EntitiesMap, Key, OptionalPartial, QueryOptions, Typenames } from './types';
+import { Cache, EntitiesMap, Key, MutationCacheOptions, MutationResult, OptionalPartial, QueryOptions, QueryResult, Typenames } from './types';
 import { useMutation } from './useMutation';
 import { useQuery } from './useQuery';
 /**
@@ -58,19 +58,22 @@ export declare const createCache: <T extends Typenames, QP, QR, MP, MR>(cache: O
         entitiesByTypenameSelector: <TN extends keyof T>(typename: TN) => { [K_2 in keyof T]: (state: unknown) => EntitiesMap<T>[K_2]; }[TN];
     };
     hooks: {
+        /** Returns client object with query function */
         useClient: () => {
-            query: <QK_1 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, MP, MR, QK_1>) => Promise<void | import("./types").QueryResult<QK_1 extends infer T_1 ? T_1 extends QK_1 ? T_1 extends keyof QP & keyof QR ? QR[T_1] : never : never : never>>;
+            query: <QK_1 extends keyof QP | keyof QR>(options: QueryOptions<T, QP, QR, MP, MR, QK_1>) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>;
+            mutate: <MK_1 extends keyof MP | keyof MR>(options: {
+                mutation: MK_1;
+                params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never;
+                cacheOptions?: MutationCacheOptions | undefined;
+            }) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
         };
         /** Fetches query when params change and subscribes to query state. */
-        useQuery: <QK_2 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_2>) => readonly [import("./types").QueryMutationState<QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never>, () => Promise<void | import("./types").QueryResult<QK_2 extends infer T_2 ? T_2 extends QK_2 ? T_2 extends keyof QP & keyof QR ? QR[T_2] : never : never : never>>];
+        useQuery: <QK_2 extends keyof QP | keyof QR>(options: import("./types").UseQueryOptions<T, QP, QR, MP, MR, QK_2>) => readonly [import("./types").QueryMutationState<QK_2 extends keyof QP & keyof QR ? QR[QK_2] : never>, () => Promise<void>];
         /** Subscribes to provided mutation state and provides mutate function. */
-        useMutation: <MK_1 extends keyof MP | keyof MR>(options: {
-            /**
-             * Creates reducer, actions and hooks for managing queries and mutations through redux cache.
-             */
-            mutation: MK_1;
-            cacheOptions?: import("./types").MutationCacheOptions | undefined;
-        }) => readonly [(params: MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never) => Promise<void>, import("./types").QueryMutationState<MK_1 extends keyof MP & keyof MR ? MP[MK_1] : never>, AbortController | undefined];
+        useMutation: <MK_2 extends keyof MP | keyof MR>(options: {
+            mutation: MK_2;
+            cacheOptions?: MutationCacheOptions | undefined;
+        }) => readonly [(params: MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never) => Promise<void>, import("./types").QueryMutationState<MK_2 extends keyof MP & keyof MR ? MP[MK_2] : never>, () => boolean];
         /** Selects entity by id and subscribes to the changes. */
         useSelectEntityById: <K_3 extends keyof T>(id: Key | null | undefined, typename: K_3) => T[K_3] | undefined;
     };

package/dist/createCache.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCache = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const mutate_1 = require("./mutate");
 const query_1 = require("./query");
 const reducer_1 = require("./reducer");
 const useMutation_1 = require("./useMutation");
@@ -57,6 +58,7 @@ const createCache = (cache) => {
             },
         },
         hooks: {
+            /** Returns client object with query function */
             useClient: () => {
                 const store = (0, react_redux_1.useStore)();
                 return (0, react_1.useMemo)(() => {
@@ -77,6 +79,10 @@ const createCache = (cache) => {
                                     getParamsKey(params);
                             return (0, query_1.query)('query', true, store, nonPartialCache, queryKey, cacheKey, cacheOptions, params);
                         },
+                        mutate: (options) => {
+                            var _a;
+                            return (0, mutate_1.mutate)('mutate', true, store, nonPartialCache, options.mutation, (_a = options.cacheOptions) !== null && _a !== void 0 ? _a : useMutation_1.defaultMutationCacheOptions, options.params);
+                        },
                     };
                     return client;
                 }, [store]);

package/dist/index.js

@@ -30,9 +30,9 @@ Object.defineProperty(exports, "defaultQueryMutationState", { enumerable: true,
 Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get: function () { return utilsAndConstants_1.processEntityChanges; } });
 // Backlog
 // ! high
+// mutate
 // cover with tests
-// support changing query key?
-// make cache fields readonly
+// suport persist (no loading etc)
 // ! medium
 // type extractors from cache
 // custom useStore
@@ -55,6 +55,8 @@ Object.defineProperty(exports, "processEntityChanges", { enumerable: true, get:
 // make error type generic
 // proper types, remove as, any, todo
 // ! low
+// make types readonly
+// support changing query key?
 // remove defaultState and keep values undefined?
 // add params to the state?
 // cancellation to queries

package/dist/mutate.d.ts

@@ -0,0 +1,5 @@
+import { Store } from 'redux';
+import { Cache, Key, MutationCacheOptions, MutationResult, Typenames } from './types';
+export declare const abortControllers: WeakMap<Store<any, import("redux").AnyAction>, Record<Key, AbortController>>;
+export declare const getAbortController: (store: Store, mutationKey: Key) => AbortController | undefined;
+export declare const mutate: <T extends Typenames, QP, QR, MP, MR, MK extends keyof MP | keyof MR>(logTag: string, returnResult: boolean, store: Store, cache: Cache<T, QP, QR, MP, MR>, mutationKey: MK, cacheOptions: MutationCacheOptions, params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void | MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;

package/dist/mutate.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutate = exports.getAbortController = exports.abortControllers = void 0;
+const reducer_1 = require("./reducer");
+const utilsAndConstants_1 = require("./utilsAndConstants");
+exports.abortControllers = new WeakMap();
+const getAbortController = (store, mutationKey) => { var _a; return (_a = exports.abortControllers.get(store)) === null || _a === void 0 ? void 0 : _a[mutationKey]; };
+exports.getAbortController = getAbortController;
+const mutate = (logTag, returnResult, store, cache, mutationKey, cacheOptions, params) => __awaiter(void 0, void 0, void 0, function* () {
+    let abortControllersOfStore = exports.abortControllers.get(store);
+    if (abortControllersOfStore === undefined) {
+        abortControllersOfStore = {};
+        exports.abortControllers.set(store, abortControllersOfStore);
+    }
+    {
+        const abortController = abortControllersOfStore[mutationKey];
+        cache.options.logsEnabled &&
+            (0, utilsAndConstants_1.log)(logTag, {
+                mutationKey,
+                params,
+                previousAborted: abortController !== undefined,
+            });
+        if (abortController !== undefined) {
+            abortController.abort();
+        }
+        else {
+            cacheOptions.cacheMutationState &&
+                store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                    loading: true,
+                    result: undefined,
+                }));
+        }
+    }
+    const abortController = new AbortController();
+    abortControllersOfStore[mutationKey] = abortController;
+    let response;
+    let error;
+    const fetchFn = cache.mutations[mutationKey].mutation;
+    try {
+        response = yield fetchFn(
+        // @ts-expect-error fix later
+        params, abortController.signal);
+    }
+    catch (e) {
+        error = e;
+    }
+    cache.options.logsEnabled &&
+        (0, utilsAndConstants_1.log)(`${logTag} finished`, {
+            response,
+            error,
+            aborted: abortController.signal.aborted,
+        });
+    if (abortController.signal.aborted) {
+        return returnResult ? { aborted: true } : undefined;
+    }
+    delete abortControllersOfStore[mutationKey];
+    if (error) {
+        if (cacheOptions.cacheMutationState) {
+            store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                error: error,
+                loading: false,
+            }));
+        }
+        return { error };
+    }
+    if (response) {
+        store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, cacheOptions.cacheMutationState
+            ? {
+                error: undefined,
+                loading: false,
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                result: response.result,
+            }
+            : undefined, cacheOptions.cacheEntities ? response : undefined));
+        // @ts-expect-error fix later
+        return returnResult ? { result: response.result } : undefined;
+    }
+    throw new Error(`${logTag}: both error and response are not defined`);
+});
+exports.mutate = mutate;

package/dist/query.js

@@ -21,7 +21,7 @@ const query = (logTag, returnResult, store, cache, queryKey, cacheKey, cacheOpti
     const queryStateOnStart = cacheStateSelector(store.getState()).queries[queryKey][cacheKey];
     if (queryStateOnStart === null || queryStateOnStart === void 0 ? void 0 : queryStateOnStart.loading) {
         logsEnabled &&
-            (0, utilsAndConstants_1.log)(`${logTag} cancel: already loading`, {
+            (0, utilsAndConstants_1.log)(`${logTag} cancelled: already loading`, {
                 queryStateOnStart,
                 params,
                 cacheKey,

package/dist/types.d.ts

@@ -133,6 +133,11 @@ export type MutationResponse<T extends Typenames, R> = EntityChanges<T> & {
     /** Normalized result of a mutation. */
     result?: R;
 };
+export type MutationResult<R> = {
+    error?: unknown;
+    aborted?: true;
+    result?: R;
+};
 export type QueryMutationState<R> = {
     /** `true` when query or mutation is currently in progress. */
     loading: boolean;

package/dist/useMutation.d.ts

@@ -3,4 +3,4 @@ export declare const defaultMutationCacheOptions: MutationCacheOptions;
 export declare const useMutation: <T extends Typenames, MP, MR, MK extends keyof MP | keyof MR>(cache: Cache<T, unknown, unknown, MP, MR>, options: {
     mutation: MK;
     cacheOptions?: MutationCacheOptions | undefined;
-}) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, AbortController | undefined];
+}) => readonly [(params: MK extends keyof MP & keyof MR ? MP[MK] : never) => Promise<void>, QueryMutationState<MK extends keyof MP & keyof MR ? MP[MK] : never>, () => boolean];

package/dist/useMutation.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMutation = exports.defaultMutationCacheOptions = void 0;
 const react_1 = require("react");
 const react_redux_1 = require("react-redux");
+const mutate_1 = require("./mutate");
 const reducer_1 = require("./reducer");
 const utilsAndConstants_1 = require("./utilsAndConstants");
 exports.defaultMutationCacheOptions = {
@@ -21,11 +22,6 @@ exports.defaultMutationCacheOptions = {
 const useMutation = (cache, options) => {
     var _a, _b;
     const { mutation: mutationKey, cacheOptions = (_a = cache.mutations[mutationKey].cacheOptions) !== null && _a !== void 0 ? _a : exports.defaultMutationCacheOptions, } = options;
-    const dispatch = (0, react_redux_1.useDispatch)();
-    cache.options.logsEnabled &&
-        (0, utilsAndConstants_1.log)('useMutation', {
-            cacheOptions,
-        });
     // Check values that should be set once.
     // Can be removed from deps.
     cache.options.validateHookArguments &&
@@ -43,73 +39,47 @@ const useMutation = (cache, options) => {
                 // eslint-disable-next-line react-hooks/rules-of-hooks
                 .forEach((args) => (0, utilsAndConstants_1.useAssertValueNotChanged)(...args));
         })();
-    const abortControllerRef = (0, react_1.useRef)();
-    const mutationStateSelector = (0, react_1.useCallback)((state) => {
-        cache.options.logsEnabled &&
-            (0, utilsAndConstants_1.log)('mutationStateSelector', {
-                state,
-                cacheState: cache.cacheStateSelector(state),
-            });
-        return cache.cacheStateSelector(state).mutations[mutationKey];
-        // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, []);
-    // @ts-expect-error fix later
-    const mutationState = (_b = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultQueryMutationState;
-    const mutate = (0, react_1.useCallback)((params) => __awaiter(void 0, void 0, void 0, function* () {
-        cache.options.logsEnabled &&
-            (0, utilsAndConstants_1.log)('mutate', {
-                mutationKey,
-                params,
-                abortController: abortControllerRef.current,
-            });
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-        }
-        else {
-            cacheOptions.cacheMutationState &&
-                dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, { loading: true }));
-        }
-        const abortController = new AbortController();
-        abortControllerRef.current = abortController;
-        let response;
-        let error;
-        const fetchFn = cache.mutations[mutationKey].mutation;
-        try {
-            response = yield fetchFn(
-            // @ts-expect-error fix later
-            params, abortController.signal);
-        }
-        catch (e) {
-            error = e;
-        }
-        cache.options.logsEnabled &&
-            (0, utilsAndConstants_1.log)('mutate finished', {
-                response,
-                error,
-                aborted: abortController.signal.aborted,
-            });
-        if (abortController.signal.aborted) {
-            return;
-        }
-        abortControllerRef.current = undefined;
-        if (response) {
-            dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, cacheOptions.cacheMutationState
-                ? {
-                    error: undefined,
-                    loading: false,
-                    result: response.result,
+    const store = (0, react_redux_1.useStore)();
+    // Using single useMemo for performance reasons
+    const [mutationStateSelector, mutate, abort] = (0, react_1.useMemo)(() => {
+        return [
+            // mutationStateSelector
+            (state) => {
+                cache.options.logsEnabled &&
+                    (0, utilsAndConstants_1.log)('mutationStateSelector', {
+                        state,
+                        cacheState: cache.cacheStateSelector(state),
+                    });
+                return cache.cacheStateSelector(state).mutations[mutationKey];
+            },
+            // mutate
+            (params) => __awaiter(void 0, void 0, void 0, function* () {
+                yield (0, mutate_1.mutate)('useMutation.mutate', false, store, cache, mutationKey, cacheOptions, params);
+            }),
+            // abort
+            () => {
+                const abortController = (0, mutate_1.getAbortController)(store, mutationKey);
+                if (abortController === undefined || abortController.signal.aborted) {
+                    return false;
                 }
-                : undefined, cacheOptions.cacheEntities ? response : undefined));
-        }
-        else if (error && cacheOptions.cacheMutationState) {
-            dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
-                error: error,
-                loading: false,
-            }));
-        }
-    }), 
+                abortController.abort();
+                cacheOptions.cacheMutationState &&
+                    store.dispatch((0, reducer_1.setMutationStateAndEntities)(mutationKey, {
+                        loading: false,
+                    }));
+                return true;
+            },
+        ];
+    }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    []);
-    return [mutate, mutationState, abortControllerRef.current];
+    [store, cacheOptions.cacheEntities, cacheOptions.cacheMutationState]);
+    // @ts-expect-error fix later
+    const mutationState = (_b = (0, react_redux_1.useSelector)(mutationStateSelector)) !== null && _b !== void 0 ? _b : utilsAndConstants_1.defaultQueryMutationState;
+    cache.options.logsEnabled &&
+        (0, utilsAndConstants_1.log)('useMutation', {
+            options,
+            mutationState,
+        });
+    return [mutate, mutationState, abort];
 };
 exports.useMutation = useMutation;

package/dist/useQuery.d.ts

@@ -5,4 +5,4 @@ export declare const defaultQueryCacheOptions: {
     readonly cacheQueryState: true;
     readonly cacheEntities: true;
 };
-export declare const useQuery: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<void | 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: <T extends Typenames, QP, QR, MP, MR, QK extends keyof QP | keyof QR>(cache: Cache<T, QP, QR, MP, MR>, options: UseQueryOptions<T, QP, QR, MP, MR, QK>) => readonly [QueryMutationState<QK extends keyof QP & keyof QR ? QR[QK] : never>, () => Promise<void>];

package/dist/useQuery.js

@@ -1,4 +1,13 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useQuery = exports.defaultQueryCacheOptions = exports.queryCacheOptionsByPolicy = void 0;
 const react_1 = require("react");
@@ -51,25 +60,33 @@ const useQuery = (cache, options) => {
     // @ts-expect-error fix later
     params);
     const [cacheKey, resultSelector] = (0, react_1.useMemo)(() => {
-        const cacheKeyImpl = getCacheKey
-            ? // @ts-expect-error fix types later
-                getCacheKey(params)
-            : paramsKey;
-        const resultSelectorImpl = cacheResultSelector &&
-            ((state) => cacheResultSelector(cacheStateSelector(state), 
-            // @ts-expect-error fix types later
-            params));
-        return [cacheKeyImpl, resultSelectorImpl];
+        return [
+            // cacheKey
+            getCacheKey
+                ? // @ts-expect-error fix types later
+                    getCacheKey(params)
+                : paramsKey,
+            // resultSelector
+            cacheResultSelector &&
+                ((state) => cacheResultSelector(cacheStateSelector(state), 
+                // @ts-expect-error fix types later
+                params)),
+        ];
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [paramsKey]);
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const resultFromSelector = (resultSelector && (0, react_redux_1.useSelector)(resultSelector));
     const hasResultFromSelector = resultFromSelector !== undefined;
-    const cacheOptionsKey = `${cacheOptions.policy}${cacheOptions.cacheEntities}${cacheOptions.cacheQueryState}`; // Allows to not memoize cache options
-    const fetch = (0, react_1.useCallback)(() => {
-        return (0, query_1.query)('useQuery.fetch', false, store, cache, queryKey, cacheKey, cacheOptions, params);
+    const fetch = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, query_1.query)('useQuery.fetch', false, store, cache, queryKey, cacheKey, cacheOptions, params);
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [cacheKey, paramsKey, cacheOptionsKey]); // TODO put args to ref and make empty deps?
+    }), [
+        cacheKey,
+        paramsKey,
+        cacheOptions.policy,
+        cacheOptions.cacheEntities,
+        cacheOptions.cacheQueryState,
+    ]);
     const queryStateFromSelector = (_c = (0, react_redux_1.useSelector)((state) => {
         const queryState = cacheStateSelector(state).queries[queryKey][cacheKey];
         return queryState; // TODO proper type
@@ -101,6 +118,11 @@ const useQuery = (cache, options) => {
             resultFromSelector,
             queryState,
         });
-    return [queryState, fetch];
+    return [
+        /** Query state */
+        queryState,
+        /** Refetch query with the same parameters */
+        fetch,
+    ];
 };
 exports.useQuery = useQuery;

package/dist/utilsAndConstants.js

@@ -98,11 +98,12 @@ const processEntityChanges = (entities, changes, options) => {
         result !== null && result !== void 0 ? result : (result = Object.assign({}, entities));
         result[typename] = newEntities;
     }
-    (0, exports.log)('processEntityChanges', {
-        entities,
-        changes,
-        result,
-    });
+    options.logsEnabled &&
+        (0, exports.log)('processEntityChanges', {
+            entities,
+            changes,
+            result,
+        });
     return result;
 };
 exports.processEntityChanges = processEntityChanges;

package/package.json

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