TypeScript

Fastify is shipped with a typings file, but it still require to install @types/node, depending on the Node.js version that you are using.

Types support

We do care about the TypeScript community, but the framework is written in plain JavaScript and currently no one of the core team is a TypeScript user while only one of the collaborators is. We do our best to have the typing updated with the latest version of the API, but it can happen that the typings are not in sync.Luckly this is Open Source and you can contribute to fix them, we will be very happy to accept the fix and release it as soon as possible as a patch release. Checkout the contributing rules!

Plugins may or may not include typings. See Plugin Types for more information.

Example

This example TypeScript app closely aligns with the JavaScript examples:

  1. import * as fastify from 'fastify'
  2. import { Server, IncomingMessage, ServerResponse } from 'http'
  4. // Create a http server. We pass the relevant typings for our http version used.
  5. // By passing types we get correctly typed access to the underlying http objects in routes.
  6. // If using http2 we'd pass <http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>
  7. const server: fastify.FastifyInstance<Server, IncomingMessage, ServerResponse> = fastify({})
  9. const opts: fastify.RouteShorthandOptions = {
  10.   schema: {
  11.     response: {
  12.       200: {
  13.         type: 'object',
  14.         properties: {
  15.           pong: {
  16.             type: 'string'
  17.           }
  18.         }
  19.       }
  20.     }
  21.   }
  22. }
  24. server.get('/ping', opts, (request, reply) => {
  25.   console.log(reply.res) // this is the http.ServerResponse with correct typings!
  26.   reply.code(200).send({ pong: 'it worked!' })
  27. })

Generic Parameters

Since you can validate the querystring, params, body, and headers, you can also override the default types of those values on the request interface:

  1. import * as fastify from 'fastify'
  3. const server = fastify({})
  5. interface Query {
  6.   foo?: number
  7. }
  9. interface Params {
  10.   bar?: string
  11. }
  13. interface Body {
  14.   baz?: string
  15. }
  17. interface Headers {
  18.   a?: string
  19. }
  21. const opts: fastify.RouteShorthandOptions = {
  22.   schema: {
  23.     querystring: {
  24.       type: 'object',
  25.       properties: {
  26.         foo: {
  27.           type: 'number'
  28.         }
  29.       }
  30.     },
  31.     params: {
  32.       type: 'object',
  33.       properties: {
  34.         bar: {
  35.           type: 'string'
  36.         }
  37.       }
  38.     },
  39.     body: {
  40.       type: 'object',
  41.       properties: {
  42.         baz: {
  43.           type: 'string'
  44.         }
  45.       }
  46.     },
  47.     headers: {
  48.       type: 'object',
  49.       properties: {
  50.         a: {
  51.           type: 'string'
  52.         }
  53.       }
  54.     }
  55.   }
  56. }
  58. server.get<Query, Params, Body, Headers>('/ping/:bar', opts, (request, reply) => {
  59.   console.log(request.query) // this is of type Query!
  60.   console.log(request.params) // this is of type Params!
  61.   console.log(request.body) // this is of type Body!
  62.   console.log(request.headers) // this is of type Headers!
  63.   reply.code(200).send({ pong: 'it worked!' })
  64. })

All generic types are optional, so you can also pass types for the parts you validate with schemas:

  1. import * as fastify from 'fastify'
  3. const server = fastify({})
  5. interface Params {
  6.   bar?: string
  7. }
  9. const opts: fastify.RouteShorthandOptions = {
  10.   schema: {
  11.     params: {
  12.       type: 'object',
  13.       properties: {
  14.         bar: {
  15.           type: 'string'
  16.         }
  17.       }
  18.     },
  19.   }
  20. }
  22. server.get<fastify.DefaultQuery, Params, unknown>('/ping/:bar', opts, (request, reply) => {
  23.   console.log(request.query) // this is of type fastify.DefaultQuery!
  24.   console.log(request.params) // this is of type Params!
  25.   console.log(request.body) // this is of type unknown!
  26.   console.log(request.headers) // this is of type fastify.DefaultHeader because typescript will use the default type value!
  27.   reply.code(200).send({ pong: 'it worked!' })
  28. })
  30. // Given that you haven't validated the querystring, body, or headers, it would be best
  31. // to type those params as 'unknown'. However, it's up to you. The example below is the
  32. // best way to prevent you from shooting yourself in the foot. In other words, don't
  33. // use values you haven't validated.
  34. server.get<unknown, Params, unknown, unknown>('/ping/:bar', opts, (request, reply) => {
  35.   console.log(request.query) // this is of type unknown!
  36.   console.log(request.params) // this is of type Params!
  37.   console.log(request.body) // this is of type unknown!
  38.   console.log(request.headers) // this is of type unknown!
  39.   reply.code(200).send({ pong: 'it worked!' })
  40. })

