fastify

fastify

Version 5.10.0
Published 10 days ago
2.87 MB
15 dependencies
MIT license

Install

npm i fastify

yarn add fastify

pnpm add fastify

Overview

Fast and low overhead web framework, for Node.js

Index

Variables

variable errorCodes

const errorCodes: FastifyErrorCodes;

variable fastify

const fastify: typeof import('/fastify.d.ts');

Functions

function fastify

fastify: typeof import('/fastify.d.ts');

Fastify factory function for the standard fastify http, https, or http2 server instance.
The default function utilizes http
Parameter opts
Fastify server options
Returns
Fastify server instance

Classes

class LogController

class LogController {}

constructor

constructor(options?: LogControllerOptions);

property disableRequestLogging

disableRequestLogging: boolean | ((req: FastifyRequest) => boolean);

property requestIdLogLabel

requestIdLogLabel: string;

method defaultErrorLog

defaultErrorLog: (
    error: Error,
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

method incomingRequest

incomingRequest: (
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

method isLogDisabled

isLogDisabled: (request: FastifyRequest) => boolean;

method requestCompleted

requestCompleted: (
    error: Error | null,
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

method routeNotFound

routeNotFound: (
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

method serializerError

serializerError: (
    error: Error,
    request: FastifyRequest,
    reply: FastifyReply,
    metadata: { statusCode: number }
) => void;

method serviceUnavailable

serviceUnavailable: (logger: FastifyBaseLogger, server: FastifyInstance) => void;

method streamError

streamError: (
    error: Error,
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

method writeHeadError

writeHeadError: (
    error: Error,
    request: FastifyRequest,
    reply: FastifyReply,
    metadata?: Record<string, unknown>
) => void;

Interfaces

interface AddContentTypeParser

interface AddContentTypeParser<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    SchemaCompiler extends FastifySchema = FastifySchema,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Natively, Fastify only supports 'application/json' and 'text/plain' content types. The default charset is utf-8. If you need to support different content types, you can use the addContentTypeParser API. The default JSON and/or plain text parser can be changed.

call signature

(
    contentType: string | string[] | RegExp,
    opts: {
        bodyLimit?: number;
    },
    parser: FastifyContentTypeParser<
        RawServer,
        RawRequest,
        RouteGeneric,
        SchemaCompiler,
        TypeProvider
    >
): void;

call signature

(
    contentType: string | string[] | RegExp,
    parser: FastifyContentTypeParser<
        RawServer,
        RawRequest,
        RouteGeneric,
        SchemaCompiler,
        TypeProvider
    >
): void;

call signature

<parseAs extends string | Buffer>(
    contentType: string | string[] | RegExp,
    opts: {
        parseAs: parseAs extends Buffer ? 'buffer' : 'string';
        bodyLimit?: number;
    },
    parser: FastifyBodyParser<
        parseAs,
        RawServer,
        RawRequest,
        RouteGeneric,
        SchemaCompiler,
        TypeProvider
    >
): void;

interface ConnectionError

interface ConnectionError extends Error {}

property bytesParsed

bytesParsed: number;

property code

code: string;

property rawPacket

rawPacket: {
    type: string;
    data: number[];
};

interface DoneFuncWithErrOrRes

interface DoneFuncWithErrOrRes {}

call signature

(): void;

call signature

<TError extends Error = FastifyError>(err: TError): void;

call signature

(err: null, res: unknown): void;

interface FastifyBaseLogger

interface FastifyBaseLogger
    extends Pick<
        BaseLogger,
        'level' | 'info' | 'error' | 'debug' | 'fatal' | 'warn' | 'trace' | 'silent'
    > {}

method child

child: (bindings: Bindings, options?: ChildLoggerOptions) => FastifyBaseLogger;

interface FastifyContextConfig

interface FastifyContextConfig {}

interface FastifyContextConfig

interface FastifyContextConfig {}

property bar

bar: number;

property foo

foo: string;

property includeMessage

includeMessage?: boolean;

interface FastifyInstance

interface FastifyInstance<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Fastify server instance. Returned by the core fastify() method.

property decorate

decorate: DecorationMethod<
    FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
>;

property decorateReply

decorateReply: DecorationMethod<
    FastifyReply,
    FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
>;

property decorateRequest

decorateRequest: DecorationMethod<
    FastifyRequest,
    FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
>;

property listeningOrigin

listeningOrigin: string;

property log

log: Logger;

property pluginName

pluginName: string;

property prefix

prefix: string;

property register

register: FastifyRegister<
    FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> &
        SafePromiseLike<undefined>
>;

property server

server: RawServer;

property version

version: string;

method [Symbol.asyncDispose]

[Symbol.asyncDispose]: () => Promise<undefined>;

Alias for

method addConstraintStrategy

addConstraintStrategy: (
    strategy: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>
) => void;

method addresses

addresses: () => AddressInfo[];

method addSchema

addSchema: (
    schema: unknown
) => FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;

method after

after: {
    (): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> &
        SafePromiseLike<undefined>;
    (afterListener: (err: Error) => void): FastifyInstance<
        RawServer,
        RawRequest,
        RawReply,
        Logger,
        TypeProvider
    >;
};

method close

close: { (): Promise<undefined>; (closeListener: () => void): undefined };

method getDecorator

getDecorator: <T>(name: string | symbol) => T;

method getSchema

getSchema: (schemaId: string) => unknown;

method getSchemas

getSchemas: () => Record<string, unknown>;

method hasConstraintStrategy

hasConstraintStrategy: (strategyName: string) => boolean;

method hasDecorator

hasDecorator: (decorator: string | symbol) => boolean;

method hasPlugin

hasPlugin: (name: string) => boolean;

method hasReplyDecorator

hasReplyDecorator: (decorator: string | symbol) => boolean;

method hasRequestDecorator

hasRequestDecorator: (decorator: string | symbol) => boolean;

method inject

inject: {
    (opts: InjectOptions | string, cb: LightMyRequestCallback): void;
    (opts: any): Promise<LightMyRequestResponse>;
    (): LightMyRequestChain;
};

method listen

listen: {
    (
        opts: FastifyListenOptions,
        callback: (err: Error | null, address: string) => void
    ): void;
    (opts?: FastifyListenOptions): Promise<string>;
    (callback: (err: Error, address: string) => void): void;
};

method ready

ready: {
    (): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> &
        SafePromiseLike<undefined>;
    (readyListener: (err: Error) => void | Promise<void>): FastifyInstance<
        RawServer,
        RawRequest,
        RawReply,
        Logger,
        TypeProvider
    >;
};

method route

route: <
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    ContextConfig = unknown
>() => any;

method routing

routing: (req: RawRequest, res: RawReply) => void;

method withTypeProvider

withTypeProvider: <Provider extends FastifyTypeProvider>() => FastifyInstance<
    RawServer,
    RawRequest,
    RawReply,
    Logger,
    Provider
>;

interface FastifyInstance

interface FastifyInstance {}

property typedTestProperty

typedTestProperty: boolean;

property typedTestPropertyGetterSetter

typedTestPropertyGetterSetter: string;

method typedTestMethod

typedTestMethod: (x: string) => string;

interface FastifyListenOptions

interface FastifyListenOptions {}

property backlog

backlog?: number;

Specify the maximum length of the queue of pending connections. The actual length will be determined by the OS through sysctl settings such as tcp_max_syn_backlog and somaxconn on Linux. Default to 511.

property exclusive

exclusive?: boolean;

Default to false.

property host

host?: string;

Default to localhost.

property ipv6Only

ipv6Only?: boolean;

For TCP servers, setting ipv6Only to true will disable dual-stack support, i.e., binding to host :: won't make 0.0.0.0 be bound. Default to false.

property listenTextResolver

listenTextResolver?: (address: string) => string;

Function that resolves text to log after server has been successfully started
Parameter address

property path

path?: string;

Will be ignored if port is specified.
See Also
- [Identifying paths for IPC connections](https://nodejs.org/api/net.html#identifying-paths-for-ipc-connections).

property port

port?: number;

Default to 0 (picks the first available open port).

property readableAll

readableAll?: boolean;

For IPC servers makes the pipe readable for all users. Default to false.

property signal

signal?: AbortSignal;

An AbortSignal that may be used to close a listening server. This option is available only in Node.js v15.6.0 and greater

property writableAll

writableAll?: boolean;

For IPC servers makes the pipe writable for all users. Default to false.

interface FastifyLoggerOptions

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
    >
> {}

Fastify Custom Logger options.

property file

file?: string;

property genReqId

genReqId?: (req: RawRequest) => string;

property level

level?: string;

property serializers

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;
    };
};

property stream

stream?: FastifyLoggerStreamDestination;

interface FastifyRegister

interface FastifyRegister<
    T = void,
    RawServer extends RawServerBase = RawServerDefault,
    TypeProviderDefault extends FastifyTypeProvider = FastifyTypeProvider,
    LoggerDefault extends FastifyBaseLogger = FastifyBaseLogger
> {}

FastifyRegister
Function for adding a plugin to fastify. The options are inferred from the passed in FastifyPlugin parameter.

call signature

<
    Server extends RawServerBase = RawServer,
    TypeProvider extends FastifyTypeProvider = TypeProviderDefault,
    Logger extends FastifyBaseLogger = LoggerDefault
>(
    plugin: FastifyPluginCallback<
        FastifyPluginOptions,
        Server,
        TypeProvider,
        Logger
    >
): T;

call signature

<
    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;

call signature

<
    Server extends RawServerBase = RawServer,
    TypeProvider extends FastifyTypeProvider = TypeProviderDefault,
    Logger extends FastifyBaseLogger = LoggerDefault
>(
    plugin: FastifyPluginAsync<
        FastifyPluginOptions,
        Server,
        TypeProvider,
        Logger
    >
): T;

call signature

<
    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;

call signature

<
    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;

call signature

<
    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;

interface FastifyReply

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
    >
> {}

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.

property elapsedTime

elapsedTime: number;

property log

log: FastifyBaseLogger;

property raw

raw: RawReply;

property request

request: FastifyRequest<
    RouteGeneric,
    RawServer,
    RawRequest,
    SchemaCompiler,
    TypeProvider
>;

property routeOptions

readonly routeOptions: Readonly<
    RequestRouteOptions<ContextConfig, SchemaCompiler>
>;

property sent

sent: boolean;

property server

server: FastifyInstance;

property statusCode

statusCode: number;

property trailer

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
>;

method callNotFound

callNotFound: () => void;

method code

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
    >
>;

method compileSerializationSchema

compileSerializationSchema: (
    schema: { [key: string]: unknown },
    httpStatus?: string,
    contentType?: string
) => (payload: { [key: string]: unknown }) => string;

method getDecorator

getDecorator: <T>(name: string | symbol) => T;

method getHeader

getHeader: (key: HttpHeader) => number | string | string[] | undefined;

method getHeaders

getHeaders: () => Record<HttpHeader, number | string | string[] | undefined>;

method getSerializationFunction

getSerializationFunction: {
    (httpStatus: string, contentType?: string): (payload: {
        [key: string]: unknown;
    }) => string;
    (schema: { [key: string]: unknown }): (payload: {
        [key: string]: unknown;
    }) => string;
};

method hasHeader

hasHeader: (key: HttpHeader) => boolean;

method hasTrailer

hasTrailer: (key: string) => boolean;

method header

header: (
    key: HttpHeader,
    value: any
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method headers

headers: (
    values: Partial<Record<HttpHeader, number | string | string[] | undefined>>
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method hijack

hijack: () => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method redirect

redirect: (
    url: string,
    statusCode?: number
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method removeHeader

removeHeader: (
    key: HttpHeader
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method removeTrailer

removeTrailer: (
    key: string
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method send

send: (
    ...args: SendArgs<ReplyType>
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method serialize

serialize: (payload: any) => string | ArrayBuffer | Buffer;

method serializeInput

serializeInput: {
    (
        input: { [key: string]: unknown },
        schema: { [key: string]: unknown },
        httpStatus?: string,
        contentType?: string
    ): string;
    (
        input: { [key: string]: unknown },
        httpStatus: string,
        contentType?: string
    ): unknown;
};

method serializer

serializer: (
    fn: (payload: any) => string
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method status

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
    >
>;

method then

then: (fulfilled: () => void, rejected: (err: Error) => void) => void;

method type

type: (
    contentType: string
) => FastifyReply<
    RouteGeneric,
    RawServer,
    RawRequest,
    RawReply,
    ContextConfig,
    SchemaCompiler,
    TypeProvider
>;

method writeEarlyHints

writeEarlyHints: (
    hints: Record<string, string | string[]>,
    callback?: () => void
) => void;

interface FastifyReply

interface FastifyReply {}

property testProp

testProp: TestType;

interface FastifyReply

interface FastifyReply {}

property typedTestReplyProperty

typedTestReplyProperty: boolean;

property typedTestReplyPropertyGetterSetter

typedTestReplyPropertyGetterSetter: string;

method typedTestReplyMethod

typedTestReplyMethod: (x: string) => string;

interface FastifyReplyContext

interface FastifyReplyContext<ContextConfig = ContextConfigDefault> {}

property config

config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;

Deprecated
Use Reply#routeOptions#config or Reply#routeOptions#schema instead

interface FastifyRequest

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
    >
> {}

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.

property body

body: RequestType['body'];

property headers

headers: RawRequest['headers'] & RequestType['headers'];

property host

readonly host: string;

Derived from Host/:authority/X-Forwarded-Host request metadata. Treat as untrusted input and validate before security-sensitive use.

property hostname

readonly hostname: string;

property id

id: string;

property ip

readonly ip: string;

Derived from request socket metadata or forwarding headers. Treat as untrusted input and validate before security-sensitive use.

property ips

readonly ips?: string[];

Derived from forwarding headers when trustProxy is enabled. Treat as untrusted input and validate before security-sensitive use.

property is404

readonly is404: boolean;

property log

log: Logger;

property mediaType

readonly mediaType: string | undefined;

property method

readonly method: string;

property originalUrl

readonly originalUrl: string;

property params

params: RequestType['params'];

property port

readonly port: number | null;

Parsed from request host metadata. Treat as untrusted input and validate before security-sensitive use.

property protocol

readonly protocol: 'http' | 'https';

Derived from socket state or forwarding headers. Treat as untrusted input and validate before security-sensitive use.

property query

query: RequestType['query'];

property raw

raw: RawRequest;

property req

readonly req: RawRequest & RouteGeneric['Headers'];

Deprecated
Use raw property

property routeOptions

readonly routeOptions: Readonly<
    RequestRouteOptions<ContextConfig, SchemaCompiler>
>;

property server

server: FastifyInstance;

property signal

readonly signal: AbortSignal;

property socket

readonly socket: RawRequest['socket'];

property url

readonly url: string;

property validationError

validationError?: Error & { validation: any; validationContext: string };

in order for this to be used the user should ensure they have set the attachValidation option.

method compileValidationSchema

compileValidationSchema: (
    schema: { [key: string]: any },
    httpPart?: HTTPRequestPart
) => ValidationFunction;

method getDecorator

getDecorator: <T>(name: string | symbol) => T;

method getValidationFunction

getValidationFunction: {
    (httpPart: HTTPRequestPart): ValidationFunction | undefined;
    (schema: { [key: string]: any }): ValidationFunction;
};

method setDecorator

setDecorator: <T = unknown>(name: string | symbol, value: T) => void;

method validateInput

validateInput: {
    (
        input: any,
        schema: { [key: string]: any },
        httpPart?: HTTPRequestPart
    ): boolean;
    (input: any, httpPart?: HTTPRequestPart): boolean;
};

interface FastifyRequest

interface FastifyRequest {}

property testProp

testProp: TestType;

interface FastifyRequest

interface FastifyRequest {}

property typedTestRequestProperty

typedTestRequestProperty: boolean;

property typedTestRequestPropertyGetterSetter

typedTestRequestPropertyGetterSetter: string;

method typedTestRequestMethod

typedTestRequestMethod: (x: string) => string;

interface FastifyRequest

interface FastifyRequest<
    RouteGeneric,
    RawServer,
    RawRequest,
    SchemaCompiler,
    TypeProvider,
    ContextConfig,
    Logger,
    RequestType
> {}

property message

message: ContextConfig extends { includeMessage: true } ? string : null;

interface FastifyRequestContext

interface FastifyRequestContext<ContextConfig = ContextConfigDefault> {}

Route context object. Properties defined here will be available in the route's handler

property config

config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;

Deprecated
Use Request#routeOptions#config or Request#routeOptions#schema instead

interface FastifySchema

interface FastifySchema {}

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

property body

body?: unknown;

property headers

headers?: unknown;

property params

params?: unknown;

property querystring

querystring?: unknown;

property response

response?: unknown;

interface FastifySchemaValidationError

interface FastifySchemaValidationError {}

property instancePath

instancePath: string;

property keyword

keyword: string;

property message

message?: string;

property params

params: Record<string, unknown>;

property schemaPath

schemaPath: string;

interface FastifyServerFactory

interface FastifyServerFactory<RawServer extends RawServerBase = RawServerDefault> {}

call signature

(
    handler: FastifyServerFactoryHandler<RawServer>,
    opts: Record<string, unknown>
): RawServer;

interface FastifyTypeProvider

interface FastifyTypeProvider {}

property schema

readonly schema: unknown;

property serializer

readonly serializer: unknown;

property validator

readonly validator: unknown;

interface FastifyTypeProviderDefault

interface FastifyTypeProviderDefault extends FastifyTypeProvider {}

interface onCloseAsyncHookHandler

interface onCloseAsyncHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    instance: FastifyInstance<
        RawServer,
        RawRequest,
        RawReply,
        Logger,
        TypeProvider
    >
): Promise<unknown>;

interface onCloseHookHandler

interface onCloseHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Triggered when fastify.close() is invoked to stop the server. It is useful when plugins need a "shutdown" event, for example to close an open connection to a database.

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    instance: FastifyInstance<
        RawServer,
        RawRequest,
        RawReply,
        Logger,
        TypeProvider
    >,
    done: HookHandlerDoneFunction
): void;

interface onErrorAsyncHookHandler

interface onErrorAsyncHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    ContextConfig = ContextConfigDefault,
    TError extends Error = FastifyError,
    SchemaCompiler extends FastifySchema = FastifySchema,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> {}

call signature

(
    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
    >,
    error: TError
): Promise<unknown>;

interface onErrorHookHandler

interface onErrorHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    ContextConfig = ContextConfigDefault,
    TError extends Error = FastifyError,
    SchemaCompiler extends FastifySchema = FastifySchema,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> {}

This hook is useful if you need to do some custom error logging or add some specific header in case of error. It is not intended for changing the error, and calling reply.send will throw an exception. This hook will be executed before the customErrorHandler. Notice: unlike the other hooks, pass an error to the done function is not supported.

call signature

(
    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
    >,
    error: TError,
    done: () => void
): void;

interface onListenAsyncHookHandler

interface onListenAsyncHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
): Promise<unknown>;

interface onListenHookHandler

interface onListenHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Triggered when fastify.listen() is invoked to start the server. It is useful when plugins need a "onListen" event, for example to run logics after the server start listening for requests.

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    done: HookHandlerDoneFunction
): void;

interface onReadyAsyncHookHandler

interface onReadyAsyncHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
): Promise<unknown>;

interface onReadyHookHandler

interface onReadyHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Triggered when fastify.listen() or fastify.ready() is invoked to start the server. It is useful when plugins need a "ready" event, for example to load data before the server start listening for requests.

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    done: HookHandlerDoneFunction
): void;

interface onRegisterHookHandler

interface onRegisterHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
    Options extends FastifyPluginOptions = FastifyPluginOptions
> {}

Triggered when a new plugin is registered and a new encapsulation context is created. The hook will be executed before the registered code. This hook can be useful if you are developing a plugin that needs to know when a plugin context is formed, and you want to operate in that specific context. Note: This hook will not be called if a plugin is wrapped inside fastify-plugin.

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    instance: FastifyInstance<
        RawServer,
        RawRequest,
        RawReply,
        Logger,
        TypeProvider
    >,
    opts: RegisterOptions & Options
): Promise<unknown> | void;

interface onRequestAbortAsyncHookHandler

interface onRequestAbortAsyncHookHandler<
    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
> {}

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    request: FastifyRequest<
        RouteGeneric,
        RawServer,
        RawRequest,
        SchemaCompiler,
        TypeProvider,
        ContextConfig,
        Logger
    >
): Promise<unknown>;

interface onRequestAbortHookHandler

interface onRequestAbortHookHandler<
    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
> {}

onRequestAbort is useful if you need to monitor the if the client aborts the request (if the request.raw.aborted property is set to true). The onRequestAbort hook is executed when a client closes the connection before the entire request has been received. Therefore, you will not be able to send data to the client. Notice: client abort detection is not completely reliable. See: https://github.com/fastify/fastify/blob/main/docs/Guides/Detecting-When-Clients-Abort.md

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    request: FastifyRequest<
        RouteGeneric,
        RawServer,
        RawRequest,
        SchemaCompiler,
        TypeProvider,
        ContextConfig,
        Logger
    >,
    done: HookHandlerDoneFunction
): void;

interface onRequestAsyncHookHandler

interface onRequestAsyncHookHandler<
    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
> {}

call signature

(
    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
    >
): Promise<unknown>;

interface onRequestHookHandler

interface onRequestHookHandler<
    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
> {}

onRequest is the first hook to be executed in the request lifecycle. There was no previous hook, the next hook will be preParsing. Notice: in the onRequest hook, request.body will always be null, because the body parsing happens before the preHandler hook.

call signature

(
    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
    >,
    done: HookHandlerDoneFunction
): void;

interface onResponseAsyncHookHandler

interface onResponseAsyncHookHandler<
    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
> {}

call signature

(
    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
    >
): Promise<unknown>;

interface onResponseHookHandler

interface onResponseHookHandler<
    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
> {}

onResponse is the seventh and last hook in the request hook lifecycle. The previous hook was onSend, there is no next hook. The onResponse hook is executed when a response has been sent, so you will not be able to send more data to the client. It can however be useful for sending data to external services, for example to gather statistics.

call signature

(
    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
    >,
    done: HookHandlerDoneFunction
): void;

interface onRouteHookHandler

interface onRouteHookHandler<
    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
> {}

Triggered when a new route is registered. Listeners are passed a routeOptions object as the sole parameter. The interface is synchronous, and, as such, the listener does not get passed a callback

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    opts: RouteOptions<
        RawServer,
        RawRequest,
        RawReply,
        RouteGeneric,
        ContextConfig,
        SchemaCompiler,
        TypeProvider
    > & { routePath: string; path: string; prefix: string }
): Promise<unknown> | void;

interface onSendAsyncHookHandler

interface onSendAsyncHookHandler<
    OnSendPayload = unknown,
    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
> {}

call signature

(
    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
    >,
    payload: OnSendPayload
): Promise<unknown>;

interface onSendHookHandler

interface onSendHookHandler<
    OnSendPayload = unknown,
    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
> {}

You can change the payload with the onSend hook. It is the sixth hook to be executed in the request lifecycle. The previous hook was preSerialization, the next hook will be onResponse. Note: If you change the payload, you may only change it to a string, a Buffer, a stream, or null.

call signature

(
    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
    >,
    payload: OnSendPayload,
    done: DoneFuncWithErrOrRes
): void;

interface onTimeoutAsyncHookHandler

interface onTimeoutAsyncHookHandler<
    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
> {}

call signature

(
    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
    >
): Promise<unknown>;

interface onTimeoutHookHandler

interface onTimeoutHookHandler<
    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
> {}

onTimeout is useful if you need to monitor the request timed out in your service. (if the connectionTimeout property is set on the fastify instance) The onTimeout hook is executed when a request is timed out and the http socket has been hanged up. Therefore you will not be able to send data to the client.

call signature

(
    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
    >,
    done: HookHandlerDoneFunction
): void;

interface preCloseAsyncHookHandler

interface preCloseAsyncHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
): Promise<unknown>;

