node-fastify 5.8.3

package/types/logger.d.ts

@@ -0,0 +1,107 @@
+import { FastifyError } from '@fastify/error'
+import { FastifyInstance } from './instance'
+import { FastifyReply } from './reply'
+import { FastifyRequest } from './request'
+import { RouteGenericInterface } from './route'
+import { FastifySchema } from './schema'
+import { FastifyTypeProvider, FastifyTypeProviderDefault } from './type-provider'
+import { ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
+
+import type {
+  BaseLogger,
+  LogFn as FastifyLogFn,
+  LevelWithSilent as LogLevel,
+  Bindings,
+  ChildLoggerOptions,
+  LoggerOptions as PinoLoggerOptions
+} from 'pino'
+
+export type {
+  FastifyLogFn,
+  LogLevel,
+  Bindings,
+  ChildLoggerOptions,
+  PinoLoggerOptions
+}
+
+export interface FastifyBaseLogger extends Pick<BaseLogger, 'level' | 'info' | 'error' | 'debug' | 'fatal' | 'warn' | 'trace' | 'silent'> {
+  child(bindings: Bindings, options?: ChildLoggerOptions): FastifyBaseLogger
+}
+
+// TODO delete FastifyLoggerInstance in the next major release. It seems that it is enough to have only FastifyBaseLogger.
+/**
+ * @deprecated Use FastifyBaseLogger instead
+ */
+export type FastifyLoggerInstance = FastifyBaseLogger
+
+export interface FastifyLoggerStreamDestination {
+  write(msg: string): void;
+}
+
+// TODO: once node 18 is EOL, this type can be replaced with plain FastifyReply.
+/**
+ * Specialized reply type used for the `res` log serializer, since only `statusCode` is passed in certain cases.
+ */
+export type ResSerializerReply<
+  RawServer extends RawServerBase,
+  RawReply extends FastifyReply<RouteGenericInterface, RawServer>
+> = Partial<RawReply> & Pick<RawReply, 'statusCode'>
+
+/**
+ * Fastify Custom Logger options.
+ */
+export interface FastifyLoggerOptions<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends FastifyRequest<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, FastifyTypeProvider> = FastifyRequest<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, FastifyTypeProviderDefault>,
+  RawReply extends FastifyReply<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, ContextConfigDefault, FastifySchema, FastifyTypeProvider> = FastifyReply<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault>
+> {
+  serializers?: {
+    req?: (req: RawRequest) => {
+      method?: string;
+      url?: string;
+      version?: string;
+      host?: string;
+      remoteAddress?: string;
+      remotePort?: number;
+      [key: string]: unknown;
+    };
+    err?: (err: FastifyError) => {
+      type: string;
+      message: string;
+      stack: string;
+      [key: string]: unknown;
+    };
+    res?: (res: ResSerializerReply<RawServer, RawReply>) => {
+      statusCode?: string | number;
+      [key: string]: unknown;
+    };
+  };
+  level?: string;
+  file?: string;
+  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/plugin.d.ts

@@ -0,0 +1,44 @@
+import { FastifyInstance } from './instance'
+import { RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault } from './utils'
+import { FastifyTypeProvider, FastifyTypeProviderDefault } from './type-provider'
+import { FastifyBaseLogger } from './logger'
+
+export type FastifyPluginOptions = Record<string, any>
+
+/**
+ * FastifyPluginCallback
+ *
+ * Fastify allows the user to extend its functionalities with plugins. A plugin can be a set of routes, a server decorator or whatever. To activate plugins, use the `fastify.register()` method.
+ */
+export type FastifyPluginCallback<
+  Options extends FastifyPluginOptions = Record<never, never>,
+  Server extends RawServerBase = RawServerDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> = (
+  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
+  opts: Options,
+  done: (err?: Error) => void
+) => void
+
+/**
+ * FastifyPluginAsync
+ *
+ * Fastify allows the user to extend its functionalities with plugins. A plugin can be a set of routes, a server decorator or whatever. To activate plugins, use the `fastify.register()` method.
+ */
+export type FastifyPluginAsync<
+  Options extends FastifyPluginOptions = Record<never, never>,
+  Server extends RawServerBase = RawServerDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> = (
+  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
+  opts: Options
+) => Promise<void>
+
+/**
+ * Generic plugin type.
+ * @deprecated union type doesn't work well with type inference in TS and is therefore deprecated in favor of explicit types. Use `FastifyPluginCallback` or `FastifyPluginAsync` instead. To activate
+ * plugins use `FastifyRegister`. https://fastify.dev/docs/latest/Reference/TypeScript/#register
+ */
+export type FastifyPlugin<Options extends FastifyPluginOptions = Record<never, never>> = FastifyPluginCallback<Options> | FastifyPluginAsync<Options>

package/types/register.d.ts

@@ -0,0 +1,42 @@
+import { FastifyPluginOptions, FastifyPluginCallback, FastifyPluginAsync } from './plugin'
+import { LogLevel } from './logger'
+import { FastifyInstance } from './instance'
+import { RawServerBase } from './utils'
+import { FastifyBaseLogger, FastifyTypeProvider, RawServerDefault } from '../fastify'
+
+export interface RegisterOptions {
+  prefix?: string;
+  logLevel?: LogLevel;
+  logSerializers?: Record<string, (value: any) => string>;
+}
+
+export type FastifyRegisterOptions<Options> = (RegisterOptions & Options) | ((instance: FastifyInstance) => RegisterOptions & Options)
+
+/**
+ * FastifyRegister
+ *
+ * Function for adding a plugin to fastify. The options are inferred from the passed in FastifyPlugin parameter.
+ */
+export interface FastifyRegister<T = void, RawServer extends RawServerBase = RawServerDefault, TypeProviderDefault extends FastifyTypeProvider = FastifyTypeProvider, LoggerDefault extends FastifyBaseLogger = FastifyBaseLogger> {
+  <Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<FastifyPluginOptions, Server, TypeProvider, Logger>
+  ): T;
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider, Logger>,
+    opts: FastifyRegisterOptions<Options>
+  ): T;
+  <Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginAsync<FastifyPluginOptions, Server, TypeProvider, Logger>
+  ): T;
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginAsync<Options, Server, TypeProvider, Logger>,
+    opts: FastifyRegisterOptions<Options>
+  ): T;
+  <Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<FastifyPluginOptions, Server, TypeProvider, Logger> | FastifyPluginAsync<FastifyPluginOptions, Server, TypeProvider, Logger> | Promise<{ default: FastifyPluginCallback<FastifyPluginOptions, Server, TypeProvider, Logger> }> | Promise<{ default: FastifyPluginAsync<FastifyPluginOptions, Server, TypeProvider, Logger> }>,
+  ): T;
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider, Logger> | FastifyPluginAsync<Options, Server, TypeProvider, Logger> | Promise<{ default: FastifyPluginCallback<Options, Server, TypeProvider, Logger> }> | Promise<{ default: FastifyPluginAsync<Options, Server, TypeProvider, Logger> }>,
+    opts: FastifyRegisterOptions<Options>
+  ): T;
+}

