fastify 4.0.0-rc.3 → 4.0.0

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

@@ -261,6 +261,7 @@ type InitialConfig = Readonly<{
   http2?: boolean,
   https?: boolean | Readonly<{ allowHTTP1: boolean }>,
   ignoreTrailingSlash?: boolean,
+  ignoreDuplicateSlashes?: boolean,
   disableRequestLogging?: boolean,
   maxParamLength?: number,
   onProtoPoisoning?: 'error' | 'remove' | 'ignore',

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

@@ -1,4 +1,4 @@
-import { expectType } from 'tsd'
+import { expectError, expectType } from 'tsd'
 import fastify, {
   FastifyLogFn,
   LogLevel,
@@ -212,3 +212,15 @@ const passPinoOption = fastify({
 })
 
 expectType<FastifyBaseLogger>(passPinoOption.log)
+
+const childParent = fastify().log
+// we test different option variant here
+expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info' }))
+expectType<FastifyLoggerInstance>(childParent.child({}, { redact: ['pass', 'pin'] }))
+expectType<FastifyLoggerInstance>(childParent.child({}, { serializers: { key: () => {} } }))
+expectType<FastifyLoggerInstance>(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/route.test-d.ts

@@ -27,6 +27,14 @@ const routeHandler: RouteHandlerMethod = function (request, reply) {
   expectType<FastifyReply>(reply)
 }
 
+const routeHandlerWithReturnValue: RouteHandlerMethod = function (request, reply) {
+  expectType<FastifyInstance>(this)
+  expectType<FastifyRequest>(request)
+  expectType<FastifyReply>(reply)
+
+  return reply.send()
+}
+
 type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options'
 
 ;['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE', 'OPTIONS'].forEach(method => {
@@ -216,3 +224,9 @@ expectType<FastifyInstance>(fastify().route({
 expectError(fastify().route({
   prefixTrailingSlash: true // Not a valid value
 }))
+
+expectType<FastifyInstance>(fastify().route({
+  url: '/',
+  method: 'GET',
+  handler: routeHandlerWithReturnValue
+}))

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

@@ -13,6 +13,12 @@ import { RouteGenericInterface } from '../../types/route'
 
 const server = fastify()
 
+// -------------------------------------------------------------------
+// Default (unknown)
+// -------------------------------------------------------------------
+
+expectAssignable(server.get('/', (req) => expectType<unknown>(req.body)))
+
 // -------------------------------------------------------------------
 // Remapping
 // -------------------------------------------------------------------

package/types/instance.d.ts

@@ -619,6 +619,7 @@ export interface FastifyInstance<
     http2?: boolean,
     https?: boolean | Readonly<{ allowHTTP1: boolean }>,
     ignoreTrailingSlash?: boolean,
+    ignoreDuplicateSlashes?: boolean,
     disableRequestLogging?: boolean,
     maxParamLength?: number,
     onProtoPoisoning?: ProtoAction,

package/types/logger.d.ts

@@ -17,11 +17,13 @@ export type LogLevel = pino.Level
 
 export type Bindings = pino.Bindings
 
+export type ChildLoggerOptions = pino.ChildLoggerOptions
+
 export type FastifyLoggerInstance = pino.Logger
 // TODO make pino export BaseLogger again
 // export type FastifyBaseLogger = pino.BaseLogger & {
 export type FastifyBaseLogger = pino.Logger & {
-  child(bindings: Bindings): FastifyBaseLogger
+  child(bindings: Bindings, options?: ChildLoggerOptions): FastifyBaseLogger
 }
 
 export interface FastifyLoggerStreamDestination {

package/types/route.d.ts

@@ -154,7 +154,7 @@ export type RouteHandler<
   this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, RequestType, Logger>,
   reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>
-) => void | Promise<RouteGeneric['Reply'] | void>
+) => RouteGeneric['Reply'] | void | Promise<RouteGeneric['Reply'] | void>
 
 export type DefaultRoute<Request, Reply> = (
   req: Request,

package/types/schema.d.ts

@@ -4,7 +4,7 @@ import { FastifyInstance, FastifyServerOptions } from '../fastify'
  * Schemas in Fastify follow the JSON-Schema standard. For this reason
  * we have opted to not ship strict schema based types. Instead we provide
  * an example in our documentation on how to solve this problem. Check it
- * out here: https://github.com/fastify/fastify/blob/main/docs/TypeScript.md#json-schema
+ * out here: https://github.com/fastify/fastify/blob/main/docs/Reference/TypeScript.md#json-schema
  */
 export interface FastifySchema {
   body?: unknown;

package/types/type-provider.d.ts

@@ -11,9 +11,8 @@ export interface FastifyTypeProvider {
   readonly output: unknown,
 }
 
-export interface FastifyTypeProviderDefault extends FastifyTypeProvider {
-  output: unknown
-}
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface FastifyTypeProviderDefault extends FastifyTypeProvider {}
 
 export type CallTypeProvider<F extends FastifyTypeProvider, I> = (F & { input: I })['output']
 
@@ -93,7 +92,7 @@ TypeProvider,
 SchemaCompiler,
 RouteGeneric
 > extends infer Return ?
-  (void | Promise<Return | void>)
+  (Return | void | Promise<Return | void>)
 // review: support both async and sync return types
 // (Promise<Return> | Return | Promise<void> | void)
   : unknown