abhimanyoo / backend-starter-kit

:truck: A boilerplate for Node.js, Express, Mongoose, Heroku, mLab, Nodemon, PM2, and Babel. REST / GraphQL API Server | PaaS | SaaS | CaaS | CI/CD | Jest | Supertest | Docker | MongoDB | PostgreSQL | Sequelize | Lodash | RxJS | JWT | Passport | Socket.IO | Redis | CircleCI | Apollo | TensorFlow

Backend Starter Kit

🚚 A boilerplate for Node.js, Express, Mongoose, Heroku, mLab, Nodemon, PM2, and Babel.

//

🌈 Live Demo

This seed repository provides the following features:

• ---------- Essentials ----------
• Application routing with Express.
• Data query language with GraphQL.
• Object document mapping with Mongoose.
• Object relational mapping with Sequelize.
• Utility functions with Lodash.
• Reactive extensions with ReactiveX.
• Authenticate requests with Passport.
• Real-time bidirectional communication with Socket.
• In-memory data structure store with Redis.
• Machine learning with TensorFlow.
• ---------- Tools ----------
• Next generation JavaScript with Babel.
• JavaScript static code analyzer with ESLint.
• Testing platform with Jest.
• HTTP testing with Supertest.
• Test coverage integration with Codecov.
• Automatically restart application with Nodemon.
• Keeping application alive with PM2.
• ---------- Environments ----------
• Server-side platform with Node.
• Version control with Git.
• Code repository with GitHub.
• Fast and deterministic builds with Yarn.
• Cloud application hosting with Heroku.
• Cloud NoSQL database hosting with mLab.
• Cloud SQL database hosting with ElephantSQL.
• Cloud memory cache hosting with RedisLabs.
• Cloud Storage‎ hosting with Cloudinary.
• Monitoring service with UptimeRobot.
• Log management service with Papertrail.
• Performance and security with Cloudflare.
• Software container with Docker.
• Continuous integration with CircleCI.

Here are some related seed repositories:

• ---------- Client-side ----------
• Web Starter Kit - Progressive Web Apps.
• Mobile Starter Kit - Cross-platform Mobile Apps.
• Desktop Starter Kit - Cross-platform Desktop Apps.
• ---------- Server-side ----------
• Platform Starter Kit - Flexible Cloud Platform.
• Functions Starter Kit - Serverless Cloud Functions.
• Infrastructure Starter Kit - Containerized Cloud Infrastructure.

Table of Contents

• Getting Started
• Dockerization
• Configuration
• Using Libraries
• Directory Structure

Getting Started

Follow steps to execute this boilerplate.

1. Clone this boilerplate

$ git clone --depth 1 https://github.com/Shyam-Chen/Backend-Starter-Kit.git <PROJECT_NAME>
$ cd <PROJECT_NAME>

2. Install dependencies

$ yarn install

3. Start a local server

$ yarn start

4. Compile and bundle code

$ yarn build

5. Check the code quality

$ yarn lint

6. Run the unit tests

$ yarn test

7. Run the end-to-end tests

$ yarn e2e

Dockerization

Dockerize an application.

1. Build and run the container in the background

$ docker-compose up -d api

2. Run a command in a running container

$ docker-compose exec api <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 api

5. Push images to Docker Cloud

# .gitignore

  .DS_Store
  node_modules
  dist
  coverage
+ dev.Dockerfile
+ stage.Dockerfile
+ prod.Dockerfile
  *.log

$ docker login
$ docker build -f ./tools/<dev|stage|prod>.Dockerfile -t <IMAGE_NAME>:<IMAGE_TAG> .

# checkout
$ docker images

$ docker tag <IMAGE_NAME>:<IMAGE_TAG> <DOCKER_ID_USER>/<IMAGE_NAME>:<IMAGE_TAG>
$ docker push <DOCKER_ID_USER>/<IMAGE_NAME>:<IMAGE_TAG>

# remove
$ docker rmi <REPOSITORY>:<TAG>
# or
$ docker rmi <IMAGE_ID>

6. Pull images from Docker Cloud

# circle.yml

+ echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
  docker login -u="<DOCKER_USERNAME>" -p="${HEROKU_TOKEN}" registry.heroku.com
- docker build -f ./tools/<dev|stage|prod>.Dockerfile -t registry.heroku.com/<HEROKU_PROJECT>/web .
+ docker pull <DOCKER_ID_USER>/<IMAGE_NAME>:<IMAGE_TAG>
+ docker tag <IMAGE_NAME>:<IMAGE_TAG> registry.heroku.com/<HEROKU_PROJECT>/web
  docker push registry.heroku.com/<HEROKU_PROJECT>/web

Configuration

Default environments

Set your local environment variables.