package/types/reply.d.ts

@@ -0,0 +1,81 @@
+import { Buffer } from 'node:buffer'
+import { FastifyInstance } from './instance'
+import { FastifyBaseLogger } from './logger'
+import { FastifyRequest, RequestRouteOptions } from './request'
+import { RouteGenericInterface } from './route'
+import { FastifySchema } from './schema'
+import { CallSerializerTypeProvider, FastifyReplyType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyReplyType, SendArgs } from './type-provider'
+import { CodeToReplyKey, ContextConfigDefault, HttpHeader, HttpKeys, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault, ReplyKeysToCodes } from './utils'
+
+export interface ReplyGenericInterface {
+  Reply?: ReplyDefault;
+}
+
+type HttpCodesReplyType = Partial<Record<HttpKeys, unknown>>
+
+type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>> =
+  RouteGenericReply extends HttpCodesReplyType & Record<Exclude<keyof RouteGenericReply, keyof HttpCodesReplyType>, never> ?
+    Code extends keyof RouteGenericReply ? RouteGenericReply[Code] :
+      CodeToReplyKey<Code> extends keyof RouteGenericReply ? RouteGenericReply[CodeToReplyKey<Code>] : unknown :
+    RouteGenericReply
+
+export type ResolveReplyTypeWithRouteGeneric<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault> =
+  Code extends keyof SchemaCompiler['response'] ?
+    CallSerializerTypeProvider<TypeProvider, SchemaCompiler['response'][Code]> :
+    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.
+ */
+export interface FastifyReply<
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  ReplyType extends FastifyReplyType = ResolveFastifyReplyType<TypeProvider, SchemaCompiler, RouteGeneric>
+> {
+  readonly routeOptions: Readonly<RequestRouteOptions<ContextConfig, SchemaCompiler>>
+
+  raw: RawReply;
+  elapsedTime: number;
+  log: FastifyBaseLogger;
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>;
+  server: FastifyInstance;
+  code<Code extends keyof SchemaCompiler['response'] extends never ? ReplyKeysToCodes<keyof RouteGeneric['Reply']> : keyof SchemaCompiler['response'] extends ReplyKeysToCodes<keyof RouteGeneric['Reply']> ? keyof SchemaCompiler['response'] : ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  status<Code extends keyof SchemaCompiler['response'] extends never ? ReplyKeysToCodes<keyof RouteGeneric['Reply']> : keyof SchemaCompiler['response'] extends ReplyKeysToCodes<keyof RouteGeneric['Reply']> ? keyof SchemaCompiler['response'] : ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  statusCode: number;
+  sent: boolean;
+  send(...args: SendArgs<ReplyType>): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  header(key: HttpHeader, value: any): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  headers(values: Partial<Record<HttpHeader, number | string | string[] | undefined>>): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  getHeader(key: HttpHeader): number | string | string[] | undefined;
+  getHeaders(): Record<HttpHeader, number | string | string[] | undefined>;
+  removeHeader(key: HttpHeader): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  hasHeader(key: HttpHeader): boolean;
+  redirect(url: string, statusCode?: number): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
+  hijack(): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  callNotFound(): void;
+  type(contentType: string): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  serializer(fn: (payload: any) => string): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  serialize(payload: any): string | ArrayBuffer | Buffer;
+  // Serialization Methods
+  getSerializationFunction(httpStatus: string, contentType?: string): ((payload: { [key: string]: unknown }) => string) | undefined;
+  getSerializationFunction(schema: { [key: string]: unknown }): ((payload: { [key: string]: unknown }) => string) | undefined;
+  compileSerializationSchema(schema: { [key: string]: unknown }, httpStatus?: string, contentType?: string): (payload: { [key: string]: unknown }) => string;
+  serializeInput(input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string, contentType?: string): string;
+  serializeInput(input: { [key: string]: unknown }, httpStatus: string, contentType?: string): unknown;
+  then(fulfilled: () => void, rejected: (err: Error) => void): void;
+  trailer: (
+    key: string,
+    fn: ((reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>, payload: string | Buffer | null) => Promise<string>) | ((reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>, payload: string | Buffer | null, done: (err: Error | null, value?: string) => void) => void)
+  ) => FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  hasTrailer(key: string): boolean;
+  removeTrailer(key: string): FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>;
+  getDecorator<T>(name: string | symbol): T;
+}

