Express Starter

:truck: A boilerplate for Node.js, Express, Mongoose, Heroku, Atlas, Nodemon, PM2, and Babel.

:rainbow: Live Demo

:muscle: This seed repository provides the following features:

• ---------- Essentials ----------
• Web application framework with Express.
• Object-document mapping with Mongoose.
• Make authenticated requests with Passport.
• File upload with Multer.
• Real-time communication with WS.
• ---------- Tools ----------
• Next generation JavaScript with Babel.
• JavaScript static code analyzer with ESLint.
• Code formatter with Prettier.
• Unit testing with Jest.
• End-to-End testing with Supertest.
• Mocking external requests with Nock.
• Automatically restart application with Nodemon.
• Keeping application alive with PM2.
• Reverse proxy with Caddy.
• ---------- Environments ----------
• Cloud application hosting with Heroku.
• Cloud NoSQL database hosting with Atlas.
• Cloud storage hosting with Cloudinary.
• Error tracking service with Sentry.
• Software container with Docker.
• Continuous integration with CircleCI.
• Fix and prevent known vulnerabilities with Snyk.
• Test coverage integration with Codecov.

[!NOTE]

:thinking: Think about next-generation application development:

• Fastify is one of the fastest Node.js web frameworks.
• Nest uses a modular architecture and allows the choice of either Express or Fastify as the server framework.

If you're interested in Fastify, you can refer to my Fastify Starter.

Table of Contents

• Project Setup
• Dockerization
• Configuration
• Examples
• Directory Structure
• Microservices

Project Setup

Follow steps to execute this boilerplate.

Install dependencies

$ npm install

Start a development server

$ brew services start mongodb-community
$ yarn serve

Produce a production-ready bundle

$ yarn build

Lints and fixes files

$ yarn lint

Runs unit tests

Files: src/**/*.spec.js

$ yarn unit

Runs end-to-end tests

Files: e2e/**/*.spec.js

# Before running the `meas` command, make sure to run the following commands.
$ yarn build
$ yarn preview

# If it's not setup, run it.
$ yarn setup

$ yarn e2e

Measures APIs

Files: e2e/**/*.meas.js

# Before running the `meas` command, make sure to run the following commands.
$ yarn build
$ yarn preview

# If it's not setup, run it.
$ yarn setup

$ yarn meas

Mocks third-party APIs

# If it's not active, run it.
$ yarn active

$ yarn mock

Dockerization

Dockerize an application.

1. Build and run the container in the background

$ docker-compose up -d mongodb app

2. Run a command in a running container

$ docker-compose exec app <COMMAND>

3. Remove the old container before creating the new one

$ docker-compose rm -fs

4. Restart up the container in the background

$ docker-compose up -d --build app

Configuration

Control the environment.

Default environments

Set your local environment variables. (use export const <ENV_NAME> = process.env.<ENV_NAME> || <LOCAL_ENV>;)

// src/env.js

export const NODE_ENV = process.env.NODE_ENV || 'development';
export const INDEX_NAME = process.env.INDEX_NAME || 'local';

export const HOST = process.env.HOST || '0.0.0.0';
export const PORT = process.env.PORT || 3000;

export const SECRET_KEY = process.env.SECRET_KEY || 'jbmpHPLoaV8N0nEpuLxlpT95FYakMPiu';

export const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://127.0.0.1:27017/test';

// ---

export const FACEBOOK_APP_ID = process.env.FACEBOOK_APP_ID || 'XXX';
export const FACEBOOK_APP_SECRET = process.env.FACEBOOK_APP_SECRET || 'XXX';

export const GOOGLE_CLIENT_ID = process.env.GOOGLE_CLIENT_ID || 'XXX';
export const GOOGLE_CLIENT_SECRET = process.env.GOOGLE_CLIENT_SECRET || 'XXX';

export const APPLE_SERVICES_ID = process.env.APPLE_SERVICES_ID || 'XXX';
export const APPLE_TEAM_ID = process.env.APPLE_TEAM_ID || 'XXX';
export const APPLE_KEY_ID = process.env.APPLE_KEY_ID || 'XXX';
export const APPLE_PRIVATE_KEY = process.env.APPLE_PRIVATE_KEY || 'XXX';

export const CLOUDINARY_URL = process.env.CLOUDINARY_URL || 'cloudinary://key:secret@domain_name';

export const RATE_LIMIT = process.env.RATE_LIMIT || 0;

export const SENTRY_DSN = process.env.SENTRY_DSN || null;

Continuous integration environments

Add environment variables to the CircleCI build.

# Project Settings > Environment Variables > Add Environment Variable

SECRET_KEY
MONGODB_URI
CLOUDINARY_URL
SENTRY_DSN

File-based environments

If you want to set environment variables from a file.

.
├── e2e
├── envs
│   ├── dev.js
│   ├── stage.js
│   └── prod.js
├── mock
└── src

// envs/<ENV_NAME>.js

function Environment() {
  this.NODE_ENV = 'production';
  // more...
}

module.exports = new Environment();

$ npm install babel-plugin-transform-inline-environment-variables env-cmd -D

// babel.config.js

    plugins: [
      // ...
      'transform-inline-environment-variables',
    ],

// package.json

  "scripts": {
    // "env-cmd -f ./envs/<ENV_NAME>.js" + "yarn build"
    "build:dev": "env-cmd -f ./envs/dev.js yarn build",
    "build:stage": "env-cmd -f ./envs/stage.js yarn build",
    "build:prod": "env-cmd -f ./envs/prod.js yarn build",
  },

Examples

• Hello World
• CRUD Operations
• Authentication
• File Uploads
• Realtime Data

Directory Structure

The structure follows the LIFT Guidelines.

.
├── e2e
├── mock
│   ├── requests
│   └── responses
├── src
│   ├── core
│   │   └── ...
│   ├── <FEATURE> -> feature modules
│   │   ├── __tests__
│   │   │   ├── controller.spec.js
│   │   │   ├── service.spec.js
│   │   │   └── model.spec.js
│   │   ├── controller.js
│   │   ├── service.js
│   │   ├── model.js
│   │   └── index.js
│   ├── <GROUP> -> module group
│   │   └── <FEATURE> -> feature modules
│   │       ├── __tests__
│   │       │   ├── controller.spec.js
│   │       │   ├── service.spec.js
│   │       │   └── model.spec.js
│   │       ├── controller.js
│   │       ├── service.js
│   │       ├── model.js
│   │       └── index.js
│   ├── app.js
│   ├── env.js
│   └── server.js
├── .editorconfig
├── .eslintrc
├── .gitignore
├── .prettierrc
├── babel.config
├── Caddyfile
├── circle.yml
├── develop.Dockerfile
├── docker-compose.yml
├── Dockerfile
├── jest.config.js
├── LICENSE
├── package-lock.json
├── package.json
├── processes.js
├── produce.Dockerfile
└── README.md

Microservices

Microservice architecture – a variant of the service-oriented architecture structural style – arranges an application as a collection of loosely coupled services. In a microservices architecture, services are fine-grained and the protocols are lightweight.

See Server-side Micro-Fullstack for instructions on how to create microservices from source code.