fastify 5.0.0 → 5.2.0

package/test/trust-proxy.test.js

@@ -1,12 +1,13 @@
 'use strict'
 
-const t = require('tap')
-const { test, before } = t
+const { test, before } = require('node:test')
 const sget = require('simple-get').concat
 const fastify = require('..')
 const helper = require('./helper')
 
-const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
+const noop = () => {}
+
+const sgetForwardedRequest = (app, forHeader, path, protoHeader, testCaseDone) => {
   const headers = {
     'X-Forwarded-For': forHeader,
     'X-Forwarded-Host': 'example.com'
@@ -18,30 +19,30 @@ const sgetForwardedRequest = (app, forHeader, path, protoHeader) => {
     method: 'GET',
     headers,
     url: 'http://localhost:' + app.server.address().port + path
-  }, () => {})
+  }, testCaseDone || noop)
 }
 
 const testRequestValues = (t, req, options) => {
   if (options.ip) {
-    t.ok(req.ip, 'ip is defined')
-    t.equal(req.ip, options.ip, 'gets ip from x-forwarded-for')
+    t.assert.ok(req.ip, 'ip is defined')
+    t.assert.strictEqual(req.ip, options.ip, 'gets ip from x-forwarded-for')
   }
   if (options.host) {
-    t.ok(req.host, 'host is defined')
-    t.equal(req.host, options.host, 'gets host from x-forwarded-host')
-    t.ok(req.hostname)
-    t.equal(req.hostname, options.host, 'gets hostname from x-forwarded-host')
+    t.assert.ok(req.host, 'host is defined')
+    t.assert.strictEqual(req.host, options.host, 'gets host from x-forwarded-host')
+    t.assert.ok(req.hostname)
+    t.assert.strictEqual(req.hostname, options.host, 'gets hostname from x-forwarded-host')
   }
   if (options.ips) {
-    t.same(req.ips, options.ips, 'gets ips from x-forwarded-for')
+    t.assert.deepStrictEqual(req.ips, options.ips, 'gets ips from x-forwarded-for')
   }
   if (options.protocol) {
-    t.ok(req.protocol, 'protocol is defined')
-    t.equal(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
+    t.assert.ok(req.protocol, 'protocol is defined')
+    t.assert.strictEqual(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
   }
   if (options.port) {
-    t.ok(req.port, 'port is defined')
-    t.equal(req.port, options.port, 'port is taken from x-forwarded-for or host')
+    t.assert.ok(req.port, 'port is defined')
+    t.assert.strictEqual(req.port, options.port, 'port is taken from x-forwarded-for or host')
   }
 }
 
@@ -50,11 +51,13 @@ before(async function () {
   [localhost] = await helper.getLoopbackHost()
 })
 
-test('trust proxy, not add properties to node req', (t) => {
+test('trust proxy, not add properties to node req', (t, done) => {
   t.plan(14)
   const app = fastify({
     trustProxy: true
   })
+  t.after(() => app.close())
+
   app.get('/trustproxy', function (req, reply) {
     testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
     reply.code(200).send({ ip: req.ip, host: req.host })
@@ -65,17 +68,23 @@ test('trust proxy, not add properties to node req', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy')
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain')
+    t.assert.ifError(err)
+
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxy', undefined, completed)
+    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxychain', undefined, completed)
+
+    let pending = 2
+    function completed () {
+      if (--pending === 0) {
+        done()
+      }
+    }
   })
 })
 
-test('trust proxy chain', (t) => {
+test('trust proxy chain', (t, done) => {
   t.plan(9)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
@@ -86,16 +95,15 @@ test('trust proxy chain', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '192.168.1.1, 1.1.1.1', '/trustproxychain', undefined, done)
   })
 })
 
-test('trust proxy function', (t) => {
+test('trust proxy function', (t, done) => {
   t.plan(9)
   const app = fastify({
     trustProxy: (address) => address === localhost
@@ -105,16 +113,15 @@ test('trust proxy function', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyfunc', undefined, done)
   })
 })
 
-test('trust proxy number', (t) => {
+test('trust proxy number', (t, done) => {
   t.plan(10)
   const app = fastify({
     trustProxy: 1
@@ -124,16 +131,15 @@ test('trust proxy number', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '2.2.2.2, 1.1.1.1', '/trustproxynumber', undefined, done)
   })
 })
 
-test('trust proxy IP addresses', (t) => {
+test('trust proxy IP addresses', (t, done) => {
   t.plan(10)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
@@ -143,16 +149,15 @@ test('trust proxy IP addresses', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
-
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
-    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs')
+    t.assert.ifError(err)
+    t.after(() => app.close())
+    sgetForwardedRequest(app, '3.3.3.3, 2.2.2.2, 1.1.1.1', '/trustproxyipaddrs', undefined, done)
   })
 })
 
-test('trust proxy protocol', (t) => {
+test('trust proxy protocol', (t, done) => {
   t.plan(31)
   const app = fastify({
     trustProxy: true
@@ -170,13 +175,14 @@ test('trust proxy protocol', (t) => {
     reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
-  t.teardown(app.close.bind(app))
+  t.after(() => app.close())
 
   app.listen({ port: 0 }, (err) => {
     app.server.unref()
-    t.error(err)
+    t.assert.ifError(err)
     sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocol', 'lorem')
     sgetForwardedRequest(app, '1.1.1.1', '/trustproxynoprotocol')
-    sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor')
+    // Allow for sgetForwardedRequest requests above to finish
+    setTimeout(() => sgetForwardedRequest(app, '1.1.1.1', '/trustproxyprotocols', 'ipsum, dolor', done))
   })
 })

package/test/type-provider.test.js

@@ -1,20 +1,22 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const Fastify = require('..')
 
-test('Should export withTypeProvider function', t => {
+test('Should export withTypeProvider function', (t, done) => {
   t.plan(1)
   try {
     Fastify().withTypeProvider()
-    t.pass()
+    t.assert.ok('pass')
+    done()
   } catch (e) {
-    t.fail()
+    t.assert.fail(e)
   }
 })
 
-test('Should return same instance', t => {
+test('Should return same instance', (t, done) => {
   t.plan(1)
   const fastify = Fastify()
-  t.equal(fastify, fastify.withTypeProvider())
+  t.assert.strictEqual(fastify, fastify.withTypeProvider())
+  done()
 })

package/test/types/content-type-parser.test-d.ts

@@ -1,6 +1,6 @@
 import fastify, { FastifyBodyParser } from '../../fastify'
 import { expectError, expectType } from 'tsd'
-import { IncomingMessage } from 'http'
+import { IncomingMessage } from 'node:http'
 import { FastifyRequest } from '../../types/request'
 
 expectType<void>(fastify().addContentTypeParser('contentType', function (request, payload, done) {

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

@@ -1,8 +1,8 @@
 import { ErrorObject as AjvErrorObject } from 'ajv'
-import * as http from 'http'
-import * as http2 from 'http2'
-import * as https from 'https'
-import { Socket } from 'net'
+import * as http from 'node:http'
+import * as http2 from 'node:http2'
+import * as https from 'node:https'
+import { Socket } from 'node:net'
 import { expectAssignable, expectError, expectNotAssignable, expectType } from 'tsd'
 import fastify, {
   ConnectionError,
@@ -21,6 +21,7 @@ import fastify, {
   RouteGenericInterface,
   SafePromiseLike
 } from '../../fastify'
+import { Bindings, ChildLoggerOptions } from '../../types/logger'
 
 // FastifyInstance
 // http server
@@ -219,6 +220,17 @@ expectAssignable<FastifyInstance>(fastify({
   }
 }))
 
+expectAssignable<FastifyInstance>(fastify({
+  childLoggerFactory: function (this: FastifyInstance, logger: FastifyBaseLogger, bindings: Bindings, opts: ChildLoggerOptions, req: RawRequestDefaultExpression) {
+    expectType<FastifyBaseLogger>(logger)
+    expectType<Bindings>(bindings)
+    expectType<ChildLoggerOptions>(opts)
+    expectType<RawRequestDefaultExpression>(req)
+    expectAssignable<FastifyInstance>(this)
+    return logger.child(bindings, opts)
+  }
+}))
+
 // Thenable
 expectAssignable<PromiseLike<FastifyInstance>>(fastify({ return503OnClosing: true }))
 fastify().then(fastifyInstance => expectAssignable<FastifyInstance>(fastifyInstance))

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

@@ -131,7 +131,8 @@ server.addHook('onRoute', function (opts) {
   expectType<RouteOptions & { routePath: string; path: string; prefix: string }>(opts)
 })
 
-server.addHook('onRegister', (instance, opts) => {
+server.addHook('onRegister', function (instance, opts) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
   expectType<RegisterOptions & FastifyPluginOptions>(opts)
 })

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

@@ -13,7 +13,7 @@ import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
-import { AddressInfo } from 'net'
+import { AddressInfo } from 'node:net'
 import { Bindings, ChildLoggerOptions } from '../../types/logger'
 
 const server = fastify()
@@ -193,6 +193,8 @@ function invalidSchemaErrorFormatter (err: Error) {
 }
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
+expectType<FastifyInstance>(server.addHttpMethod('SEARCH', { hasBody: true }))
+
 // test listen opts objects
 expectAssignable<PromiseLike<string>>(server.listen())
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))
@@ -370,12 +372,11 @@ expectError(server.decorate<string>('test', true))
 expectError(server.decorate<(myNumber: number) => number>('test', function (myNumber: number): string {
   return ''
 }))
-// TODO(mcollina): uncomment after https://github.com/tsdjs/tsd/pull/220 lands.
-// expectError(server.decorate<string>('test', {
-//   getter () {
-//     return true
-//   }
-// }))
+expectError(server.decorate<string>('test', {
+  getter () {
+    return true
+  }
+}))
 expectError(server.decorate<string>('test', {
   setter (x) {}
 }))
@@ -419,12 +420,11 @@ server.decorate('typedTestProperty')
 server.decorate('typedTestProperty', null, ['foo'])
 expectError(server.decorate('typedTestProperty', null))
 expectError(server.decorate('typedTestProperty', 'foo'))
-// TODO(mcollina): uncomment after https://github.com/tsdjs/tsd/pull/220 lands.
-// expectError(server.decorate('typedTestProperty', {
-//  getter () {
-//    return 'foo'
-//  }
-// }))
+expectError(server.decorate('typedTestProperty', {
+  getter () {
+    return 'foo'
+  }
+}))
 server.decorate('typedTestMethod', function (x) {
   expectType<string>(x)
   expectType<FastifyInstance>(this)

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

@@ -7,8 +7,8 @@ import fastify, {
   FastifyReply,
   FastifyBaseLogger
 } from '../../fastify'
-import { Server, IncomingMessage, ServerResponse } from 'http'
-import * as fs from 'fs'
+import { Server, IncomingMessage, ServerResponse } from 'node:http'
+import * as fs from 'node:fs'
 import P from 'pino'
 import { ResSerializerReply } from '../../types/logger'
 

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

@@ -1,6 +1,6 @@
 import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify'
-import * as http from 'http'
-import * as https from 'https'
+import * as http from 'node:http'
+import * as https from 'node:https'
 import { expectType, expectError, expectAssignable } from 'tsd'
 import { FastifyPluginCallback, FastifyPluginAsync } from '../../types/plugin'
 import { FastifyError } from '@fastify/error'
@@ -10,8 +10,16 @@ interface TestOptions extends FastifyPluginOptions {
   option1: string;
   option2: boolean;
 }
-const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, done) { }
-const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (instance, opts) { }
+const testOptions: TestOptions = {
+  option1: 'a',
+  option2: false,
+}
+const testPluginOpts: FastifyPluginCallback<TestOptions> = function (instance, opts, done) {
+  expectType<TestOptions>(opts)
+}
+const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (instance, opts) {
+  expectType<TestOptions>(opts)
+}
 
 const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
 const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
@@ -39,7 +47,7 @@ expectAssignable<FastifyInstance>(fastify().register(function (instance, opts):
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, () => { }))
 expectAssignable<FastifyInstance>(fastify().register(async function (instance, opts) { }, { logLevel: 'info', prefix: 'foobar' }))
 
-expectError(fastify().register(function (instance, opts, done) { }, { logLevel: '' })) // must use a valid logLevel
+expectError(fastify().register(function (instance, opts, done) { }, { ...testOptions, logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
 expectError<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & Promise<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
@@ -48,7 +56,7 @@ expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerRespon
 
 // Chainable
 httpsServer
-  .register(testPluginOpts)
+  .register(testPluginOpts, testOptions)
   .after((_error) => { })
   .ready((_error) => { })
   .close(() => { })
@@ -57,7 +65,7 @@ httpsServer
 expectAssignable<PromiseLike<undefined>>(httpsServer.after())
 expectAssignable<PromiseLike<undefined>>(httpsServer.close())
 expectAssignable<PromiseLike<undefined>>(httpsServer.ready())
-expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOpts))
+expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOpts, testOptions))
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithType))
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithTypeAsync))
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithType, { prefix: '/test' }))
@@ -66,6 +74,6 @@ expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWith
 /* eslint-disable @typescript-eslint/no-unused-vars */
 async function testAsync (): Promise<void> {
   await httpsServer
-    .register(testPluginOpts)
-    .register(testPluginOpts)
+    .register(testPluginOpts, testOptions)
+    .register(testPluginOpts, testOptions)
 }

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

@@ -1,6 +1,6 @@
 import { expectAssignable, expectError, expectType } from 'tsd'
-import { IncomingMessage, Server, ServerResponse } from 'http'
-import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'http2'
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
 import fastify, { FastifyInstance, FastifyError, FastifyLoggerInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
 
 const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
@@ -48,14 +48,22 @@ const testPluginWithHttp2: FastifyPluginCallback<TestOptions, Http2Server> = fun
 const testPluginWithHttp2Async: FastifyPluginAsync<TestOptions, Http2Server> = async function (instance, opts) { }
 const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
 const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
+const testOptions: TestOptions = {
+  option1: 'a',
+  option2: false,
+}
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOpts))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsAsync))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithType))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithTypeAsync))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2))
-expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2Async))
+// @ts-expect-error
+serverWithHttp2.register(testPluginWithHttp2)
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2, testOptions))
+// @ts-expect-error
+serverWithHttp2.register(testPluginWithHttp2Async)
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2Async, testOptions))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithType))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithTypeAsync))
 expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance) => {
@@ -85,8 +93,12 @@ expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPlu
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsAsync))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithType))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithTypeAsync))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProvider))
-expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderAsync))
+// @ts-expect-error
+serverWithTypeProvider.register(testPluginWithTypeProvider)
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProvider, testOptions))
+// @ts-expect-error
+serverWithTypeProvider.register(testPluginWithTypeProviderAsync)
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderAsync, testOptions))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithType))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithTypeAsync))
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance) => {
@@ -128,8 +140,12 @@ expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogge
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsAsync))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithType))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithTypeAsync))
+// @ts-expect-error
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions))
+// @ts-expect-error
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync, testOptions))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync))
 expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register((instance) => {

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

@@ -1,4 +1,4 @@
-import { Buffer } from 'buffer'
+import { Buffer } from 'node:buffer'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyContextConfig, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
 import { FastifyInstance } from '../../types/instance'

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

@@ -1,5 +1,5 @@
 import { FastifyError } from '@fastify/error'
-import * as http from 'http'
+import * as http from 'node:http'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify'
 import { RequestPayload } from '../../types/hooks'
@@ -398,9 +398,21 @@ type LowerCaseHTTPMethods = 'delete' | 'get' | 'head' | 'patch' | 'post' | 'put'
   })
 })
 
