reactjrx 1.41.0 → 1.44.1

package/dist/index.cjs

@@ -472,7 +472,9 @@ const mergeResults = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  rxjs.distinctUntilChanged(shallowEqual)
+  rxjs.distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
 );
 function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
@@ -638,10 +640,16 @@ const createActivityTrigger = (params$) => {
       return shouldRunTrigger !== false ? rxjs.merge(
         rxjs.fromEvent(document, "visibilitychange").pipe(
           rxjs.filter(() => !document.hidden),
-          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          rxjs.map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         ),
         rxjs.fromEvent(window, "focus").pipe(
-          rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          rxjs.map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         )
       ) : rxjs.EMPTY;
     })
@@ -652,7 +660,10 @@ const createNetworkTrigger = (params$) => {
     rxjs.switchMap(({ options: { refetchOnReconnect = true } }) => {
       const shouldRunTrigger = typeof refetchOnReconnect === "function" ? refetchOnReconnect({}) : refetchOnReconnect;
       return shouldRunTrigger !== false ? rxjs.fromEvent(window, "online").pipe(
-        rxjs.map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        rxjs.map(() => ({
+          type: "refetch",
+          ignoreStale: shouldRunTrigger === "always"
+        }))
       ) : rxjs.EMPTY;
     })
   );
