tanstack-cacher 1.4.0 → 1.4.2

package/index.d.ts

@@ -1,6 +1,7 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import { QueryClient, QueryKey, UseMutationOptions } from '@tanstack/react-query';
 export * from '@tanstack/react-query';
+import react, { ReactNode } from 'react';
 
 interface PaginationConfig {
     totalElementsPath?: string;
@@ -43,6 +44,7 @@ declare class QueryCacheManager<TData, TItem> {
     refetch(key?: string | string[]): void;
     hasQuery(key?: string): boolean;
     removeQuery(key?: string): void;
+    getConfig(): typeof this.config;
     createHandlers(): CacheHandlers<TItem>;
 }
 
@@ -68,13 +70,20 @@ type CustomMutationOptions<TData, TError, TVariables> = UseMutationOptions<TData
     successMessage?: string;
     cacheActions?: CacheActions<TData>[] | CacheActions<TData>;
     notificationConfig?: NotificationOptions;
-    getErrorMessage?: (error: TError) => string;
 };
 interface NotificationOptions {
     duration?: number;
     [key: string]: any;
 }
 
+interface CacheContextType {
+    showError: (message: string, options?: NotificationOptions) => void;
+    showSuccess: (message: string, options?: NotificationOptions) => void;
+    getErrorMessage: (error: any) => void;
+}
+
+declare const useCacherContext: () => CacheContextType;
+
 declare const useCustomMutation: <TData, TError, TVariables = void>(options: CustomMutationOptions<TData, TError, TVariables>) => _tanstack_react_query.UseMutationResult<TData, TError, TVariables, unknown>;
 
 declare const useQueryCacheManagers: <T extends Record<string, QueryCacheManager<any, any>>>(configs: { [K in keyof T]: {
@@ -82,16 +91,15 @@ declare const useQueryCacheManagers: <T extends Record<string, QueryCacheManager
     options?: Partial<Omit<CacheConfig<any, any>, "queryClient">>;
 }; }) => T;
 
