Node.js Starter-Projekt mit GraphQL, Redis, JWT und Sequelize

Diese Vorlage stellt ein Node.js-Starterprojekt vorkonfiguriert mit GraphQL für API, Redis für Caching und temporär zur Verfügung Datenspeicherung, JWT für Authentifizierung und Autorisierung und Sequelize für ORMs, die mit relationalen Datenbanken wie PostgreSQL oder MySQL verbunden sind. Das Projekt verfügt über eine modulare Struktur, die es Ihnen ermöglicht, sofort moderne Webanwendungen mit integrierten und skalierbaren Funktionen zu entwickeln.

? Projektübersicht

Dieses Projekt soll die Entwicklung von Backend-Anwendungen mit einer GraphQL-API erleichtern, die Redis für das Daten-Caching und JWT zum Sichern der API verwendet. Sequelize wird als ORM verwendet, um die Interaktion mit relationalen Datenbanken zu erleichtern. Darüber hinaus gibt es Middleware, die die Handhabung von Authentifizierung, Validierung und Protokollierung erleichtert.

Hauptmerkmale

• GraphQL-API für flexiblere und effizientere Abfragen und Datenmutation
• JWT-Authentifizierung für sichere tokenbasierte Authentifizierung
• Redis für Daten-Caching und Verbesserung der Anwendungsleistung
• Fortsetzung von ORM für die relationale Datenbankverwaltung
• Middleware für die zentrale Autorisierung und Anfragebearbeitung
• Modular und gut strukturiertfür Skalierbarkeit und einfachere Wartung

---

?️ Verwendete Technologie

• Node.js: Plattform zum Erstellen serverseitiger Anwendungen mit JavaScript. Erfahren Sie mehr
• GraphQL: Abfragesprache für APIs, die einen effizienten und flexiblen Datenabruf ermöglicht. Erfahren Sie mehr
• Redis: Temporärer Datenspeicher (In-Memory), der häufig zum Caching und zur Nachrichtenvermittlung verwendet wird. Erfahren Sie mehr
• JWT: Sichere und einfache tokenbasierte Authentifizierungstechnologie. Erfahren Sie mehr
• Sequelize: ORM für Node.js, das PostgreSQL, MySQL und andere relationale Datenbanken unterstützt. Erfahren Sie mehr

---

? Schritte zum Einrichten und Ausführen eines Projekts

1. Repository klonen

Klonen Sie zunächst dieses Vorlagen-Repository auf Ihren lokalen Computer:

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

Wenn Sie bei Null anfangen, initialisieren Sie das neue Projekt mit:

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

2. Installation von Abhängigkeiten

Nachdem Sie das Repository geklont oder ein neues Projekt erstellt haben, führen Sie den Befehl aus, um die erforderlichen Abhängigkeiten zu installieren:

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

Dadurch werden alle in der Datei package.json aufgeführten Abhängigkeiten installiert.

---

3. Umgebungskonfiguration

Erstellen Sie eine .env-Datei im Projektstammverzeichnis und fügen Sie die folgenden Konfigurationen für Redis, JWT und Datenbank hinzu:

yarn install

Ändern Sie Benutzer, Passwort und mydatabase entsprechend Ihrer Datenbankkonfiguration.

---

4. Vorbereiten der Datenbank mit Sequelize

Wenn Sie keine Datenbank konfiguriert haben, führen Sie den Befehl aus, um Sequelize zu initialisieren und das Modell zu erstellen:

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

Dadurch wird eine Verzeichnisstruktur für Konfigurationen, Modelle und Migrationen in Ihrem Projekt erstellt. Erstellen Sie als Nächstes die erforderlichen Modelle für die Anwendung, z. B. Benutzer und Beitrag, und führen Sie Migrationen durch, um Tabellen in der Datenbank zu erstellen.

yarn sequelize init

Stellen Sie sicher, dass die Datenbank ausgeführt wird (z. B. mit PostgreSQL oder MySQL).

---

5. Einrichten des GraphQL-Servers

Abhängigkeiten für Apollo Server und GraphQL installieren:

yarn sequelize db:migrate

Erstellen Sie anschließend eine GraphQL-Serverkonfigurationsdatei, ein Schema und Resolver. Sie können den GraphQL-Server folgendermaßen konfigurieren:

src/server.ts

yarn add apollo-server graphql

src/graphql/schema.ts

GraphQL-Schema für Abfragen und Mutationen definieren:

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

Resolver für Abfragen und Mutationen implementieren:

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. Server für Entwicklung ausführen

Um den Server in einer Entwicklungsumgebung mit Hot-Reload auszuführen, verwenden Sie den folgenden Befehl:

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

Der Server läuft unter http://localhost:4000 und Sie können auf den GraphQL Playground zugreifen, um API-Abfragen und Mutationen zu testen.

---

? Struktur des Projektverzeichnisses

Diese Projektverzeichnisstruktur soll die verschiedenen Teile der Anwendung trennen, um sie modularer und einfacher zu warten:

yarn dev

---

? Bereitstellungen

Um das Projekt für die Produktion vorzubereiten, verwenden Sie den folgenden Befehl, um TypeScript in JavaScript zu integrieren:

/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

Die Ausgabe befindet sich im Ordner dist/ und kann auf dem Produktionsserver bereitgestellt werden.

Vorbereitung auf Cloud-Plattformen

Dieses Projekt kann mit den folgenden Schritten auf Plattformen wie Heroku, AWS oder DigitalOcean bereitgestellt werden:

1. Code an Git-Repository senden (GitHub, GitLab oder andere).
2. Umgebungsvariablen festlegen auf der ausgewählten Cloud-Plattform (Redis, JWT Secret, URL-Datenbank).
3. Stellen Sie das Projekt bereit mithilfe von Befehlen oder Integrationen von der Cloud-Plattform.

---

? Ressource

• GraphQL-Dokumentation
• Redis-Dokumentation
• JWT-Dokumentation
• Sequelize-Dokumentation

---

Indem Sie die oben genannten Schritte ausführen, können Sie jetzt GraphQL-API-Anwendungen mit Redis, JWT und Sequelize ausführen und entwickeln.

Das obige ist der detaillierte Inhalt vonNode.js Starter-Projekt mit GraphQL, Redis, JWT und Sequelize. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!