pipework 0.274.0 → 0.276.0

package/src/request/http/server.ts

@@ -13,7 +13,7 @@ import { createRequestContext } from '../context/index.js'
 import { executeInTransaction } from '../context/run-in-transaction.js'
 import { resolveAndExecute, parseRouteInputs, resolveHandlerDatabases, buildCheckpoint, type ResolveOptions } from '../di/resolve.js'
 import { createRateLimitClasses } from './rate-limit-classes.js'
-import { RequestAbortedError } from './aborted.js'
+import { RequestAbortedError, isAbortCaused } from './aborted.js'
 import { buildContext, type ContextOptions } from './middleware.js'
 import { closeTrace } from '../../trace/entry/close-trace.js'
 import { recordErrorStep } from './error-step.js'
@@ -39,6 +39,9 @@ import { withTenantSetting } from '../../auth/tenant/in-tenant.js'
 import type { Resource } from '../fixture/types.js'
 import { resourceToHandlers } from '../fixture/to-handlers.js'
 
+/** The errors an aborted, injected request's raw response was destroyed with. */
+const settledAborts = new WeakSet<object>()
+
 /** Fastify server wrapper with route registration, handler auto-wiring, and inject() for testing. */
 export interface PipeworkServer {
   route(method: HttpMethod, path: string, handler: Handler<Record<string, unknown>, unknown>): void
@@ -169,6 +172,8 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
   }
 
   app.setErrorHandler(async (error, req, reply) => {
+    // The error an aborted request's raw response was destroyed with: not a fault, nothing to send.
+    if (typeof error === 'object' && error !== null && settledAborts.has(error)) return reply
     const status = (error as { statusCode?: unknown }).statusCode
     const open = requestFlows.get(req)
     const routeOf = (): string => (req.routeOptions as { url?: string } | undefined)?.url ?? req.url.split('?')[0]!
@@ -458,6 +463,20 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
           }
         }
       }
+      // An aborted request is never answered: the raw response is destroyed, so an
+      // injected caller's promise rejects with AbortError and a real socket stays closed.
+      const settleAborted = (): FastifyReply => {
+        const injected = (req.raw as { _lightMyRequest?: unknown })._lightMyRequest !== undefined
+        if (reply.raw.destroyed) return reply
+        if (!injected) {
+          reply.raw.destroy()
+          return reply
+        }
+        const abortError = new DOMException('The request was aborted', 'AbortError')
+        settledAborts.add(abortError)
+        reply.raw.destroy(abortError)
+        return reply
+      }
       // Ends the upload stream and closes the connection if the body was left unread.
       const finishUpload = (failed: boolean): void => {
         if (settleUpload(uploaded?.stream) || (failed && upload !== null)) void reply.header('connection', 'close')
@@ -536,20 +555,29 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
           result = await runInContext(ctx, () => resolveAndExecute(handler, body, req.query, req.params, httpOptions))
         }
 
+        if (abort.signal.aborted) {
+          finishUpload(true)
+          recordErrorStep(ctx, { method, route: path, status: 499, code: 'REQUEST_ABORTED', error: abort.signal.reason })
+          void closeTrace(instance, ctx.trace, 'error')
+          req.log.info({ route: `${method} ${path}`, requestId: String(req.id) }, 'request aborted by client')
+          return settleAborted()
+        }
         finishUpload(false)
         void closeTrace(instance, ctx.trace, 'closed')
         return await sendResult(reply, req, result, handler.meta.file ?? null, `${method} ${path}`)
       } catch (error) {
         finishUpload(true)
-        // The client is gone, whatever the error was (a cancelled statement, the abort itself):
-        // not a fault, nothing to send.
-        if (abort.signal.aborted) {
+        // The client is gone, so nothing is sent. What the abort caused (the abort itself, a
+        // cancelled statement) is not a fault; any other error is classified and reported as usual.
+        const aborted = abort.signal.aborted
+        if (aborted && isAbortCaused(error, abort.signal)) {
           const reason: unknown = abort.signal.reason
           recordErrorStep(ctx, { method, route: path, status: 499, code: 'REQUEST_ABORTED', error: reason })
           if (ctx !== undefined) void closeTrace(instance, ctx.trace, 'error')
           req.log.info({ route: `${method} ${path}`, requestId: String(req.id) }, 'request aborted by client')
-          return reply
+          return settleAborted()
         }
+        const send = (status: number, body: unknown): FastifyReply => (aborted ? settleAborted() : sendError(reply, status, body))
         // Records the error step, runs `refused` (the route's onRefused hook) while the
         // trace is still open, then closes the trace.
         const failWith = async (status: number, code: string, refused?: () => Promise<void>): Promise<void> => {
@@ -565,7 +593,7 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
           await failWith(500, 'FILE_RESPONSE_INVALID')
           req.log.error({ route: `${method} ${path}`, requestId: String(req.id), err: error }, 'File response refused')
           await reportInternalError(req, error, handler)
-          return sendError(reply, 500, { error: { code: 'FILE_RESPONSE_INVALID', message: error.message } })
+          return send(500, { error: { code: 'FILE_RESPONSE_INVALID', message: error.message } })
         }
 
         if (isPipeworkError(error)) {
@@ -581,7 +609,7 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
           const retryAfter = response.error.retryAfterSeconds
           if (retryAfter !== undefined) void reply.header('Retry-After', String(retryAfter))
           if (error.httpStatus >= 500) await reportInternalError(req, error, handler)
-          return sendError(reply, error.httpStatus, response)
+          return send(error.httpStatus, response)
         }
 
         // A malformed multipart body surfaces as a Fastify client error (4xx).
@@ -589,13 +617,13 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
         if (typeof clientStatus === 'number' && clientStatus >= 400 && clientStatus < 500) {
           const response = buildClientErrorResponse(clientStatus, error)
           await failWith(clientStatus, response.error.code, () => runRefusedHook(req, handler.meta, ctx, clientStatus, response))
-          return sendError(reply, clientStatus, response)
+          return send(clientStatus, response)
         }
 
         await failWith(500, 'INTERNAL_ERROR')
         req.log.error(error, 'Unhandled error in route handler')
         await reportInternalError(req, error, handler)
-        return sendError(reply, 500, buildInternalErrorResponse(error, config.exposeErrorDetails))
+        return send(500, buildInternalErrorResponse(error, config.exposeErrorDetails))
       }
     }
 

package/src/test/plugin.ts

@@ -73,6 +73,7 @@ export async function beginTestIsolation(instance: Manifold, task?: WatchedTask)
           '  Fix: call connectionIds() on a pool opened with instance.pool.getOrCreate() or tap(), outside test isolation.',
         ))
       },
+      async cancelBackend() { /* the one pinned test connection is never cancelled */ },
       async close() { /* test harness manages lifecycle */ },
     })
   }