interface preCloseHookHandler

interface preCloseHookHandler<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
    Logger extends FastifyBaseLogger = FastifyBaseLogger,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> {}

Triggered when fastify.close() is invoked to stop the server. It is useful when plugins need to cancel some state to allow the server to close successfully.

call signature

(
    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
    done: HookHandlerDoneFunction
): void;

interface preHandlerAsyncHookHandler

interface preHandlerAsyncHookHandler<
    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
> {}

call signature

(
    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
    >
): Promise<unknown>;

interface preHandlerHookHandler

interface preHandlerHookHandler<
    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
> {}

preHandler is the fourth hook to be executed in the request lifecycle. The previous hook was preValidation, the next hook will be preSerialization.

call signature

(
    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
    >,
    done: HookHandlerDoneFunction
): void;

interface preParsingAsyncHookHandler

interface preParsingAsyncHookHandler<
    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
> {}

call signature

(
    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
    >,
    payload: RequestPayload
): Promise<RequestPayload | unknown>;

interface preParsingHookHandler

interface preParsingHookHandler<
    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
> {}

preParsing is the second hook to be executed in the request lifecycle. The previous hook was onRequest, the next hook will be preValidation. Notice: in the preParsing hook, request.body will always be null, because the body parsing happens before the preHandler hook.