@@ -714,18 +725,18 @@ function useQuery({
         newKeyTrigger$,
         newObservableObjectQuery$
       );
-      const refetch$ = rxjs.merge(
-        internalRefresh$.current.pipe(rxjs.map(() => ({ ignoreStale: true }))),
+      const trigger$ = rxjs.merge(
+        internalRefresh$.current,
         rxjs.merge(activityRefetch$, networkRefetch$).pipe(rxjs.throttleTime(500))
       );
       return newQueryTrigger$.pipe(
         rxjs.withLatestFrom(key$),
         rxjs.switchMap(([, key]) => {
-          const { result$ } = client.query$({
+          const { result$ } = client.query({
             key,
             fn$,
             options$,
-            refetch$
+            trigger$
           });
           return result$.pipe(
             rxjs.scan(
@@ -762,7 +773,7 @@ function useQuery({
     [client]
   );
   const refetch = react.useCallback(() => {
-    internalRefresh$.current.next();
+    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
   }, [client]);
   return { ...result, refetch };
 }
@@ -973,7 +984,6 @@ const createQueryStore = () => {
   };
 };
 const createQueryTrigger = ({
-  refetch$,
   options$,
   queryStore,
   key
@@ -991,12 +1001,6 @@ const createQueryTrigger = ({
       rxjs.filter((event) => key === event.key),
       rxjs.map(({ trigger: trigger2 }) => trigger2)
     ),
-    refetch$.pipe(
-      rxjs.map((event) => ({
-        ...event,
-        type: "refetch"
-      }))
-    ),
     enabledTrigger$.pipe(
       rxjs.map(() => ({
         type: "enabled",
@@ -1011,12 +1015,18 @@ const deduplicate = (key, queryStore) => (source) => {
   return rxjs.defer(() => {
     var _a;
     const sourceFromStore = (_a = queryStore.get(key)) == null ? void 0 : _a.deduplication_fn;
+    if (sourceFromStore)
+      return sourceFromStore;
+    let sourceToDeduplicate;
     const deleteFromStore = () => {
-      queryStore.update(key, {
-        deduplication_fn: void 0
-      });
+      var _a2;
+      if (((_a2 = queryStore.get(key)) == null ? void 0 : _a2.deduplication_fn) === sourceToDeduplicate) {
+        queryStore.update(key, {
+          deduplication_fn: void 0
+        });
+      }
     };
-    const finalSource = sourceFromStore ?? source.pipe(
+    sourceToDeduplicate = source.pipe(
       /**
        * Ideally we would want to remove the query from the store only on finalize,
        * which means whenever the query complete or error. Unfortunately finalize is
@@ -1036,12 +1046,10 @@ const deduplicate = (key, queryStore) => (source) => {
         bufferSize: 1
       })
     );
-    if (!sourceFromStore) {
-      queryStore.update(key, {
-        deduplication_fn: finalSource
-      });
-    }
-    return finalSource;
+    queryStore.update(key, {
+      deduplication_fn: sourceToDeduplicate
+    });
+    return sourceToDeduplicate;
   });
 };
 const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
@@ -1165,8 +1173,9 @@ const createQueryFetch = ({
   const query = queryStore.get(serializedKey);
   const cacheResult = query == null ? void 0 : query.cache_fnResult;
   const hasCache = !!cacheResult;
+  const ignoreStale = trigger2.type === "refetch" && trigger2.ignoreStale;
   if (hasCache) {
-    if (!(query == null ? void 0 : query.isStale) && !trigger2.ignoreStale) {
+    if (!(query == null ? void 0 : query.isStale) && !ignoreStale) {
       return rxjs.of({
         fetchStatus: "idle",
         status: "success",
@@ -1236,6 +1245,9 @@ const createInvalidationClient = ({
       keysToRefetch = Array.from(queryStore.keys());
     }
     keysToRefetch.forEach((key) => {
+      queryStore.update(key, {
+        deduplication_fn: void 0
+      });
       queryStore.dispatchQueryTrigger({
         key,
         trigger: { ignoreStale: true, type: "refetch" }
@@ -1246,10 +1258,7 @@ const createInvalidationClient = ({
     invalidateQueries
   };
 };
-const logger$1 = Logger.namespace("refetch");
-const createRefetchClient = ({
-  queryStore
-}) => {
+const createRefetchClient = (_) => {
   const pipeQueryResult = ({
     options$
   }) => (stream) => {
@@ -1279,26 +1288,11 @@ const createRefetchClient = ({
       )
     );
   };
-  const pipeQueryTrigger = ({
-    key
-  }) => (stream) => {
-    return rxjs.merge(
-      stream.pipe(
-        rxjs.tap(({ ignoreStale }) => {
-          const query = queryStore.get(key);
-          if (query && ignoreStale && !query.isStale) {
-            logger$1.log(key, "marked stale by trigger!");
-            queryStore.update(key, {
-              isStale: true
-            });
-          }
-        })
-      )
-    );
+  const refetchQueries = (_2) => {
   };
   return {
     pipeQueryResult,
-    pipeQueryTrigger
+    refetchQueries
   };
 };
 const difference = (a, b) => a.filter((element) => !b.includes(element));
@@ -1472,10 +1466,11 @@ const updateStoreWithNewQuery = ({
   key
 }) => (stream) => stream.pipe(
   rxjs.withLatestFrom(options$),
-  rxjs.map(([value, options]) => {
+  rxjs.map(([trigger2, options]) => {
     if (key.length === 0)
-      return [value, () => {
-      }];
+      return [trigger2, void 0];
+    if (trigger2.type !== "initial")
+      return [trigger2, void 0];
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key }));
     } else {
@@ -1486,10 +1481,10 @@ const updateStoreWithNewQuery = ({
         }
       });
     }
-    return [value, queryStore.addRunner(serializedKey, runner$)];
+    return [trigger2, queryStore.addRunner(serializedKey, runner$)];
   })
 );
-const logger = Logger.namespace("cache");
+const logger$1 = Logger.namespace("cache");
 const createCacheClient = ({
   queryStore
 }) => {
@@ -1500,7 +1495,7 @@ const createCacheClient = ({
     const serializedKey = serializeKey(queryKey);
     if (queryKey.length === 0)
       return;
-    logger.log("set cache for query", serializeKey);
+    logger$1.log("set cache for query", serializeKey);
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key: queryKey }));
     }
@@ -1533,55 +1528,107 @@ const createCacheClient = ({
     setQueryData
   };
 };
+const logger = Logger.namespace("refetch");
+const markQueryAsStaleIfRefetch = ({
+  key,
+  serializedKey,
+  queryStore
+}) => (stream) => {
+  return stream.pipe(
+    rxjs.tap((trigger2) => {
+      if (trigger2.type !== "refetch")
+        return;
+      const query = queryStore.get(serializedKey);
+      if (query && trigger2.ignoreStale && !query.isStale) {
+        logger.log(key, "marked stale by trigger!");
+        queryStore.update(serializedKey, {
+          isStale: true
+        });
+      }
+    })
+  );
+};
+const dispatchExternalRefetchToAllQueries = ({
+  queryStore,
+  serializedKey
+}) => (stream) => stream.pipe(
+  rxjs.tap((trigger2) => {
+    if (trigger2.type === "refetch") {
+      queryStore.update(serializedKey, {
+        deduplication_fn: void 0
+      });
+      queryStore.dispatchQueryTrigger({
+        key: serializedKey,
+        trigger: trigger2
+      });
+    }
+  }),
+  rxjs.filter((trigger2) => trigger2.type !== "refetch")
+);
 const createClient = () => {
   const queryStore = createQueryStore();
   const invalidationClient = createInvalidationClient({ queryStore });
   const cacheClient = createCacheClient({ queryStore });
-  const refetchClient = createRefetchClient({ queryStore });
-  const query$ = ({
+  const refetchClient = createRefetchClient();
+  let hasCalledStart = false;
+  const query = ({
     key,
     fn$: maybeFn$,
     fn: maybeFn,
-    refetch$ = new rxjs.Subject(),
+    trigger$: externalTrigger$ = new rxjs.Subject(),
     options$ = new rxjs.BehaviorSubject({})
   }) => {
+    if (!hasCalledStart) {
+      throw new Error("You forgot to start client");
+    }
     const serializedKey = serializeKey(key);
-    const internalRefetch$ = new rxjs.Subject();
     const fn$ = maybeFn$ ?? (maybeFn ? rxjs.of(maybeFn) : rxjs.NEVER);
-    Logger.log("query$()", serializedKey);
+    Logger.log("query$)", serializedKey);
     const runner$ = options$.pipe(rxjs.map((options) => ({ options })));
     let deleteRunner = () => {
     };
-    const initialTrigger$ = rxjs.of({
-      type: "initial",
-      ignoreStale: false
-    });
-    const trigger$ = createQueryTrigger({
-      options$,
-      refetch$: rxjs.merge(refetch$, internalRefetch$),
-      key: serializedKey,
-      queryStore
-    }).pipe(refetchClient.pipeQueryTrigger({ options$, key: serializedKey }));
-    const result$ = rxjs.merge(
-      initialTrigger$.pipe(
-        updateStoreWithNewQuery({
-          key,
+    const trigger$ = rxjs.merge(
+      externalTrigger$.pipe(
+        dispatchExternalRefetchToAllQueries({
           queryStore,
-          runner$,
-          serializedKey,
-          options$
-        }),
-        rxjs.map(([value, deleteRunnerFn]) => {
-          deleteRunner = deleteRunnerFn;
-          return value;
+          serializedKey
         })
       ),
+      createQueryTrigger({
+        options$,
+        key: serializedKey,
+        queryStore
+      })
+    ).pipe(rxjs.share());
+    const result$ = rxjs.merge(
+      rxjs.of({
+        type: "initial"
+      }),
       trigger$
     ).pipe(
+      updateStoreWithNewQuery({
+        key,
+        queryStore,
+        runner$,
+        serializedKey,
+        options$
+      }),
+      rxjs.map(([value, deleteRunnerFn]) => {
+        if (deleteRunnerFn) {
+          deleteRunner = deleteRunnerFn;
+        }
+        return value;
+      }),
+      markQueryAsStaleIfRefetch({
+        key,
+        options$,
+        queryStore,
+        serializedKey
+      }),
       rxjs.withLatestFrom(fn$, options$),
       rxjs.map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
       rxjs.map((value) => {
-        Logger.log("reactjrx", serializedKey, "query trigger", {
+        Logger.log(serializedKey, "query trigger", {
           trigger: value.trigger,
           options: value.options
         });
@@ -1599,19 +1646,6 @@ const createClient = () => {
           trigger$
         })
       ),
-      // hooks
-      rxjs.switchMap(
-        (result) => rxjs.merge(
-          rxjs.of(result).pipe(
-            refetchClient.pipeQueryResult({
-              key: serializedKey,
-              queryStore,
-              options$,
-              refetch$: internalRefetch$
-            })
-          )
-        )
-      ),
       mergeResults,
       rxjs.withLatestFrom(options$),
       rxjs.takeWhile(([result, options]) => {
@@ -1647,6 +1681,7 @@ const createClient = () => {
     )
   );
   const start = () => {
+    hasCalledStart = true;
     const queryListenerSub = queryListener$.subscribe();
     const started = [queryStore.start()];
     return () => {
@@ -1658,7 +1693,7 @@ const createClient = () => {
   };
   return {
     start,
-    query$,
+    query,
     queryStore,
     ...invalidationClient,
     ...cacheClient,

package/dist/index.js

@@ -470,7 +470,9 @@ const mergeResults = (stream$) => stream$.pipe(
       status: "loading"
     }
   ),
-  distinctUntilChanged(shallowEqual)
+  distinctUntilChanged(
+    ({ data: prevData, ...prev }, { data: currData, ...curr }) => shallowEqual(prev, curr) && shallowEqual(prevData, currData)
+  )
 );
 function useAsyncQuery(query, mapOperatorOrOptions, options = {}) {
   const queryRef = useLiveRef(query);
@@ -636,10 +638,16 @@ const createActivityTrigger = (params$) => {
       return shouldRunTrigger !== false ? merge(
         fromEvent(document, "visibilitychange").pipe(
           filter(() => !document.hidden),
-          map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         ),
         fromEvent(window, "focus").pipe(
-          map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+          map(() => ({
+            type: "refetch",
+            ignoreStale: shouldRunTrigger === "always"
+          }))
         )
       ) : EMPTY;
     })
@@ -650,7 +658,10 @@ const createNetworkTrigger = (params$) => {
     switchMap(({ options: { refetchOnReconnect = true } }) => {
       const shouldRunTrigger = typeof refetchOnReconnect === "function" ? refetchOnReconnect({}) : refetchOnReconnect;
       return shouldRunTrigger !== false ? fromEvent(window, "online").pipe(
-        map(() => ({ ignoreStale: shouldRunTrigger === "always" }))
+        map(() => ({
+          type: "refetch",
+          ignoreStale: shouldRunTrigger === "always"
+        }))
       ) : EMPTY;
     })
   );
@@ -712,18 +723,18 @@ function useQuery({
         newKeyTrigger$,
         newObservableObjectQuery$
       );
-      const refetch$ = merge(
-        internalRefresh$.current.pipe(map(() => ({ ignoreStale: true }))),
+      const trigger$ = merge(
+        internalRefresh$.current,
         merge(activityRefetch$, networkRefetch$).pipe(throttleTime(500))
       );
       return newQueryTrigger$.pipe(
         withLatestFrom(key$),
         switchMap(([, key]) => {
-          const { result$ } = client.query$({
+          const { result$ } = client.query({
             key,
             fn$,
             options$,
-            refetch$
+            trigger$
           });
           return result$.pipe(
             scan(
@@ -760,7 +771,7 @@ function useQuery({
     [client]
   );
   const refetch = useCallback(() => {
-    internalRefresh$.current.next();
+    internalRefresh$.current.next({ type: "refetch", ignoreStale: true });
   }, [client]);
   return { ...result, refetch };
 }
@@ -971,7 +982,6 @@ const createQueryStore = () => {
   };
 };
 const createQueryTrigger = ({
-  refetch$,
   options$,
   queryStore,
   key
@@ -989,12 +999,6 @@ const createQueryTrigger = ({
       filter((event) => key === event.key),
       map(({ trigger: trigger2 }) => trigger2)
     ),
-    refetch$.pipe(
-      map((event) => ({
-        ...event,
-        type: "refetch"
-      }))
-    ),
     enabledTrigger$.pipe(
       map(() => ({
         type: "enabled",
@@ -1009,12 +1013,18 @@ const deduplicate = (key, queryStore) => (source) => {
   return defer(() => {
     var _a;
     const sourceFromStore = (_a = queryStore.get(key)) == null ? void 0 : _a.deduplication_fn;
+    if (sourceFromStore)
+      return sourceFromStore;
+    let sourceToDeduplicate;
     const deleteFromStore = () => {
-      queryStore.update(key, {
-        deduplication_fn: void 0
-      });
+      var _a2;
+      if (((_a2 = queryStore.get(key)) == null ? void 0 : _a2.deduplication_fn) === sourceToDeduplicate) {
+        queryStore.update(key, {
+          deduplication_fn: void 0
+        });
+      }
     };
-    const finalSource = sourceFromStore ?? source.pipe(
+    sourceToDeduplicate = source.pipe(
       /**
        * Ideally we would want to remove the query from the store only on finalize,
        * which means whenever the query complete or error. Unfortunately finalize is
@@ -1034,12 +1044,10 @@ const deduplicate = (key, queryStore) => (source) => {
         bufferSize: 1
       })
     );
-    if (!sourceFromStore) {
-      queryStore.update(key, {
-        deduplication_fn: finalSource
-      });
-    }
-    return finalSource;
+    queryStore.update(key, {
+      deduplication_fn: sourceToDeduplicate
+    });
+    return sourceToDeduplicate;
   });
 };
 const notifyQueryResult = (options$) => (stream$) => stream$.pipe(
@@ -1163,8 +1171,9 @@ const createQueryFetch = ({
   const query = queryStore.get(serializedKey);
   const cacheResult = query == null ? void 0 : query.cache_fnResult;
   const hasCache = !!cacheResult;
+  const ignoreStale = trigger2.type === "refetch" && trigger2.ignoreStale;
   if (hasCache) {
-    if (!(query == null ? void 0 : query.isStale) && !trigger2.ignoreStale) {
+    if (!(query == null ? void 0 : query.isStale) && !ignoreStale) {
       return of({
         fetchStatus: "idle",
         status: "success",
@@ -1234,6 +1243,9 @@ const createInvalidationClient = ({
       keysToRefetch = Array.from(queryStore.keys());
     }
     keysToRefetch.forEach((key) => {
+      queryStore.update(key, {
+        deduplication_fn: void 0
+      });
       queryStore.dispatchQueryTrigger({
         key,
         trigger: { ignoreStale: true, type: "refetch" }
@@ -1244,10 +1256,7 @@ const createInvalidationClient = ({
     invalidateQueries
   };
 };
-const logger$1 = Logger.namespace("refetch");
-const createRefetchClient = ({
-  queryStore
-}) => {
+const createRefetchClient = (_) => {
   const pipeQueryResult = ({
     options$
   }) => (stream) => {
@@ -1277,26 +1286,11 @@ const createRefetchClient = ({
       )
     );
   };
-  const pipeQueryTrigger = ({
-    key
-  }) => (stream) => {
-    return merge(
-      stream.pipe(
-        tap(({ ignoreStale }) => {
-          const query = queryStore.get(key);
-          if (query && ignoreStale && !query.isStale) {
-            logger$1.log(key, "marked stale by trigger!");
-            queryStore.update(key, {
-              isStale: true
-            });
-          }
-        })
-      )
-    );
+  const refetchQueries = (_2) => {
   };
   return {
     pipeQueryResult,
-    pipeQueryTrigger
+    refetchQueries
   };
 };
 const difference = (a, b) => a.filter((element) => !b.includes(element));
@@ -1470,10 +1464,11 @@ const updateStoreWithNewQuery = ({
   key
 }) => (stream) => stream.pipe(
   withLatestFrom(options$),
-  map(([value, options]) => {
+  map(([trigger2, options]) => {
     if (key.length === 0)
-      return [value, () => {
-      }];
+      return [trigger2, void 0];
+    if (trigger2.type !== "initial")
+      return [trigger2, void 0];
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key }));
     } else {
@@ -1484,10 +1479,10 @@ const updateStoreWithNewQuery = ({
         }
       });
     }
-    return [value, queryStore.addRunner(serializedKey, runner$)];
+    return [trigger2, queryStore.addRunner(serializedKey, runner$)];
   })
 );
-const logger = Logger.namespace("cache");
+const logger$1 = Logger.namespace("cache");
 const createCacheClient = ({
   queryStore
 }) => {
@@ -1498,7 +1493,7 @@ const createCacheClient = ({
     const serializedKey = serializeKey(queryKey);
     if (queryKey.length === 0)
       return;
-    logger.log("set cache for query", serializeKey);
+    logger$1.log("set cache for query", serializeKey);
     if (!queryStore.get(serializedKey)) {
       queryStore.set(serializedKey, getInitialQueryEntity({ key: queryKey }));
     }
@@ -1531,55 +1526,107 @@ const createCacheClient = ({
     setQueryData
   };
 };
+const logger = Logger.namespace("refetch");
+const markQueryAsStaleIfRefetch = ({
+  key,
+  serializedKey,
+  queryStore
+}) => (stream) => {
+  return stream.pipe(
+    tap((trigger2) => {
+      if (trigger2.type !== "refetch")
+        return;
+      const query = queryStore.get(serializedKey);
+      if (query && trigger2.ignoreStale && !query.isStale) {
+        logger.log(key, "marked stale by trigger!");
+        queryStore.update(serializedKey, {
+          isStale: true
+        });
+      }
+    })
+  );
+};
+const dispatchExternalRefetchToAllQueries = ({
+  queryStore,
+  serializedKey
+}) => (stream) => stream.pipe(
+  tap((trigger2) => {
+    if (trigger2.type === "refetch") {
+      queryStore.update(serializedKey, {
+        deduplication_fn: void 0
+      });
+      queryStore.dispatchQueryTrigger({
+        key: serializedKey,
+        trigger: trigger2
+      });
+    }
+  }),
+  filter((trigger2) => trigger2.type !== "refetch")
+);
 const createClient = () => {
   const queryStore = createQueryStore();
   const invalidationClient = createInvalidationClient({ queryStore });
   const cacheClient = createCacheClient({ queryStore });
-  const refetchClient = createRefetchClient({ queryStore });
-  const query$ = ({
+  const refetchClient = createRefetchClient();
+  let hasCalledStart = false;
+  const query = ({
     key,
     fn$: maybeFn$,
     fn: maybeFn,
-    refetch$ = new Subject(),
+    trigger$: externalTrigger$ = new Subject(),
     options$ = new BehaviorSubject({})
   }) => {
+    if (!hasCalledStart) {
+      throw new Error("You forgot to start client");
+    }
     const serializedKey = serializeKey(key);
-    const internalRefetch$ = new Subject();
     const fn$ = maybeFn$ ?? (maybeFn ? of(maybeFn) : NEVER);
-    Logger.log("query$()", serializedKey);
+    Logger.log("query$)", serializedKey);
     const runner$ = options$.pipe(map((options) => ({ options })));
     let deleteRunner = () => {
     };
-    const initialTrigger$ = of({
-      type: "initial",
-      ignoreStale: false
-    });
-    const trigger$ = createQueryTrigger({
-      options$,
-      refetch$: merge(refetch$, internalRefetch$),
-      key: serializedKey,
-      queryStore
-    }).pipe(refetchClient.pipeQueryTrigger({ options$, key: serializedKey }));
-    const result$ = merge(
-      initialTrigger$.pipe(
-        updateStoreWithNewQuery({
-          key,
+    const trigger$ = merge(
+      externalTrigger$.pipe(
+        dispatchExternalRefetchToAllQueries({
           queryStore,
-          runner$,
-          serializedKey,
-          options$
-        }),
-        map(([value, deleteRunnerFn]) => {
-          deleteRunner = deleteRunnerFn;
-          return value;
+          serializedKey
         })
       ),
+      createQueryTrigger({
+        options$,
+        key: serializedKey,
+        queryStore
+      })
+    ).pipe(share());
+    const result$ = merge(
+      of({
+        type: "initial"
+      }),
       trigger$
     ).pipe(
+      updateStoreWithNewQuery({
+        key,
+        queryStore,
+        runner$,
+        serializedKey,
+        options$
+      }),
+      map(([value, deleteRunnerFn]) => {
+        if (deleteRunnerFn) {
+          deleteRunner = deleteRunnerFn;
+        }
+        return value;
+      }),
+      markQueryAsStaleIfRefetch({
+        key,
+        options$,
+        queryStore,
+        serializedKey
+      }),
       withLatestFrom(fn$, options$),
       map(([trigger2, fn, options]) => ({ trigger: trigger2, fn, options })),
       map((value) => {
-        Logger.log("reactjrx", serializedKey, "query trigger", {
+        Logger.log(serializedKey, "query trigger", {
           trigger: value.trigger,
           options: value.options
         });
@@ -1597,19 +1644,6 @@ const createClient = () => {
           trigger$
         })
       ),
-      // hooks
-      switchMap(
-        (result) => merge(
-          of(result).pipe(
-            refetchClient.pipeQueryResult({
-              key: serializedKey,
-              queryStore,
-              options$,
-              refetch$: internalRefetch$
-            })
-          )
-        )
-      ),
       mergeResults,
       withLatestFrom(options$),
       takeWhile(([result, options]) => {
@@ -1645,6 +1679,7 @@ const createClient = () => {
     )
   );
   const start = () => {
+    hasCalledStart = true;
     const queryListenerSub = queryListener$.subscribe();
     const started = [queryStore.start()];
     return () => {
@@ -1656,7 +1691,7 @@ const createClient = () => {
   };
   return {
     start,
-    query$,
+    query,
     queryStore,
     ...invalidationClient,
     ...cacheClient,

package/dist/lib/queries/client/createClient.d.ts

@@ -26,10 +26,9 @@ export declare const createClient: () => {
         options$: Observable<QueryOptions<T>>;
         refetch$: Observable<QueryTrigger>;
     }) => import("rxjs").MonoTypeOperatorFunction<R>;
-    pipeQueryTrigger: <T_4>({ key }: {
-        key: string;
-        options$: Observable<QueryOptions<T_4>>;
-    }) => import("rxjs").MonoTypeOperatorFunction<QueryTrigger>;
+    refetchQueries: (_: {
+        queryKey: QueryKey;
+    }) => void;
     setQueryData: ({ queryKey, updater }: {
         queryKey: QueryKey;
         updater: unknown;
@@ -40,16 +39,14 @@ export declare const createClient: () => {
         predicate?: ((storeObject: import("./store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
     }) => void;
     start: () => () => void;
-    query$: <T_5>({ key, fn$: maybeFn$, fn: maybeFn, refetch$, options$ }: {
+    query: <T_4>({ key, fn$: maybeFn$, fn: maybeFn, trigger$: externalTrigger$, options$ }: {
         key: QueryKey;
-        fn?: QueryFn<T_5> | undefined;
-        fn$?: Observable<QueryFn<T_5>> | undefined;
-        refetch$?: Observable<{
-            ignoreStale: boolean;
-        }> | undefined;
-        options$?: Observable<QueryOptions<T_5>> | undefined;
+        fn?: QueryFn<T_4> | undefined;
+        fn$?: Observable<QueryFn<T_4>> | undefined;
+        trigger$?: Observable<QueryTrigger> | undefined;
+        options$?: Observable<QueryOptions<T_4>> | undefined;
     }) => {
-        result$: Observable<QueryResult<T_5>>;
+        result$: Observable<QueryResult<T_4>>;
     };
     queryStore: {
         set: (key: string, value: import("./store/createQueryStore").StoreObject<unknown>) => void;

package/dist/lib/queries/client/refetch/client.d.ts

@@ -1,7 +1,8 @@
 import { type MonoTypeOperatorFunction, type Observable } from "rxjs";
 import { type createQueryStore } from "../store/createQueryStore";
 import { type QueryTrigger, type QueryOptions, type QueryResult } from "../types";
-export declare const createRefetchClient: ({ queryStore }: {
+import { type QueryKey } from "../keys/types";
+export declare const createRefetchClient: (_: {
     queryStore: ReturnType<typeof createQueryStore>;
 }) => {
     pipeQueryResult: <R extends Partial<QueryResult<T>>, T>({ options$ }: {
@@ -10,8 +11,7 @@ export declare const createRefetchClient: ({ queryStore }: {
         options$: Observable<QueryOptions<T>>;
         refetch$: Observable<QueryTrigger>;
     }) => MonoTypeOperatorFunction<R>;
-    pipeQueryTrigger: <T_1>({ key }: {
-        key: string;
-        options$: Observable<QueryOptions<T_1>>;
-    }) => MonoTypeOperatorFunction<QueryTrigger>;
+    refetchQueries: (_: {
+        queryKey: QueryKey;
+    }) => void;
 };

package/dist/lib/queries/client/refetch/dispatchExternalRefetchToAllQueries.d.ts

@@ -0,0 +1,3 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryPipelineParams, type QueryTrigger } from "../types";
+export declare const dispatchExternalRefetchToAllQueries: <R>({ queryStore, serializedKey }: Pick<QueryPipelineParams<R>, "queryStore" | "serializedKey">) => MonoTypeOperatorFunction<QueryTrigger>;

package/dist/lib/queries/client/refetch/logger.d.ts

@@ -0,0 +1,24 @@
+export declare const logger: {
+    namespaces: {
+        name: string;
+        style: {
+            backgroundColor: string;
+            color: string;
+        };
+    }[];
+    namespace(name: string, style?: {
+        backgroundColor: string;
+        color: string;
+    } | undefined): any;
+    printNamespaces(): {
+        namespaces: string;
+        styles: string[];
+    };
+    print(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    printWithoutNamespace(method: "log" | "warn" | "error" | "group", ...message: any[]): any;
+    log(...message: any): any;
+    warn(...message: any): any;
+    error(...message: any): any;
+    group(...message: any): any;
+    groupEnd(): any;
+};

package/dist/lib/queries/client/refetch/markQueryAsStaleIfRefetch.d.ts

@@ -0,0 +1,3 @@
+import { type MonoTypeOperatorFunction } from "rxjs";
+import { type QueryPipelineParams, type QueryTrigger } from "../types";
+export declare const markQueryAsStaleIfRefetch: <T>({ key, serializedKey, queryStore }: QueryPipelineParams<T>) => MonoTypeOperatorFunction<QueryTrigger>;

package/dist/lib/queries/client/store/updateStoreWithNewQuery.d.ts

@@ -1,7 +1,10 @@
 import { type OperatorFunction, type Observable } from "rxjs";
-import { type QueryPipelineParams, type QueryOptions } from "../types";
-export declare const updateStoreWithNewQuery: <T, R>({ queryStore, serializedKey, runner$, options$, key }: QueryPipelineParams<R> & {
+import { type QueryPipelineParams, type QueryOptions, type QueryTrigger } from "../types";
+export declare const updateStoreWithNewQuery: <R>({ queryStore, serializedKey, runner$, options$, key }: QueryPipelineParams<R> & {
     runner$: Observable<{
         options: QueryOptions<R>;
     }>;
-}) => OperatorFunction<T, [T, () => void]>;
+}) => OperatorFunction<QueryTrigger, [
+    QueryTrigger,
+    (() => void) | undefined
+]>;

package/dist/lib/queries/client/triggers.d.ts

@@ -1,17 +1,8 @@
 import { type Observable } from "rxjs";
-import { type QueryOptions } from "./types";
+import { type QueryTrigger, type QueryOptions } from "./types";
 import { type QueryStore } from "./store/createQueryStore";
-export declare const createQueryTrigger: <T>({ refetch$, options$, queryStore, key }: {
-    refetch$: Observable<{
-        ignoreStale: boolean;
-    }>;
+export declare const createQueryTrigger: <T>({ options$, queryStore, key }: {
     options$: Observable<QueryOptions<T>>;
     queryStore: QueryStore;
     key: string;
-}) => Observable<import("./types").QueryTrigger | {
-    type: string;
-    ignoreStale: boolean;
-} | {
-    type: string;
-    ignoreStale: boolean;
-}>;
+}) => Observable<QueryTrigger>;

package/dist/lib/queries/client/types.d.ts

@@ -26,10 +26,20 @@ export interface QueryPipelineParams<R> {
     key: QueryKey;
     options$: Observable<QueryOptions<R>>;
 }
-export interface QueryTrigger {
-    type: string;
+/**
+ * Events that trigger stream chain of query.
+ * What will happens then depends of what event is triggered
+ * and subsequent variables. This is just standardized way
+ * of what trigger a query.
+ */
+export type QueryTrigger = {
+    type: "initial";
+} | {
+    type: "refetch";
     ignoreStale: boolean;
-}
+} | {
+    type: "enabled";
+};
 export interface QueryOptions<T = unknown> {
     enabled?: boolean;
     retry?: false | number | ((attempt: number, error: unknown) => boolean);

package/dist/lib/queries/react/Provider.d.ts

@@ -32,10 +32,9 @@ export declare const useQueryClient: () => {
         options$: import("rxjs").Observable<import("../client/types").QueryOptions<T>>;
         refetch$: import("rxjs").Observable<import("../client/types").QueryTrigger>;
     }) => import("rxjs").MonoTypeOperatorFunction<R>;
-    pipeQueryTrigger: <T_4>({ key }: {
-        key: string;
-        options$: import("rxjs").Observable<import("../client/types").QueryOptions<T_4>>;
-    }) => import("rxjs").MonoTypeOperatorFunction<import("../client/types").QueryTrigger>;
+    refetchQueries: (_: {
+        queryKey: import("../client/keys/types").QueryKey;
+    }) => void;
     setQueryData: ({ queryKey, updater }: {
         queryKey: import("../client/keys/types").QueryKey;
         updater: unknown;
@@ -46,16 +45,14 @@ export declare const useQueryClient: () => {
         predicate?: ((storeObject: import("../client/store/createQueryStore").StoreObject<unknown>) => boolean) | undefined;
     }) => void;
     start: () => () => void;
-    query$: <T_5>({ key, fn$: maybeFn$, fn: maybeFn, refetch$, options$ }: {
+    query: <T_4>({ key, fn$: maybeFn$, fn: maybeFn, trigger$: externalTrigger$, options$ }: {
         key: import("../client/keys/types").QueryKey;
-        fn?: import("../client/types").QueryFn<T_5> | undefined;
-        fn$?: import("rxjs").Observable<import("../client/types").QueryFn<T_5>> | undefined;
-        refetch$?: import("rxjs").Observable<{
-            ignoreStale: boolean;
-        }> | undefined;
-        options$?: import("rxjs").Observable<import("../client/types").QueryOptions<T_5>> | undefined;
+        fn?: import("../client/types").QueryFn<T_4> | undefined;
+        fn$?: import("rxjs").Observable<import("../client/types").QueryFn<T_4>> | undefined;
+        trigger$?: import("rxjs").Observable<import("../client/types").QueryTrigger> | undefined;
+        options$?: import("rxjs").Observable<import("../client/types").QueryOptions<T_4>> | undefined;
     }) => {
-        result$: import("rxjs").Observable<import("../client/types").QueryResult<T_5>>;
+        result$: import("rxjs").Observable<import("../client/types").QueryResult<T_4>>;
     };
     queryStore: {
         set: (key: string, value: import("../client/store/createQueryStore").StoreObject<unknown>) => void;

package/dist/lib/queries/react/triggers/activityTrigger.d.ts

@@ -3,7 +3,9 @@ import { type UseQueryOptions } from "../types";
 export declare const createActivityTrigger: <T>(params$: Observable<{
     options: UseQueryOptions<T>;
 }>) => Observable<{
+    type: "refetch";
     ignoreStale: boolean;
 } | {
+    type: "refetch";
     ignoreStale: boolean;
 }>;

package/dist/lib/queries/react/triggers/networkTrigger.d.ts

@@ -3,5 +3,6 @@ import { type UseQueryOptions } from "../types";
 export declare const createNetworkTrigger: <T>(params$: Observable<{
     options: UseQueryOptions<T>;
 }>) => Observable<{
+    type: "refetch";
     ignoreStale: boolean;
 }>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "reactjrx",
   "private": false,
-  "version": "1.41.0",
+  "version": "1.44.1",
   "type": "module",
   "files": [
     "dist"