Ce modèle fournit un Projet de démarrage Node.js qui a été configuré avec GraphQL pour l'API, Redis pour mise en cache et stockage temporaire des données, JWT pour l'authentification et l'autorisation, et Sequelize pour ORM qui se connecte à une base de données relationnelle telle que PostgreSQL ou MySQL. Le projet a une structure modulaire qui vous permet de développer instantanément des applications Web modernes avec des fonctionnalités intégrées et évolutives.

? Aperçu du projet

Ce projet est conçu pour faciliter le développement d'applications backend avec une API GraphQL qui utilise Redis pour la mise en cache des données et JWT pour sécuriser l'API. Sequelize est utilisé comme ORM pour faciliter l'interaction avec les bases de données relationnelles. De plus, il existe un middleware qui facilite la gestion de l'authentification, de la validation et de la journalisation.

Principales fonctionnalités

• API GraphQL pour des requêtes et des mutations de données plus flexibles et plus efficaces
• Authentification JWT pour une authentification sécurisée basée sur un jeton
• Redis pour la mise en cache des données et l'amélioration des performances des applications
• Sequelize ORM pour la gestion de bases de données relationnelles
• Middleware pour une gestion centralisée des autorisations et des demandes
• Modulaire et bien structuré pour une évolutivité et une maintenance plus facile

?️ Technologie utilisée

• Node.js : plate-forme de création d'applications côté serveur avec JavaScript. Apprendre encore plus
• GraphQL : langage de requête pour les API qui permet une récupération de données efficace et flexible. Apprendre encore plus
• Redis : stockage de données temporaire (en mémoire) qui est souvent utilisé pour la mise en cache et le courtage de messages. Apprendre encore plus
• JWT : technologie d'authentification sécurisée et simple basée sur des jetons. Apprendre encore plus
• Sequelize : ORM pour Node.js qui prend en charge PostgreSQL, MySQL et d'autres bases de données relationnelles. Apprendre encore plus

? Étapes pour configurer et exécuter un projet

1. Dépôt de clones

Tout d'abord, clonez ce référentiel de modèles sur votre ordinateur local :

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

Si vous partez de zéro, initialisez un nouveau projet avec :

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

2. Installation des dépendances

Après avoir cloné le référentiel ou créé un nouveau projet, exécutez la commande pour installer les dépendances requises :

yarn install

Cela installera toutes les dépendances répertoriées dans le fichier package.json.

3. Configuration de l'environnement

Créez un fichier .env dans le répertoire racine du projet et ajoutez les configurations suivantes pour Redis, JWT et Base de données :

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

Modifiez l'utilisateur, le mot de passe et ma base de données en fonction de la configuration de votre base de données.

4. Préparation de la base de données avec Sequelize

Si aucune base de données n'est configurée, exécutez la commande pour initialiser Sequelize et créer le modèle :

yarn sequelize init

Cela créera une structure de répertoires de configuration, de modèles et de migrations au sein de votre projet. Ensuite, créez les modèles nécessaires pour l'application tels que User et Post, et effectuez des migrations pour créer des tables dans la base de données.

yarn sequelize db:migrate

Assurez-vous que la base de données est en cours d'exécution (par exemple en utilisant PostgreSQL ou MySQL).

5. Configuration du serveur GraphQL

Installer les dépendances pour Apollo Server et GraphQL :

yarn add apollo-server graphql

Après cela, créez un fichier de configuration, un schéma et des résolveurs de serveur GraphQL. Vous pouvez configurer le serveur GraphQL de la manière suivante :

src/serveur.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

Définir le schéma GraphQL pour les requêtes et les 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

Implémenter des résolveurs pour les requêtes et les 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. Exécution du serveur pour le développement

Pour exécuter le serveur dans un environnement de développement avec hot-reload, utilisez la commande suivante :

yarn dev

Le serveur s'exécutera sur http://localhost:4000 et vous pourrez accéder à GraphQL Playground pour tester les requêtes et les mutations de l'API.

? Structure du répertoire du projet

Cette structure de répertoires de projet est conçue pour séparer les différentes parties de l'application afin de la rendre plus modulaire et plus facile à maintenir :

/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

? Déploiements

Pour préparer le projet pour la production, utilisez la commande suivante pour créer TypeScript en JavaScript :

yarn build

La sortie sera dans le dossier dist/ et prête à être déployée sur le serveur de production.

Préparation aux plateformes cloud

Ce projet peut être déployé sur des plates-formes telles que Heroku, AWS ou DigitalOcean en suivant les étapes suivantes :

1. Pousser le code vers le référentiel Git (GitHub, GitLab ou autre).
2. Définir les variables d'environnement sur la plate-forme cloud sélectionnée (Redis, JWT Secret, URL Database).
3. Déployez le projet à l'aide de commandes ou d'intégrations à partir de la plateforme cloud.

? Ressource

• Documentation GraphQL
• Documentation Redis
• Documentation JWT
• Séquelle la documentation

En suivant les étapes ci-dessus, vous pouvez désormais exécuter et développer des applications API GraphQL à l'aide de Redis, JWT et Sequelize.