call signature

(
    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
    >,
    payload: RequestPayload,
    done: <TError extends Error = FastifyError>(
        err?: TError | null,
        res?: RequestPayload
    ) => void
): void;

interface preSerializationAsyncHookHandler

interface preSerializationAsyncHookHandler<
    PreSerializationPayload = unknown,
    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
> {}

call signature

(
    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
    >,
    payload: PreSerializationPayload
): Promise<unknown>;

interface preSerializationHookHandler

interface preSerializationHookHandler<
    PreSerializationPayload = unknown,
    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
> {}

preSerialization is the fifth hook to be executed in the request lifecycle. The previous hook was preHandler, the next hook will be onSend. Note: the hook is NOT called if the payload is a string, a Buffer, a stream or null.

call signature

(
    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
    >,
    payload: PreSerializationPayload,
    done: DoneFuncWithErrOrRes
): void;

interface preValidationAsyncHookHandler

interface preValidationAsyncHookHandler<
    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
> {}

call signature

(
    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
    >
): Promise<unknown>;

interface preValidationHookHandler

interface preValidationHookHandler<
    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
> {}

preValidation is the third hook to be executed in the request lifecycle. The previous hook was preParsing, the next hook will be preHandler.

call signature

(
    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
    >,
    done: HookHandlerDoneFunction
): void;

