Este modelo fornece um Node.js Starter Project que foi configurado com GraphQL para API, Redis para cache e armazenamento temporário de dados, JWT para autenticação e autorização e Sequelize para ORM que se conecta a um banco de dados relacional como PostgreSQL ou MySQL. O projeto possui uma estrutura modular que permite desenvolver instantaneamente aplicações web modernas com recursos integrados e escaláveis.

? Visão geral do projeto

Este projeto foi projetado para facilitar o desenvolvimento de aplicativos de back-end com uma API GraphQL que usa Redis para armazenamento em cache de dados e JWT para proteger a API. Sequelize é usado como um ORM para facilitar a interação com bancos de dados relacionais. Além disso, existe um middleware que facilita o gerenciamento de autenticação, validação e registro.

Principais recursos

• API GraphQL para consulta e mutação de dados mais flexíveis e eficientes
• Autenticação JWT para autenticação segura baseada em token
• Redis para armazenamento em cache de dados e melhoria do desempenho de aplicativos
• Sequelize ORM para gerenciamento de banco de dados relacional
• Middleware para autorização centralizada e tratamento de solicitações
• Modular e bem estruturado para escalabilidade e manutenção mais fácil

?️ Tecnologia usada

• Node.js: Plataforma para construção de aplicações server-side com JavaScript. Saber mais
• GraphQL: linguagem de consulta para APIs que permite recuperação de dados eficiente e flexível. Saber mais
• Redis: armazenamento temporário de dados (na memória), que é frequentemente usado para armazenamento em cache e corretagem de mensagens. Saber mais
• JWT: tecnologia de autenticação segura e simples baseada em token. Saber mais
• Sequelize: ORM para Node.js que suporta PostgreSQL, MySQL e outros bancos de dados relacionais. Saber mais

? Etapas para configurar e executar um projeto

1. Clone Repositório

Primeiro de tudo, clone este repositório de modelos em sua máquina local:

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

Se você está começando do zero, inicialize um novo projeto com:

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

2. Instalando Dependências

Após clonar o repositório ou criar um novo projeto, execute o comando para instalar as dependências necessárias:

yarn install

Isso instalará todas as dependências listadas no arquivo package.json.

3. Configuração do ambiente

Crie um arquivo .env no diretório raiz do projeto e adicione as seguintes configurações para Redis, JWT e Database:

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

Altere usuário, senha e meu banco de dados de acordo com a configuração do seu banco de dados.

4. Preparando o banco de dados com Sequelize

Se você não possui um banco de dados configurado, execute o comando para inicializar o Sequelize e criar o modelo:

yarn sequelize init

Isso criará uma estrutura de diretórios de configuração, modelos e migrações em seu projeto. Em seguida, crie os modelos necessários para a aplicação como User e Post, e realize migrações para criação de tabelas no banco de dados.

yarn sequelize db:migrate

Certifique-se de que o banco de dados esteja em execução (por exemplo, usando PostgreSQL ou MySQL).

5. Configurando o servidor GraphQL

Instalar dependências para Apollo Server e GraphQL:

yarn add apollo-server graphql

Depois disso, crie um arquivo de configuração, esquema e resolvedores do servidor GraphQL. Você pode configurar o servidor GraphQL da seguinte maneira:

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

Defina o esquema GraphQL para consultas e mutações:

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

Implementar resolvedores para consultas e mutações:

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. Executando Servidor para Desenvolvimento

Para executar o servidor em um ambiente de desenvolvimento com hot-reload, use o seguinte comando:

yarn dev

O servidor será executado em http://localhost:4000, e você pode acessar o GraphQL Playground para testar consultas e mutações da API.

? Estrutura de diretório do projeto

Esta estrutura de diretório do projeto foi projetada para separar diferentes partes do aplicativo para torná-lo mais modular e fácil de manter:

/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

? Implantações

Para preparar o projeto para produção, use o seguinte comando para construir TypeScript em JavaScript:

yarn build

A saída estará na pasta dist/ e pronta para ser implantada no servidor de produção.

Preparando-se para plataformas em nuvem

Este projeto pode ser implantado em plataformas como Heroku, AWS ou DigitalOcean com as seguintes etapas:

1. Enviar código para o repositório Git (GitHub, GitLab ou outro).
2. Definir variáveis ​​de ambiente na plataforma de nuvem selecionada (Redis, JWT Secret, banco de dados de URL).
3. Implante o projeto usando comandos ou integrações da plataforma em nuvem.

? Recurso

• Documentação do GraphQL
• Documentação do Redis
• Documentação JWT
• Documentação de sequenciação

Seguindo as etapas acima, agora você pode executar e desenvolver aplicativos GraphQL API usando Redis, JWT e Sequelize.