Node.js Starter Project avec GraphQL, Redis, JWT et Sequelize

Ce modèle fournit un Projet de démarrage Node.js préconfiguré avec GraphQL pour l'API, Redis pour la mise en cache et les tâches temporaires. stockage de données, JWT pour l'authentification et l'autorisation, ainsi que Sequelize pour les ORM connectés à des bases de données relationnelles telles 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 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 : Plateforme 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 machine locale :

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

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

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

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 :

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

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 Database :

yarn install

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éparer la base de données avec Sequelize

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

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

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 à l'application tels que User et Post, et effectuez des migrations pour créer des tables dans la base de données.

yarn sequelize init

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 sequelize db:migrate

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

yarn add apollo-server graphql

src/graphql/schema.ts

Définir le schéma GraphQL pour les requêtes et les mutations :

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/resolvers.ts

Implémenter des résolveurs 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
  }
`;

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 :

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;
    },
  },
};

Le serveur fonctionnera sur http://localhost:4000 et vous pourrez accéder au 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 :

yarn dev

? Déploiements

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

/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

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 plateformes telles que Heroku, AWS ou DigitalOcean en suivant les étapes suivantes :

1. Pousser le code vers le référentiel Git (GitHub, GitLab ou autres).
2. Définissez 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 depuis la plateforme cloud.

? Ressource

• Documentation GraphQL
• Documentation Redis
• Documentation JWT
• Séqueliser 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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!