interface PrintRoutesOptions

interface PrintRoutesOptions {}

property commonPrefix

commonPrefix?: boolean;

property includeHooks

includeHooks?: boolean;

property includeMeta

includeMeta?: boolean | (string | symbol)[];

property method

method?: HTTPMethods;

interface RegisterOptions

interface RegisterOptions {}

property logLevel

logLevel?: LogLevel;

property logSerializers

logSerializers?: Record<string, (value: any) => string>;

property prefix

prefix?: string;

interface RequestGenericInterface

interface RequestGenericInterface {}

property Body

Body?: RequestBodyDefault;

property Headers

Headers?: RequestHeadersDefault;

property Params

Params?: RequestParamsDefault;

property Querystring

Querystring?: RequestQuerystringDefault;

interface RequestPayload

interface RequestPayload extends Readable {}

property receivedEncodedLength

receivedEncodedLength?: number;

interface RouteGenericInterface

interface RouteGenericInterface
    extends RequestGenericInterface,
        ReplyGenericInterface {}

interface RouteOptions

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
    > {}

Fastify route method options.

property handler

handler: RouteHandlerMethod<
    RawServer,
    RawRequest,
    RawReply,
    RouteGeneric,
    ContextConfig,
    SchemaCompiler,
    TypeProvider,
    Logger
