Fastify is shipped with a typings file, but you may need to install , depending on the Node.js version you are using.

Types support

We do care about the TypeScript community, and one of our core team members is currently reworking all types. We do our best to have the typings updated with the latest version of the API, but it can happen that the typings are not in sync.Luckily 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 for more information.

This example TypeScript app closely aligns with the JavaScript examples:

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:

import * as fastify from 'fastify'
const server = fastify({})
interface Query {
  foo?: number
}
interface Params {
  bar?: string
}
interface Body {
  baz?: string
}
interface Headers {
  a?: string
}
const opts: fastify.RouteShorthandOptions = {
  schema: {
    querystring: {
      type: 'object',
      properties: {
        foo: {
          type: 'number'
        }
      }
    },
    params: {
      properties: {
        bar: {
          type: 'string'
        }
      }
    body: {
      type: 'object',
      properties: {
        baz: {
          type: 'string'
        }
      }
    },
    headers: {
      type: 'object',
      properties: {
        a: {
          type: 'string'
        }
      }
    }
  }
}
server.get<Query, Params, Headers, Body>('/ping/:bar', opts, (request, reply) => {
  console.log(request.query) // this is of type Query!
  console.log(request.params) // this is of type Params!
  console.log(request.body) // this is of type Body!
  console.log(request.headers) // this is of type Headers!
  reply.code(200).send({ pong: 'it worked!' })
})

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

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:

interface CustomIncomingMessage extends http.IncomingMessage {
  getClientDeviceType: () => string
}
// Passing overrides for the http prototypes to fastify
const server: fastify.FastifyInstance<http.Server, CustomIncomingMessage, http.ServerResponse> = fastify()
  // Access our custom method on the http prototype
  const clientDeviceType = request.raw.getClientDeviceType()
})

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 plugins

Make sure to read our CONTRIBUTING.md file before getting started to make sure things go smoothly!

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

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 .

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

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.

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

import * as Fastify from 'fastify'
import * as fastifyStatic from 'fastify-static'
const app = Fastify()
// the options here are type-checked
app.register(fastifyStatic, {
  acceptRanges: true,
  cacheControl: true,
  decorateReply: true,
  dotfiles: true,
  etag: true,
  extensions: ['.js'],
  immutable: true,
  index: ['1'],
  lastModified: true,
  maxAge: '',
  prefix: '',
  root: '',
  schemaHide: true,
  serve: true,
  setHeaders: (res, pathName) => {
    res.setHeader('some-header', pathName)
  }
})
app.get('/file', (request, reply) => {
  // using newly defined function on FastifyReply
})

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