react-redux-cache 0.18.1 → 0.18.3

package/dist/createCache.d.ts

@@ -175,6 +175,11 @@ export declare const withTypenames: <T extends Typenames = Typenames>() => {
             useSelectEntityById: <TN extends keyof T>(id: Key | null | undefined, typename: TN) => T[TN] | undefined;
         };
         utils: {
+            /** Creates client by providing the store. Can be used when the store is a singleton - to not use a hook for getting the client, but import it directly. */
+            createClient: (store: Store) => {
+                query: <QK extends keyof (QP & QR)>(options: QueryOptions<N, T, QP, QR, QK, MP, MR>) => Promise<QueryResult<QK extends keyof QP & keyof QR ? QR[QK] : never>>;
+                mutate: <MK extends keyof (MP & MR)>(options: MutateOptions<N, T, QP, QR, MP, MR, MK>) => Promise<MutationResult<MK extends keyof MP & keyof MR ? MR[MK] : never>>;
+            };
             /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
             getInitialState: () => import("./types").CacheState<T, QP, QR, MP, MR>;
             /** Apply changes to the entities map.
@@ -359,6 +364,11 @@ export declare const createCache: <N extends string, QP, QR, MP, MR>(partialCach
         useSelectEntityById: <TN extends string>(id: Key | null | undefined, typename: TN) => object | undefined;
     };
     utils: {
+        /** Creates client by providing the store. Can be used when the store is a singleton - to not use a hook for getting the client, but import it directly. */
+        createClient: (store: Store) => {
+            query: <QK_1 extends keyof QP | keyof QR>(options: QueryOptions<N, Typenames, QP, QR, QK_1, MP, MR>) => Promise<QueryResult<QK_1 extends keyof QP & keyof QR ? QR[QK_1] : never>>;
+            mutate: <MK_1 extends keyof MP | keyof MR>(options: MutateOptions<N, Typenames, QP, QR, MP, MR, MK_1>) => Promise<MutationResult<MK_1 extends keyof MP & keyof MR ? MR[MK_1] : never>>;
+        };
         /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
         getInitialState: () => import("./types").CacheState<Typenames, QP, QR, MP, MR>;
         /** Apply changes to the entities map.

package/dist/createCache.js

@@ -37,10 +37,8 @@ const withTypenames = () => {
             (_g = (_s = partialCache.globals.queries).fetchPolicy) !== null && _g !== void 0 ? _g : (_s.fetchPolicy = utilsAndConstants_1.FetchPolicy.NoCacheOrExpired);
             (_h = (_t = partialCache.globals.queries).skipFetch) !== null && _h !== void 0 ? _h : (_t.skipFetch = false);
             (_j = partialCache.storeHooks) !== null && _j !== void 0 ? _j : (partialCache.storeHooks = {
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                useStore: require('react-redux').useStore,
-                // eslint-disable-next-line @typescript-eslint/no-var-requires
-                useSelector: require('react-redux').useSelector,
+                useStore: require.call(undefined, 'react-redux').useStore,
+                useSelector: require.call(undefined, 'react-redux').useSelector,
             });
             (_k = partialCache.cacheStateSelector) !== null && _k !== void 0 ? _k : (partialCache.cacheStateSelector = (state) => state[cache.name]);
             (_l = partialCache.mutations) !== null && _l !== void 0 ? _l : (partialCache.mutations = {});
@@ -60,6 +58,27 @@ const withTypenames = () => {
             const { updateQueryStateAndEntities, updateMutationStateAndEntities, mergeEntityChanges, invalidateQuery, clearQueryState, clearMutationState, clearCache, } = actions;
             // reducer
             const reducer = (0, createCacheReducer_1.createCacheReducer)(actions, Object.keys(cache.queries), cache.options);
+            // createClient
+            const createClient = (store) => {
+                const client = {
+                    query: (options) => {
+                        var _a;
+                        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, 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, selectors, options.mutation, options.params, abortControllers, 
+                        // @ts-expect-error fix later
+                        options.onCompleted, options.onSuccess, options.onError);
+                    },
+                };
+                return client;
+            };
             return {
                 /** Keeps all options, passed while creating the cache. */
                 cache,
@@ -118,26 +137,7 @@ const withTypenames = () => {
                     /** Returns client object with query and mutate functions. */
                     useClient: () => {
                         const store = cache.storeHooks.useStore();
-                        return (0, react_1.useMemo)(() => {
-                            const client = {
-                                query: (options) => {
-                                    var _a;
-                                    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, 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, selectors, options.mutation, options.params, abortControllers, 
-                                    // @ts-expect-error fix later
-                                    options.onCompleted, options.onSuccess, options.onError);
-                                },
-                            };
-                            return client;
-                        }, [store]);
+                        return (0, react_1.useMemo)(() => createClient(store), [store]);
                     },
                     /** Fetches query when params change and subscribes to query state changes (except `expiresAt` field). */
                     useQuery: (options) => (0, useQuery_1.useQuery)(cache, actions, selectors, options),
@@ -149,6 +149,8 @@ const withTypenames = () => {
                     },
                 },
                 utils: {
+                    /** Creates client by providing the store. Can be used when the store is a singleton - to not use a hook for getting the client, but import it directly. */
+                    createClient,
                     /** Generates the initial state by calling a reducer. Not needed for redux — it already generates it the same way when creating the store. */
                     getInitialState: () => {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/createCacheReducer.js

@@ -48,15 +48,24 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                 const oldQueryState = state.queries[queryKey][queryCacheKey];
                 let newQueryState = queryState && Object.assign(Object.assign({}, oldQueryState), queryState);
                 if (newQueryState) {
+                    if (oldQueryState && deepEqual) {
+                        // set back params if deeply same value
+                        if (newQueryState.params !== oldQueryState.params &&
+                            deepEqual(newQueryState.params, oldQueryState.params)) {
+                            newQueryState.params = oldQueryState.params;
+                        }
+                        // set back if deeply same value
+                        if (newQueryState.result !== oldQueryState.result &&
+                            deepEqual(newQueryState.result, oldQueryState.result)) {
+                            newQueryState.result = oldQueryState.result;
+                        }
+                    }
                     // remove undefined optional fields
                     for (const key of optionalQueryKeys) {
                         if (key in newQueryState && newQueryState[key] === undefined) {
                             delete newQueryState[key];
                         }
                     }
-                    if ('loading' in newQueryState && !newQueryState.loading) {
-                        delete newQueryState.loading;
-                    }
                     // skip if new state deep equals to the old state
                     if (deepEqual === null || deepEqual === void 0 ? void 0 : deepEqual(oldQueryState !== null && oldQueryState !== void 0 ? oldQueryState : utilsAndConstants_1.EMPTY_OBJECT, newQueryState)) {
                         newQueryState = undefined;
@@ -87,6 +96,18 @@ const createCacheReducer = (actions, queryKeys, cacheOptions) => {
                 const oldMutationState = state.mutations[mutationKey];
                 let newMutationState = mutationState && Object.assign(Object.assign({}, oldMutationState), mutationState);
                 if (newMutationState) {
+                    if (oldMutationState && deepEqual) {
+                        // set back params if deeply same value
+                        if (newMutationState.params !== oldMutationState.params &&
+                            deepEqual(newMutationState.params, oldMutationState.params)) {
+                            newMutationState.params = oldMutationState.params;
+                        }
+                        // set back if deeply same value
+                        if (newMutationState.result !== oldMutationState.result &&
+                            deepEqual(newMutationState.result, oldMutationState.result)) {
+                            newMutationState.result = oldMutationState.result;
+                        }
+                    }
                     // remove optional fields with default values
                     for (const key of optionalMutationKeys) {
                         if (key in newMutationState && newMutationState[key] === undefined) {

package/dist/index.js

@@ -26,13 +26,10 @@ Object.defineProperty(exports, "defaultGetCacheKey", { enumerable: true, get: fu
 Object.defineProperty(exports, "FetchPolicy", { enumerable: true, get: function () { return utilsAndConstants_1.FetchPolicy; } });
 Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: function () { return utilsAndConstants_1.isEmptyObject; } });
 // Backlog
-// highest
-// generate full api docs
-// cancel all queries / mutations
-// selectors optional cache key
 // ! high (1.0.0-rc.0)
+// generate full api docs
 // optimistic response
-// features list
+// features list (table)
 // ! medium
 // onCancel & onAbort
 // remove empty entities and queries from state
@@ -51,3 +48,7 @@ Object.defineProperty(exports, "isEmptyObject", { enumerable: true, get: functio
 // readonly types?
 // proper types, remove as, any, todo
 // add number of retries param?
+// mutation state wrong type - can be undefined?
+// ! on hold
+// better support queries without params: useQuery & selectors optional cache key (making useQuery params optional doesn't seem like a good idea)
+// cancel all queries / mutations (already possible by recreating the store - this lib is pure)

package/dist/utilsAndConstants.js

@@ -6,7 +6,7 @@ exports.optionalUtils = {
     deepEqual: undefined,
 };
 try {
-    exports.optionalUtils.deepEqual = require('fast-deep-equal/es6');
+    exports.optionalUtils.deepEqual = require.call(undefined, 'fast-deep-equal/es6');
 }
 catch (_a) {
     console.debug(exports.PACKAGE_SHORT_NAME + ': fast-deep-equal optional dependency was not installed');

package/package.json

@@ -2,7 +2,7 @@
   "name": "react-redux-cache",
   "author": "Alexander Danilov",
   "license": "MIT",
-  "version": "0.18.1",
+  "version": "0.18.3",
   "description": "Powerful data fetching and caching library for Redux and Zustand that supports normalization.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",