package/types/request.d.ts

@@ -0,0 +1,95 @@
+import { ErrorObject } from '@fastify/ajv-compiler'
+import { FastifyContextConfig } from './context'
+import { FastifyInstance } from './instance'
+import { FastifyBaseLogger } from './logger'
+import { FastifyRouteConfig, RouteGenericInterface, RouteHandlerMethod } from './route'
+import { FastifySchema } from './schema'
+import { FastifyRequestType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyRequestType } from './type-provider'
+import { ContextConfigDefault, HTTPMethods, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './utils'
+
+type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
+export interface RequestGenericInterface {
+  Body?: RequestBodyDefault;
+  Querystring?: RequestQuerystringDefault;
+  Params?: RequestParamsDefault;
+  Headers?: RequestHeadersDefault;
+}
+
+export interface ValidationFunction {
+  (input: any): boolean
+  errors?: null | ErrorObject[];
+}
+
+export interface RequestRouteOptions<ContextConfig = ContextConfigDefault, SchemaCompiler = FastifySchema> {
+  method: HTTPMethods | HTTPMethods[];
+  // `url` can be `undefined` for instance when `request.is404` is true
+  url: string | undefined;
+  bodyLimit: number;
+  handlerTimeout: number;
+  attachValidation: boolean;
+  logLevel: string;
+  exposeHeadRoute: boolean;
+  prefixTrailingSlash: string;
+  config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
+  schema?: SchemaCompiler; // it is empty for 404 requests
+  handler: RouteHandlerMethod;
+  version?: string;
+}
+
+/**
+ * FastifyRequest is an instance of the standard http or http2 request objects.
+ * It defaults to http.IncomingMessage, and it also extends the relative request object.
+ */
+export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  ContextConfig = ContextConfigDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  RequestType extends FastifyRequestType = ResolveFastifyRequestType<TypeProvider, SchemaCompiler, RouteGeneric>
+// ^ Temporary Note: RequestType has been re-ordered to be the last argument in
+//   generic list. This generic argument is now considered optional as it can be
+//   automatically inferred from the SchemaCompiler, RouteGeneric and TypeProvider
+//   arguments. Implementations that already pass this argument can either omit
+//   the RequestType (preferred) or swap Logger and RequestType arguments when
+//   creating custom types of FastifyRequest. Related issue #4123
+> {
+  id: string;
+  params: RequestType['params']; // deferred inference
+  raw: RawRequest;
+  query: RequestType['query'];
+  headers: RawRequest['headers'] & RequestType['headers']; // this enables the developer to extend the existing http(s|2) headers list
+  log: Logger;
+  server: FastifyInstance;
+  body: RequestType['body'];
+
+  /** in order for this to be used the user should ensure they have set the attachValidation option. */
+  validationError?: Error & { validation: any; validationContext: string };
+
+  /**
+   * @deprecated Use `raw` property
+   */
+  readonly req: RawRequest & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
+  readonly ip: string;
+  readonly ips?: string[];
+  readonly host: string;
+  readonly port: number;
+  readonly hostname: string;
+  readonly url: string;
+  readonly originalUrl: string;
+  readonly protocol: 'http' | 'https';
+  readonly method: string;
+  readonly routeOptions: Readonly<RequestRouteOptions<ContextConfig, SchemaCompiler>>
+  readonly is404: boolean;
+  readonly socket: RawRequest['socket'];
+  readonly signal: AbortSignal;
+
+  getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction
+  getValidationFunction(schema: { [key: string]: any }): ValidationFunction
+  compileValidationSchema(schema: { [key: string]: any }, httpPart?: HTTPRequestPart): ValidationFunction
+  validateInput(input: any, schema: { [key: string]: any }, httpPart?: HTTPRequestPart): boolean
+  validateInput(input: any, httpPart?: HTTPRequestPart): boolean
+  getDecorator<T>(name: string | symbol): T;
+  setDecorator<T = unknown>(name: string | symbol, value: T): void;
+}

package/types/route.d.ts

@@ -0,0 +1,199 @@
+import { FastifyError } from '@fastify/error'
+import { ConstraintStrategy } from 'find-my-way'
+import { FastifyContextConfig } from './context'
+import {
+  onErrorHookHandler,
+  onRequestAbortHookHandler,
+  onRequestHookHandler,
+  onResponseHookHandler,
+  onSendHookHandler,
+  onTimeoutHookHandler,
+  preHandlerHookHandler,
+  preParsingHookHandler,
+  preSerializationHookHandler,
+  preValidationHookHandler
+} from './hooks'
+import { FastifyInstance } from './instance'
+import { FastifyBaseLogger, FastifyChildLoggerFactory, LogLevel } from './logger'
+import { FastifyReply, ReplyGenericInterface } from './reply'
+import { FastifyRequest, RequestGenericInterface } from './request'
+import { FastifySchema, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorFormatter } from './schema'
+import {
+  FastifyTypeProvider,
+  FastifyTypeProviderDefault,
+  ResolveFastifyReplyReturnType
+} from './type-provider'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
+
+export interface FastifyRouteConfig {
+  url: string;
+  method: HTTPMethods | HTTPMethods[];
+}
+
+export interface RouteGenericInterface extends RequestGenericInterface, ReplyGenericInterface { }
+
+export type RouteConstraintType = Omit<ConstraintStrategy<any>, 'deriveConstraint'> & {
+  deriveConstraint<Context>(req: RawRequestDefaultExpression<RawServerDefault>, ctx?: Context, done?: (err: Error, ...args: any) => any): any,
+}
+
+export interface RouteConstraint {
+  version?: string
+  host?: RegExp | string
+  [name: string]: unknown
+}
+
+/**
+ * Route shorthand options for the various shorthand methods
+ */
+type RouteShorthandHook<T extends (...args: any) => any> = (...args: Parameters<T>) => void | Promise<unknown>
+
+export interface RouteShorthandOptions<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> {
+  schema?: SchemaCompiler, // originally FastifySchema
+  attachValidation?: boolean;
+  exposeHeadRoute?: boolean;
+
+  validatorCompiler?: FastifySchemaCompiler<NoInfer<SchemaCompiler>>;
+  serializerCompiler?: FastifySerializerCompiler<NoInfer<SchemaCompiler>>;
+  bodyLimit?: number;
+  handlerTimeout?: number;
+  logLevel?: LogLevel;
+  config?: FastifyContextConfig & ContextConfig;
+  constraints?: RouteConstraint,
+  prefixTrailingSlash?: 'slash' | 'no-slash' | 'both';
+  errorHandler?: (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+    error: FastifyError,
+    request: FastifyRequest<RouteGeneric, RawServer, RawRequest, NoInfer<SchemaCompiler>, TypeProvider, ContextConfig, Logger>,
+    reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider>
+  ) => void;
+  childLoggerFactory?: FastifyChildLoggerFactory<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  schemaErrorFormatter?: SchemaErrorFormatter;
+
+  // hooks
+  onRequest?: RouteShorthandHook<onRequestHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onRequestHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  preParsing?: RouteShorthandHook<preParsingHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<preParsingHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  preValidation?: RouteShorthandHook<preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<preValidationHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  preHandler?: RouteShorthandHook<preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<preHandlerHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  preSerialization?: RouteShorthandHook<preSerializationHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<preSerializationHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  onSend?: RouteShorthandHook<onSendHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onSendHookHandler<unknown, RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  onResponse?: RouteShorthandHook<onResponseHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onResponseHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  onTimeout?: RouteShorthandHook<onTimeoutHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onTimeoutHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  onError?: RouteShorthandHook<onErrorHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onErrorHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, FastifyError, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+  onRequestAbort?: RouteShorthandHook<onRequestAbortHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>
+  | RouteShorthandHook<onRequestAbortHookHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>>[];
+}
+/**
+ * Route handler method declaration.
+ */
+export type RouteHandlerMethod<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> = (
+  this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
+  reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>
+  // This return type used to be a generic type argument. Due to TypeScript's inference of return types, this rendered returns unchecked.
+) => ResolveFastifyReplyReturnType<TypeProvider, SchemaCompiler, RouteGeneric>
+
+/**
+ * Shorthand options including the handler function property
+ */
+export interface RouteShorthandOptionsWithHandler<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> {
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, NoInfer<SchemaCompiler>, TypeProvider, Logger>;
+}
+
+/**
+ * Fastify Router Shorthand method type that is similar to the Express/Restify approach
+ */
+export interface RouteShorthandMethod<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> {
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, const SchemaCompiler extends FastifySchema = FastifySchema>(
+    path: string,
+    opts: RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>,
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, const SchemaCompiler extends FastifySchema = FastifySchema>(
+    path: string,
+    handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  <RouteGeneric extends RouteGenericInterface = RouteGenericInterface, ContextConfig = ContextConfigDefault, const SchemaCompiler extends FastifySchema = FastifySchema>(
+    path: string,
+    opts: RouteShorthandOptionsWithHandler<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>
+  ): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+}
+
+/**
+ * Fastify route method options.
+ */
+export interface RouteOptions<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> extends RouteShorthandOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger> {
+  method: HTTPMethods | HTTPMethods[];
+  url: string;
+  handler: RouteHandlerMethod<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>;
+}
+
+export type RouteHandler<
+  RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
+  ContextConfig = ContextConfigDefault,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
+> = (
+  this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
+  request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger>,
+  reply: FastifyReply<RouteGeneric, RawServer, RawRequest, RawReply, ContextConfig, SchemaCompiler, TypeProvider>
+) => RouteGeneric['Reply'] | void | Promise<RouteGeneric['Reply'] | void>
+
+export type DefaultRoute<Request, Reply> = (
+  req: Request,
+  res: Reply,
+) => void

package/types/schema.d.ts

@@ -0,0 +1,61 @@
+import { ValidatorFactory } from '@fastify/ajv-compiler'
+import { SerializerFactory } from '@fastify/fast-json-stringify-compiler'
+import { FastifyInstance, SafePromiseLike } 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/Reference/TypeScript.md#json-schema
+ */
+export interface FastifySchema {
+  body?: unknown;
+  querystring?: unknown;
+  params?: unknown;
+  headers?: unknown;
+  response?: unknown;
+}
+
+export interface FastifyRouteSchemaDef<T> {
+  schema: T;
+  method: string;
+  url: string;
+  httpPart?: string;
+  httpStatus?: string;
+  contentType?: string;
+}
+
+export interface FastifySchemaValidationError {
+  keyword: string;
+  instancePath: string;
+  schemaPath: string;
+  params: Record<string, unknown>;
+  message?: string;
+}
+
+export interface FastifyValidationResult {
+  (data: any): boolean | SafePromiseLike<any> | { error?: Error | FastifySchemaValidationError[], value?: any }
+  errors?: FastifySchemaValidationError[] | null;
+}
+
+/**
+ * Compiler for FastifySchema Type
+ */
+export type FastifySchemaCompiler<T> = (routeSchema: FastifyRouteSchemaDef<T>) => FastifyValidationResult
+
+export type FastifySerializerCompiler<T> = (routeSchema: FastifyRouteSchemaDef<T>) => (data: any) => string
+
+export interface FastifySchemaControllerOptions {
+  bucket?: (parentSchemas?: unknown) => {
+    add(schema: unknown): FastifyInstance;
+    getSchema(schemaId: string): unknown;
+    getSchemas(): Record<string, unknown>;
+  };
+  compilersFactory?: {
+    buildValidator?: ValidatorFactory;
+    buildSerializer?: SerializerFactory;
+  };
+}
+
+export type SchemaErrorDataVar = 'body' | 'headers' | 'params' | 'querystring'
+
+export type SchemaErrorFormatter = (errors: FastifySchemaValidationError[], dataVar: SchemaErrorDataVar) => Error

package/types/server-factory.d.ts

@@ -0,0 +1,19 @@
+import { RawServerBase, RawServerDefault, RawReplyDefaultExpression, RawRequestDefaultExpression } from './utils'
+import * as http from 'node:http'
+import * as https from 'node:https'
+import * as http2 from 'node:http2'
+
+export type FastifyServerFactoryHandler<
+  RawServer extends RawServerBase = RawServerDefault,
+  RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
+  RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>
+> =
+RawServer extends http.Server | https.Server ?
+    (request: http.IncomingMessage & RawRequest, response: http.ServerResponse & RawReply) => void :
+    (request: http2.Http2ServerRequest & RawRequest, response: http2.Http2ServerResponse & RawReply) => void
+
+export interface FastifyServerFactory<
+  RawServer extends RawServerBase = RawServerDefault
+> {
+  (handler: FastifyServerFactoryHandler<RawServer>, opts: Record<string, unknown>): RawServer;
+}