fastify 4.19.1 → 4.20.0

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

@@ -1,9 +1,9 @@
-import fastify, { FastifyInstance, FastifyRequest, FastifyReply, RouteHandlerMethod } from '../../fastify'
-import { expectType, expectError, expectAssignable, printType } from 'tsd'
-import { HTTPMethods } from '../../types/utils'
+import { FastifyError } from '@fastify/error'
 import * as http from 'http'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify'
 import { RequestPayload } from '../../types/hooks'
-import { FastifyError } from '@fastify/error'
+import { HTTPMethods } from '../../types/utils'
 
 /*
  * Testing Fastify HTTP Routes and Route Shorthands.
@@ -57,6 +57,9 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
     errorHandler: (error, request, reply) => {
       expectType<FastifyError>(error)
       reply.send('error')
+    },
+    childLoggerFactory: function (logger, bindings, opts) {
+      return logger.child(bindings, opts)
     }
   }))
 
@@ -74,7 +77,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
     Headers: HeadersInterface;
   }
 
-  fastify()[lowerCaseMethod]<RouteGeneric, RouteSpecificContextConfigType>('/', { config: { foo: 'bar', bar: 100, extra: true, url: '/', method: lowerCaseMethod } }, (req, res) => {
+  fastify()[lowerCaseMethod]<RouteGeneric, RouteSpecificContextConfigType>('/', { config: { foo: 'bar', bar: 100, extra: true } }, (req, res) => {
     expectType<BodyInterface>(req.body)
     expectType<QuerystringInterface>(req.query)
     expectType<ParamsInterface>(req.params)
@@ -94,7 +97,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   fastify().route<RouteGeneric>({
     url: '/',
     method: method as HTTPMethods,
-    config: { foo: 'bar', bar: 100, url: '/', method: method as HTTPMethods },
+    config: { foo: 'bar', bar: 100 },
     prefixTrailingSlash: 'slash',
     onRequest: (req, res, done) => { // these handlers are tested in `hooks.test-d.ts`
       expectType<BodyInterface>(req.body)
@@ -231,7 +234,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   fastify().route<RouteGeneric>({
     url: '/',
     method: method as HTTPMethods,
-    config: { foo: 'bar', bar: 100, url: '/', method: method as HTTPMethods },
+    config: { foo: 'bar', bar: 100 },
     prefixTrailingSlash: 'slash',
     onRequest: async (req, res, done) => { // these handlers are tested in `hooks.test-d.ts`
       expectType<BodyInterface>(req.body)

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

@@ -299,6 +299,8 @@ expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
+    expectType<(payload?: string | number | { error: string }) => typeof res>(res.code(200).send)
+    expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))
 
@@ -527,6 +529,8 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
+    expectType<(payload?: string | number | { [x: string]: unknown, error?: string | undefined }) => typeof res>(res.code(200).send)
+    expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))
 

package/types/context.d.ts

@@ -1,8 +1,8 @@
-import { ContextConfigDefault } from './utils'
 import { FastifyRouteConfig } from './route'
+import { ContextConfigDefault } from './utils'
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface FastifyContextConfig extends FastifyRouteConfig {
+export interface FastifyContextConfig {
 }
 
 /**
@@ -12,5 +12,5 @@ export interface FastifyContext<ContextConfig = ContextConfigDefault> {
   /**
    * @deprecated Use Request#routeConfig or Request#routeSchema instead
    */
-  config: FastifyContextConfig & ContextConfig;
+  config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
 }

package/types/errors.d.ts

@@ -2,6 +2,14 @@ import { FastifyErrorConstructor } from '@fastify/error'
 
 export type FastifyErrorCodes = Record<
 'FST_ERR_NOT_FOUND' |
