jishushell 0.6.5 → 0.7.3

package/node_modules/fastify/test/types/logger.tst.ts

@@ -0,0 +1,276 @@
+import * as fs from 'node:fs'
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import P from 'pino'
+import { expect } from 'tstyche'
+import fastify, {
+  FastifyBaseLogger,
+  FastifyError,
+  FastifyLogFn,
+  FastifyReply,
+  FastifyRequest,
+  LogLevel
+} from '../../fastify.js'
+import { ResSerializerReply } from '../../types/logger.js'
+
+expect(fastify().log).type.toBe<FastifyBaseLogger>()
+
+class Foo { }
+
+['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]
+  ).type.toBe<FastifyLogFn>()
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]('')
+  ).type.toBe<void>()
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({})
+  ).type.toBe<void>()
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({ foo: 'bar' })
+  ).type.toBe<void>()
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Error())
+  ).type.toBe<void>()
+  expect(
+    fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Foo())
+  ).type.toBe<void>()
+})
+
+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 })
+
+expect(serverWithCustomLogger.log).type.toBe<CustomLoggerImpl>()
+
+const serverWithPino = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  P.Logger
+>({
+  logger: P({
+    level: 'info',
+    redact: ['x-userinfo']
+  })
+})
+
+expect(serverWithPino.log).type.toBe<P.Logger>()
+
+serverWithPino.route({
+  method: 'GET',
+  url: '/',
+  handler (request) {
+    expect(this.log).type.toBe<P.Logger>()
+    expect(request.log).type.toBe<P.Logger>()
+  }
+})
+
+serverWithPino.get('/', function (request) {
+  expect(this.log).type.toBe<P.Logger>()
+  expect(request.log).type.toBe<P.Logger>()
+})
+
+const serverWithLogOptions = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse
+>({
+  logger: {
+    level: 'info'
+  }
+})
+
+expect(serverWithLogOptions.log).type.toBe<FastifyBaseLogger>()
+
+const serverWithFileOption = fastify<
+  Server,
+  IncomingMessage,
+  ServerResponse
+>({
+  logger: {
+    level: 'info',
+    file: '/path/to/file'
+  }
+})
+
+expect(serverWithFileOption.log).type.toBe<FastifyBaseLogger>()
+
+const serverAutoInferringTypes = fastify({
+  logger: {
+    level: 'info'
+  }
+})
+
+expect(serverAutoInferringTypes.log).type.toBe<FastifyBaseLogger>()
+
+const serverWithLoggerInstance = fastify({
+  loggerInstance: P({
+    level: 'info',
+    redact: ['x-userinfo']
+  })
+})
+
+expect(serverWithLoggerInstance.log).type.toBe<P.Logger>()
+
+const serverWithPinoConfig = fastify({
+  logger: {
+    level: 'info',
+    serializers: {
+      req (request) {
+        expect(request).type.toBe<FastifyRequest>()
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'fastify.test',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (reply) {
+        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
+        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.not.toBeAssignableTo<FastifyReply>()
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (error) {
+        expect(error).type.toBe<FastifyError>()
+
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expect(serverWithPinoConfig.log).type.toBe<FastifyBaseLogger>()
+
+const serverAutoInferredFileOption = fastify({
+  logger: {
+    level: 'info',
+    file: '/path/to/file'
+  }
+})
+
+expect(serverAutoInferredFileOption.log).type.toBe<FastifyBaseLogger>()
+
+const serverAutoInferredSerializerResponseObjectOption = fastify({
+  logger: {
+    serializers: {
+      res (reply) {
+        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
+        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.not.toBeAssignableTo<FastifyReply>()
+        return {
+          status: '200'
+        }
+      }
+    }
+  }
+})
+
+expect(serverAutoInferredSerializerResponseObjectOption.log).type.toBe<FastifyBaseLogger>()
+
+const serverAutoInferredSerializerObjectOption = fastify({
+  logger: {
+    serializers: {
+      req (request) {
+        expect(request).type.toBe<FastifyRequest>()
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'fastify.test',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (reply) {
+        expect(reply).type.toBe<ResSerializerReply<Server, FastifyReply>>()
+        expect(reply).type.toBeAssignableTo<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>()
+        expect(reply).type.not.toBeAssignableTo<FastifyReply>()
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expect(serverAutoInferredSerializerObjectOption.log).type.toBe<FastifyBaseLogger>()
+
+const passStreamAsOption = fastify({
+  logger: {
+    stream: fs.createWriteStream('/tmp/stream.out')
+  }
+})
+
+expect(passStreamAsOption.log).type.toBe<FastifyBaseLogger>()
+
+const passPinoOption = fastify({
+  logger: {
+    redact: ['custom'],
+    messageKey: 'msg',
+    nestedKey: 'nested',
+    enabled: true
+  }
+})
+
+expect(passPinoOption.log).type.toBe<FastifyBaseLogger>()
+
+const childParent = fastify().log
+// we test different option variant here
+expect(childParent.child({}, { level: 'info' })).type.toBe<FastifyBaseLogger>()
+expect(childParent.child({}, { level: 'silent' })).type.toBe<FastifyBaseLogger>()
+expect(childParent.child({}, { redact: ['pass', 'pin'] })).type.toBe<FastifyBaseLogger>()
+expect(childParent.child({}, { serializers: { key: () => { } } })).type.toBe<FastifyBaseLogger>()
+expect(childParent.child({}, { level: 'info', redact: ['pass', 'pin'], serializers: { key: () => { } } })).type.toBe<FastifyBaseLogger>()
+
+expect(childParent.child).type.not.toBeCallableWith()
+
+expect(childParent.child).type.not.toBeCallableWith({}, { nonExist: true })

package/node_modules/fastify/test/types/plugin.tst.ts

@@ -0,0 +1,96 @@
+import * as http from 'node:http'
+import * as https from 'node:https'
+import { FastifyError } from '@fastify/error'
+import { expect } from 'tstyche'
+import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify.js'
+import { FastifyPluginCallback, FastifyPluginAsync } from '../../types/plugin.js'
+
+// 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) {
+  expect(opts).type.toBe<TestOptions>()
+}
+const testPluginOptsAsync: FastifyPluginAsync<TestOptions> = async function (instance, opts) {
+  expect(opts).type.toBe<TestOptions>()
+}
+
+const testPluginOptsWithType = (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions,
+  done: (error?: FastifyError) => void
+) => { }
+const testPluginOptsWithTypeAsync = async (
+  instance: FastifyInstance,
+  opts: FastifyPluginOptions
+) => { }
+
+expect(fastify().register).type.not.toBeCallableWith(testPluginOpts, {}) // must provide required options
+expect(fastify().register).type.not.toBeCallableWith(testPluginOptsAsync, {}) // must provide required options
+
+expect(fastify().register(testPluginOpts, { option1: '', option2: true })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(testPluginOptsAsync, { option1: '', option2: true })).type.toBeAssignableTo<FastifyInstance>()
+
+expect(fastify().register(function (instance, opts, done) { })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(function (instance, opts, done) { }, () => { })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(function (instance, opts, done) { }, { logLevel: 'info', prefix: 'foobar' })).type.toBeAssignableTo<FastifyInstance>()
+
+expect(fastify().register(import('./dummy-plugin.mjs'))).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(import('./dummy-plugin.mjs'), { foo: 1 })).type.toBeAssignableTo<FastifyInstance>()
+
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
+expect(fastify().register(testPluginCallback, {})).type.toBeAssignableTo<FastifyInstance>()
+
+const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
+expect(fastify().register(testPluginAsync, {})).type.toBeAssignableTo<FastifyInstance>()
+
+expect(
+  fastify().register(function (instance, opts): Promise<void> { return Promise.resolve() })
+).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(async function (instance, opts) { }, () => { })).type.toBeAssignableTo<FastifyInstance>()
+expect(fastify().register(async function (instance, opts) { }, { logLevel: 'info', prefix: 'foobar' })).type.toBeAssignableTo<FastifyInstance>()
+
+expect(fastify().register).type.not.toBeCallableWith(function () { }, { logLevel: '', prefix: 'foobar' }) // must provide valid logLevel
+
+const httpsServer = fastify({ https: {} })
+expect(httpsServer).type.not.toBeAssignableTo<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  Promise<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(httpsServer).type.toBeAssignableTo<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+expect(httpsServer).type.toBe<
+  FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> &
+  SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>
+>()
+
+// Chainable
+httpsServer
+  .register(testPluginOpts, testOptions)
+  .after((_error) => { })
+  .ready((_error) => { })
+  .close(() => { })
+
+// Thenable
+expect(httpsServer.after()).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.close()).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.ready()).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.register(testPluginOpts, testOptions)).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.register(testPluginOptsWithType)).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.register(testPluginOptsWithTypeAsync)).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.register(testPluginOptsWithType, { prefix: '/test' })).type.toBeAssignableTo<PromiseLike<undefined>>()
+expect(httpsServer.register(testPluginOptsWithTypeAsync, { prefix: '/test' })).type.toBeAssignableTo<PromiseLike<undefined>>()
+
+async function testAsync (): Promise<void> {
+  await httpsServer
+    .register(testPluginOpts, testOptions)
+    .register(testPluginOpts, testOptions)
+}

package/node_modules/fastify/test/types/register.tst.ts

@@ -0,0 +1,245 @@
+import { IncomingMessage, Server, ServerResponse } from 'node:http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'node:http2'
+import { expect } from 'tstyche'
+import fastify, {
+  FastifyInstance,
+  FastifyError,
+  FastifyBaseLogger,
+  FastifyPluginAsync,
+  FastifyPluginCallback,
+  FastifyPluginOptions,
+  RawServerDefault
+} from '../../fastify.js'
+
+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
+expect(fastify().register).type.not.toBeCallableWith(testPluginOptsAsync, { prefix: 1 })
+expect(fastify().register).type.not.toBeCallableWith(testPluginOptsAsync, { logLevel: () => ({}) })
+expect(fastify().register).type.not.toBeCallableWith(testPluginOptsAsync, { logSerializers: () => ({}) })
+expect(fastify().register).type.not.toBeCallableWith({})
+
+expect(
+  fastify().register(
+    testPluginOptsAsync, { prefix: '/example', logLevel: 'info', logSerializers: { key: (value: any) => `${value}` } }
+  )
+).type.toBeAssignableTo<FastifyInstance>()
+
+expect(
+  fastify().register(testPluginOptsAsync, () => {
+    return {}
+  })
+).type.toBeAssignableTo<FastifyInstance>()
+
+expect(
+  fastify().register(testPluginOptsAsync, (instance) => {
+    expect(instance).type.toBe<FastifyInstance>()
+  })
+).type.toBeAssignableTo<FastifyInstance>()
+
+// 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
+}
+expect(serverWithHttp2.register(testPluginCallback)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginAsync)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginOpts)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginOptsAsync)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginOptsWithType)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginOptsWithTypeAsync)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register).type.not.toBeCallableWith(testPluginWithHttp2)
+expect(serverWithHttp2.register(testPluginWithHttp2, testOptions)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register).type.not.toBeCallableWith(testPluginWithHttp2Async)
+expect(serverWithHttp2.register(testPluginWithHttp2Async, testOptions)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginWithHttp2WithType)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(testPluginWithHttp2WithTypeAsync)).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register((instance) => {
+  expect(instance).type.toBe<FastifyInstance>()
+})).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register((instance: ServerWithHttp2) => {
+  expect(instance).type.toBe<ServerWithHttp2>()
+})).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(async (instance) => {
+  expect(instance).type.toBe<FastifyInstance>()
+})).type.toBeAssignableTo<ServerWithHttp2>()
+expect(serverWithHttp2.register(async (instance: ServerWithHttp2) => {
+  expect(instance).type.toBe<ServerWithHttp2>()
+})).type.toBeAssignableTo<ServerWithHttp2>()
+
+// 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
+) => { }
+expect(serverWithTypeProvider.register(testPluginCallback)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginAsync)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginOpts)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginOptsAsync)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginOptsWithType)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginOptsWithTypeAsync)).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register).type.not.toBeCallableWith(testPluginWithTypeProvider)
+expect(serverWithTypeProvider.register(testPluginWithTypeProvider, testOptions))
+  .type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register).type.not.toBeCallableWith(testPluginWithTypeProviderAsync)
+expect(serverWithTypeProvider.register(testPluginWithTypeProviderAsync, testOptions))
+  .type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginWithTypeProviderWithType))
+  .type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(testPluginWithTypeProviderWithTypeAsync))
+  .type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register((instance) => {
+  expect(instance).type.toBe<FastifyInstance>()
+})).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register((instance: ServerWithTypeProvider) => {
+  expect(instance).type.toBe<ServerWithTypeProvider>()
+})).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(async (instance) => {
+  expect(instance).type.toBe<FastifyInstance>()
+})).type.toBeAssignableTo<ServerWithTypeProvider>()
+expect(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
+  expect(instance).type.toBe<ServerWithTypeProvider>()
+})).type.toBeAssignableTo<ServerWithTypeProvider>()
+
+// 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
+) => { }
+expect(serverWithTypeProviderAndLogger.register(testPluginCallback))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register(testPluginAsync))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register(testPluginOpts))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register(testPluginOptsAsync))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register(testPluginOptsWithType))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register(testPluginOptsWithTypeAsync))
+  .type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register).type.not.toBeCallableWith(testPluginWithTypeProviderAndLogger)
+expect(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger, testOptions)
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(serverWithTypeProviderAndLogger.register).type.not.toBeCallableWith(testPluginWithTypeProviderAndLoggerAsync)
+expect(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync, testOptions)
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType)
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync)
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register((instance) => {
+    expect(instance).type.toBe<FastifyInstance>()
+  })
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register((instance: ServerWithTypeProviderAndLogger) => {
+    expect(instance).type.toBe<ServerWithTypeProviderAndLogger>()
+  })
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register(async (instance) => {
+    expect(instance).type.toBe<FastifyInstance>()
+  })
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()
+expect(
+  serverWithTypeProviderAndLogger.register(async (instance: ServerWithTypeProviderAndLogger) => {
+    expect(instance).type.toBe<ServerWithTypeProviderAndLogger>()
+  })
+).type.toBeAssignableTo<ServerWithTypeProviderAndLogger>()