jishushell 0.6.5 → 0.7.3

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

@@ -1,277 +0,0 @@
-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/node_modules/fastify/test/types/plugin.test-d.ts

@@ -1,97 +0,0 @@
-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/node_modules/fastify/test/types/register.test-d.ts

@@ -1,237 +0,0 @@
-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)
-  })
-)