+'FST_ERR_OPTIONS_NOT_OBJ' |
+'FST_ERR_QSP_NOT_FN' |
+'FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN' |
+'FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN' |
+'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ' |
+'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR' |
+'FST_ERR_VERSION_CONSTRAINT_NOT_STR' |
+'FST_ERR_VALIDATION' |
 'FST_ERR_CTP_ALREADY_PRESENT' |
 'FST_ERR_CTP_INVALID_TYPE' |
 'FST_ERR_CTP_EMPTY_TYPE' |
@@ -11,65 +19,63 @@ export type FastifyErrorCodes = Record<
 'FST_ERR_CTP_INVALID_MEDIA_TYPE' |
 'FST_ERR_CTP_INVALID_CONTENT_LENGTH' |
 'FST_ERR_CTP_EMPTY_JSON_BODY' |
+'FST_ERR_CTP_INSTANCE_ALREADY_STARTED' |
 'FST_ERR_DEC_ALREADY_PRESENT' |
 'FST_ERR_DEC_DEPENDENCY_INVALID_TYPE' |
 'FST_ERR_DEC_MISSING_DEPENDENCY' |
 'FST_ERR_DEC_AFTER_START' |
 'FST_ERR_HOOK_INVALID_TYPE' |
 'FST_ERR_HOOK_INVALID_HANDLER' |
+'FST_ERR_HOOK_INVALID_ASYNC_HANDLER' |
+'FST_ERR_HOOK_NOT_SUPPORTED' |
 'FST_ERR_MISSING_MIDDLEWARE' |
 'FST_ERR_HOOK_TIMEOUT' |
 'FST_ERR_LOG_INVALID_DESTINATION' |
 'FST_ERR_LOG_INVALID_LOGGER' |
 'FST_ERR_REP_INVALID_PAYLOAD_TYPE' |
 'FST_ERR_REP_ALREADY_SENT' |
-'FST_ERR_REP_SENT_VALUE'|
-'FST_ERR_SEND_INSIDE_ONERR'|
-'FST_ERR_SEND_UNDEFINED_ERR'|
-'FST_ERR_BAD_STATUS_CODE'|
+'FST_ERR_REP_SENT_VALUE' |
+'FST_ERR_SEND_INSIDE_ONERR' |
+'FST_ERR_SEND_UNDEFINED_ERR' |
+'FST_ERR_BAD_STATUS_CODE' |
 'FST_ERR_BAD_TRAILER_NAME' |
 'FST_ERR_BAD_TRAILER_VALUE' |
 'FST_ERR_FAILED_ERROR_SERIALIZATION' |
 'FST_ERR_MISSING_SERIALIZATION_FN' |
+'FST_ERR_MISSING_CONTENTTYPE_SERIALIZATION_FN' |
 'FST_ERR_REQ_INVALID_VALIDATION_INVOCATION' |
 'FST_ERR_SCH_MISSING_ID' |
 'FST_ERR_SCH_ALREADY_PRESENT' |
+'FST_ERR_SCH_CONTENT_MISSING_SCHEMA' |
 'FST_ERR_SCH_DUPLICATE' |
 'FST_ERR_SCH_VALIDATION_BUILD' |
 'FST_ERR_SCH_SERIALIZATION_BUILD' |
+'FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX' |
 'FST_ERR_HTTP2_INVALID_VERSION' |
 'FST_ERR_INIT_OPTS_INVALID' |
 'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE' |
 'FST_ERR_DUPLICATED_ROUTE' |
 'FST_ERR_BAD_URL' |
+'FST_ERR_ASYNC_CONSTRAINT' |
 'FST_ERR_DEFAULT_ROUTE_INVALID_TYPE' |
 'FST_ERR_INVALID_URL' |
