create-fastify-app

Create Fastify App is an utility that help you to generate or add plugin to your Fastify project. This mean that you can easily:

Generate a Fastify Project, also from a given swagger file.
Generate a service skeleton in existing Fastify Project.
Add fastify-cors plugin in existing Fastify Project.
Add fastify-mongodb plugin in existing Fastify Project.
Add fastify-redis plugin in existing Fastify Project.
Add fastify-postgres plugin in existing Fastify Project.
Add point-of-view plugin in existing Fastify Project.

Install

If you want to use fastify-app you must first install globally on your machine

npm install -g create-fastify-app

Enable autocompletion

run the following command from your terminal. Pay attention to the . ./ or the autocompletion feature won't start.

. ./cfa-autocompletion.sh

Usage

Generate Fastify projects and utilities:

  fastify-app [command] <options>

Command
  generate:project     Generate a ready to use Fastify project
  generate:service     Generate service skeleton source in given project
  add:mysql            Add fastify-mysql plugin in given project folder
  add:mongo            Add fastify-mongodb plugin in given project folder
  add:cors             Add fastify-cors plugin in given project folder
  add:redis            Add fastify-redis plugin in given project folder
  add:postgres         Add fastify-postgres plugin in given project folder
  add:pov              Add Point-Of-View plugin in given project folder

Options

  -d, --directory
      Fastify project folder

  -h, --help
      Show this help message

Except for generate:project command the others work on an existent project created with fastify-app.

`generate:project`

Generate a new Fastify project run following command

fastify-app generate:project -d <project-folder>

If -d, or --directory, option is omitted the new project will be created in curret folder. At this point further information will be asked:

Application Name: the application name.
Description: a short description non how the application do.
Author: the application author.
Email: the application email author.
Version: semver version.
Keywords: a list of comma separated keywords.
License: the application license.
Swagger File: a swagger file to start from (YAML or JSON).

After providing these information the entire application skeleton will be created for you. Simply run

cd /your/wonderful/application
npm install
npm run dev

Project structure

By default fastify-app generate a project structured in this way:

/your/wonderful/application
├── docker-compose.yml
├── Dockerfile
├── help
│   └── start.txt
├── package.json
├── README.md
├── src
│   ├── hooks
│   │   ├── onError.js
│   │   ├── onRequest.js
│   │   ├── onResponse.js
│   │   ├── onSend.js
│   │   ├── preHandler.js
│   │   ├── preParsing.js
│   │   ├── preSerialization.js
│   │   └── preValidation.js
│   ├── index.js
│   ├── plugins
│   │   ├── README.md
│   │   └── support.js
│   └── services
│       ├── hello
│       │   └── index.js
│       ├── README.md
│       └── root.js
└── test
    ├── helper.js
    ├── plugins
    │   └── support.test.js
    └── services
        ├── example.test.js
        └── root.test.js

The src folder contains all you need to develop your application. In particular, she contains the following directories:

plugins: here you can add all your plugins you need into you application.
services: here you can develop all the endpoint you need for your application, or the generated endpoint if you give a swagger file at project creation.
hooks: here you can declare all the hooks you need for your fastify application.

The package.json file comes with three predefined npm task:

"scripts": {
  "test": "tap test/**/*.test.js",
  "start": "fastify-app run",
  "dev": "fastify-app run -l info -P -w"
}

npm test: runs the test
npm start: start your application
npm run dev: start your application with pino-colada pretty logging and in watching mode

The Dockerfile and the docker-compose.yml files allow you to dockerize your application. When you add a plugin, for example with add:mongo, the docker-compose.yml will automatically updated with given information. Here the Dockerfile generated:

FROM node:latest
RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app
COPY package.json /usr/src/app/
RUN npm install
COPY . /usr/src/app
EXPOSE 3000
CMD [ "npm", "install", "-g", "create-fastify-app" ]
CMD [ “npm”, "start" ]

and the docker-compose.yml:

version: '3.7'
services:
  fastify-app:
    container_name: fastify-app
    restart: always
    build: .
    image: fastify-app:1.0.0
    ports:
      - '3000:3000'
    expose:
      - '3000'

Options

You can pass the following options via command line with fastify run <options>. Every options has the corresponding environment variable:

Description	Short command	Full command	Environment variable
The application file to start	`-f`	`--file`	`FASTIFY_FILE`
Port to listen on (default to 3000)	`-p`	`--port`	`FASTIFY_PORT or PORT`
Address to listen on	`-a`	`--address`	`FASTIFY_ADDRESS`
Log level (default to fatal)	`-l`	`--log-level`	`FASTIFY_LOG_LEVEL`
Prints pretty logs	`-P`	`--pretty-logs`	`FASTIFY_PRETTY_LOGS`
Use custom options	`-o`	`--options`	`FASTIFY_OPTIONS`
Set the prefix	`-r`	`--prefix`	`FASTIFY_PREFIX`
Set the plugin timeout	`-T`	`--plugin-timeout`	`FASTIFY_PLUGIN_TIMEOUT`
Defines the maximum payload, in bytes, the server is allowed to accept		`--body-limit`	`FASTIFY_BODY_LIMIT`
Start the application in watching mode on your file changes	`-w`	`--watch`

Generate a project from a swagger file

When you generate a new project you can give in input a swagger file. In an api driven project this feature can be very important because fastify-app will generate all your project endpoints for you. You will only have to worry about the development of the various endpoints.

If you give in input the Petstore swagger file given as example on Swagger.io, you can see that fastify-app automatically generate a project with fastify-swagger already configured and ready to use in your project. If you take a look at /documentation endpoint you'll find something like that:

In your src/services folder you'll find your endpoints folder

./src/services
├── README.md
├── pet
│   ├── index.js
│   └── routes.schema.js
├── root.js
├── store
│   ├── index.js
│   └── routes.schema.js
└── user
    ├── index.js
    └── routes.schema.js