jishushell 0.6.18 → 0.7.3

package/node_modules/fastify/test/types/{logger.test-d.ts → logger.tst.ts}

@@ -1,39 +1,40 @@
 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 { expect } from 'tstyche'
 import fastify, {
   FastifyBaseLogger,
+  FastifyError,
   FastifyLogFn,
   FastifyReply,
   FastifyRequest,
   LogLevel
-} from '../../fastify'
-import { FastifyLoggerInstance, ResSerializerReply } from '../../types/logger'
+} from '../../fastify.js'
+import { ResSerializerReply } from '../../types/logger.js'
 
-expectType<FastifyBaseLogger>(fastify().log)
+expect(fastify().log).type.toBe<FastifyBaseLogger>()
 
 class Foo { }
 
 ['trace', 'debug', 'info', 'warn', 'error', 'fatal'].forEach(logLevel => {
-  expectType<FastifyLogFn>(
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]
-  )
-  expectType<void>(
+  ).type.toBe<FastifyLogFn>()
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]('')
-  )
-  expectType<void>(
+  ).type.toBe<void>()
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({})
-  )
-  expectType<void>(
+  ).type.toBe<void>()
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel]({ foo: 'bar' })
-  )
-  expectType<void>(
+  ).type.toBe<void>()
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Error())
-  )
-  expectType<void>(
+  ).type.toBe<void>()
+  expect(
     fastify<Server, IncomingMessage, ServerResponse, FastifyBaseLogger>().log[logLevel as LogLevel](new Foo())
-  )
+  ).type.toBe<void>()
 })
 
 interface CustomLogger extends FastifyBaseLogger {
@@ -68,7 +69,7 @@ const serverWithCustomLogger = fastify<
   CustomLoggerImpl
 >({ logger: customLogger })
 
-expectType<CustomLoggerImpl>(serverWithCustomLogger.log)
+expect(serverWithCustomLogger.log).type.toBe<CustomLoggerImpl>()
 
 const serverWithPino = fastify<
   Server,
@@ -82,20 +83,20 @@ const serverWithPino = fastify<
   })
 })
 
-expectType<P.Logger>(serverWithPino.log)
+expect(serverWithPino.log).type.toBe<P.Logger>()
 
 serverWithPino.route({
   method: 'GET',
   url: '/',
   handler (request) {
-    expectType<P.Logger>(this.log)
-    expectType<P.Logger>(request.log)
+    expect(this.log).type.toBe<P.Logger>()
+    expect(request.log).type.toBe<P.Logger>()
   }
 })
 
 serverWithPino.get('/', function (request) {
-  expectType<P.Logger>(this.log)
-  expectType<P.Logger>(request.log)
+  expect(this.log).type.toBe<P.Logger>()
+  expect(request.log).type.toBe<P.Logger>()
 })
 
 const serverWithLogOptions = fastify<
@@ -108,7 +109,7 @@ const serverWithLogOptions = fastify<
   }
 })
 
-expectType<FastifyBaseLogger>(serverWithLogOptions.log)
+expect(serverWithLogOptions.log).type.toBe<FastifyBaseLogger>()
 
 const serverWithFileOption = fastify<
   Server,
@@ -121,7 +122,7 @@ const serverWithFileOption = fastify<
   }
 })
 
-expectType<FastifyBaseLogger>(serverWithFileOption.log)
+expect(serverWithFileOption.log).type.toBe<FastifyBaseLogger>()
 
 const serverAutoInferringTypes = fastify({
   logger: {
@@ -129,7 +130,7 @@ const serverAutoInferringTypes = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
+expect(serverAutoInferringTypes.log).type.toBe<FastifyBaseLogger>()
 
 const serverWithLoggerInstance = fastify({
   loggerInstance: P({
@@ -138,14 +139,14 @@ const serverWithLoggerInstance = fastify({
   })
 })
 
-expectType<P.Logger>(serverWithLoggerInstance.log)
+expect(serverWithLoggerInstance.log).type.toBe<P.Logger>()
 
 const serverWithPinoConfig = fastify({
   logger: {
     level: 'info',
     serializers: {
-      req (IncomingMessage) {
-        expectType<FastifyRequest>(IncomingMessage)
+      req (request) {
+        expect(request).type.toBe<FastifyRequest>()
         return {
           method: 'method',
           url: 'url',
@@ -156,15 +157,17 @@ const serverWithPinoConfig = fastify({
           other: ''
         }
       },
-      res (ServerResponse) {
-        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
-        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
-        expectNotAssignable<FastifyReply>(ServerResponse)
+      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) {
+      err (error) {
+        expect(error).type.toBe<FastifyError>()
+
         return {
           other: '',
           type: 'type',
@@ -176,7 +179,7 @@ const serverWithPinoConfig = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(serverWithPinoConfig.log)
+expect(serverWithPinoConfig.log).type.toBe<FastifyBaseLogger>()
 
 const serverAutoInferredFileOption = fastify({
   logger: {
@@ -185,15 +188,15 @@ const serverAutoInferredFileOption = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
+expect(serverAutoInferredFileOption.log).type.toBe<FastifyBaseLogger>()
 
 const serverAutoInferredSerializerResponseObjectOption = fastify({
   logger: {
     serializers: {
-      res (ServerResponse) {
-        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
-        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
-        expectNotAssignable<FastifyReply>(ServerResponse)
+      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'
         }
@@ -202,13 +205,13 @@ const serverAutoInferredSerializerResponseObjectOption = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(serverAutoInferredSerializerResponseObjectOption.log)
+expect(serverAutoInferredSerializerResponseObjectOption.log).type.toBe<FastifyBaseLogger>()
 
 const serverAutoInferredSerializerObjectOption = fastify({
   logger: {
     serializers: {
-      req (IncomingMessage) {
-        expectType<FastifyRequest>(IncomingMessage)
+      req (request) {
+        expect(request).type.toBe<FastifyRequest>()
         return {
           method: 'method',
           url: 'url',
@@ -219,10 +222,10 @@ const serverAutoInferredSerializerObjectOption = fastify({
           other: ''
         }
       },
-      res (ServerResponse) {
-        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
-        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
-        expectNotAssignable<FastifyReply>(ServerResponse)
+      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'
         }
@@ -239,7 +242,7 @@ const serverAutoInferredSerializerObjectOption = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(serverAutoInferredSerializerObjectOption.log)
+expect(serverAutoInferredSerializerObjectOption.log).type.toBe<FastifyBaseLogger>()
 
 const passStreamAsOption = fastify({
   logger: {
@@ -247,7 +250,7 @@ const passStreamAsOption = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(passStreamAsOption.log)
+expect(passStreamAsOption.log).type.toBe<FastifyBaseLogger>()
 
 const passPinoOption = fastify({
   logger: {
@@ -258,20 +261,16 @@ const passPinoOption = fastify({
   }
 })
 
-expectType<FastifyBaseLogger>(passPinoOption.log)
-
-// FastifyLoggerInstance is deprecated
-expectDeprecated({} as FastifyLoggerInstance)
+expect(passPinoOption.log).type.toBe<FastifyBaseLogger>()
 
 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 }))
+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>()