pipework 0.264.3 → 0.266.0

package/src/request/di/resolve.ts

@@ -26,7 +26,7 @@ export interface ResolveOptions {
    * would be a footgun.
    */
   readonly checkpoint?: CheckpointFn
-  /** A job's own signal, injected as the `signal` dep. */
+  /** A job's own signal, or an HTTP request's abort signal, injected as the `signal` dep. */
   readonly signal?: AbortSignal
 }
 

package/src/request/http/aborted.ts

@@ -0,0 +1,15 @@
+import { PipeworkError } from '../../core/errors/index.js'
+
+/**
+ * The reason a request's `signal` aborts with when the client closes the
+ * connection before the response is finished. Not an internal error: nothing
+ * is sent (the socket is gone) and `onInternalError` is not called.
+ */
+export class RequestAbortedError extends PipeworkError {
+  readonly code = 'REQUEST_ABORTED' as const
+  readonly httpStatus = 499 as const
+
+  constructor(method: string, route: string) {
+    super(`[pipework] The client closed the connection before the response was sent (${method} ${route}).`, { method, route })
+  }
+}

package/src/request/http/namespace.ts

@@ -1,5 +1,7 @@
 import { file } from './file.js'
 import { detectMediaType, resolveMediaType, SNIFF_BYTES } from './sniff.js'
 
-/** HTTP namespace: `http.file()` builds a file response; `http.detectMediaType()` names bytes the way uploads do; the server itself is managed by manifold.start(). */
+/** HTTP namespace: `http.file()` builds a file response; `http.detectMediaType()` names bytes the way uploads do; the server itself is managed by manifold.start().
+ *
+ * A client that disconnects before its response is finished aborts the request: the in-flight statement is cancelled, the transaction rolled back and the connection released. The context's `signal` (`flow.require().signal`) aborts with a `RequestAbortedError` (499, `REQUEST_ABORTED`); pass it to the handler's own outbound calls (`fetch(url, { signal })`, a `quota.call` send). The aborted request is not an internal error: `onInternalError` is not called and nothing is sent. */
 export const http = { file, detectMediaType, resolveMediaType, SNIFF_BYTES } as const

package/src/request/http/server.ts

@@ -13,6 +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 { buildContext, type ContextOptions } from './middleware.js'
 import { closeTrace } from '../../trace/entry/close-trace.js'
 import { recordErrorStep } from './error-step.js'
@@ -438,12 +439,19 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
       let ctx: Flow | undefined
       let uploaded: BinaryUpload | MultipartUpload | undefined
       const track = newUploadTrack()
+      // Aborted when the client closes the connection before the response is finished.
+      const abort = new AbortController()
+      const onClose = (): void => {
+        if (!reply.raw.writableEnded && !abort.signal.aborted) abort.abort(new RequestAbortedError(method, path))
+      }
+      reply.raw.once('close', onClose)
+      reply.raw.once('finish', () => { reply.raw.removeListener('close', onClose) })
       // 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')
       }
       try {
-        ctx = await buildContext(req, contextOptions, handler.meta.authRequirement)
+        ctx = { ...(await buildContext(req, contextOptions, handler.meta.authRequirement)), signal: abort.signal }
         ;(req as FastifyRequest & { pipeworkTraceId: string | null }).pipeworkTraceId = ctx.trace?.id ?? null
         requestFlows.set(req, ctx)
 
@@ -477,6 +485,7 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
           },
           ...(rawBodyBuffer !== undefined ? { rawBody: rawBodyBuffer } : {}),
           ...(uploaded !== undefined ? { upload: uploaded } : {}),
+          signal: abort.signal,
         }
 
         // Fastify hands a missing body over as null; the input sees undefined.
@@ -497,6 +506,7 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
             resolveHandlerDatabases(handler, instance),
             tenantConfig,
             txTimeoutMs,
+            abort.signal,
           )
           result = await runInContext(ctx, () =>
             resolveAndExecute(handler, body, req.query, req.params, { ...httpOptions, checkpoint }),
@@ -508,6 +518,7 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
             tenantConfig,
             txTimeoutMs,
             () => resolveAndExecute(handler, body, req.query, req.params, httpOptions),
+            abort.signal,
           )
         } else {
           result = await runInContext(ctx, () => resolveAndExecute(handler, body, req.query, req.params, httpOptions))
@@ -518,6 +529,15 @@ export function createServer(instance: Manifold, config: ServerConfig = {}): Pip
         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) {
+          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
+        }
         // 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> => {

package/src/request/http/types.ts

@@ -171,6 +171,7 @@ export interface ServerConfig {
   readyPath?: string
   healthChecks?: readonly HealthCheck[]
   transactionPerRequest?: boolean | readonly string[]
+  /** Bounds only opening the request's transactions (multi-database setup); it does not time the handler or its statements. A client disconnect, not this, ends a request's running work. */
   transactionTimeoutMs?: number
   /** Maximum request body size in bytes. Forwarded to Fastify (default 1 MiB). A per-route `.route(m, p, { bodyLimit })` overrides this for that route. */
   bodyLimit?: number