This template provides a Node.js Starter Project that has been configured with GraphQL for API, Redis for caching and temporary data storage, JWT for authentication and authorization, and Sequelize for ORM that connects to a relational database such as PostgreSQL or MySQL. The project has a modular structure that allows you to instantly develop modern web applications with integrated and scalable features.

? Project Overview

This project is designed to make it easier to develop backend applications with a GraphQL API that uses Redis for data caching and JWT for securing the API. Sequelize is used as an ORM to facilitate interaction with relational databases. In addition, there is middleware that makes it easier to handle authentication, validation, and logging.

Key Features

• GraphQL API for more flexible and efficient querying and data mutation
• JWT Authentication for secure token-based authentication
• Redis for data caching and improving application performance
• Sequelize ORM for relational database management
• Middleware for centralized authorization and request handling
• Modular and well structured for scalability and easier maintenance

?️ Technology Used

• Node.js: Platform for building server-side applications with JavaScript. Learn more
• GraphQL: Query language for APIs that enables efficient and flexible data retrieval. Learn more
• Redis: Temporary data storage (in-memory) which is often used for caching and message brokering. Learn more
• JWT: Secure and simple token-based authentication technology. Learn more
• Sequelize: ORM for Node.js that supports PostgreSQL, MySQL, and other relational databases. Learn more

? Steps to Set Up and Run a Project

1. Clone Repository

First of all, clone this template repository to your local machine:

git clone https://gitlab.com/dioarafi1/graphify-api.git
cd graphify-api

If you are starting from scratch, initialize a new project with:

mkdir blog-api
cd blog-api
npm init -y

2. Installing Dependencies

After cloning the repository or creating a new project, run the command to install the required dependencies:

yarn install

This will install all dependencies listed in the package.json file.

3. Environment Configuration

Create an .env file in the project root directory and add the following configurations for Redis, JWT, and Database:

DATABASE_URL="postgresql://user:password@localhost:5432/mydatabase"
JWT_SECRET="your_jwt_secret_key"
REDIS_HOST="localhost"
REDIS_PORT="6379"

Change user, password, and mydatabase according to your database configuration.

4. Preparing the Database with Sequelize

If you don't have a database configured, run the command to initialize Sequelize and create the model:

yarn sequelize init

This will create a config, models, and migrations directory structure within your project. Next, create the necessary models for the application such as User and Post, and perform migrations to create tables in the database.

yarn sequelize db:migrate

Make sure the database is running (for example using PostgreSQL or MySQL).

5. Setting Up GraphQL Server

Install dependencies for Apollo Server and GraphQL:

yarn add apollo-server graphql

After that, create a GraphQL server configuration file, schema, and resolvers. You can configure the GraphQL server in the following way:

src/server.ts

import { ApolloServer } from 'apollo-server-express';
import express from 'express';
import { typeDefs, resolvers } from './graphql';
import { authenticateJWT } from './middlewares/auth';
import { sequelize } from './config/database';

const app = express();

// Gunakan middleware JWT
app.use(authenticateJWT);

// Inisialisasi Apollo Server
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({ user: req.user }),
});

server.applyMiddleware({ app });

const PORT = process.env.PORT || 4000;

app.listen(PORT, async () => {
  console.log(`Server running at http://localhost:${PORT}${server.graphqlPath}`);
  await sequelize.authenticate();
  console.log('Database connected');
});

src/graphql/schema.ts

Define GraphQL schema for queries and mutations:

import { gql } from 'apollo-server-express';

export const typeDefs = gql`
  type User {
    id: ID!
    username: String!
  }

  type Post {
    id: ID!
    title: String!
    content: String!
    user: User!
  }

  type Query {
    posts: [Post]
    post(id: ID!): Post
    users: [User]
  }

  type Mutation {
    createPost(title: String!, content: String!): Post
    register(username: String!, password: String!): User
    login(username: String!, password: String!): String # JWT token
  }
`;

src/graphql/resolvers.ts

Implement resolvers for queries and mutations:

import { Post, User } from '../models';
import jwt from 'jsonwebtoken';
import bcrypt from 'bcryptjs';

export const resolvers = {
  Query: {
    posts: () => Post.findAll(),
    post: (_, { id }) => Post.findByPk(id),
    users: () => User.findAll(),
  },
  Mutation: {
    createPost: async (_, { title, content }, { user }) => {
      if (!user) throw new Error('Authentication required');
      const post = await Post.create({ title, content, userId: user.id });
      return post;
    },
    register: async (_, { username, password }) => {
      const hashedPassword = await bcrypt.hash(password, 10);
      const user = await User.create({ username, password: hashedPassword });
      return user;
    },
    login: async (_, { username, password }) => {
      const user = await User.findOne({ where: { username } });
      if (!user) throw new Error('User not found');

      const match = await bcrypt.compare(password, user.password);
      if (!match) throw new Error('Invalid password');

      const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET!, { expiresIn: '1h' });
      return token;
    },
  },
};

6. Running Server for Development

To run the server in a development environment with hot-reload, use the following command:

yarn dev

The server will run at http://localhost:4000, and you can access GraphQL Playground to test API queries and mutations.

? Project Directory Structure

This project directory structure is designed to separate different parts of the application to make it more modular and easy to maintain:

/myapp
├── src
│   ├── middlewares      # Berisi middleware untuk otentikasi (JWT), caching (Redis), dan validasi
│   ├── routes           # Definisi endpoint API dan resolver GraphQL
│   ├── services         # Logika bisnis utama dan pengolahan data
│   ├── app.ts           # File utama untuk inisialisasi aplikasi dan middleware
│   ├── graphql          # Menyimpan konfigurasi GraphQL, schema, dan resolvers
│   ├── models           # Model Sequelize untuk mengelola database relasional
│   ├── config           # File konfigurasi global untuk Redis, JWT, database, dll
│   ├── index.ts         # Entry point aplikasi, menginisialisasi server dan middleware
│   ├── resolvers        # Berisi resolver GraphQL untuk query dan mutasi
│   ├── server.ts        # File untuk setup Apollo Server dan konfigurasi GraphQL
│   ├── schema           # Definisi schema GraphQL
│   ├── types            # TypeScript types dan interfaces untuk GraphQL dan lainnya
│   └── utils            # Berisi helper dan fungsi utility
├──

 .env                 # File konfigurasi environment (Redis, JWT Secret, Database URL)
├── package.json         # Metadata proyek dan dependensi
└── tsconfig.json        # Konfigurasi TypeScript

? Deployments

To prepare the project for production, use the following command to build TypeScript into JavaScript:

yarn build

The output will be in the dist/ folder and ready to be deployed to the production server.

Preparing for Cloud Platforms

This project can be deployed to platforms such as Heroku, AWS, or DigitalOcean with the following steps:

1. Push Code to Git Repository (GitHub, GitLab, or other).
2. Set Environment Variables on the selected cloud platform (Redis, JWT Secret, URL Database).
3. Deploy the project using commands or integrations from the cloud platform.

? Resource

• GraphQL Documentation
• Redis Documentation
• JWT Documentation
• Sequelize Documentation

By following the steps above, you can now run and develop GraphQL API applications using Redis, JWT, and Sequelize.