>;

property method

method: HTTPMethods | HTTPMethods[];

property url

url: string;

interface RouteShorthandMethod

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
> {}

Fastify Router Shorthand method type that is similar to the Express/Restify approach

call signature

interface RouteShorthandOptions

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
> {}

property attachValidation

attachValidation?: boolean;

property bodyLimit

bodyLimit?: number;

property childLoggerFactory

childLoggerFactory?: FastifyChildLoggerFactory<
    RawServer,
    RawRequest,
    RawReply,
    Logger,
    TypeProvider
>;

property config

config?: FastifyContextConfig & ContextConfig;

property constraints

constraints?: RouteConstraint;

property errorHandler

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;

property exposeHeadRoute

exposeHeadRoute?: boolean;

property handlerTimeout

handlerTimeout?: number;

property logLevel

logLevel?: LogLevel;

property onError

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
          >
      >[];

property onRequest

onRequest?:
    | RouteShorthandHook<
          onRequestHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          onRequestHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property onRequestAbort

onRequestAbort?:
    | RouteShorthandHook<
          onRequestAbortHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          onRequestAbortHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property onResponse

onResponse?:
    | RouteShorthandHook<
          onResponseHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          onResponseHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property onSend

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
          >
      >[];

property onTimeout

onTimeout?:
    | RouteShorthandHook<
          onTimeoutHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          onTimeoutHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property prefixTrailingSlash