-'FST_ERR_REOPENED_CLOSE_SERVER' |
-'FST_ERR_REOPENED_SERVER' |
-'FST_ERR_PLUGIN_VERSION_MISMATCH' |
-'FST_ERR_PLUGIN_CALLBACK_NOT_FN' |
-'FST_ERR_PLUGIN_NOT_VALID' |
-'FST_ERR_ROOT_PLG_BOOTED' |
-'FST_ERR_PARENT_PLUGIN_BOOTED' |
-'FST_ERR_PLUGIN_TIMEOUT' |
-'FST_ERR_OPTIONS_NOT_OBJ' |
-'FST_ERR_QSP_NOT_FN' |
-'FST_ERR_SCHEMA_CONTROLLER_BUCKET_OPT_NOT_FN' |
-'FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN' |
-'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ' |
-'FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR' |
-'FST_ERR_VERSION_CONSTRAINT_NOT_STR' |
-'FST_ERR_CTP_INSTANCE_ALREADY_STARTED' |
-'FST_ERR_HOOK_NOT_SUPPORTED' |
-'FST_ERR_SCH_RESPONSE_SCHEMA_NOT_NESTED_2XX' |
 'FST_ERR_ROUTE_OPTIONS_NOT_OBJ' |
 'FST_ERR_ROUTE_DUPLICATED_HANDLER' |
 'FST_ERR_ROUTE_HANDLER_NOT_FN' |
 'FST_ERR_ROUTE_MISSING_HANDLER' |
+'FST_ERR_ROUTE_METHOD_INVALID' |
 'FST_ERR_ROUTE_METHOD_NOT_SUPPORTED' |
 'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED' |
 'FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT' |
 'FST_ERR_ROUTE_REWRITE_NOT_STR' |
+'FST_ERR_REOPENED_CLOSE_SERVER' |
+'FST_ERR_REOPENED_SERVER' |
+'FST_ERR_INSTANCE_ALREADY_LISTENING' |
+'FST_ERR_PLUGIN_VERSION_MISMATCH' |
 'FST_ERR_PLUGIN_NOT_PRESENT_IN_INSTANCE' |
-'FST_ERR_INSTANCE_ALREADY_LISTENING'
+'FST_ERR_PLUGIN_CALLBACK_NOT_FN' |
+'FST_ERR_PLUGIN_NOT_VALID' |
+'FST_ERR_ROOT_PLG_BOOTED' |
+'FST_ERR_PARENT_PLUGIN_BOOTED' |
+'FST_ERR_PLUGIN_TIMEOUT'
 , FastifyErrorConstructor>

package/types/instance.d.ts

@@ -4,11 +4,11 @@ import * as http from 'http'
 import { CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse } from 'light-my-request'
 import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction, removeAllContentTypeParsers, removeContentTypeParser } from './content-type-parser'
 import { onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, preCloseHookHandler, preCloseAsyncHookHandler } from './hooks'
-import { FastifyBaseLogger } from './logger'
+import { FastifyBaseLogger, FastifyChildLoggerFactory } from './logger'
 import { FastifyRegister } from './register'
 import { FastifyReply } from './reply'
 import { FastifyRequest } from './request'
