fastify 5.6.2 → 5.7.1

package/test/logger/logging.test.js

@@ -16,7 +16,7 @@ t.test('logging', { timeout: 60000 }, async (t) => {
   let localhost
   let localhostForURL
 
-  t.plan(13)
+  t.plan(14)
 
   t.before(async function () {
     [localhost, localhostForURL] = await helper.getLoopbackHost()
@@ -282,6 +282,43 @@ t.test('logging', { timeout: 60000 }, async (t) => {
     t.assert.strictEqual(stream.readableLength, 0)
   })
 
+  await t.test('should log incoming request and outgoing response based on disableRequestLogging function', async (t) => {
+    const lines = [
+      'incoming request',
+      'request completed'
+    ]
+    t.plan(lines.length)
+
+    const stream = split(JSON.parse)
+    const loggerInstance = pino(stream)
+
+    const fastify = Fastify({
+      disableRequestLogging: (request) => {
+        return request.url !== '/not-logged'
+      },
+      loggerInstance
+    })
+    t.after(() => fastify.close())
+
+    fastify.get('/logged', (req, reply) => {
+      return reply.code(200).send({})
+    })
+
+    fastify.get('/not-logged', (req, reply) => {
+      return reply.code(200).send({})
+    })
+
+    await fastify.ready()
+
+    await fastify.inject({ method: 'GET', url: '/not-logged' })
+    await fastify.inject({ method: 'GET', url: '/logged' })
+
+    for await (const [line] of on(stream, 'data')) {
+      t.assert.strictEqual(line.msg, lines.shift())
+      if (lines.length === 0) break
+    }
+  })
+
   await t.test('defaults to info level', async (t) => {
     const lines = [
       { req: { method: 'GET' }, msg: 'incoming request' },

package/test/router-options.test.js

@@ -447,6 +447,157 @@ test('Should honor disableRequestLogging option in frameworkErrors wrapper - FST
   )
 })
 
+test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_BAD_URL', (t, done) => {
+  t.plan(4)
+
+  let logCallCount = 0
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    disableRequestLogging: (req) => {
+      // Disable logging for URLs containing 'silent'
+      return req.url.includes('silent')
+    },
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      level: 'info'
+    }
+  })
+
+  fastify.get('/test/:id', (req, res) => {
+    res.send('{ hello: \'world\' }')
+  })
+
+  logStream.on('data', (json) => {
+    if (json.msg === 'incoming request') {
+      logCallCount++
+    }
+  })
+
+  // First request: URL does not contain 'silent', so logging should happen
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/test/%world'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, '\'/test/%world\' is not a valid url component - FST_ERR_BAD_URL')
+
+      // Second request: URL contains 'silent', so logging should be disabled
+      fastify.inject(
+        {
+          method: 'GET',
+          url: '/silent/%world'
+        },
+        (err2, res2) => {
+          t.assert.ifError(err2)
+          // Give time for any potential log events
+          setImmediate(() => {
+            // Only the first request should have logged
+            t.assert.strictEqual(logCallCount, 1)
+            done()
+          })
+        }
+      )
+    }
+  )
+})
+
+test('Should honor disableRequestLogging function in frameworkErrors wrapper - FST_ERR_ASYNC_CONSTRAINT', (t, done) => {
+  t.plan(4)
+
+  let logCallCount = 0
+
+  const constraint = {
+    name: 'secret',
+    storage: function () {
+      const secrets = {}
+      return {
+        get: (secret) => { return secrets[secret] || null },
+        set: (secret, store) => { secrets[secret] = store }
+      }
+    },
+    deriveConstraint: (req, ctx, done) => {
+      done(Error('kaboom'))
+    },
+    validate () { return true }
+  }
+
+  const logStream = split(JSON.parse)
+
+  const fastify = Fastify({
+    constraints: { secret: constraint },
+    disableRequestLogging: (req) => {
+      // Disable logging for URLs containing 'silent'
+      return req.url.includes('silent')
+    },
+    frameworkErrors: function (err, req, res) {
+      res.send(`${err.message} - ${err.code}`)
+    },
+    logger: {
+      stream: logStream,
+      level: 'info'
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  fastify.route({
+    method: 'GET',
+    url: '/silent',
+    constraints: { secret: 'alpha' },
+    handler: (req, reply) => {
+      reply.send({ hello: 'from alpha' })
+    }
+  })
+
+  logStream.on('data', (json) => {
+    if (json.msg === 'incoming request') {
+      logCallCount++
+    }
+  })
+
+  // First request: URL does not contain 'silent', so logging should happen
+  fastify.inject(
+    {
+      method: 'GET',
+      url: '/'
+    },
+    (err, res) => {
+      t.assert.ifError(err)
+      t.assert.strictEqual(res.body, 'Unexpected error from async constraint - FST_ERR_ASYNC_CONSTRAINT')
+
+      // Second request: URL contains 'silent', so logging should be disabled
+      fastify.inject(
+        {
+          method: 'GET',
+          url: '/silent'
+        },
+        (err2, res2) => {
+          t.assert.ifError(err2)
+          // Give time for any potential log events
+          setImmediate(() => {
+            // Only the first request should have logged
+            t.assert.strictEqual(logCallCount, 1)
+            done()
+          })
+        }
+      )
+    }
+  )
+})
+
 test('Should honor routerOptions.defaultRoute', async t => {
   t.plan(3)
   const fastify = Fastify({
@@ -895,3 +1046,21 @@ test('Should honor routerOptions.useSemicolonDelimiter over useSemicolonDelimite
   })
   t.assert.strictEqual(res.statusCode, 200)
 })
+
+test('Should support extra find-my-way options', async t => {
+  t.plan(1)
+  // Use a real upstream option from find-my-way
+  const fastify = Fastify({
+    routerOptions: {
+      buildPrettyMeta: (route) => {
+        const cleanMeta = Object.assign({}, route.store)
+        return cleanMeta
+      }
+    }
+  })
+
+  await fastify.ready()
+
+  // Ensure the option is preserved after validation
+  t.assert.strictEqual(typeof fastify.initialConfig.routerOptions.buildPrettyMeta, 'function')
+})

package/test/server.test.js

@@ -1,11 +1,14 @@
 'use strict'
 
 const dns = require('node:dns')
+const { networkInterfaces } = require('node:os')
 const { test } = require('node:test')
 const Fastify = require('..')
 const undici = require('undici')
 const proxyquire = require('proxyquire')
 
+const isIPv6Missing = !Object.values(networkInterfaces()).flat().some(({ family }) => family === 'IPv6')
+
 test('listen should accept null port', async t => {
   const fastify = Fastify()
   t.after(() => fastify.close())
@@ -81,7 +84,7 @@ test('Test for hostname and port', async (t) => {
   await fetch('http://localhost:8000/host')
 })
 
-test('Test for IPV6 port', async (t) => {
+test('Test for IPV6 port', { skip: isIPv6Missing }, async (t) => {
   t.plan(3)
   const app = Fastify()
   t.after(() => app.close())

package/test/types/fastify.test-d.ts

@@ -1,4 +1,4 @@
-import { ErrorObject as AjvErrorObject } from 'ajv'
+import Ajv, { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'node:http'
 import * as http2 from 'node:http2'
 import * as https from 'node:https'
@@ -65,12 +65,12 @@ expectType<
 >(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
 expectType<LightMyRequestChain>(fastify({ http2: true, https: {} }).inject())
 expectType<
-  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
-  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
 >(fastify({ schemaController: {} }))
 expectType<
-  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
-  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+  FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>
 >(
   fastify({
     schemaController: {
@@ -115,6 +115,7 @@ expectAssignable<FastifyInstance>(fastify({ pluginTimeout: 1000 }))
 expectAssignable<FastifyInstance>(fastify({ bodyLimit: 100 }))
 expectAssignable<FastifyInstance>(fastify({ maxParamLength: 100 }))
 expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: true }))
+expectAssignable<FastifyInstance>(fastify({ disableRequestLogging: (req) => req.url?.includes('/health') ?? false }))
 expectAssignable<FastifyInstance>(fastify({ requestIdLogLabel: 'request-id' }))
 expectAssignable<FastifyInstance>(fastify({ onProtoPoisoning: 'error' }))
 expectAssignable<FastifyInstance>(fastify({ onConstructorPoisoning: 'error' }))
@@ -232,12 +233,32 @@ expectAssignable<FastifyInstance>(fastify({
     customOptions: {
       removeAdditional: 'all'
     },
-    plugins: [() => { }]
+    plugins: [(ajv: Ajv): Ajv => ajv]
+  }
+}))
+expectAssignable<FastifyInstance>(fastify({
+  ajv: {
+    plugins: [[(ajv: Ajv): Ajv => ajv, ['keyword1', 'keyword2']]]
+  }
+}))
+expectError(fastify({
+  ajv: {
+    customOptions: {
+      removeAdditional: 'all'
+    },
+    plugins: [
+      () => {
+        // error, plugins always return the Ajv instance fluently
+      }
+    ]
   }
 }))
 expectAssignable<FastifyInstance>(fastify({
   ajv: {
-    plugins: [[() => { }, ['keyword1', 'keyword2']]]
+    onCreate: (ajvInstance) => {
+      expectType<Ajv>(ajvInstance)
+      return ajvInstance
+    }
   }
 }))
 expectAssignable<FastifyInstance>(fastify({ frameworkErrors: () => { } }))

package/test/types/instance.test-d.ts

@@ -1,9 +1,10 @@
-import { expectAssignable, expectError, expectNotDeprecated, expectType } from 'tsd'
+import { expectAssignable, expectError, expectNotAssignable, expectNotDeprecated, expectType } from 'tsd'
 import fastify, {
   FastifyBaseLogger,
   FastifyBodyParser,
   FastifyError,
   FastifyInstance,
+  FastifyRouterOptions,
   RawReplyDefaultExpression,
   RawRequestDefaultExpression,
   RawServerDefault,
@@ -15,7 +16,7 @@ import { FastifyRequest } from '../../types/request'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
 import { AddressInfo } from 'node:net'
 import { Bindings, ChildLoggerOptions } from '../../types/logger'
-import { ConstraintStrategy } from 'find-my-way'
+import { Config as FindMyWayConfig, ConstraintStrategy } from 'find-my-way'
 import { FindMyWayVersion } from '../../types/instance'
 
 const server = fastify()
@@ -92,12 +93,12 @@ interface ReplyPayload {
 // typed sync error handler
 server.setErrorHandler<CustomError, ReplyPayload>((error, request, reply) => {
   expectType<CustomError>(error)
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
 })
 // typed async error handler send
 server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
   expectType<CustomError>(error)
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
 })
 // typed async error handler return
 server.setErrorHandler<CustomError, ReplyPayload>(async (error, request, reply) => {
@@ -323,7 +324,7 @@ type InitialConfig = Readonly<{
   https?: boolean | Readonly<{ allowHTTP1: boolean }>,
   ignoreTrailingSlash?: boolean,
   ignoreDuplicateSlashes?: boolean,
-  disableRequestLogging?: boolean,
+  disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
   maxParamLength?: number,
   onProtoPoisoning?: 'error' | 'remove' | 'ignore',
   onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
@@ -332,25 +333,32 @@ type InitialConfig = Readonly<{
   requestIdLogLabel?: string,
   http2SessionTimeout?: number,
   useSemicolonDelimiter?: boolean,
-  routerOptions?: {
-    allowUnsafeRegex?: boolean,
-    buildPrettyMeta?: (route: { [k: string]: unknown, store: { [k: string]: unknown } }) => object,
-    caseSensitive?: boolean,
-    constraints?: {
-      [name: string]: ConstraintStrategy<FindMyWayVersion<RawServerDefault>, unknown>
-    }
-    defaultRoute?: (req: FastifyRequest, res: FastifyReply) => void,
-    ignoreDuplicateSlashes?: boolean,
-    ignoreTrailingSlash?: boolean,
-    maxParamLength?: number,
-    onBadUrl?: (path: string, req: FastifyRequest, res: FastifyReply) => void,
-    querystringParser?: (str: string) => { [key: string]: unknown },
-    useSemicolonDelimiter?: boolean,
-  }
+  routerOptions?: FastifyRouterOptions<RawServerDefault>
 }>
 
 expectType<InitialConfig>(fastify().initialConfig)
 
+const routerOptionsForFindMyWay = {} as FastifyRouterOptions<RawServerDefault>
+expectAssignable<FindMyWayConfig<FindMyWayVersion<RawServerDefault>>>(routerOptionsForFindMyWay)
+
+fastify({
+  routerOptions: {
+    defaultRoute: (req, res) => {
+      expectType<RawRequestDefaultExpression<RawServerDefault>>(req)
+      expectType<RawReplyDefaultExpression<RawServerDefault>>(res)
+      expectNotAssignable<FastifyReply>(res)
+      res.end('foo')
+    },
+    onBadUrl: (path, req, res) => {
+      expectType<string>(path)
+      expectType<RawRequestDefaultExpression<RawServerDefault>>(req)
+      expectType<RawReplyDefaultExpression<RawServerDefault>>(res)
+      expectNotAssignable<FastifyReply>(res)
+      res.end('foo')
+    }
+  }
+})
+
 expectType<FastifyBodyParser<string>>(server.defaultTextParser)
 
 expectType<FastifyBodyParser<string>>(server.getDefaultJsonParser('ignore', 'error'))
@@ -562,7 +570,7 @@ expectError(server.decorateReply('typedTestReplyMethod', async function (x) {
 const foo = server.getDecorator<string>('foo')
 expectType<string>(foo)
 
-const versionConstraintStrategy = {
+const versionConstraintStrategy: ConstraintStrategy<FindMyWayVersion<RawServerDefault>> = {
   name: 'version',
   storage: () => ({
     get: () => () => {},

package/test/types/reply.test-d.ts

@@ -16,14 +16,14 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.status)
-  expectType<(payload?: unknown) => FastifyReply>(reply.code(100 as number).send)
+  expectType<(...args: [payload?: unknown]) => FastifyReply>(reply.code(100 as number).send)
   expectType<number>(reply.elapsedTime)
   expectType<number>(reply.statusCode)
   expectType<boolean>(reply.sent)
   expectType<
           (hints: Record<string, string | string[]>, callback?: (() => void) | undefined) => void
             >(reply.writeEarlyHints)
-  expectType<((payload?: unknown) => FastifyReply)>(reply.send)
+  expectType<((...args: [payload?: unknown]) => FastifyReply)>(reply.send)
   expectAssignable<(key: string, value: any) => FastifyReply>(reply.header)
   expectAssignable<(values: { [key: string]: any }) => FastifyReply>(reply.headers)
   expectAssignable<(key: string) => number | string | string[] | undefined>(reply.getHeader)
@@ -100,9 +100,29 @@ interface InvalidReplyHttpCodes {
   }
 }
 
+interface ReplyVoid {
+  Reply: void;
+}
+
+interface ReplyUndefined {
+  Reply: undefined;
+}
+
+// Issue #5534 scenario: 204 No Content should allow empty send(), 201 Created should require payload
+// Note: `204: undefined` gets converted to `unknown` via UndefinedToUnknown in type-provider.d.ts,
+// meaning send() is optional but send({}) is also allowed. Use `void` instead of `undefined`
+// if you want stricter "no payload allowed" semantics.
+interface ReplyHttpCodesWithNoContent {
+  Reply: {
+    201: { id: string };
+    204: undefined;
+  }
+}
+
 const typedHandler: RouteHandler<ReplyPayload> = async (request, reply) => {
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
-  expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.code(100).send)
+  // When Reply type is specified, send() requires a payload argument
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.code(100).send)
 }
 
 const server = fastify()
@@ -111,6 +131,10 @@ server.get('/typed', typedHandler)
 server.get<ReplyPayload>('/get-generic-send', async function handler (request, reply) {
   reply.send({ test: true })
 })
+// When Reply type is specified, send() requires a payload - calling without arguments should error
+expectError(server.get<ReplyPayload>('/get-generic-send-missing-payload', async function handler (request, reply) {
+  reply.send()
+}))
 server.get<ReplyPayload>('/get-generic-return', async function handler (request, reply) {
   return { test: false }
 })
@@ -201,3 +225,30 @@ const httpHeaderHandler: RouteHandlerMethod = function (_request, reply) {
   reply.headers({ 'x-fastify-test': 'test' })
   reply.removeHeader('x-fastify-test')
 }
+
+// Test: send() without arguments is valid when no Reply type is specified (default unknown)
+server.get('/get-no-type-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Test: send() without arguments is valid when Reply type is void
+server.get<ReplyVoid>('/get-void-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Test: send() without arguments is valid when Reply type is undefined
+server.get<ReplyUndefined>('/get-undefined-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Issue #5534 scenario: HTTP status codes with 204 No Content
+server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-no-content', async function handler (request, reply) {
+  // 204 No Content - send() without payload is valid because Reply is undefined
+  reply.code(204).send()
+  // 201 Created - send() requires payload
+  reply.code(201).send({ id: '123' })
+})
+// 201 Created without payload should error
+expectError(server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-201-missing-payload', async function handler (request, reply) {
+  reply.code(201).send()
+}))

package/test/types/type-provider.test-d.ts

@@ -479,9 +479,9 @@ expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
-    expectType<(payload?: string) => typeof res>(res.code(200).send)
-    expectType<(payload?: number) => typeof res>(res.code(400).send)
-    expectType<(payload?: { error: string }) => typeof res>(res.code(500).send)
+    expectType<((...args: [payload: string]) => typeof res)>(res.code(200).send)
+    expectType<((...args: [payload: number]) => typeof res)>(res.code(400).send)
+    expectType<((...args: [payload: { error: string }]) => typeof res)>(res.code(500).send)
     expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))
@@ -711,9 +711,9 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
-    expectType<(payload?: string) => typeof res>(res.code(200).send)
-    expectType<(payload?: number) => typeof res>(res.code(400).send)
-    expectType<(payload?: { [x: string]: unknown; error?: string }) => typeof res>(res.code(500).send)
+    expectType<((...args: [payload: string]) => typeof res)>(res.code(200).send)
+    expectType<((...args: [payload: number]) => typeof res)>(res.code(400).send)
+    expectType<((...args: [payload: { [x: string]: unknown; error?: string }]) => typeof res)>(res.code(500).send)
     expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))

package/test/web-api.test.js

@@ -5,6 +5,7 @@ const Fastify = require('../fastify')
 const fs = require('node:fs')
 const { Readable } = require('node:stream')
 const { fetch: undiciFetch } = require('undici')
+const http = require('node:http')
 
 test('should response with a ReadableStream', async (t) => {
   t.plan(2)
@@ -330,3 +331,138 @@ test('allow to pipe with undici.fetch', async (t) => {
   t.assert.strictEqual(response.statusCode, 200)
   t.assert.deepStrictEqual(response.json(), { ok: true })
 })
+
+test('WebStream error before headers sent should trigger error handler', async (t) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.error(new Error('stream error'))
+      }
+    })
+    reply.send(stream)
+  })
+
+  const response = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.assert.strictEqual(response.statusCode, 500)
+  t.assert.strictEqual(response.json().message, 'stream error')
+})
+
+test('WebStream error after headers sent should destroy response', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  fastify.get('/', function (request, reply) {
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.enqueue('hello')
+      },
+      pull (controller) {
+        setTimeout(() => {
+          controller.error(new Error('stream error'))
+        }, 10)
+      }
+    })
+    reply.header('content-type', 'text/plain').send(stream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+
+    let finished = false
+    http.get(`http://localhost:${fastify.server.address().port}`, (res) => {
+      res.on('close', () => {
+        if (!finished) {
+          finished = true
+          t.assert.ok('response closed')
+          done()
+        }
+      })
+      res.resume()
+    })
+  })
+})
+
+test('WebStream should cancel reader when response is destroyed', (t, done) => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  t.after(() => fastify.close())
+
+  let readerCancelled = false
+
+  fastify.get('/', function (request, reply) {
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.enqueue('hello')
+      },
+      pull (controller) {
+        return new Promise(() => {})
+      },
+      cancel () {
+        readerCancelled = true
+      }
+    })
+    reply.header('content-type', 'text/plain').send(stream)
+  })
+
+  fastify.listen({ port: 0 }, err => {
+    t.assert.ifError(err)
+
+    const req = http.get(`http://localhost:${fastify.server.address().port}`, (res) => {
+      res.once('data', () => {
+        req.destroy()
+        setTimeout(() => {
+          t.assert.strictEqual(readerCancelled, true)
+          done()
+        }, 50)
+      })
+    })
+  })
+})
+
+test('WebStream should warn when headers already sent', async (t) => {
+  t.plan(2)
+
+  let warnCalled = false
+  const spyLogger = {
+    level: 'warn',
+    fatal: () => { },
+    error: () => { },
+    warn: (msg) => {
+      if (typeof msg === 'string' && msg.includes('use res.writeHead in stream mode')) {
+        warnCalled = true
+      }
+    },
+    info: () => { },
+    debug: () => { },
+    trace: () => { },
+    child: () => spyLogger
+  }
+
+  const fastify = Fastify({ loggerInstance: spyLogger })
+  t.after(() => fastify.close())
+
+  fastify.get('/', function (request, reply) {
+    reply.raw.writeHead(200, { 'content-type': 'text/plain' })
+    const stream = new ReadableStream({
+      start (controller) {
+        controller.enqueue('hello')
+        controller.close()
+      }
+    })
+    reply.send(stream)
+  })
+
+  await fastify.listen({ port: 0 })
+
+  const response = await fetch(`http://localhost:${fastify.server.address().port}/`)
+  t.assert.strictEqual(response.status, 200)
+  t.assert.strictEqual(warnCalled, true)
+})