fastify-cli

The fastify command provides a single interface for common Fastify tasks. You can view all available commands and their descriptions by running fastify or fastify help.

Available Commands:

• start: Start a Fastify server.
• eject: Convert your application into a standalone executable by adding a server.js or server.ts file.
• generate: Scaffold a new Fastify project.
• generate-plugin: Scaffold a new plugin project.
• generate-swagger: Generate Swagger/OpenAPI schemas (requires @fastify/swagger).
• readme: Generate a README.md for a plugin.
• print-routes: Debug the internal radix tree used by the router.
• print-plugins: Debug the internal plugin tree used by avvio.
• version: Show the current fastify-cli version.
• help: Show help about commands.

$ fastify

When you need to share functionality (such as database connections, authentication logic, or utility functions) across multiple route files, do not define them within the routes/ folder. Instead:

1. Place the shared functionality in the plugins/ folder.
2. Register the functionality as a Fastify plugin.
3. Use decorators to make the functionality available to your routes.

When you need to share functionality (such as database connections, utility functions, or shared state) across different routes, do not duplicate the logic in each route file. Instead:

1. Place the shared functionality in the plugins folder.
2. Register the functionality using Fastify decorators.
3. Access the decorated properties/methods within your route plugins.

The plugins folder is used to define behavior that is common to all routes in your application. You should place logic for cross-cutting concerns here, such as:

• Authentication
• Caching
• Template engines
• Other shared application logic

Files in this folder are typically wrapped with the fastify-plugin module to make them non-encapsulated. This allows them to define decorators and set hooks that are accessible throughout the rest of your application.

In a fastify-cli application, the plugins folder is intended for defining behavior that is common to all routes. You should place logic for cross-cutting concerns here, such as:

• Authentication
• Caching
• Template engines
• Other application-wide behaviors

Files in this folder are typically defined using the fastify-plugin module. Using fastify-plugin makes these plugins non-encapsulated, allowing them to define decorators and set hooks that are accessible throughout the rest of your application.

By default, log output is consumed by the Node Test runner. If you want log messages to appear in your console during testing, you must configure your logger to output to stderr (destination 2) instead of stdout.

You can pass this configuration via the serverOptions parameter in the build or listen helpers.

const { build } = require('fastify-cli/helper')
const { test } = require('node:test')
const assert = require('node:assert')

const logger = {
  transport: {
    target: 'pino-pretty',
    options: {
      destination: 2, // Redirects to stderr
    },
  },
}

const argv = ['app.js']

test('test my application with logging enabled', async t => {
  const app = await build(argv, {}, { logger })
  t.after(() => app.close())

  const res = await app.inject('/')
  assert.deepStrictEqual(res.json(), { hello: 'one' })
})

Use fastify generate-plugin <yourplugin> to create a boilerplate for plugin development.

Workflow:

1. fastify generate-plugin <yourplugin>
2. cd yourplugin
3. npm install

Available Scripts:

• npm run unit: Runs all unit tests.
• npm run lint: Checks code style.
• npm run test:typescript: Runs type tests.
• npm test: Runs all checks at once.

$ fastify generate-plugin my-plugin

Install the __packageName__ plugin using npm or yarn.

npm i __packageName__
yarn add __packageName__

Use fastify generate <yourapp> to create a new project structure.

Workflow:

1. fastify generate <yourapp>
2. cd yourapp
3. npm install

Project Structure:

• app.js: The entry point (a standard Fastify plugin).
• plugins/: Custom plugins.
• routes/: Endpoint declarations.
• test/: Test files.

Available Flags:

• --esm: Generates an ESM-based JavaScript template.
• --lang=ts or --lang=typescript: Uses the TypeScript template.
• --integrate: Use this if generating into the current directory (.) that already contains a package.json. It will add/alter main, scripts, dependencies, and devDependencies. Use with care as it may overwrite existing files like app.js.
• --standardlint: Includes the Standard linter for JavaScript templates.

$ fastify generate my-app

The routes/ folder is used to define the endpoints of your web application. Following a modular monolith approach, each route file should be a Fastify plugin. This structure allows you to group related routes logically (e.g., all /users routes in users.js) and facilitates future scaling or extraction into microservices.

To manage complexity:

• Logical Grouping: Group routes by resource (e.g., users.js, products.js).
• Sub-folders: If a single route file becomes too large, create a folder containing an index.js file. This index.js must be a Fastify plugin, and it will be automatically loaded by the application, allowing you to split the routes into multiple files within that folder.