Esta plantilla proporciona un Proyecto inicial de Node.js que se ha configurado con GraphQL para API, Redis para almacenamiento en caché y almacenamiento temporal de datos, JWT para autenticación y autorización, y Sequelize para ORM que se conecta a una base de datos relacional como PostgreSQL o MySQL. El proyecto tiene una estructura modular que le permite desarrollar instantáneamente aplicaciones web modernas con características integradas y escalables.

? Descripción general del proyecto

Este proyecto está diseñado para facilitar el desarrollo de aplicaciones backend con una API GraphQL que utiliza Redis para el almacenamiento en caché de datos y JWT para proteger la API. Sequelize se utiliza como ORM para facilitar la interacción con bases de datos relacionales. Además, existe middleware que facilita el manejo de la autenticación, la validación y el registro.

Características clave

• API GraphQL para consultas y mutación de datos más flexibles y eficientes
• Autenticación JWT para autenticación segura basada en tokens
• Redis para almacenamiento en caché de datos y mejora del rendimiento de las aplicaciones
• Sequelize ORM para gestión de bases de datos relacionales
• Middleware para autorización centralizada y manejo de solicitudes
• Modular y bien estructurado para escalabilidad y mantenimiento más sencillo

?️ Tecnología utilizada

• Node.js: Plataforma para crear aplicaciones del lado del servidor con JavaScript. Más información
• GraphQL: lenguaje de consulta para API que permite una recuperación de datos eficiente y flexible. Más información
• Redis: almacenamiento de datos temporal (en memoria) que a menudo se utiliza para almacenamiento en caché y intermediación de mensajes. Más información
• JWT: Tecnología de autenticación basada en tokens segura y sencilla. Más información
• Sequelize: ORM para Node.js que admite PostgreSQL, MySQL y otras bases de datos relacionales. Más información

? Pasos para configurar y ejecutar un proyecto

1. Repositorio de clones

En primer lugar, clona este repositorio de plantillas en tu máquina local:

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

Si estás empezando desde cero, inicializa un nuevo proyecto con:

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

2. Instalación de dependencias

Después de clonar el repositorio o crear un nuevo proyecto, ejecute el comando para instalar las dependencias requeridas:

yarn install

Esto instalará todas las dependencias enumeradas en el archivo package.json.

3. Configuración del entorno

Cree un archivo .env en el directorio raíz del proyecto y agregue las siguientes configuraciones para Redis, JWT y Base de datos:

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

Cambie usuario, contraseña y mibase de datos según la configuración de su base de datos.

4. Preparando la base de datos con Sequelize

Si no tiene una base de datos configurada, ejecute el comando para inicializar Sequelize y crear el modelo:

yarn sequelize init

Esto creará una estructura de directorio de configuración, modelos y migraciones dentro de su proyecto. A continuación, cree los modelos necesarios para la aplicación, como Usuario y Publicar, y realice migraciones para crear tablas en la base de datos.

yarn sequelize db:migrate

Asegúrese de que la base de datos esté ejecutándose (por ejemplo, usando PostgreSQL o MySQL).

5. Configurando el servidor GraphQL

Instalar dependencias para Apollo Server y GraphQL:

yarn add apollo-server graphql

Después de eso, cree un archivo de configuración, un esquema y un solucionador del servidor GraphQL. Puede configurar el servidor GraphQL de la siguiente manera:

src/servidor.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 el esquema GraphQL para consultas y mutaciones:

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 solucionadores para consultas y mutaciones:

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. Servidor en ejecución para desarrollo

Para ejecutar el servidor en un entorno de desarrollo con recarga en caliente, use el siguiente comando:

yarn dev

El servidor se ejecutará en http://localhost:4000 y podrás acceder a GraphQL Playground para probar consultas y mutaciones de API.

? Estructura del directorio del proyecto

Esta estructura de directorios del proyecto está diseñada para separar diferentes partes de la aplicación para hacerla más modular y fácil de mantener:

/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

? Implementaciones

Para preparar el proyecto para producción, use el siguiente comando para compilar TypeScript en JavaScript:

yarn build

La salida estará en la carpeta dist/ y lista para ser implementada en el servidor de producción.

Preparándose para las plataformas en la nube

Este proyecto se puede implementar en plataformas como Heroku, AWS o DigitalOcean con los siguientes pasos:

1. Enviar código al repositorio de Git (GitHub, GitLab u otro).
2. Establecer variables de entorno en la plataforma en la nube seleccionada (Redis, JWT Secret, URL Database).
3. Implementar el proyecto usando comandos o integraciones desde la plataforma en la nube.

? Recurso

• Documentación de GraphQL
• Documentación de Redis
• Documentación JWT
• Sequelizar documentación

Si sigue los pasos anteriores, ahora puede ejecutar y desarrollar aplicaciones GraphQL API usando Redis, JWT y Sequelize.