So erstellen Sie blitzschnelle REST-APIs mit Node.js, MongoDB, Fastify und Swagger

Eine Schritt-für-Schritt-Anleitung

Bildnachweis: Entworfen von Dooder

Vermutlich kennt kein Webentwickler die REST-APIs und die Herausforderungen, die die Entwicklung einer effektiven und effizienten API-Lösung mit sich bringt, so gut wie gar nicht.

Diese Herausforderungen umfassen:

  • Geschwindigkeit. (API-Antwortzeiten.)
  • Dokumentation. (Klare, präzise Dokumente, die die API beschreiben.)
  • Architektur und Nachhaltigkeit. (Wartbare und erweiterbare Codebasis.)

In diesem Tutorial werden wir alle oben genannten Probleme mit einer Kombination aus Node.js, MongoDB, Fastify und Swagger lösen.

Der Quellcode für das Projekt ist auf GitHub verfügbar.

Bevor wir anfangen

Sie sollten über Anfänger- bis Fortgeschrittenenkenntnisse in JavaScript verfügen, von Node.js und MongoDB gehört haben und wissen, was REST-APIs sind.

Nachfolgend finden Sie einige Links, um Sie auf den neuesten Stand zu bringen:

  • JavaScript
  • Node.js
  • MongoDB
  • REST-APIs

Die Technologie, die wir verwenden werden

  • Fasten
  • Mungo
  • Stolzieren

Es ist eine gute Idee, die oben genannten Seiten in neuen Registerkarten zu öffnen, um eine einfache Referenz zu ermöglichen.

Sie müssen Folgendes installiert haben

  • Node.js / npm
  • MongoDB
  • Postbote

Sie benötigen außerdem eine IDE und ein Terminal. Ich verwende iTerm2 für Mac und Hyper für Windows.

Lass uns anfangen

Initialisieren Sie ein neues Projekt, indem Sie Ihr Terminal öffnen und die folgenden Codezeilen ausführen:

mkdir fastify-api
cd fastify-api
mkdir src
cd src
Berühren Sie index.js
npm init

Im obigen Code haben wir zwei neue Verzeichnisse erstellt, in diese navigiert, eine index.js-Datei erstellt und unser Projekt über npm initialisiert.

Bei der Initialisierung eines neuen Projekts werden Sie aufgefordert, mehrere Werte einzugeben. Diese können Sie leer lassen und zu einem späteren Zeitpunkt aktualisieren.

Nach Abschluss wird eine package.json-Datei im Verzeichnis src generiert. In dieser Datei können Sie die Werte ändern, die bei der Initialisierung des Projekts eingegeben wurden.

Als Nächstes installieren wir alle Abhängigkeiten, die wir benötigen:

npm i nodemon mongoose fastify-swagger boom

Nachfolgend finden Sie eine kurze Beschreibung der einzelnen Pakete auf den jeweiligen Websites:

Nodemon

nodemon ist ein Tool, mit dem Sie Node.js-basierte Anwendungen entwickeln können, indem Sie die Knotenanwendung automatisch neu starten, wenn Dateiänderungen im Verzeichnis erkannt werden.
nodemon erfordert keine zusätzlichen Änderungen an Ihrem Code oder Ihrer Entwicklungsmethode. nodemon ist ein Ersatz-Wrapper für node, mit dem Sie bei der Ausführung Ihres Skripts das Wort node in der Befehlszeile durch nodemon ersetzen können.

Um nodemon einzurichten, müssen wir unserer package.json-Datei im scripts-Objekt die folgende Codezeile hinzufügen:

"Start": "./node_modules/nodemon/bin/nodemon.js ./src/index.js",

Unsere package.json-Datei sollte nun wie folgt aussehen:

Mungo

Mongoose bietet eine einfache, schemabasierte Lösung zur Modellierung Ihrer Anwendungsdaten. Eingebautes Typ-Casting, Validierung, Abfrageerstellung, Business Logic Hooks und vieles mehr sind bereits im Lieferumfang enthalten.

Fasten

Fastify ist ein Webframework, das sich stark darauf konzentriert, das beste Entwicklererlebnis mit dem geringsten Overhead und einer leistungsstarken Plug-in-Architektur zu bieten. Es ist von Hapi und Express inspiriert und unseres Wissens eines der schnellsten Web-Frameworks der Stadt.

fastify-swagger

Swagger-Dokumentationsgenerator für Fastify. Es verwendet die in Ihren Routen deklarierten Schemata, um ein mit Swagger kompatibles Dokument zu generieren.

Boom

