fix(start): don't log aborted server function requests as errors

.changeset/serverfn-dont-log-aborts.md

@@ -0,0 +1,7 @@
+---
+'@tanstack/start-client-core': patch
+---
+
+fix(start): don't log an aborted server function request as an error
+
+`serverFnFetcher` logged every non-`Response` error before rethrowing, including the `AbortError` thrown when the caller cancels the request (e.g. TanStack Query aborting a query when its component unmounts). Cancellation is expected control flow, so it is no longer logged. Genuine errors are still logged, and all errors are still rethrown so callers can handle them.

packages/start-client-core/src/client-rpc/serverFnFetcher.ts

@@ -222,6 +222,20 @@ async function getFetchBody(
   return undefined
 }
 
+/**
+ * Whether an error is an abort, i.e. the caller cancelled the request (e.g. TanStack Query
+ * cancelling a query on unmount). Covers both `DOMException` (the standard `fetch` abort) and any
+ * `Error` with `name === 'AbortError'`.
+ */
+function isAbortError(error: unknown): boolean {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'name' in error &&
+    (error as { name: unknown }).name === 'AbortError'
+  )
+}
+
 /**
  * Retrieves a response from a given function and manages potential errors
  * and special response types including redirects and not found errors.
@@ -238,7 +252,11 @@ async function getResponse(fn: () => Promise<Response>) {
     if (error instanceof Response) {
       response = error
     } else {
-      console.log(error)
+      // A caller aborting the request is expected control flow, not a failure, so don't log it.
+      // We still rethrow so the caller can handle the cancellation.
+      if (!isAbortError(error)) {
+        console.log(error)
+      }
       throw error
     }
   }

packages/start-client-core/tests/serverFnFetcher.test.ts

@@ -0,0 +1,33 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { serverFnFetcher } from '../src/client-rpc/serverFnFetcher'
+
+describe('serverFnFetcher error handling', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('does not log when the request is aborted, but still rethrows', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const abortError = new DOMException(
+      'The operation was aborted',
+      'AbortError',
+    )
+    const handler = vi.fn((): Promise<Response> => Promise.reject(abortError))
+
+    await expect(serverFnFetcher('/_serverFn/test', [{}], handler)).rejects.toBe(
+      abortError,
+    )
+    expect(logSpy).not.toHaveBeenCalled()
+  })
+
+  it('logs and rethrows a genuine error', async () => {
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    const error = new Error('boom')
+    const handler = vi.fn((): Promise<Response> => Promise.reject(error))
+
+    await expect(serverFnFetcher('/_serverFn/test', [{}], handler)).rejects.toBe(
+      error,
+    )
+    expect(logSpy).toHaveBeenCalledWith(error)
+  })
+})