-import { DefaultRoute, RouteGenericInterface, RouteOptions, RouteShorthandMethod } from './route'
+import { DefaultRoute, RouteGenericInterface, RouteOptions, RouteShorthandMethod, RouteHandlerMethod } from './route'
 import {
   FastifySchema,
   FastifySchemaCompiler,
@@ -103,6 +103,12 @@ type DecorationMethod<This, Return = This> = {
     >,
     dependencies?: string[]
   ): Return;
+
+  (property: string | symbol): Return;
+
+  (property: string | symbol, value: null): Return;
+
+  (property: string | symbol, value: null|undefined, dependencies: string[]): Return;
 }
 
 /**
@@ -520,10 +526,10 @@ export interface FastifyInstance<
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger>;
 
   /**
-   * Set the 404 handler
-   */
-  setNotFoundHandler<RouteGeneric extends RouteGenericInterface = RouteGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema> (
-    handler: (request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfigDefault, SchemaCompiler, TypeProvider>) => void | Promise<RouteGeneric['Reply'] | void>
+     * Set the 404 handler
+     */
+  setNotFoundHandler<RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig extends ContextConfigDefault = ContextConfigDefault, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema> (
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
   setNotFoundHandler<RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig extends ContextConfigDefault = ContextConfigDefault, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema> (
@@ -531,7 +537,7 @@ export interface FastifyInstance<
       preValidation?: preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
       preHandler?: preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider> | preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>[];
     },
-    handler: (request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfigDefault, SchemaCompiler, TypeProvider>) => void | Promise<RouteGeneric['Reply'] | void>
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
 
   /**
@@ -546,6 +552,32 @@ export interface FastifyInstance<
     handler: (this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>, error: TError, request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, reply: FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfigDefault, SchemaCompiler, TypeProvider>) => any | Promise<any>
   ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
+  /**
+   * Hook function that is called when creating a child logger instance for each request
+   * which allows for modifying or adding child logger bindings and logger options, or
+   * returning a completely custom child logger implementation.
+   */
+  childLoggerFactory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+
+  /**
+   * Hook function that is called when creating a child logger instance for each request
+   * which allows for modifying or adding child logger bindings and logger options, or
+   * returning a completely custom child logger implementation.
+   *
+   * Child logger bindings have a performance advantage over per-log bindings, because
+   * they are pre-serialised by Pino when the child logger is created.
+   *
+   * For example:
+   * ```
+   * function childLoggerFactory(logger, bindings, opts, rawReq) {
+   *   // Calculate additional bindings from the request
+   *   bindings.traceContext = rawReq.headers['x-cloud-trace-context']
+   *   return logger.child(bindings, opts);
+   * }
+   * ```
+   */
+  setChildLoggerFactory(factory: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+
   /**
    * Fastify schema validator for all routes.
    */

package/types/logger.d.ts

@@ -5,6 +5,7 @@ import { FastifyReply } from './reply'
 import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
 import { FastifyTypeProvider, FastifyTypeProviderDefault } from './type-provider'
 import { FastifySchema } from './schema'
+import { FastifyInstance } from './instance'
 
 import pino from 'pino'
 
@@ -78,3 +79,27 @@ export interface FastifyLoggerOptions<
   genReqId?: (req: RawRequest) => string;
   stream?: FastifyLoggerStreamDestination;
 }
+
+export interface FastifyChildLoggerFactory<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> {
+  /**
+   * @param logger The parent logger
+   * @param bindings The bindings object that will be passed to the child logger
+   * @param childLoggerOpts The logger options that will be passed to the child logger
+   * @param rawReq The raw request
+   * @this The fastify instance
+   * @returns The child logger instance
+   */
+  (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+    logger: Logger,
+    bindings: Bindings,
+    childLoggerOpts: ChildLoggerOptions,
+    rawReq: RawRequest
+  ): Logger
+}

package/types/reply.d.ts

@@ -6,17 +6,22 @@ import { FastifyRequest } from './request'
 import { RouteGenericInterface } from './route'
 import { FastifySchema } from './schema'
 import { FastifyReplyType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyReplyType } from './type-provider'
-import { CodeToReplyKey, ContextConfigDefault, ReplyKeysToCodes, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault } from './utils'
+import { CodeToReplyKey, ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault, ReplyKeysToCodes } from './utils'
 
 export interface ReplyGenericInterface {
   Reply?: ReplyDefault;
 }
 
-export type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>, ReplyKey = CodeToReplyKey<Code>> =
+type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>, ReplyKey = CodeToReplyKey<Code>> =
   Code extends keyof RouteGenericReply ? RouteGenericReply[Code] :
     [ReplyKey] extends [never] ? unknown :
       ReplyKey extends keyof RouteGenericReply ? RouteGenericReply[ReplyKey] :
-        unknown;
+        RouteGenericReply;
+
+export type ResolveReplyTypeWithRouteGeneric<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault> =
+  ResolveFastifyReplyType<TypeProvider, SchemaCompiler, { Reply: ReplyTypeConstrainer<RouteGenericReply, Code> }>
 /**
  * FastifyReply is an instance of the standard http or http2 reply types.
  * It defaults to http.ServerResponse, and it also extends the relative reply object.
@@ -36,8 +41,8 @@ export interface FastifyReply<
   log: FastifyBaseLogger;
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>;
   server: FastifyInstance;
-  code<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReplyTypeConstrainer<RouteGeneric['Reply'], Code>>;
-  status<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReplyTypeConstrainer<RouteGeneric['Reply'], Code>>;
+  code<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  status<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
   statusCode: number;
   sent: boolean;
   send(payload?: ReplyType): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;

package/types/request.d.ts

@@ -1,11 +1,11 @@
 import { ErrorObject } from '@fastify/ajv-compiler'
+import { FastifyContext } from './context'
+import { FastifyInstance } from './instance'
 import { FastifyBaseLogger } from './logger'
-import { ContextConfigDefault, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './utils'
 import { RouteGenericInterface } from './route'
-import { FastifyInstance } from './instance'
-import { FastifyTypeProvider, FastifyTypeProviderDefault, FastifyRequestType, ResolveFastifyRequestType } from './type-provider'
 import { FastifySchema } from './schema'
-import { FastifyContext, FastifyContextConfig } from './context'
+import { FastifyRequestType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyRequestType } from './type-provider'
+import { ContextConfigDefault, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './utils'
 
 type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
 export interface RequestGenericInterface {
@@ -59,7 +59,7 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   server: FastifyInstance;
   body: RequestType['body'];
   context: FastifyContext<ContextConfig>;
-  routeConfig: FastifyContextConfig & ContextConfig;
+  routeConfig: FastifyContext<ContextConfig>['config'];
   routeSchema: FastifySchema
 
   /** in order for this to be used the user should ensure they have set the attachValidation option. */

package/types/route.d.ts

@@ -1,17 +1,17 @@
+import { FastifyError } from '@fastify/error'
+import { FastifyContext } from './context'
+import { onErrorHookHandler, onRequestAbortHookHandler, onRequestHookHandler, onResponseHookHandler, onSendHookHandler, onTimeoutHookHandler, preHandlerHookHandler, preParsingHookHandler, preSerializationHookHandler, preValidationHookHandler } from './hooks'
 import { FastifyInstance } from './instance'
-import { FastifyRequest, RequestGenericInterface } from './request'
+import { FastifyBaseLogger, FastifyChildLoggerFactory, LogLevel } from './logger'
 import { FastifyReply, ReplyGenericInterface } from './reply'
+import { FastifyRequest, RequestGenericInterface } from './request'
 import { FastifySchema, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorFormatter } from './schema'
-import { HTTPMethods, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
-import { preValidationHookHandler, preHandlerHookHandler, preSerializationHookHandler, onRequestHookHandler, preParsingHookHandler, onResponseHookHandler, onSendHookHandler, onErrorHookHandler, onTimeoutHookHandler, onRequestAbortHookHandler } from './hooks'
-import { FastifyError } from '@fastify/error'
-import { FastifyContext } from './context'
 import {
   FastifyTypeProvider,
   FastifyTypeProviderDefault,
   ResolveFastifyReplyReturnType
 } from './type-provider'
-import { FastifyBaseLogger, LogLevel } from './logger'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 
 export interface FastifyRouteConfig {
   url: string;
@@ -41,11 +41,12 @@ export interface RouteShorthandOptions<
   serializerCompiler?: FastifySerializerCompiler<SchemaCompiler>;
   bodyLimit?: number;
   logLevel?: LogLevel;
-  config?: FastifyContext<ContextConfig>['config'];
+  config?: Omit<FastifyContext<ContextConfig>['config'], 'url' | 'method'>;
   version?: string;
   constraints?: { [name: string]: any },
   prefixTrailingSlash?: 'slash'|'no-slash'|'both';
   errorHandler?: (this: FastifyInstance, error: FastifyError, request: FastifyRequest, reply: FastifyReply) => void;
+  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
   schemaErrorFormatter?: SchemaErrorFormatter;
 
   // hooks