-expectError(fastify().route({
+expectType<FastifyInstance>(fastify().route({
+  url: '/',
+  method: 'CONNECT', // not a valid method but could be implemented by the user
+  handler: routeHandler
+}))
+
+expectType<FastifyInstance>(fastify().route({
   url: '/',
-  method: 'CONNECT', // not a valid method
+  method: 'OPTIONS',
+  handler: routeHandler
+}))
+
+expectType<FastifyInstance>(fastify().route({
+  url: '/',
+  method: 'OPTION', // OPTION is a typo for OPTIONS
   handler: routeHandler
 }))
 
@@ -410,7 +422,7 @@ expectType<FastifyInstance>(fastify().route({
   handler: routeHandler
 }))
 
-expectError(fastify().route({
+expectType<FastifyInstance>(fastify().route({
   url: '/',
   method: ['GET', 'POST', 'OPTION'], // OPTION is a typo for OPTIONS
   handler: routeHandler
@@ -506,3 +518,21 @@ expectType<FastifyInstance>(fastify().route({
   method: ['put', 'patch'],
   handler: routeHandlerWithReturnValue
 }))
+
+expectType<FastifyInstance>(fastify().route({
+  url: '/',
+  method: 'GET',
+  handler: (req) => {
+    expectType<HTTPMethods | HTTPMethods[]>(req.routeOptions.method)
+    expectAssignable<string | Array<string>>(req.routeOptions.method)
+  }
+}))
+
+expectType<FastifyInstance>(fastify().route({
+  url: '/',
+  method: ['HEAD', 'GET'],
+  handler: (req) => {
+    expectType<HTTPMethods | HTTPMethods[]>(req.routeOptions.method)
+    expectAssignable<string | Array<string>>(req.routeOptions.method)
+  }
+}))

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

@@ -1,5 +1,5 @@
 import fastify, { FastifyServerFactory } from '../../fastify'
-import * as http from 'http'
+import * as http from 'node:http'
 import { expectType } from 'tsd'
 
 // Custom Server

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

@@ -8,7 +8,7 @@ import fastify, {
   SafePromiseLike
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
-import { IncomingHttpHeaders } from 'http'
+import { IncomingHttpHeaders } from 'node:http'
 import { Type, TSchema, Static } from '@sinclair/typebox'
 import { FromSchema, JSONSchema } from 'json-schema-to-ts'