vlkpa / nestjs-graphql-microservices

GraphQL API with gRPC back-end microservices built using the NestJS framework. Used for learning/trial & boilerplate purposes only.

NestJS GraphQL API + gRPC microservices

This project is a monorepo containing a GraphQL API with gRPC back-end microservices built using the NestJS framework. This project is mainly used for learning/trial and boilerplate purposes only.

Graph Model

When creating GraphQL APIs, one must understand what Graph Theory and Graph Data Modelling are. One must also think in graphs as per the GraphQL specification recommends. A diagram of the graph data model is shown below.

Explanation

1. Users can write both posts and comments therefore, users are authors posts and comments.
2. Posts are authored by users and comments can be linked/submitted for them.
3. Comments are authored by users and are linked/submitted to posts.

Architecture Overview

The GraphQL API acts as a gateway/proxy for the different microservices it exposes. The resolvers of the GraphQL API make calls to the gRPC microservices through client-server communication. The services and the data interchange are defined using Protocol Buffers. The gRPC microservices handle and fulfill the requests whether they are database or storage operations or any other internal or external calls.

Diagram

A diagram of the architecture is shown below.

This architecture implements the following Microservice Design Patterns:

1. Microservice Architecture
2. Subdomain Decomposition
3. Externalized Configuration
4. Remote Procedure Invocation
5. API Gateway
6. Database per Service

Layers

API Layer

NestJS + GraphQL acts as the API Layer for the architecture. It takes care of listening for client requests and calling the appropriate back-end microservice to fulfill them.

Microservice Layer

NestJS + gRPC was chosen as the framework to do the microservices. Protocol buffers was used as the data interchange format between the client (GraphQL API) and the server (gRPC microservices). NestJS is still the framework used to create the gRPC Microservices.

Persistence Layer

PostgreSQL is used as the database and Sequelize is used as the Object-Relational Mapper (ORM).

Deployment

Deployment is done with containers in mind. A Docker Compose file along with Dockerfiles for the GraphQL API Gateway and each microservice are given to run the whole thing on any machine. For production, it's always recommended to use Kubernetes for these kinds of microservices architecture to deploy in production. Istio takes care of service discovery, distributed tracing and other observability requirements.

How to Run

Pre-requisites

You must install the following on your local machine:

1. Node.js (v12.x recommended)
2. Docker
3. Docker Compose
4. PostgreSQL Client (libpq as required by pg-native)

Running

1. On the Terminal, go into the project's root folder (cd /project/root/folder) and execute npm start. The start script will install all npm dependencies for all projects, lint the code, transpile the code, build the artifacts (Docker images) and run all of them via docker-compose.

2. Once the start script is done, the GraphQL Playground will be running on http://localhost:3000

Roadmap

API Gateway

• Add unit tests
• Add refresh token support
• Add request/input data validation
• Improve logging
• Improve error handling
• Add DataLoader support

Microservices

• Add authorization
• Add caching
• Add health checks
• Add unit tests
• Improve logging
• Improve error handling