Diese Vorlage stellt ein Node.js-Starterprojekt bereit, das mit GraphQL für die API, Redis für konfiguriert wurde Caching und temporäre Datenspeicherung, JWT für Authentifizierung und Autorisierung und Sequelize für ORM die eine Verbindung zu einer relationalen Datenbank wie PostgreSQL oder MySQL herstellt. Das Projekt ist modular aufgebaut und ermöglicht Ihnen die sofortige Entwicklung moderner Webanwendungen mit integrierten und skalierbaren Funktionen.

? Projektübersicht

Dieses Projekt soll die Entwicklung von Backend-Anwendungen mit einer GraphQL-API erleichtern, die Redis für das Daten-Caching und JWT für die Sicherung 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 Datenmutationen
• 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 strukturiert fü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 (im Arbeitsspeicher), der häufig für Caching und 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 ein neues Projekt mit:

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

2. Abhängigkeiten installieren

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

yarn install

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:

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

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

yarn sequelize init

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 Post, und führen Sie Migrationen durch, um Tabellen in der Datenbank zu erstellen.

yarn sequelize db:migrate

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 add apollo-server graphql

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

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

GraphQL-Schema für Abfragen und Mutationen definieren:

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

Resolver für Abfragen und Mutationen implementieren:

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

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

yarn dev

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 verschiedene Teile der Anwendung trennen, um sie modularer und einfacher zu warten:

/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

? Bereitstellungen

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

yarn build

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 in das Git-Repository übertragen (GitHub, GitLab oder andere).
2. Umgebungsvariablen festlegen auf der ausgewählten Cloud-Plattform (Redis, JWT Secret, URL-Datenbank).
3. Stellen Sie das Projekt bereit mit Befehlen oder Integrationen von der Cloud-Plattform.

? Ressource

• GraphQL-Dokumentation
• Redis-Dokumentation
• JWT-Dokumentation
• Fortsetzung der 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.