chore: Remove Dockerfile and docker-compose.yml, update README and migration guide for backend log checks

frontend/node_modules/@tanstack/query-core/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@tanstack/query-core",
-  "version": "5.90.12",
+  "version": "5.90.16",
   "description": "The framework agnostic core that powers TanStack Query",
   "author": "tannerlinsley",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/TanStack/query.git",
+    "url": "git+https://github.com/TanStack/query.git",
     "directory": "packages/query-core"
   },
   "homepage": "https://tanstack.com/query",

frontend/node_modules/@tanstack/query-core/src/infiniteQueryBehavior.ts

@@ -1,4 +1,9 @@
-import { addToEnd, addToStart, ensureQueryFn } from './utils'
+import {
+  addConsumeAwareSignal,
+  addToEnd,
+  addToStart,
+  ensureQueryFn,
+} from './utils'
 import type { QueryBehavior } from './query'
 import type {
   InfiniteData,
@@ -23,19 +28,11 @@ export function infiniteQueryBehavior<TQueryFnData, TError, TData, TPageParam>(
       const fetchFn = async () => {
         let cancelled = false
         const addSignalProperty = (object: unknown) => {
-          Object.defineProperty(object, 'signal', {
-            enumerable: true,
-            get: () => {
-              if (context.signal.aborted) {
-                cancelled = true
-              } else {
-                context.signal.addEventListener('abort', () => {
-                  cancelled = true
-                })
-              }
-              return context.signal
-            },
-          })
+          addConsumeAwareSignal(
+            object,
+            () => context.signal,
+            () => (cancelled = true),
+          )
         }
 
         const queryFn = ensureQueryFn(context.options, context.fetchOptions)

frontend/node_modules/@tanstack/query-core/src/mutation.ts

@@ -278,14 +278,22 @@ export class Mutation<
           this as Mutation<unknown, unknown, unknown, unknown>,
           mutationFnContext,
         )
+      } catch (e) {
+        void Promise.reject(e)
+      }
 
+      try {
         await this.options.onError?.(
           error as TError,
           variables,
           this.state.context,
           mutationFnContext,
         )
+      } catch (e) {
+        void Promise.reject(e)
+      }
 
+      try {
         // Notify cache callback
         await this.#mutationCache.config.onSettled?.(
           undefined,
@@ -295,7 +303,11 @@ export class Mutation<
           this as Mutation<unknown, unknown, unknown, unknown>,
           mutationFnContext,
         )
+      } catch (e) {
+        void Promise.reject(e)
+      }
 
+      try {
         await this.options.onSettled?.(
           undefined,
           error as TError,
@@ -303,10 +315,12 @@ export class Mutation<
           this.state.context,
           mutationFnContext,
         )
-        throw error
-      } finally {
-        this.#dispatch({ type: 'error', error: error as TError })
+      } catch (e) {
+        void Promise.reject(e)
       }
+
+      this.#dispatch({ type: 'error', error: error as TError })
+      throw error
     } finally {
       this.#mutationCache.runNext(this)
     }

frontend/node_modules/@tanstack/query-core/src/mutationObserver.ts

@@ -172,33 +172,49 @@ export class MutationObserver<
         } satisfies MutationFunctionContext
 
         if (action?.type === 'success') {
-          this.#mutateOptions.onSuccess?.(
-            action.data,
-            variables,
-            onMutateResult,
-            context,
-          )
-          this.#mutateOptions.onSettled?.(
-            action.data,
-            null,
-            variables,
-            onMutateResult,
-            context,
-          )
+          try {
+            this.#mutateOptions.onSuccess?.(
+              action.data,
+              variables,
+              onMutateResult,
+              context,
+            )
+          } catch (e) {
+            void Promise.reject(e)
+          }
+          try {
+            this.#mutateOptions.onSettled?.(
+              action.data,
+              null,
+              variables,
+              onMutateResult,
+              context,
+            )
+          } catch (e) {
+            void Promise.reject(e)
+          }
         } else if (action?.type === 'error') {
-          this.#mutateOptions.onError?.(
-            action.error,
-            variables,
-            onMutateResult,
-            context,
-          )
-          this.#mutateOptions.onSettled?.(
-            undefined,
-            action.error,
-            variables,
-            onMutateResult,
-            context,
-          )
+          try {
+            this.#mutateOptions.onError?.(
+              action.error,
+              variables,
+              onMutateResult,
+              context,
+            )
+          } catch (e) {
+            void Promise.reject(e)
+          }
+          try {
+            this.#mutateOptions.onSettled?.(
+              undefined,
+              action.error,
+              variables,
+              onMutateResult,
+              context,
+            )
+          } catch (e) {
+            void Promise.reject(e)
+          }
         }
       }
 