boom bietet eine Reihe von Dienstprogrammen zur Rückgabe von HTTP-Fehlern.

Richten Sie den Server ein und erstellen Sie die erste Route

Fügen Sie Ihrer index.js-Datei den folgenden Code hinzu:

Wir benötigen das Fastify-Framework, deklarieren unsere erste Route und initialisieren den Server auf Port 3000. Der Code ist recht selbsterklärend. Beachten Sie jedoch das Optionsobjekt, das bei der Initialisierung von Fastify übergeben wurde:

// Benötige das fastify Framework und instanziiere es
const fastify = erfordern ('fastify') ({
  Logger: wahr
})

Mit dem obigen Code wird der integrierte Logger von Fastify aktiviert, der standardmäßig deaktiviert ist.

Sie können jetzt den folgenden Code in Ihrem src-Verzeichnis in Ihrem Terminal ausführen:

npm start

Wenn Sie nun zu http: // localhost: 3000 / navigieren, sollte das Objekt {hello: world} zurückgegeben werden.

Wir kehren zur Datei index.js zurück, fahren jedoch vorerst mit der Einrichtung unserer Datenbank fort.

Starten Sie MongoDB und erstellen Sie das Modell

Sobald MongoDB erfolgreich installiert wurde, können Sie ein neues Terminalfenster öffnen und eine MongoDB-Instanz starten, indem Sie Folgendes ausführen:

Mongod

Mit MongoDB müssen wir keine Datenbank erstellen. Wir können nur einen Namen im Setup angeben und sobald wir Daten speichern, wird MongoDB diese Datenbank für uns erstellen.

Fügen Sie Ihrer index.js-Datei Folgendes hinzu:

