@choksheak/react-utils 0.2.0 → 0.2.2

package/sharedQuery.js

@@ -21,15 +21,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var sharedQuery_exports = {};
 __export(sharedQuery_exports, {
   SharedQuery: () => SharedQuery,
+  SharedQueryDefaults: () => SharedQueryDefaults,
   sharedQuery: () => sharedQuery,
-  useQuery: () => useQuery
+  useSharedQuery: () => useSharedQuery
 });
 module.exports = __toCommonJS(sharedQuery_exports);
-var import_kvStore3 = require("@choksheak/ts-utils/kvStore");
+var import_timeConstants2 = require("@choksheak/ts-utils/timeConstants");
 var import_react2 = require("react");
 
 // src/sharedState.ts
-var import_kvStore2 = require("@choksheak/ts-utils/kvStore");
 var import_timeConstants = require("@choksheak/ts-utils/timeConstants");
 var import_react = require("react");
 
@@ -134,17 +134,17 @@ var IndexedDbAdapter = class {
 };
 
 // src/sharedState.ts
-var SharedStateConfig = class {
+var SharedStateDefaults = {
   /**
    * Default duration for storage expiration in milliseconds. Initial value
    * is 30 days, but can be changed to anything.
    */
-  static storeExpiryMs = import_timeConstants.MS_PER_DAY * 30;
+  storeExpiryMs: 30 * import_timeConstants.MS_PER_DAY,
   /**
    * True to load from storage only on mount, false (default) to load in
    * the top level scope when the shared state is defined.
    */
-  static lazyLoad = false;
+  lazyLoad: false
 };
 var PubSubStore = class {
   dataByKey = /* @__PURE__ */ new Map();
@@ -199,11 +199,14 @@ var SharedState = class {
   constructor(defaultValue, options) {
     this.defaultValue = defaultValue;
     this.pubSubKey = String(stateKey++);
-    this.storageAdapter = getStorageAdapter(options, import_kvStore2.DEFAULT_EXPIRY_DELTA_MS);
+    this.storageAdapter = getStorageAdapter(
+      options,
+      SharedStateDefaults.storeExpiryMs
+    );
     this.setValueBounded = (arg) => this.setValue(arg);
     pubSubStore.setNoNotify(this.pubSubKey, defaultValue);
     const lazyLoad = options?.lazyLoad;
-    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
+    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateDefaults.lazyLoad;
     if (!lazy) {
       void this.initDefaultValueOnce();
     }
@@ -265,7 +268,7 @@ function stringifyDeterministicForKeys(params) {
     if (typeof value === "function") {
       throw new Error(`Functions should not be passed into query parameters`);
     }
-    if (!value || typeof value !== "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
       return value;
     }
     if (cache.has(value)) {
@@ -290,14 +293,31 @@ function stringifyDeterministicForKeys(params) {
 }
 
 // src/sharedQuery.ts
-var DEFAULT_STALE_MS = 0;
+var SharedQueryDefaults = {
+  staleMs: 0,
+  expiryMs: 30 * import_timeConstants2.MS_PER_DAY,
+  persistTo: void 0
+};
 var SharedQuery = class {
-  constructor(queryName, fetchFn, options) {
-    this.queryName = queryName;
-    this.fetchFn = fetchFn;
-    this.expiryMs = options?.expiryMs !== void 0 ? options?.expiryMs : import_kvStore3.DEFAULT_EXPIRY_DELTA_MS;
-    this.staleMs = options?.staleMs !== void 0 ? options?.staleMs : DEFAULT_STALE_MS;
-    this.revalidateOnStale = Boolean(options?.revalidateOnStale);
+  inflightPromises = /* @__PURE__ */ new Map();
+  queryState;
+  queryName;
+  queryFn;
+  expiryMs;
+  staleMs;
+  refetchOnStale;
+  constructor(options) {
+    this.queryName = options.queryName;
+    this.queryFn = options.queryFn;
+    this.expiryMs = options?.expiryMs !== void 0 ? options?.expiryMs : SharedQueryDefaults.expiryMs;
+    this.staleMs = options?.staleMs !== void 0 ? options?.staleMs : SharedQueryDefaults.staleMs;
+    this.refetchOnStale = Boolean(options?.refetchOnStale);
+    const persistTo = options.persistTo ?? SharedQueryDefaults.persistTo;
+    if (persistTo === "localStorage") {
+      options.localStorageKey = options.queryName;
+    } else if (persistTo === "indexedDb") {
+      options.indexedDbKey = options.queryName;
+    }
     this.queryState = sharedState(
       {},
       {
@@ -307,109 +327,101 @@ var SharedQuery = class {
       }
     );
   }
-  inflightPromises = /* @__PURE__ */ new Map();
-  queryState;
-  expiryMs;
-  staleMs;
-  revalidateOnStale;
   getQueryKey(args) {
     return this.queryName + ":" + stringifyDeterministicForKeys(args);
   }
-  isStale(entry) {
+  isStale(dataUpdatedMs) {
     if (this.staleMs === 0) return true;
-    const ageMs = Date.now() - entry.updatedMs;
+    const ageMs = Date.now() - dataUpdatedMs;
     return ageMs > this.staleMs;
   }
-  isExpired(entry) {
+  isExpired(dataUpdatedMs) {
     if (this.expiryMs === 0) return false;
-    const ageMs = Date.now() - entry.updatedMs;
+    const ageMs = Date.now() - dataUpdatedMs;
     return ageMs > this.expiryMs;
   }
-  fetchNoCaching(queryKey, ...args) {
+  async getCachedOrFetch(...args) {
+    const queryKey = this.getQueryKey(args);
+    const cached = this.queryState.getSnapshot()?.[queryKey];
+    if (cached?.data && !this.isExpired(cached.dataUpdatedMs ?? 0)) {
+      if (!this.isStale(cached.dataUpdatedMs ?? 0)) {
+        console.log(
+          `Return fresh data ${queryKey} from cache without fetching`
+        );
+        return cached.data;
+      }
+      if (this.refetchOnStale) {
+        console.log(`refetchOnStale for ${queryKey}`);
+        void this.dedupedFetch(queryKey, ...args);
+      }
+      console.log(`Returning stale data for ${queryKey}`);
+      return cached.data;
+    }
+    return await this.dedupedFetch(queryKey, ...args);
+  }
+  dedupedFetch(queryKey, ...args) {
     const inflightPromise = this.inflightPromises.get(queryKey);
     if (inflightPromise) {
       console.log(`Deduplicating inflight fetch for ${queryKey}`);
       return inflightPromise;
     }
+    const promise = this.startFetching(queryKey, args);
+    this.inflightPromises.set(queryKey, promise);
+    return promise;
+  }
+  async startFetching(queryKey, args) {
     console.log(`Start fetching ${queryKey}`);
-    const promise = this.fetchFn(...args).then((result) => {
+    try {
+      const data = await this.queryFn(...args);
       console.log(`Successfully fetched ${queryKey}`);
-      this.setCache(queryKey, result);
-      return result;
-    }).catch((e) => {
+      this.setData(queryKey, data, Date.now());
+      return data;
+    } catch (e) {
       console.error(`Failed to fetch ${queryKey}: ${e}`);
       throw e;
-    }).finally(() => {
+    } finally {
       this.inflightPromises.delete(queryKey);
-    });
-    this.inflightPromises.set(queryKey, promise);
-    return promise;
-  }
-  async getCachedOrFetch(...args) {
-    const queryKey = this.getQueryKey(args);
-    const cached = this.queryState.getSnapshot()?.[queryKey];
-    if (cached?.data && !this.isExpired(cached.data)) {
-      if (!this.isStale(cached.data)) {
-        console.log(
-          `Return fresh data ${queryKey} from cache without fetching`
-        );
-        return cached.data.value;
-      }
-      if (this.revalidateOnStale) {
-        console.log(`revalidateOnStale for ${queryKey}`);
-        void this.fetchNoCaching(queryKey, ...args);
-      }
-      console.log(`Returning stale data for ${queryKey}`);
-      return cached.data.value;
     }
-    return await this.fetchNoCaching(queryKey, ...args);
   }
-  async setCache(queryKey, value) {
+  /** Set the data directly if the user obtained it from somewhere else. */
+  async setData(queryKey, data, dataUpdatedMs = Date.now()) {
     const entry = {
-      data: { value, updatedMs: Date.now() },
       loading: false,
-      error: null
+      data,
+      dataUpdatedMs
     };
     this.queryState.setValue((prev) => ({ ...prev, [queryKey]: entry }));
   }
   /** Do a new fetch even when the data is already cached. */
   async updateFromSource(...args) {
     const key = this.getQueryKey(args);
-    return await this.fetchNoCaching(key, ...args);
-  }
-  /** Delete the currently cached data. */
-  invalidate(args) {
-    if (args) {
-      const queryKey = this.getQueryKey(args);
-      const record = this.queryState.getSnapshot();
-      const clone = { ...record };
-      delete clone[queryKey];
-      this.queryState.setValue(clone);
-      this.inflightPromises.delete(queryKey);
-    } else {
-      this.clearAll();
-    }
+    return await this.dedupedFetch(key, ...args);
+  }
+  /** Delete the cached data for one set of arguments. */
+  deleteData(args) {
+    const queryKey = this.getQueryKey(args);
+    const record = this.queryState.getSnapshot();
+    const clone = { ...record };
+    delete clone[queryKey];
+    this.queryState.setValue(clone);
+    this.inflightPromises.delete(queryKey);
   }
-  /** Delete the currently cached data & all inflight promises. */
-  clearAll() {
+  /** Delete all currently cached data & all inflight promises. */
+  clear() {
     this.queryState.delete();
     this.inflightPromises.clear();
   }
 };
 var seenQueryNames = /* @__PURE__ */ new Set();
-function sharedQuery(queryName, fetchFn, options) {
-  if (seenQueryNames.has(queryName)) {
-    throw new Error(`Duplicate shared query "${queryName}"`);
+function sharedQuery(options) {
+  if (seenQueryNames.has(options.queryName)) {
+    throw new Error(`Duplicate shared query "${options.queryName}"`);
   }
-  seenQueryNames.add(queryName);
-  return new SharedQuery(queryName, fetchFn, options);
+  seenQueryNames.add(options.queryName);
+  return new SharedQuery(options);
 }
-var DEFAULT_QUERY_STATE_ENTRY = {
-  data: null,
-  loading: true,
-  error: null
-};
-function useQuery(query, args) {
+var DEFAULT_QUERY_STATE_ENTRY = { loading: true };
+function useSharedQuery(query, args = []) {
   const [queryState, setQueryState] = useSharedState(query.queryState);
   const isMounted = (0, import_react2.useRef)(true);
   const queryKey = query.getQueryKey(args);
@@ -418,25 +430,21 @@ function useQuery(query, args) {
     setQueryState((prev) => {
       const clone = { ...prev };
       clone[queryKey] = {
-        data: clone[queryKey]?.data ?? null,
-        loading: true,
-        error: null
+        ...clone[queryKey] ?? {},
+        loading: true
       };
       return clone;
     });
     try {
-      const value = await query.getCachedOrFetch(...args);
+      const data = await query.getCachedOrFetch(...args);
       if (isMounted.current) {
         setQueryState((prev) => {
           const clone = { ...prev };
-          const now = Date.now();
           clone[queryKey] = {
-            data: {
-              value,
-              updatedMs: now
-            },
+            // Don't keep old error.
             loading: false,
-            error: null
+            data,
+            dataUpdatedMs: Date.now()
           };
           return clone;
         });
@@ -447,9 +455,11 @@ function useQuery(query, args) {
         setQueryState((prev) => {
           const clone = { ...prev };
           clone[queryKey] = {
-            data: clone[queryKey]?.data ?? null,
+            // Keep old data.
+            ...clone[queryKey] ?? {},
             loading: false,
-            error
+            error,
+            errorUpdatedMs: Date.now()
           };
           return clone;
         });
@@ -463,11 +473,26 @@ function useQuery(query, args) {
       isMounted.current = false;
     };
   }, [execute]);
-  return queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
+  return (0, import_react2.useMemo)(() => {
+    const state = queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
+    return {
+      ...state,
+      refetch: () => {
+        return query.updateFromSource(...args);
+      },
+      setData: (data, dataUpdatedMs) => {
+        query.setData(queryKey, data, dataUpdatedMs ?? Date.now());
+      },
+      deleteData: () => {
+        query.deleteData(args);
+      }
+    };
+  }, [query, queryKey, queryState]);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   SharedQuery,
+  SharedQueryDefaults,
   sharedQuery,
-  useQuery
+  useSharedQuery
 });

package/sharedQuery.mjs

@@ -1,9 +1,8 @@
 // src/sharedQuery.ts
-import { DEFAULT_EXPIRY_DELTA_MS as DEFAULT_EXPIRY_DELTA_MS2 } from "@choksheak/ts-utils/kvStore";
-import { useCallback, useEffect, useRef } from "react";
+import { MS_PER_DAY as MS_PER_DAY2 } from "@choksheak/ts-utils/timeConstants";
+import { useCallback, useEffect, useMemo, useRef } from "react";
 
 // src/sharedState.ts
-import { DEFAULT_EXPIRY_DELTA_MS } from "@choksheak/ts-utils/kvStore";
 import { MS_PER_DAY } from "@choksheak/ts-utils/timeConstants";
 import { useSyncExternalStore } from "react";
 
@@ -108,17 +107,17 @@ var IndexedDbAdapter = class {
 };
 
 // src/sharedState.ts
-var SharedStateConfig = class {
+var SharedStateDefaults = {
   /**
    * Default duration for storage expiration in milliseconds. Initial value
    * is 30 days, but can be changed to anything.
    */
-  static storeExpiryMs = MS_PER_DAY * 30;
+  storeExpiryMs: 30 * MS_PER_DAY,
   /**
    * True to load from storage only on mount, false (default) to load in
    * the top level scope when the shared state is defined.
    */
-  static lazyLoad = false;
+  lazyLoad: false
 };
 var PubSubStore = class {
   dataByKey = /* @__PURE__ */ new Map();
@@ -173,11 +172,14 @@ var SharedState = class {
   constructor(defaultValue, options) {
     this.defaultValue = defaultValue;
     this.pubSubKey = String(stateKey++);
-    this.storageAdapter = getStorageAdapter(options, DEFAULT_EXPIRY_DELTA_MS);
+    this.storageAdapter = getStorageAdapter(
+      options,
+      SharedStateDefaults.storeExpiryMs
+    );
     this.setValueBounded = (arg) => this.setValue(arg);
     pubSubStore.setNoNotify(this.pubSubKey, defaultValue);
     const lazyLoad = options?.lazyLoad;
-    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateConfig.lazyLoad;
+    const lazy = lazyLoad !== void 0 ? lazyLoad : SharedStateDefaults.lazyLoad;
     if (!lazy) {
       void this.initDefaultValueOnce();
     }
@@ -239,7 +241,7 @@ function stringifyDeterministicForKeys(params) {
     if (typeof value === "function") {
       throw new Error(`Functions should not be passed into query parameters`);
     }
-    if (!value || typeof value !== "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
       return value;
     }
     if (cache.has(value)) {
@@ -264,14 +266,31 @@ function stringifyDeterministicForKeys(params) {
 }
 
 // src/sharedQuery.ts
-var DEFAULT_STALE_MS = 0;
+var SharedQueryDefaults = {
+  staleMs: 0,
+  expiryMs: 30 * MS_PER_DAY2,
+  persistTo: void 0
+};
 var SharedQuery = class {
-  constructor(queryName, fetchFn, options) {
-    this.queryName = queryName;
-    this.fetchFn = fetchFn;
-    this.expiryMs = options?.expiryMs !== void 0 ? options?.expiryMs : DEFAULT_EXPIRY_DELTA_MS2;
-    this.staleMs = options?.staleMs !== void 0 ? options?.staleMs : DEFAULT_STALE_MS;
-    this.revalidateOnStale = Boolean(options?.revalidateOnStale);
+  inflightPromises = /* @__PURE__ */ new Map();
+  queryState;
+  queryName;
+  queryFn;
+  expiryMs;
+  staleMs;
+  refetchOnStale;
+  constructor(options) {
+    this.queryName = options.queryName;
+    this.queryFn = options.queryFn;
+    this.expiryMs = options?.expiryMs !== void 0 ? options?.expiryMs : SharedQueryDefaults.expiryMs;
+    this.staleMs = options?.staleMs !== void 0 ? options?.staleMs : SharedQueryDefaults.staleMs;
+    this.refetchOnStale = Boolean(options?.refetchOnStale);
+    const persistTo = options.persistTo ?? SharedQueryDefaults.persistTo;
+    if (persistTo === "localStorage") {
+      options.localStorageKey = options.queryName;
+    } else if (persistTo === "indexedDb") {
+      options.indexedDbKey = options.queryName;
+    }
     this.queryState = sharedState(
       {},
       {
@@ -281,109 +300,101 @@ var SharedQuery = class {
       }
     );
   }
-  inflightPromises = /* @__PURE__ */ new Map();
-  queryState;
-  expiryMs;
-  staleMs;
-  revalidateOnStale;
   getQueryKey(args) {
     return this.queryName + ":" + stringifyDeterministicForKeys(args);
   }
-  isStale(entry) {
+  isStale(dataUpdatedMs) {
     if (this.staleMs === 0) return true;
-    const ageMs = Date.now() - entry.updatedMs;
+    const ageMs = Date.now() - dataUpdatedMs;
     return ageMs > this.staleMs;
   }
-  isExpired(entry) {
+  isExpired(dataUpdatedMs) {
     if (this.expiryMs === 0) return false;
-    const ageMs = Date.now() - entry.updatedMs;
+    const ageMs = Date.now() - dataUpdatedMs;
     return ageMs > this.expiryMs;
   }
-  fetchNoCaching(queryKey, ...args) {
+  async getCachedOrFetch(...args) {
+    const queryKey = this.getQueryKey(args);
+    const cached = this.queryState.getSnapshot()?.[queryKey];
+    if (cached?.data && !this.isExpired(cached.dataUpdatedMs ?? 0)) {
+      if (!this.isStale(cached.dataUpdatedMs ?? 0)) {
+        console.log(
+          `Return fresh data ${queryKey} from cache without fetching`
+        );
+        return cached.data;
+      }
+      if (this.refetchOnStale) {
+        console.log(`refetchOnStale for ${queryKey}`);
+        void this.dedupedFetch(queryKey, ...args);
+      }
+      console.log(`Returning stale data for ${queryKey}`);
+      return cached.data;
+    }
+    return await this.dedupedFetch(queryKey, ...args);
+  }
+  dedupedFetch(queryKey, ...args) {
     const inflightPromise = this.inflightPromises.get(queryKey);
     if (inflightPromise) {
       console.log(`Deduplicating inflight fetch for ${queryKey}`);
       return inflightPromise;
     }
+    const promise = this.startFetching(queryKey, args);
+    this.inflightPromises.set(queryKey, promise);
+    return promise;
+  }
+  async startFetching(queryKey, args) {
     console.log(`Start fetching ${queryKey}`);
-    const promise = this.fetchFn(...args).then((result) => {
+    try {
+      const data = await this.queryFn(...args);
       console.log(`Successfully fetched ${queryKey}`);
-      this.setCache(queryKey, result);
-      return result;
-    }).catch((e) => {
+      this.setData(queryKey, data, Date.now());
+      return data;
+    } catch (e) {
       console.error(`Failed to fetch ${queryKey}: ${e}`);
       throw e;
-    }).finally(() => {
+    } finally {
       this.inflightPromises.delete(queryKey);
-    });
-    this.inflightPromises.set(queryKey, promise);
-    return promise;
-  }
-  async getCachedOrFetch(...args) {
-    const queryKey = this.getQueryKey(args);
-    const cached = this.queryState.getSnapshot()?.[queryKey];
-    if (cached?.data && !this.isExpired(cached.data)) {
-      if (!this.isStale(cached.data)) {
-        console.log(
-          `Return fresh data ${queryKey} from cache without fetching`
-        );
-        return cached.data.value;
-      }
-      if (this.revalidateOnStale) {
-        console.log(`revalidateOnStale for ${queryKey}`);
-        void this.fetchNoCaching(queryKey, ...args);
-      }
-      console.log(`Returning stale data for ${queryKey}`);
-      return cached.data.value;
     }
-    return await this.fetchNoCaching(queryKey, ...args);
   }
-  async setCache(queryKey, value) {
+  /** Set the data directly if the user obtained it from somewhere else. */
+  async setData(queryKey, data, dataUpdatedMs = Date.now()) {
     const entry = {
-      data: { value, updatedMs: Date.now() },
       loading: false,
-      error: null
+      data,
+      dataUpdatedMs
     };
     this.queryState.setValue((prev) => ({ ...prev, [queryKey]: entry }));
   }
   /** Do a new fetch even when the data is already cached. */
   async updateFromSource(...args) {
     const key = this.getQueryKey(args);
-    return await this.fetchNoCaching(key, ...args);
-  }
-  /** Delete the currently cached data. */
-  invalidate(args) {
-    if (args) {
-      const queryKey = this.getQueryKey(args);
-      const record = this.queryState.getSnapshot();
-      const clone = { ...record };
-      delete clone[queryKey];
-      this.queryState.setValue(clone);
-      this.inflightPromises.delete(queryKey);
-    } else {
-      this.clearAll();
-    }
+    return await this.dedupedFetch(key, ...args);
+  }
+  /** Delete the cached data for one set of arguments. */
+  deleteData(args) {
+    const queryKey = this.getQueryKey(args);
+    const record = this.queryState.getSnapshot();
+    const clone = { ...record };
+    delete clone[queryKey];
+    this.queryState.setValue(clone);
+    this.inflightPromises.delete(queryKey);
   }
-  /** Delete the currently cached data & all inflight promises. */
-  clearAll() {
+  /** Delete all currently cached data & all inflight promises. */
+  clear() {
     this.queryState.delete();
     this.inflightPromises.clear();
   }
 };
 var seenQueryNames = /* @__PURE__ */ new Set();
-function sharedQuery(queryName, fetchFn, options) {
-  if (seenQueryNames.has(queryName)) {
-    throw new Error(`Duplicate shared query "${queryName}"`);
+function sharedQuery(options) {
+  if (seenQueryNames.has(options.queryName)) {
+    throw new Error(`Duplicate shared query "${options.queryName}"`);
   }
-  seenQueryNames.add(queryName);
-  return new SharedQuery(queryName, fetchFn, options);
+  seenQueryNames.add(options.queryName);
+  return new SharedQuery(options);
 }
-var DEFAULT_QUERY_STATE_ENTRY = {
-  data: null,
-  loading: true,
-  error: null
-};
-function useQuery(query, args) {
+var DEFAULT_QUERY_STATE_ENTRY = { loading: true };
+function useSharedQuery(query, args = []) {
   const [queryState, setQueryState] = useSharedState(query.queryState);
   const isMounted = useRef(true);
   const queryKey = query.getQueryKey(args);
@@ -392,25 +403,21 @@ function useQuery(query, args) {
     setQueryState((prev) => {
       const clone = { ...prev };
       clone[queryKey] = {
-        data: clone[queryKey]?.data ?? null,
-        loading: true,
-        error: null
+        ...clone[queryKey] ?? {},
+        loading: true
       };
       return clone;
     });
     try {
-      const value = await query.getCachedOrFetch(...args);
+      const data = await query.getCachedOrFetch(...args);
       if (isMounted.current) {
         setQueryState((prev) => {
           const clone = { ...prev };
-          const now = Date.now();
           clone[queryKey] = {
-            data: {
-              value,
-              updatedMs: now
-            },
+            // Don't keep old error.
             loading: false,
-            error: null
+            data,
+            dataUpdatedMs: Date.now()
           };
           return clone;
         });
@@ -421,9 +428,11 @@ function useQuery(query, args) {
         setQueryState((prev) => {
           const clone = { ...prev };
           clone[queryKey] = {
-            data: clone[queryKey]?.data ?? null,
+            // Keep old data.
+            ...clone[queryKey] ?? {},
             loading: false,
-            error
+            error,
+            errorUpdatedMs: Date.now()
           };
           return clone;
         });
@@ -437,10 +446,25 @@ function useQuery(query, args) {
       isMounted.current = false;
     };
   }, [execute]);
-  return queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
+  return useMemo(() => {
+    const state = queryState[queryKey] ?? DEFAULT_QUERY_STATE_ENTRY;
+    return {
+      ...state,
+      refetch: () => {
+        return query.updateFromSource(...args);
+      },
+      setData: (data, dataUpdatedMs) => {
+        query.setData(queryKey, data, dataUpdatedMs ?? Date.now());
+      },
+      deleteData: () => {
+        query.deleteData(args);
+      }
+    };
+  }, [query, queryKey, queryState]);
 }
 export {
   SharedQuery,
+  SharedQueryDefaults,
   sharedQuery,
-  useQuery
+  useSharedQuery
 };