frontend/node_modules/@tanstack/query-core/src/queriesObserver.ts

@@ -106,7 +106,6 @@ export class QueriesObserver<
       const prevObservers = this.#observers
 
       const newObserverMatches = this.#findMatchingObservers(this.#queries)
-      this.#observerMatches = newObserverMatches
 
       // set options for the new observers to notify of changes
       newObserverMatches.forEach((match) =>
@@ -134,6 +133,7 @@ export class QueriesObserver<
       if (!hasStructuralChange && !hasResultChange) return
 
       if (hasStructuralChange) {
+        this.#observerMatches = newObserverMatches
         this.#observers = newObservers
       }
 

frontend/node_modules/@tanstack/query-core/src/query.ts

@@ -658,6 +658,9 @@ export class Query<
             fetchFailureReason: error,
             fetchStatus: 'idle',
             status: 'error',
+            // flag existing data as invalidated if we get a background error
+            // note that "no data" always means stale so we can set unconditionally here
+            isInvalidated: true,
           }
         case 'invalidate':
           return {

frontend/node_modules/@tanstack/query-core/src/streamedQuery.ts

@@ -1,5 +1,10 @@
-import { addToEnd } from './utils'
-import type { QueryFunction, QueryFunctionContext, QueryKey } from './types'
+import { addConsumeAwareSignal, addToEnd } from './utils'
+import type {
+  OmitKeyof,
+  QueryFunction,
+  QueryFunctionContext,
+  QueryKey,
+} from './types'
 
 type BaseStreamedQueryParams<TQueryFnData, TQueryKey extends QueryKey> = {
   streamFn: (
@@ -73,24 +78,42 @@ export function streamedQuery<
 
     let result = initialValue
 
-    const stream = await streamFn(context)
+    let cancelled: boolean = false as boolean
+    const streamFnContext = addConsumeAwareSignal<
+      OmitKeyof<typeof context, 'signal'>
+    >(
+      {
+        client: context.client,
+        meta: context.meta,
+        queryKey: context.queryKey,
+        pageParam: context.pageParam,
+        direction: context.direction,
+      },
+      () => context.signal,
+      () => (cancelled = true),
+    )
+
+    const stream = await streamFn(streamFnContext)
+
+    const isReplaceRefetch = isRefetch && refetchMode === 'replace'
 
     for await (const chunk of stream) {
-      if (context.signal.aborted) {
+      if (cancelled) {
         break
       }
 
-      // don't append to the cache directly when replace-refetching
-      if (!isRefetch || refetchMode !== 'replace') {
+      if (isReplaceRefetch) {
+        // don't append to the cache directly when replace-refetching
+        result = reducer(result, chunk)
+      } else {
         context.client.setQueryData<TData>(context.queryKey, (prev) =>
           reducer(prev === undefined ? initialValue : prev, chunk),
         )
       }
-      result = reducer(result, chunk)
     }
 
     // finalize result: replace-refetching needs to write to the cache
-    if (isRefetch && refetchMode === 'replace' && !context.signal.aborted) {
+    if (isReplaceRefetch && !cancelled) {
       context.client.setQueryData<TData>(context.queryKey, result)
     }
 

frontend/node_modules/@tanstack/query-core/src/types.ts

@@ -317,9 +317,9 @@ export interface QueryObserverOptions<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = never,
 > extends WithRequired<
-    QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,
-    'queryKey'
-  > {
+  QueryOptions<TQueryFnData, TError, TQueryData, TQueryKey, TPageParam>,
+  'queryKey'
+> {
   /**
    * Set this to `false` or a function that returns `false` to disable automatic refetching when the query mounts or changes query keys.
    * To refetch the query, use the `refetch` method returned from the `useQuery` instance.
@@ -461,7 +461,9 @@ export interface InfiniteQueryObserverOptions<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
-> extends QueryObserverOptions<
+>
+  extends
+    QueryObserverOptions<
       TQueryFnData,
       TError,
       TData,
@@ -495,9 +497,9 @@ export interface FetchQueryOptions<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = never,
 > extends WithRequired<
-    QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
-    'queryKey'
-  > {
+  QueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>,
+  'queryKey'
+> {
   initialPageParam?: never
   /**
    * The time in milliseconds after data is considered stale.
@@ -513,12 +515,12 @@ export interface EnsureQueryDataOptions<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = never,
 > extends FetchQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  > {
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryKey,
+  TPageParam
+> {
   revalidateIfStale?: boolean
 }
 
@@ -579,13 +581,15 @@ export interface RefetchOptions extends ResultOptions {
   cancelRefetch?: boolean
 }
 
-export interface InvalidateQueryFilters<TQueryKey extends QueryKey = QueryKey>
-  extends QueryFilters<TQueryKey> {
+export interface InvalidateQueryFilters<
+  TQueryKey extends QueryKey = QueryKey,
+> extends QueryFilters<TQueryKey> {
   refetchType?: QueryTypeFilter | 'none'
 }
 
-export interface RefetchQueryFilters<TQueryKey extends QueryKey = QueryKey>
-  extends QueryFilters<TQueryKey> {}
+export interface RefetchQueryFilters<
+  TQueryKey extends QueryKey = QueryKey,
+> extends QueryFilters<TQueryKey> {}
 
 export interface InvalidateOptions extends RefetchOptions {}
 export interface ResetOptions extends RefetchOptions {}
@@ -1259,11 +1263,11 @@ export interface MutationObserverIdleResult<
   TVariables = void,
   TOnMutateResult = unknown,
 > extends MutationObserverBaseResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > {
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> {
   data: undefined
   variables: undefined
   error: null
@@ -1280,11 +1284,11 @@ export interface MutationObserverLoadingResult<
   TVariables = void,
   TOnMutateResult = unknown,
 > extends MutationObserverBaseResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > {
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> {
   data: undefined
   variables: TVariables
   error: null
@@ -1301,11 +1305,11 @@ export interface MutationObserverErrorResult<
   TVariables = void,
   TOnMutateResult = unknown,
 > extends MutationObserverBaseResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > {
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> {
   data: undefined
   error: TError
   variables: TVariables
@@ -1322,11 +1326,11 @@ export interface MutationObserverSuccessResult<
   TVariables = void,
   TOnMutateResult = unknown,
 > extends MutationObserverBaseResult<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  > {
+  TData,
+  TError,
+  TVariables,
+  TOnMutateResult
+> {
   data: TData
   error: null
   variables: TVariables

frontend/node_modules/@tanstack/query-core/src/utils.ts

@@ -465,3 +465,33 @@ export function shouldThrowError<T extends (...args: Array<any>) => boolean>(
 
   return !!throwOnError
 }
+
+export function addConsumeAwareSignal<T>(
+  object: T,
+  getSignal: () => AbortSignal,
+  onCancelled: VoidFunction,
+): T & { signal: AbortSignal } {
+  let consumed = false
+  let signal: AbortSignal | undefined
+
+  Object.defineProperty(object, 'signal', {
+    enumerable: true,
+    get: () => {
+      signal ??= getSignal()
+      if (consumed) {
+        return signal
+      }
+
+      consumed = true
+      if (signal.aborted) {
+        onCancelled()
+      } else {
+        signal.addEventListener('abort', onCancelled, { once: true })
+      }
+
+      return signal
+    },
+  })
+
+  return object as T & { signal: AbortSignal }
+}