// src/env.js

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

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

export const SECRET = process.env.SECRET || 'PUT_YOUR_SECRET_HERE';

export const MONGODB_URI = process.env.MONGODB_URI || '<PUT_YOUR_MONGODB_URI_HERE>';
export const POSTGRES_URL = process.env.POSTGRES_URL || 'PUT_YOUR_POSTGRES_URL_HERE';

export const REDIS_PORT = process.env.REDIS_PORT || '<PUT_YOUR_REDIS_PORT_HERE>';
export const REDIS_HOST = process.env.REDIS_HOST || '<PUT_YOUR_REDIS_HOST_HERE>';

// ...

Deployment environments

Set your deployment environment variables.

# tools/<dev|stage|prod>.Dockerfile

# envs --
ENV SECRET <PUT_YOUR_SECRET_HERE>

ENV MONGODB_URI <PUT_YOUR_MONGODB_URI>
ENV POSTGRES_URL <PUT_YOUR_POSTGRES_URL_HERE>

ENV REDIS_PORT <PUT_YOUR_REDIS_PORT_HERE>
ENV REDIS_HOST <PUT_YOUR_REDIS_HOST_HERE>

# ...
# -- envs

Using Libraries

1. Example of REST

import { Router } from 'express';

import { List } from './document';

const router = Router();

router.get('/', async (req, res) => {
  const data = await List.find({}).exec();
  res.json(data);
});

export default router;

2. Example of GraphQL

import gql from 'graphql-tag';

import { List } from './document';

export const listTypeDefs = gql`
  type List {
    _id: ID!
    text: String!
  }

  type Query {
    list: [List]
  }
`;

export const listResolvers = {
  Query: {
    async list(root, { _id, text }) {
      try {
        const data = await List.find({}).exec();
        return data;
      } catch (err) {
        throw err;
      }
    },
  },
};

3. Example of Document

import mongoose, { Schema } from 'mongoose';

const listSchema = new Schema({
  text: {
    type: String,
    required: true,
  },
});

export const List = mongoose.model('List', listSchema);

4. Example of Relational

import Sequelize from 'sequelize';

import sequelize from '~/core/sequelize';

export const RelationalList = sequelize.define('List', {
  text: Sequelize.STRING,
});

5. Example of Lodash

import { of } from 'rxjs';
import { lowerFirst, pad } from 'lodash';

of(lowerFirst('Hello'), pad('World', 5))
  .subscribe(value => console.log(value));
  // hello
  // World

6. Example of ReactiveX

import { timer, of } from 'rxjs';
import { mapTo, combineAll } from 'rxjs/operators';

timer(2000)
  .pipe(
    mapTo(of('Hello', 'World')),
    combineAll(),
  )
  .subscribe(value => console.log(value));
  // ["Hello"]
  // ["World"]

7. Example of Socket

import { io } from '~/core/socket';

io.emit('A', { foo: 'bar' });
io.on('B', data => console.log(data));  // { foo: 'baz' }

<script src="https://cdnjs.cloudflare.com/ajax/libs/socket.io/2.2.0/socket.io.js"></script>
<script>
const socket = io();

socket.on('connect', () => console.log('WS: Accept a connection.'));

socket.on('A', (data) => {
  console.log(data);  // { foo: 'bar' }
  socket.emit('B', { foo: 'baz' });
});
</script>

8. Example of Redis

import { client } from '~/core/redis';

client.hmset('thing', {
  foo: 'js',
  bar: 'html',
  baz: 'css',
});

client.hgetall('thing', (err, object) => {
  console.log(object);
});

Directory Structure

The structure follows the LIFT Guidelines.

.
├── src
│   ├── core  -> core feature module
│   ├── <FEATURE>  -> feature modules
│   │   ├── __tests__
│   │   │   ├── <FEATURE>.e2e-spec.js
│   │   │   └── <FEATURE>.spec.js
│   │   ├── _<THING>  -> feature of private things
│   │   │   └── ...
│   │   └── <FEATURE>.js
│   ├── <GROUP>  -> module group
│   │   └── <FEATURE>  -> feature modules
│   │       ├── __tests__
│   │       │   ├── <FEATURE>.e2e-spec.js
│   │       │   └── <FEATURE>.spec.js
│   │       ├── _<THING>  -> feature of private things
│   │       │   └── ...
│   │       └── <FEATURE>.js
│   ├── shared  -> shared feature module
│   ├── api.js
│   └── env.js
├── tools
│   └── ...
├── .babelrc
├── .editorconfig
├── .eslintrc
├── .gitignore
├── Dockerfile
├── LICENSE
├── README.md
├── circle.yml
├── docker-compose.yml
├── jest.config.js
├── package.json
├── processes.js
└── yarn.lock