HTTP Prototypes

By default, fastify will determine which version of http is being used based on the options you pass to it. If for any reason you need to override this you can do so as shown below:

  1. interface CustomIncomingMessage extends http.IncomingMessage {
  2.   getClientDeviceType: () => string
  3. }
  5. // Passing overrides for the http prototypes to fastify
  6. const server: fastify.FastifyInstance<http.Server, CustomIncomingMessage, http.ServerResponse> = fastify()
  8. server.get('/ping', (request, reply) => {
  9.   // Access our custom method on the http prototype
  10.   const clientDeviceType = request.raw.getClientDeviceType()
  12.   reply.send({ clientDeviceType: `you called this endpoint from a ${clientDeviceType}` })
  13. })

In this example we pass a modified http.IncomingMessage interface since it has been extended elsewhere in our application.

Contributing

TypeScript related changes can be considered to fall into one of two categories:

  • Core - The typings bundled with fastify
  • Plugins - Fastify ecosystem pluginsMake sure to read our CONTRIBUTING.md file before getting started to make sure things go smoothly!

Core Types

When updating core types you should make a PR to this repository. Ensure you:

  • Update examples/typescript-server.ts to reflect the changes (if necessary)
  • Update test/types/index.ts to validate changes work as expected

Plugin Types

Plugins maintained by and orginized under the fastify organization on GitHub should ship with typings just like fastify itself does. Some plugins already include typings but many do not. We are happy to accept contributions to those plugins without any typings, see fastify-cors for an example of a plugin that comes with it's own typings.

Typings for third-party-plugins may either be included with the plugin or hosted on DefinitelyTyped. Remember, if you author a plugin to either include typings or publish them on DefinitelyTyped! Information of how to install typings from DefinitelyTyped can be found here.

Some types might not be available yet, so don't be shy about contributing.

Authoring Plugin Types

Typings for many plugins that extend the FastifyRequest, FastifyReply or FastifyInstance objects can be achieved as shown below.

This code shows the typings for the fastify-static plugin.

  1. // require fastify typings
  2. import fastify = require("fastify");
  3. // require necessary http typings
  4. import { Server, IncomingMessage, ServerResponse } from "http";
  6. // extend fastify typings
  7. declare module "fastify" {
  8.     interface FastifyReply<HttpResponse> {
  9.         sendFile(filename: string): FastifyReply<HttpResponse>;
  10.     }
  11. }
  13. // declare plugin type using fastify.Plugin
  14. declare const fastifyStatic: fastify.Plugin<Server, IncomingMessage, ServerResponse, {
  15.     root: string;
  16.     prefix?: string;
  17.     serve?: boolean;
  18.     decorateReply?: boolean;
  19.     schemaHide?: boolean;
  20.     setHeaders?: (...args: any[]) => void;
  21.     acceptRanges?: boolean;
  22.     cacheControl?: boolean;
  23.     dotfiles?: boolean;
  24.     etag?: boolean;
  25.     extensions?: string[];
  26.     immutable?: boolean;
  27.     index?: string[];
  28.     lastModified?: boolean;
  29.     maxAge?: string | number;
  30. }>;
  32. // export plugin type
  33. export = fastifyStatic;

Now you are good to go and could use the plugin like so:

  1. import * as Fastify from 'fastify'
  2. import * as fastifyStatic from 'fastify-static'
  4. const app = Fastify()
  6. // the options here are type-checked
  7. app.register(fastifyStatic, {
  8.   acceptRanges: true,
  9.   cacheControl: true,
  10.   decorateReply: true,
  11.   dotfiles: true,
  12.   etag: true,
  13.   extensions: ['.js'],
  14.   immutable: true,
  15.   index: ['1'],
  16.   lastModified: true,
  17.   maxAge: '',
  18.   prefix: '',
  19.   root: '',
  20.   schemaHide: true,
  21.   serve: true,
  22.   setHeaders: (res, pathName) => {
  23.     res.setHeader('some-header', pathName)
  24.   }
  25. })
  27. app.get('/file', (request, reply) => {
  28.   // using newly defined function on FastifyReply
  29.   reply.sendFile('some-file-name')
  30. })

Adding typings to all our plugins is a community effort so feel free to contribute!