:refactor: Use abortSignal for query cancellation in InfiniteQueryBehavior

Author: prateek3255

src/core/infiniteQueryBehavior.ts

@@ -143,12 +143,11 @@ export function infiniteQueryBehavior<
           pageParams: newPageParams,
         }))
 
-        const finalPromiseAsAny = finalPromise as any
-
-        finalPromiseAsAny.cancel = () => {
-          cancelled = true
+        context.signal?.addEventListener('abort', () => {
+          cancelled = true;
           abortController?.abort()
-        }
+        })
+        
 
         return finalPromise
       }

src/core/query.ts

@@ -65,6 +65,7 @@ export interface FetchContext<
 > {
   fetchFn: () => unknown | Promise<unknown>
   fetchOptions?: FetchOptions
+  signal?: AbortSignal
   options: QueryOptions<TQueryFnData, TError, TData, any>
   queryKey: EnsuredQueryKey<TQueryKey>
   state: QueryState<TData, TError>
@@ -316,7 +317,7 @@ export class Query<
         // If the transport layer does not support cancellation
         // we'll let the query continue so the result can be cached
         if (this.retryer) {
-          if (this.retryer.isTransportCancelable || this.abortSignalConsumed) {
+          if (this.abortSignalConsumed) {
             this.retryer.cancel({ revert: true })
           } else {
             this.retryer.cancelRetry()
@@ -412,6 +413,17 @@ export class Query<
       meta: this.meta,
     }
 
+    Object.defineProperty(context, 'signal', {
+      enumerable: true,
+      get: () => {
+        if (abortController) {
+          this.abortSignalConsumed = true
+          return abortController.signal
+        }
+        return undefined
+      },
+    })
+
     if (this.options.behavior?.onFetch) {
       this.options.behavior?.onFetch(context)
     }

src/core/retryer.ts

@@ -34,15 +34,6 @@ type RetryDelayFunction<TError = unknown> = (
 function defaultRetryDelay(failureCount: number) {
   return Math.min(1000 * 2 ** failureCount, 30000)
 }
-
-interface Cancelable {
-  cancel(): void
-}
-
-export function isCancelable(value: any): value is Cancelable {
-  return typeof value?.cancel === 'function'
-}
-
 export class CancelledError {
   revert?: boolean
   silent?: boolean
@@ -65,7 +56,6 @@ export class Retryer<TData = unknown, TError = unknown> {
   failureCount: number
   isPaused: boolean
   isResolved: boolean
-  isTransportCancelable: boolean
   promise: Promise<TData>
 
   private abort?: () => void
@@ -86,7 +76,6 @@ export class Retryer<TData = unknown, TError = unknown> {
     this.failureCount = 0
     this.isPaused = false
     this.isResolved = false
-    this.isTransportCancelable = false
     this.promise = new Promise<TData>((outerResolve, outerReject) => {
       promiseResolve = outerResolve
       promiseReject = outerReject
@@ -144,18 +133,9 @@ export class Retryer<TData = unknown, TError = unknown> {
           reject(new CancelledError(cancelOptions))
 
           this.abort?.()
-
-          // Cancel transport if supported
-          if (isCancelable(promiseOrValue)) {
-            try {
-              promiseOrValue.cancel()
-            } catch {}
-          }
         }
       }
 
-      // Check if the transport layer support cancellation
-      this.isTransportCancelable = isCancelable(promiseOrValue)
 
       Promise.resolve(promiseOrValue)
         .then(resolve)