prefixTrailingSlash?: 'slash' | 'no-slash' | 'both';

property preHandler

preHandler?:
    | RouteShorthandHook<
          preHandlerHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          preHandlerHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property preParsing

preParsing?:
    | RouteShorthandHook<
          preParsingHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          preParsingHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property preSerialization

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
          >
      >[];

property preValidation

preValidation?:
    | RouteShorthandHook<
          preValidationHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >
    | RouteShorthandHook<
          preValidationHookHandler<
              RawServer,
              RawRequest,
              RawReply,
              RouteGeneric,
              ContextConfig,
              NoInfer<SchemaCompiler>,
              TypeProvider,
              Logger
          >
      >[];

property schema

schema?: SchemaCompiler;

property schemaErrorFormatter

schemaErrorFormatter?: SchemaErrorFormatter;

property serializerCompiler

serializerCompiler?: FastifySerializerCompiler<NoInfer<SchemaCompiler>>;

property validatorCompiler

validatorCompiler?: FastifySchemaCompiler<NoInfer<SchemaCompiler>>;

interface RouteShorthandOptionsWithHandler

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
    > {}

Shorthand options including the handler function property

property handler

handler: RouteHandlerMethod<
    RawServer,
    RawRequest,
    RawReply,
    RouteGeneric,
    ContextConfig,
    NoInfer<SchemaCompiler>,
    TypeProvider,
    Logger
>;

Type Aliases

type ConstructorAction

type ConstructorAction = 'error' | 'remove' | 'ignore';

type ContextConfigDefault

type ContextConfigDefault = unknown;

type FastifyBodyParser

type FastifyBodyParser<
    RawBody extends string | Buffer,
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    SchemaCompiler extends FastifySchema = FastifySchema,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> =
    | ((
          request: FastifyRequest<
              RouteGeneric,
              RawServer,
              RawRequest,
              SchemaCompiler,
              TypeProvider
          >,
          rawBody: RawBody,
          done: ContentTypeParserDoneFunction
      ) => void)
    | ((
          request: FastifyRequest<
              RouteGeneric,
              RawServer,
              RawRequest,
              SchemaCompiler,
              TypeProvider
          >,
          rawBody: RawBody
      ) => Promise<any>);

Body parser method that operators on request body

type FastifyContentTypeParser

type FastifyContentTypeParser<
    RawServer extends RawServerBase = RawServerDefault,
    RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
    RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
    SchemaCompiler extends FastifySchema = FastifySchema,
    TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
> =
    | ((
          request: FastifyRequest<
              RouteGeneric,
              RawServer,
              RawRequest,
              SchemaCompiler,
              TypeProvider
          >,
          payload: RawRequest
      ) => Promise<any>)
    | ((
          request: FastifyRequest<
              RouteGeneric,
              RawServer,
              RawRequest,
              SchemaCompiler,
              TypeProvider
          >,
          payload: RawRequest,
          done: ContentTypeParserDoneFunction
      ) => void);

Content Type Parser method that operates on request content

type FastifyErrorCodes

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_VALIDATION'
    | 'FST_ERR_LISTEN_OPTIONS_INVALID'
    | 'FST_ERR_ERROR_HANDLER_NOT_FN'
    | 'FST_ERR_ERROR_HANDLER_ALREADY_SET'
    | 'FST_ERR_CTP_ALREADY_PRESENT'
    | 'FST_ERR_CTP_INVALID_TYPE'
    | 'FST_ERR_CTP_EMPTY_TYPE'
    | 'FST_ERR_CTP_INVALID_HANDLER'
    | 'FST_ERR_CTP_INVALID_PARSE_TYPE'
    | 'FST_ERR_CTP_BODY_TOO_LARGE'
    | 'FST_ERR_CTP_INVALID_MEDIA_TYPE'
    | 'FST_ERR_CTP_INVALID_CONTENT_LENGTH'
    | 'FST_ERR_CTP_EMPTY_JSON_BODY'
    | 'FST_ERR_CTP_INVALID_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_DEC_REFERENCE_TYPE'
    | 'FST_ERR_DEC_UNDECLARED'
    | '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_LOG_INVALID_LOGGER_INSTANCE'
    | 'FST_ERR_LOG_INVALID_LOGGER_CONFIG'
    | 'FST_ERR_LOG_LOGGER_AND_LOGGER_INSTANCE_PROVIDED'
    | 'FST_ERR_LOG_INVALID_LOG_CONTROLLER'
    | 'FST_ERR_REP_INVALID_PAYLOAD_TYPE'
    | 'FST_ERR_REP_RESPONSE_BODY_CONSUMED'
    | 'FST_ERR_REP_READABLE_STREAM_LOCKED'
    | '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_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_INIT_OPTS_INVALID'
    | 'FST_ERR_FORCE_CLOSE_CONNECTIONS_IDLE_NOT_AVAILABLE'
    | 'FST_ERR_DUPLICATED_ROUTE'
    | 'FST_ERR_BAD_URL'
    | 'FST_ERR_MAX_PARAM_LENGTH'
    | 'FST_ERR_ASYNC_CONSTRAINT'
    | 'FST_ERR_INVALID_URL'
    | '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_LOG_LEVEL_INVALID'
    | 'FST_ERR_ROUTE_BODY_VALIDATION_SCHEMA_NOT_SUPPORTED'
    | 'FST_ERR_ROUTE_BODY_LIMIT_OPTION_NOT_INT'
    | 'FST_ERR_HANDLER_TIMEOUT'
    | 'FST_ERR_ROUTE_HANDLER_TIMEOUT_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_PLUGIN_INVALID_ASYNC_HANDLER'
    | 'FST_ERR_PLUGIN_DEPENDENCY_NOT_REGISTERED'
    | '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
