node-fastify 5.8.3

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

@@ -0,0 +1,277 @@
+import * as fs from 'node:fs'
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import P from 'pino'
+import { expectAssignable, expectDeprecated, expectError, expectNotAssignable, expectType } from 'tsd'
+import fastify, {
+  FastifyBaseLogger,
+  FastifyLogFn,
+  FastifyReply,
+  FastifyRequest,
+  LogLevel
+} from '../../fastify'
+import { FastifyLoggerInstance, ResSerializerReply } from '../../types/logger'
+
+expectType<FastifyBaseLogger>(fastify().log)
+
+class Foo { }
+
+['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
+  expectType<FastifyLogFn>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]('')
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({})
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({ foo: 'bar' })
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Error())
+  )
+  expectType<void>(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Foo())
+  )
+})
+
+interface CustomLogger extends FastifyBaseLogger {
+  customMethod(msg: string, ...args: unknown[]): void;
+}
+
+class CustomLoggerImpl implements CustomLogger {
+  level = 'info'
+  customMethod (msg: string, ...args: unknown[]) { console.log(msg, args) }
+
+  // Implementation signature must be compatible with all overloads of FastifyLogFn
+  info (arg1: unknown, arg2?: unknown, ...args: unknown[]): void {
+    console.log(arg1, arg2, ...args)
+  }
+
+  warn (...args: unknown[]) { console.log(args) }
+  error (...args: unknown[]) { console.log(args) }
+  fatal (...args: unknown[]) { console.log(args) }
+  trace (...args: unknown[]) { console.log(args) }
+  debug (...args: unknown[]) { console.log(args) }
+  silent (...args: unknown[]) { }
+
+  child (bindings: P.Bindings, options?: P.ChildLoggerOptions): CustomLoggerImpl { return new CustomLoggerImpl() }
+}
+
+const customLogger = new CustomLoggerImpl()
+
+const serverWithCustomLogger = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  CustomLoggerImpl
+>({ logger: customLogger })
+
+expectType<CustomLoggerImpl>(serverWithCustomLogger.log)
+
+const serverWithPino = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  P.Logger
+>({
+  logger: P({
+    level: 'info',
+    redact: ['x-userinfo']
+  })
+})
+
+expectType<P.Logger>(serverWithPino.log)
+
+serverWithPino.route({
+  method: 'GET',
+  url: '/',
+  handler (request) {
+    expectType<P.Logger>(this.log)
+    expectType<P.Logger>(request.log)
+  }
+})
+
+serverWithPino.get('/', function (request) {
+  expectType<P.Logger>(this.log)
+  expectType<P.Logger>(request.log)
+})
+
+const serverWithLogOptions = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse
+>({
+  logger: {
+    level: 'info'
+  }
+})
+
+expectType<FastifyBaseLogger>(serverWithLogOptions.log)
+
+const serverWithFileOption = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse
+>({
+  logger: {
+    level: 'info',
+    file: '/path/to/file'
+  }
+})
+
+expectType<FastifyBaseLogger>(serverWithFileOption.log)
+
+const serverAutoInferringTypes = fastify({
+  logger: {
+    level: 'info'
+  }
+})
+
+expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
+
+const serverWithLoggerInstance = fastify({
+  loggerInstance: P({
+    level: 'info',
+    redact: ['x-userinfo']
+  })
+})
+
+expectType<P.Logger>(serverWithLoggerInstance.log)
+
+const serverWithPinoConfig = fastify({
+  logger: {
+    level: 'info',
+    serializers: {
+      req (IncomingMessage) {
+        expectType<FastifyRequest>(IncomingMessage)
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'fastify.test',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (ServerResponse) {
+        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
+        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
+        expectNotAssignable<FastifyReply>(ServerResponse)
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverWithPinoConfig.log)
+
+const serverAutoInferredFileOption = fastify({
+  logger: {
+    level: 'info',
+    file: '/path/to/file'
+  }
+})
+
+expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
+
+const serverAutoInferredSerializerResponseObjectOption = fastify({
+  logger: {
+    serializers: {
+      res (ServerResponse) {
+        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
+        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
+        expectNotAssignable<FastifyReply>(ServerResponse)
+        return {
+          status: '200'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverAutoInferredSerializerResponseObjectOption.log)
+
+const serverAutoInferredSerializerObjectOption = fastify({
+  logger: {
+    serializers: {
+      req (IncomingMessage) {
+        expectType<FastifyRequest>(IncomingMessage)
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'fastify.test',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (ServerResponse) {
+        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
+        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
+        expectNotAssignable<FastifyReply>(ServerResponse)
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverAutoInferredSerializerObjectOption.log)
+
+const passStreamAsOption = fastify({
+  logger: {
+    stream: fs.createWriteStream('/tmp/stream.out')
+  }
+})
+
+expectType<FastifyBaseLogger>(passStreamAsOption.log)
+
+const passPinoOption = fastify({
+  logger: {
+    redact: ['custom'],
+    messageKey: 'msg',
+    nestedKey: 'nested',
+    enabled: true
+  }
+})
+
+expectType<FastifyBaseLogger>(passPinoOption.log)
+
+// FastifyLoggerInstance is deprecated
+expectDeprecated({} as FastifyLoggerInstance)
+
+const childParent = fastify().log
+// we test different option variant here
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'info' }))
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'silent' }))
+expectType<FastifyBaseLogger>(childParent.child({}, { redact: ['pass', 'pin'] }))
+expectType<FastifyBaseLogger>(childParent.child({}, { serializers: { key: () => { } } }))
+expectType<FastifyBaseLogger>(childParent.child({}, { level: 'info', redact: ['pass', 'pin'], serializers: { key: () => { } } }))
+
+// no option pass
+expectError(childParent.child())
+// wrong option
+expectError(childParent.child({}, { nonExist: true }))

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

@@ -0,0 +1,97 @@
+import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify'
+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'
+
+// FastifyPlugin & FastifyRegister
+interface TestOptions extends FastifyPluginOptions {
+  option1: string;
+  option2: boolean;
+}
+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
+) => { }
+
+expectError(fastify().register(testPluginOpts, {})) // error because missing required options from generic declaration
+expectError(fastify().register(testPluginOptsAsync, {})) // error because missing required options from generic declaration
+
+expectAssignable<FastifyInstance>(fastify().register(testPluginOpts, { option1: '', option2: true }))
+expectAssignable<FastifyInstance>(fastify().register(testPluginOptsAsync, { option1: '', option2: true }))
+
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }))
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }, () => { }))
+expectAssignable<FastifyInstance>(fastify().register(function (instance, opts, done) { }, { logLevel: 'info', prefix: 'foobar' }))
+
+expectAssignable<FastifyInstance>(fastify().register(import('./dummy-plugin')))
+expectAssignable<FastifyInstance>(fastify().register(import('./dummy-plugin'), { foo: 1 }))
+
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
+expectAssignable<FastifyInstance>(fastify().register(testPluginCallback, {}))
+
+const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
+expectAssignable<FastifyInstance>(fastify().register(testPluginAsync, {}))
+
+expectAssignable<FastifyInstance>(
+  fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() })
+)
+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) { }, { ...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)
+expectAssignable<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(httpsServer)
+expectType<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>(httpsServer)
+
+// Chainable
+httpsServer
+  .register(testPluginOpts, testOptions)
+  .after((_error) => { })
+  .ready((_error) => { })
+  .close(() => { })
+
+// Thenable
+expectAssignable<PromiseLike<undefined>>(httpsServer.after())
+expectAssignable<PromiseLike<undefined>>(httpsServer.close())
+expectAssignable<PromiseLike<undefined>>(httpsServer.ready())
+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' }))
+expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithTypeAsync, { prefix: '/test' }))
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+async function testAsync (): Promise<void> {
+  await httpsServer
+    .register(testPluginOpts, testOptions)
+    .register(testPluginOpts, testOptions)
+}

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