...
// Benötige externe Module
const mongoose = require ('mongoose')
// Mit DB verbinden
mongoose.connect (‘mongodb: // localhost / mycargarage’)
 .then (() => console.log (‘MongoDB connected…’))
 .catch (err => console.log (err))
...

Im obigen Code benötigen wir Mongoose und stellen eine Verbindung zu unserer MongoDB-Datenbank her. Die Datenbank heißt mycargarage und wenn alles geklappt hat, sehen Sie jetzt, dass MongoDB verbunden ist ... in Ihrem Terminal.

Beachten Sie, dass Sie die App dank des zuvor hinzugefügten Nodemon-Pakets nicht neu starten mussten.

Jetzt, da unsere Datenbank läuft, können wir unser erstes Modell erstellen. Erstellen Sie im Verzeichnis src einen neuen Ordner mit dem Namen models, und erstellen Sie darin eine neue Datei mit dem Namen Car.js, und fügen Sie den folgenden Code hinzu:

Der obige Code deklariert unser carSchema, das alle Informationen zu unseren Autos enthält. Abgesehen von den zwei offensichtlichen Datentypen: String und Number.

Wir verwenden auch eine Karte, die für Mongoose relativ neu ist und über die Sie hier mehr lesen können. Wir exportieren dann unser carSchema, um es in unserer App zu verwenden.

Wir könnten mit dem Einrichten unserer Routen, Controller und Konfiguration in der Datei index.js fortfahren, aber ein Teil dieses Tutorials demonstriert eine nachhaltige Codebasis. Daher hat jede Komponente einen eigenen Ordner.

Erstellen Sie den Car Controller

Um mit dem Erstellen der Controller zu beginnen, erstellen wir einen Ordner im Verzeichnis src mit dem Namen controller. Innerhalb des Ordners erstellen wir eine Datei carController.js:

Das oben Genannte scheint ein bisschen zu viel zu sein, aber es ist eigentlich ganz einfach.

  • Wir benötigen boom, um unsere Fehler zu behandeln: boom.boomify (err).
  • Wir exportieren jede unserer Funktionen, die wir auf unserer Route verwenden werden.
  • Jede Funktion ist eine asynchrone Funktion, die einen wait-Ausdruck enthalten kann, der die Ausführung der asynchronen Funktion anhält, auf die Auflösung des übergebenen Versprechens wartet und dann die Ausführung der asynchronen Funktion fortsetzt und den aufgelösten Wert zurückgibt. Erfahren Sie hier mehr.
  • Jede Funktion ist in eine try / catch-Anweisung eingeschlossen. Erfahren Sie hier mehr.
  • Jede Funktion benötigt zwei Parameter: req (die Anfrage) und reply (die Antwort). In unserem Tutorial verwenden wir nur den Request-Parameter. Wir werden es verwenden, um auf den Anfragetext und die Anfrageparameter zuzugreifen und die Daten zu verarbeiten. Erfahren Sie hier mehr.
  • Beachten Sie den Code in Zeile 31:
    const car = new Car ({… req.body})
    Dies nutzt den JavaScript-Spread-Operator. Erfahren Sie hier mehr.
  • Beachten Sie den Code in Zeile 42:
    const {… updateData} = car
    Dies nutzt die JavaScript-Destrukturierung in Verbindung mit dem Spread-Operator. Erfahren Sie hier mehr.

Ansonsten nutzen wir einige Standardfunktionen von Mongoose, um unsere Datenbank zu manipulieren.

Sie brennen wahrscheinlich, um Ihre API zu starten und eine Überprüfung der Integrität durchzuführen, aber bevor wir dies tun, müssen wir nur den Controller mit den Routen verbinden und dann die Routen mit der App verbinden.

Erstellen und importieren Sie die Routen

Wir können wieder damit beginnen, einen Ordner im Stammverzeichnis unseres Projekts zu erstellen, diesmal heißt er jedoch Routen. Innerhalb des Ordners erstellen wir eine index.js-Datei mit dem folgenden Code:

Hier benötigen wir unseren Controller und ordnen jede der Funktionen, die wir in unserem Controller erstellt haben, unseren Routen zu.

Wie Sie sehen, besteht jede Route aus einer Methode, einer URL und einem Handler, die der App mitteilen, welche Funktion verwendet werden soll, wenn auf eine der Routen zugegriffen wird.

Die ID, die einigen Routen folgt, ist eine übliche Methode, um Parameter an die Routen zu übergeben. Auf diese Weise können wir wie folgt auf die ID zugreifen:

http://127.0.0.1:3000/api/cars/5bfe30b46fe410e1cfff2323

Alles zusammen und Testen der API

Nachdem wir die meisten unserer Teile konstruiert haben, müssen wir sie nur noch miteinander verbinden, um Daten über unsere API bereitzustellen.

Zuerst müssen wir die Routen importieren, die wir erstellt haben, indem wir die folgende Codezeile zu unserer Hauptdatei index.js hinzufügen:

const routes = require (‘./ routes’)

Wir müssen dann unser Routenarray durchlaufen, um sie mit Fastify zu initialisieren. Wir können dies mit dem folgenden Code tun, der ebenfalls zur Hauptdatei index.js hinzugefügt werden muss:

routes.forEach ((route, index) => {
 fastify.route (route)
})

Jetzt können wir mit dem Testen beginnen!

Das beste Werkzeug für diesen Job ist Postman, mit dem wir alle unsere Routen testen werden. Wir werden unsere Daten als Rohobjekte im Hauptteil der Anfrage und als Parameter senden.

Alle Autos finden:

Ein einzelnes Auto finden:

Hinzufügen eines neuen Autos **:

** Die Dienste scheinen leer zu sein, die Informationen bleiben jedoch in der Datenbank erhalten.

Auto aktualisieren:

Ein Auto löschen:

Wir haben jetzt eine voll funktionsfähige API - aber was ist mit der Dokumentation? Hier ist Swagger wirklich praktisch.

Swagger hinzufügen und einpacken

Nun erstellen wir unseren letzten Ordner namens config. Im Inneren erstellen wir eine Datei namens swagger.js mit dem folgenden Code:

Der obige Code ist ein Objekt mit den Optionen, die wir in unser fastify-swagger-Plugin übergeben werden. Dazu müssen wir unserer Datei index.js Folgendes hinzufügen:

// Swagger-Optionen importieren
const swagger = require ("./ config / swagger")
// Swagger registrieren
fastify.register (erforderlich ('fastify-swagger'), swagger.options)

Und dann müssen wir die folgende Zeile hinzufügen, nachdem wir unseren Fastify-Server initialisiert haben:

...
warte fastify.listen (3000)
fastify.swagger ()
fastify.log.info (`lauscht auf $ {fastify.server.address (). port}`)
...

Und das ist alles! Wenn Sie jetzt zu http: // localhost: 3000 / documentation navigieren, sollten Sie Folgendes sehen:

So einfach ist das! Sie verfügen jetzt über eine selbstaktualisierende API-Dokumentation, die sich mit Ihrer API weiterentwickelt. Sie können Ihren Routen problemlos zusätzliche Informationen hinzufügen. Weitere Informationen finden Sie hier.

Was kommt als nächstes

Jetzt, da wir eine grundlegende API haben, sind die Möglichkeiten grenzenlos. Es kann als Basis für jede erdenkliche App verwendet werden.

Im nächsten Tutorial werden wir GraphQL integrieren und schließlich auch das Front-End mit Vue.js integrieren!