>;

type FastifyHttp2Options

type FastifyHttp2Options<
    Server extends http2.Http2Server,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> = FastifyServerOptions<Server, Logger> & {
    http2: true;
    http2SessionTimeout?: number;
};

type FastifyHttp2SecureOptions

type FastifyHttp2SecureOptions<
    Server extends http2.Http2SecureServer,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> = FastifyServerOptions<Server, Logger> & {
    http2: true;
    https: http2.SecureServerOptions;
    http2SessionTimeout?: number;
};

type FastifyHttpOptions

type FastifyHttpOptions<
    Server extends http.Server,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> = FastifyServerOptions<Server, Logger> & {
    http?: http.ServerOptions | null;
};

type FastifyHttpsOptions

type FastifyHttpsOptions<
    Server extends https.Server,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> = FastifyServerOptions<Server, Logger> & {
    https: https.ServerOptions | null;
};

type FastifyLoggerInstance

type FastifyLoggerInstance = FastifyBaseLogger;

Deprecated
Use FastifyBaseLogger instead

type FastifyPlugin

type FastifyPlugin<Options extends FastifyPluginOptions = Record<never, never>> =
    | FastifyPluginCallback<Options>
    | FastifyPluginAsync<Options>;

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

type FastifyPluginAsync

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>;

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.

type FastifyPluginCallback

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;

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.

type FastifyPluginOptions

type FastifyPluginOptions = Record<string, any>;

type FastifyRegisterOptions

type FastifyRegisterOptions<Options> =
    | (RegisterOptions & Options)
    | ((instance: FastifyInstance) => RegisterOptions & Options);

type FastifyRouterOptions

type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<
    FindMyWayConfigForServer<RawServer>,
    'defaultRoute' | 'onBadUrl' | 'onMaxParamLength' | 'querystringParser'
> & {
    defaultRoute?: (
        req: RawRequestDefaultExpression<RawServer>,
        res: RawReplyDefaultExpression<RawServer>
    ) => void;
    onBadUrl?: (
        path: string,
        req: RawRequestDefaultExpression<RawServer>,
        res: RawReplyDefaultExpression<RawServer>
    ) => void;
    onMaxParamLength?: (
        path: string,
        req: RawRequestDefaultExpression<RawServer>,
        res: RawReplyDefaultExpression<RawServer>
    ) => void;
    querystringParser?: (str: string) => { [key: string]: unknown };
};

type FastifySchemaCompiler

type FastifySchemaCompiler<T> = (
    routeSchema: FastifyRouteSchemaDef<T>
) => FastifyValidationResult;

Compiler for FastifySchema Type

type FastifySerializerCompiler

type FastifySerializerCompiler<T> = (
    routeSchema: FastifyRouteSchemaDef<T>
) => (data: any) => string;

type FastifyServerFactoryHandler

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;

type FastifyServerOptions

type FastifyServerOptions<
    RawServer extends RawServerBase = RawServerDefault,
    Logger extends FastifyBaseLogger = FastifyBaseLogger
> = {
    ignoreTrailingSlash?: boolean;
    ignoreDuplicateSlashes?: boolean;
    connectionTimeout?: number;
    keepAliveTimeout?: number;
    maxRequestsPerSocket?: number;
    forceCloseConnections?: boolean | 'idle';
    requestTimeout?: number;
    pluginTimeout?: number;
    bodyLimit?: number;
    handlerTimeout?: number;
    maxParamLength?: number;
    /** @deprecated Use the `logController` option with `disableRequestLogging` or `isLogDisabled` override instead. Will be removed in `fastify@6`. */
    disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean);
    logController?: LogControllerClass;
    exposeHeadRoutes?: boolean;
    onProtoPoisoning?: ProtoAction;
    onConstructorPoisoning?: ConstructorAction;
    logger?: boolean | (FastifyLoggerOptions<RawServer> & PinoLoggerOptions);
    loggerInstance?: Logger;
    serializerOpts?: FJSOptions | Record<string, unknown>;
    serverFactory?: FastifyServerFactory<RawServer>;
    caseSensitive?: boolean;
    allowUnsafeRegex?: boolean;
    requestIdHeader?: string | false;
    /** @deprecated Use the `logController` option with `requestIdLogLabel` instead. Will be removed in `fastify@6`. */
    requestIdLogLabel?: string;
    useSemicolonDelimiter?: boolean;
    genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string;
    trustProxy?: boolean | string | string[] | number | TrustProxyFunction;
    querystringParser?: (str: string) => { [key: string]: unknown };
    constraints?: {
        [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>;
    };
    schemaController?: {
        bucket?: (parentSchemas?: unknown) => {
            add(schema: unknown): FastifyInstance;
            getSchema(schemaId: string): unknown;
            getSchemas(): Record<string, unknown>;
        };
        compilersFactory?: {
            buildValidator?: ValidatorFactory;
            buildSerializer?: SerializerFactory;
        };
    };
    return503OnClosing?: boolean;
    ajv?: Parameters<BuildCompilerFromPool>[1];
    frameworkErrors?: <
        RequestGeneric extends RequestGenericInterface = RequestGenericInterface,
        TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
        SchemaCompiler extends FastifySchema = FastifySchema
    >(
        error: FastifyError,
        req: FastifyRequest<
            RequestGeneric,
            RawServer,
            RawRequestDefaultExpression<RawServer>,
            FastifySchema,
            TypeProvider
        >,
        res: FastifyReply<
            RequestGeneric,
            RawServer,
            RawRequestDefaultExpression<RawServer>,
            RawReplyDefaultExpression<RawServer>,
            FastifyContextConfig,
            SchemaCompiler,
            TypeProvider
        >
    ) => void;
    rewriteUrl?: (
        // The RawRequestDefaultExpression, RawReplyDefaultExpression, and FastifyTypeProviderDefault parameters
        // should be narrowed further but those generic parameters are not passed to this FastifyServerOptions type
        this: FastifyInstance<
            RawServer,
            RawRequestDefaultExpression<RawServer>,
            RawReplyDefaultExpression<RawServer>,
            Logger,
            FastifyTypeProviderDefault
        >,
        req: RawRequestDefaultExpression<RawServer>
    ) => string;
    schemaErrorFormatter?: SchemaErrorFormatter;
    /**
     * listener to error events emitted by client connections
     */
    clientErrorHandler?: (error: ConnectionError, socket: Socket) => void;
    childLoggerFactory?: FastifyChildLoggerFactory;
    allowErrorHandlerOverride?: boolean;
    routerOptions?: FastifyRouterOptions<RawServer>;
};

Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2