@@ -0,0 +1,237 @@
+import { expectAssignable, expectError, expectType } from 'tsd'
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
+import fastify, { FastifyInstance, FastifyError, FastifyBaseLogger, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
+
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOpts: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginOptsAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
+
+interface TestOptions extends FastifyPluginOptions {
+  option1: string;
+  option2: boolean;
+}
+
+// Type validation
+expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
+expectError(fastify().register(testPluginOptsAsync, { logLevel: () => ({}) }))
+expectError(fastify().register(testPluginOptsAsync, { logSerializers: () => ({}) }))
+expectError(fastify().register({}))
+
+expectAssignable<FastifyInstance>(
+  fastify().register(
+    testPluginOptsAsync, { prefix: '/example', logLevel: 'info', logSerializers: { key: (value: any) => `${value}` } }
+  )
+)
+
+expectAssignable<FastifyInstance>(
+  fastify().register(testPluginOptsAsync, () => {
+    return {}
+  })
+)
+
+expectAssignable<FastifyInstance>(
+  fastify().register(testPluginOptsAsync, (instance) => {
+    expectType<FastifyInstance>(instance)
+  })
+)
+
+// With Http2
+const serverWithHttp2 = fastify({ http2: true })
+type ServerWithHttp2 = FastifyInstance<Http2Server, Http2ServerRequest, Http2ServerResponse>
+const testPluginWithHttp2: FastifyPluginCallback<TestOptions, Http2Server> = function (instance, opts, done) { }
+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))
+// @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) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+
+// With Type Provider
+type TestTypeProvider = { schema: 'test', validator: 'test', serializer: 'test' }
+const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
+type ServerWithTypeProvider = FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  FastifyBaseLogger,
+  TestTypeProvider
+>
+const testPluginWithTypeProvider: FastifyPluginCallback<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider
+> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAsync: FastifyPluginAsync<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider
+> = async function (instance, opts) { }
+const testPluginWithTypeProviderWithType = (
+  instance: ServerWithTypeProvider,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithTypeProviderWithTypeAsync = async (
+  instance: ServerWithTypeProvider,
+  opts: FastifyPluginOptions
+) => { }
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginCallback))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOpts))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithType))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithTypeAsync))
+// @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) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))
+
+// With Type Provider and logger
+const customLogger = {
+  level: 'info',
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  child: () => customLogger,
+  silent: () => { }
+}
+const serverWithTypeProviderAndLogger = fastify({
+  loggerInstance: customLogger
+}).withTypeProvider<TestTypeProvider>()
+type ServerWithTypeProviderAndLogger = FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  typeof customLogger,
+  TestTypeProvider
+>
+const testPluginWithTypeProviderAndLogger: FastifyPluginCallback<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider,
+  typeof customLogger
+> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAndLoggerAsync: FastifyPluginAsync<
+  TestOptions,
+  RawServerDefault,
+  TestTypeProvider,
+  typeof customLogger
+> = async function (instance, opts) { }
+const testPluginWithTypeProviderAndLoggerWithType = (
+  instance: ServerWithTypeProviderAndLogger,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginWithTypeProviderAndLoggerWithTypeAsync = async (
+  instance: ServerWithTypeProviderAndLogger,
+  opts: FastifyPluginOptions
+) => { }
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginCallback))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOpts))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithType))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  // @ts-expect-error
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  // @ts-expect-error
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync, testOptions)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync)
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register((instance) => {
+    expectAssignable<FastifyInstance>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register((instance: ServerWithTypeProviderAndLogger) => {
+    expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(async (instance) => {
+    expectAssignable<FastifyInstance>(instance)
+  })
+)
+expectAssignable<ServerWithTypeProviderAndLogger>(
+  serverWithTypeProviderAndLogger.register(async (instance: ServerWithTypeProviderAndLogger) => {
+    expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+  })
+)