-interface NotificationContextType {
-    showError: (message: string, options?: NotificationOptions) => void;
-    showSuccess: (message: string, options?: NotificationOptions) => void;
+interface CacheProviderProps {
+    children: ReactNode;
+    config: CacheContextType;
 }
-
-declare const useNotificationContext: () => NotificationContextType;
+declare const CacheProvider: ({ config, children }: CacheProviderProps) => react.JSX.Element;
 
 type CacheOptions<TData = any, TItem = any> = Omit<CacheConfig<TData, TItem>, 'queryClient' | 'queryKey'>;
 
 declare const resetCacheManager: (queryKey: QueryKey) => void;
 declare const resetAllCacheManagers: () => void;
 
-export { type CacheConfig, type CacheHandlers, type CacheManagerConstructor, type CacheOptions, type CustomMutationOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, cacheManagerFactory, resetAllCacheManagers, resetCacheManager, useCustomMutation, useNotificationContext, useQueryCacheManagers };
+export { type CacheConfig, type CacheHandlers, type CacheManagerConstructor, type CacheOptions, CacheProvider, type CustomMutationOptions, type InsertPosition, type PaginationConfig, QueryCacheManager, cacheManagerFactory, resetAllCacheManagers, resetCacheManager, useCacherContext, useCustomMutation, useQueryCacheManagers };

package/index.js

@@ -1,9 +1,25 @@
 'use strict';
 
+var React = require('react');
 var reactQuery = require('@tanstack/react-query');
-var react = require('react');
 
-// src/hooks/useCustomMutation.ts
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/hooks/useCacherContext.ts
+var CacheContext = React.createContext(void 0);
+
+// src/hooks/useCacherContext.ts
+var useCacherContext = () => {
+  const context = React.useContext(CacheContext);
+  if (!context) {
+    console.warn(
+      "useCacherContext was called outside of <NotificationProvider />. Wrap your app with <NotificationProvider /> to enable notifications."
+    );
+  }
+  return context;
+};
 
 // src/managers/QueryCacheManager/QueryCache.utils.ts
 function getAtPath(obj, path, defaultValue) {
@@ -352,6 +368,9 @@ var QueryCacheManager = class {
     const queryKey = key ?? this.config.queryKey;
     this.config.queryClient.removeQueries({ queryKey: [queryKey] });
   }
+  getConfig() {
+    return this.config;
+  }
   /**
    * Get handlers for use with mutations
    *
@@ -385,18 +404,6 @@ var CacheManagerFactory = class {
   }
 };
 var cacheManagerFactory = new CacheManagerFactory();
-var NotificationContext = react.createContext(
-  void 0
-);
-
-// src/hooks/useNotificationContext.ts
-var useNotificationContext = () => {
-  const context = react.useContext(NotificationContext);
-  if (!context) {
-    throw new Error("useNotificationContext must be used within an NotificationProvider");
-  }
-  return context;
-};
 
 // src/hooks/useCustomMutation.ts
 var useCustomMutation = (options) => {
@@ -407,38 +414,37 @@ var useCustomMutation = (options) => {
     notify = false,
     notifyError = false,
     notifySuccess = false,
-    errorMessage = "Operation failed!",
-    successMessage = "Operation successfull!",
+    successMessage = "\u018Fm\u0259liyyat u\u011Furla tamamland\u0131!",
+    errorMessage = "\u018Fm\u0259liyyat zaman\u0131 x\u0259ta ba\u015F verdi!",
     notificationConfig = { duration: 2 },
-    getErrorMessage,
     ...rest
   } = options;
-  const notificationContext = useNotificationContext();
+  const cacherContext = useCacherContext();
+  const shouldNotifyError = notify || notifyError;
+  const shouldNotifySuccess = notify || notifySuccess;
+  const cacheActionsToRun = Array.isArray(cacheActions) ? cacheActions : cacheActions ? [cacheActions] : [];
+  const runCacheActions = (data) => {
+    cacheActionsToRun.forEach((action) => {
+      const { type, ...config } = action;
+      const manager = cacheManagerFactory.create(config);
+      runCacheManagers(type, manager, data);
+    });
+  };
   return reactQuery.useMutation({
     ...rest,
-    onSuccess: (data, variables, mResult, context) => {
-      if (notify || notifySuccess) {
-        notificationContext?.showSuccess?.(successMessage, notificationConfig);
-      }
-      onSuccess?.(data, variables, mResult, context);
-      if (Array.isArray(cacheActions)) {
-        cacheActions.forEach((item) => {
-          const { type, ...rest2 } = item;
-          const manager = cacheManagerFactory.create(rest2);
-          runCacheManagers(type, manager, data);
-        });
-      } else if (cacheActions) {
-        const { type, ...rest2 } = cacheActions;
-        const manager = cacheManagerFactory.create(rest2);
-        runCacheManagers(type, manager, data);
+    onSuccess: (data, variables, meta, context) => {
+      if (shouldNotifySuccess) {
+        cacherContext?.showSuccess?.(successMessage, notificationConfig);
       }
+      onSuccess?.(data, variables, meta, context);
+      runCacheActions(data);
     },
-    onError: (apiError, variables, mResult, context) => {
-      const message = getErrorMessage ? getErrorMessage(apiError) : apiError?.error?.message ?? errorMessage;
-      if (notify || notifyError) {
-        notificationContext?.showError(message, notificationConfig);
+    onError: (apiError, variables, meta, context) => {
+      const message = cacherContext?.getErrorMessage?.(apiError) ?? apiError?.error?.message ?? errorMessage;
+      if (shouldNotifyError) {
+        cacherContext?.showError?.(message, notificationConfig);
       }
-      onError?.(apiError, variables, mResult, context);
+      onError?.(apiError, variables, meta, context);
     }
   });
 };
@@ -456,6 +462,9 @@ var useQueryCacheManagers = (configs) => {
   });
   return managers;
 };
+var CacheProvider = ({ config, children }) => {
+  return /* @__PURE__ */ React__default.default.createElement(CacheContext.Provider, { value: config }, children);
+};
 
 // src/utils/cacheRegistry.ts
 var cacheConfigRegistry = /* @__PURE__ */ new Map();
@@ -484,12 +493,13 @@ var resetAllCacheManagers = () => {
   cacheRegistry.clear();
 };
 
+exports.CacheProvider = CacheProvider;
 exports.QueryCacheManager = QueryCacheManager;
 exports.cacheManagerFactory = cacheManagerFactory;
 exports.resetAllCacheManagers = resetAllCacheManagers;
 exports.resetCacheManager = resetCacheManager;
+exports.useCacherContext = useCacherContext;
 exports.useCustomMutation = useCustomMutation;
-exports.useNotificationContext = useNotificationContext;
 exports.useQueryCacheManagers = useQueryCacheManagers;
 Object.keys(reactQuery).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tanstack-cacher",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "A lightweight cache management utility for TanStack Query that simplifies adding, updating, deleting, and synchronizing cached data",
   "license": "MIT",
   "repository": {
@@ -17,6 +17,11 @@
       "name": "Hasanli Hajagha",
       "email": "hacagahasanli@gmail.com",
       "web": "http://github.com/hacagahasanli"
+    },
+    {
+      "name": "Sahira Mammadova",
+      "email": "mammadovasahira@gmail.com",
+      "web": "https://github.com/SahiraMamedova"
     }
   ],
   "homepage": "https://github.com/hacagahasanli/tanstack-cacher#readme",
@@ -40,8 +45,8 @@
   ],
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
+      "import": "./index.js",
+      "types": "./index.d.ts"
     },
     "./package.json": "./package.json"
   },