type getDefaultJsonParser

type getDefaultJsonParser = (
    onProtoPoisoning: ProtoAction,
    onConstructorPoisoning: ConstructorAction
) => FastifyBodyParser<string>;

type hasContentTypeParser

type hasContentTypeParser = (contentType: string | RegExp) => boolean;

Checks for a type parser of a content type

type HookHandlerDoneFunction

type HookHandlerDoneFunction = <TError extends Error = FastifyError>(
    err?: TError
) => void;

type HTTPMethods

type HTTPMethods = Autocomplete<_HTTPMethods | Lowercase<_HTTPMethods>>;

type ProtoAction

type ProtoAction = 'error' | 'remove' | 'ignore';

type RawReplyDefaultExpression

type RawReplyDefaultExpression<RawServer extends RawServerBase = RawServerDefault> =
    RawServer extends http.Server | https.Server
        ? http.ServerResponse
        : RawServer extends http2.Http2Server | http2.Http2SecureServer
        ? http2.Http2ServerResponse
        : never;

The default reply type based on the server type. Utilizes generic constraining.

type RawRequestDefaultExpression

type RawRequestDefaultExpression<
    RawServer extends RawServerBase = RawServerDefault
> = RawServer extends http.Server | https.Server
    ? http.IncomingMessage
    : RawServer extends http2.Http2Server | http2.Http2SecureServer
    ? http2.Http2ServerRequest
    : never;

The default request type based on the server type. Utilizes generic constraining.

type RawServerBase

type RawServerBase =
    | http.Server
    | https.Server
    | http2.Http2Server
    | http2.Http2SecureServer;

A union type of the Node.js server types from the http, https, and http2 modules.

type RawServerDefault

type RawServerDefault = http.Server;

The default server type

type RequestBodyDefault

type RequestBodyDefault = unknown;

type RequestHeadersDefault

type RequestHeadersDefault = unknown;

type RequestParamsDefault

type RequestParamsDefault = unknown;

type RequestQuerystringDefault

type RequestQuerystringDefault = unknown;

type RouteHandler

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>;

type RouteHandlerMethod

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>;

Route handler method declaration.

type SafePromiseLike

type SafePromiseLike<T> = PromiseLike<T> & { __linterBrands: 'SafePromiseLike' };

This branded type is needed to indicate APIs that return Promise-likes which can safely "float" (not have rejections handled by calling code).
Please refer to the following Github issue for more info: https://github.com/fastify/fastify/issues/5498

type ValidationResult

type ValidationResult = FastifySchemaValidationError;

Deprecated
use FastifySchemaValidationError

Package Files (19)

Dependencies (15)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/fastify.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/fastify)

HTML

<a href="https://www.jsdocs.io/package/fastify"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated just now.
Package analyzed in 8383 ms.
Missing or incorrect documentation? Open an issue for this package.

fastify

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable errorCodes

variable fastify

Functions

function fastify

Parameter opts

Returns

Classes

class LogController

property disableRequestLogging

property requestIdLogLabel

method defaultErrorLog

method incomingRequest

method isLogDisabled

method requestCompleted

method routeNotFound

method serializerError

method serviceUnavailable

method streamError

method writeHeadError

Interfaces

interface AddContentTypeParser

interface ConnectionError

property bytesParsed

property code

property rawPacket

interface DoneFuncWithErrOrRes

interface FastifyBaseLogger

method child

interface FastifyContextConfig

interface FastifyContextConfig

property bar

property foo

property includeMessage

interface FastifyInstance

property decorate

property decorateReply

property decorateRequest

property listeningOrigin

property log

property pluginName

property prefix

property register

property server

property version

method [Symbol.asyncDispose]

method addConstraintStrategy

method addresses

method addSchema

method after

method close

method getDecorator

method getSchema

method getSchemas

method hasConstraintStrategy

method hasDecorator

method hasPlugin

method hasReplyDecorator

method hasRequestDecorator

method inject

method listen

method ready

method route

method routing

method withTypeProvider

interface FastifyInstance

property typedTestProperty

property typedTestPropertyGetterSetter

method typedTestMethod

interface FastifyListenOptions

property backlog