Die Verwaltung einer umfangreichen Anwendung kann mühsam sein, vor allem, wenn sie ohne eine gut geplante Struktur und eine strikte Code-Organisationsstrategie erstellt wird. Das kann bei der Wartung zu einem Desaster führen und sollte um jeden Preis vermieden werden. Dieses Desaster wird durch Änderungen an der Codebasis und neue Funktionen verursacht, wenn das Projekt in der Benutzerbasis wächst.
Nest.js hingegen wurde entwickelt, um Lösungen für die Probleme mit der Code-Struktur und der Code-Organisationsstrategie zu bieten. Es kombiniert moderne und modulare Ansätze mit den Prinzipien der Softwareentwicklung.
Nest.js nutzt TypeScript für die Typüberprüfung und bietet eine sofort einsatzbereite Softwarearchitektur für den Aufbau und die Bereitstellung von testbaren, skalierbaren, lose gekoppelten und leicht wartbaren Anwendungen.
In diesem Artikel lernen wir Nest.js kennen und erfahren, was du damit bauen kannst. Außerdem erklären wir die Vor- und Nachteile des Frameworks, damit du dir ein klares Bild davon machen kannst, warum Unternehmen es anderen Node.js-Frameworks vorziehen. Zum Schluss zeigen wir dir, wie du mit Nest.js eine To-Do-API erstellen kannst.
Was ist Nest.js?
Nest.js ist eines der am schnellsten wachsenden Node.js-Frameworks für den Aufbau effizienter, skalierbarer und unternehmenstauglicher Backend-Anwendungen mit Node.js. Es ist dafür bekannt, dass es mit modernem JavaScript und TypeScript hochgradig testbare, wartbare und skalierbare Anwendungen erstellt.
Mit über 46,6k Sternen und 5,4k Forks auf GitHub und wöchentlich bis zu 700.000 Downloads ist das Framework eine beliebte Anlaufstelle, um dein Backend-Projekt mit Node.js zu entwickeln.
Nest.js ist die perfekte Lösung für dein nächstes Projekt, wenn du eine skalierbare, wartbare Anwendung auf Unternehmensebene erstellen willst.
Im nächsten Abschnitt werden wir uns ansehen, wofür Nest.js verwendet wird und welche Unternehmen das Framework in der Produktion einsetzen.
Wofür wird Nest.js verwendet?
Nest.js ist ein serverseitiges Node.js-Framework, das sich hervorragend für den Aufbau von hochgradig testbaren und wartbaren Backend-Anwendungen eignet. Mit Node.js kannst du zahllose Arten von Anwendungen erstellen; du bist nur durch die Funktionen deiner Anwendungen begrenzt.
Da das Framework auf TypeScript basiert, ist Nest.js besonders bei Teams beliebt, die die Möglichkeiten von TypeScript bei der Typenprüfung nutzen wollen. Nest.js ist einfach zu erlernen und zu beherrschen und verfügt über eine leistungsstarke CLI, die die Produktivität und die Entwicklung erleichtert. Mit dieser leistungsstarken CLI ist es ein Kinderspiel, jedes serverseitige Projekt zu starten und zu Ende zu bringen.
Darüber hinaus verfügt Nest.js über eine ausführliche Dokumentation und eine sehr aktive Gemeinschaft von Entwicklern und Mitwirkenden, die bereit sind, auf Probleme zu reagieren.
Aus diesen Gründen ist es verständlich, warum so viele Unternehmen zu Nest.js wechseln. Im Folgenden findest du eine Liste der bekannten Marken, die das Framework in der Produktion einsetzen.
Roche
Roche ist ein multinationaler Gesundheitskonzern, der in zwei Geschäftsbereichen tätig ist: Pharmazeutika und Diagnostika. Das amerikanische Biotechnologieunternehmen nutzt das Nest.js-Framework auf seiner Hauptwebseite, um seine Patienten zuverlässig zu betreuen und seine Dienstleistungen weiter auszubauen.
Adidas
Adidas ist der größte Sportartikelhersteller in Europa und der zweitgrößte der Welt. Adidas ist bekannt für die Entwicklung und Herstellung von Schuhen, Kleidung und Accessoires. Aufgrund seiner globalen Reichweite und Beliebtheit hat sich das Unternehmen für das hoch skalierbare Nest.js-Framework entschieden, um große, effiziente Anwendungen für seine Marke zu entwickeln.
Decathlon
Decathlon ist ein Sportartikelhändler mit über 1.500 Geschäften in 57 Ländern. Decathlon hat sich für Nest.js als Backend für seine Webanwendung entschieden, um die Skalierbarkeit und Wartung seiner Legacy-Codebasis zu erleichtern.
Eine Liste mit weiteren Unternehmen, Projekten und Tools, die mit Nest.js entwickelt wurden, findest du auf GitHub.
Im Folgenden erläutern wir, warum du und dein Unternehmen Nest.js für dein nächstes Projekt wählen solltet, und wir geben einen Einblick, warum andere das Framework bereits nutzen und welche Vorteile es bietet.
Warum Nest.js wählen?
Die Wahl eines Frameworks hängt von der Art der Anwendung ab, die du entwickelst, denn verschiedene Anwendungen erfordern unterschiedliche Werkzeuge.
Hier listen wir verschiedene Gründe auf, die für Nest.js als Node.js-Framework für ein Upgrade oder den Aufbau deines nächsten Projekts sprechen.
- Nest.js ist leicht zu erlernen und zu beherrschen, besonders für Entwickler, die aus der Angular-Welt kommen. Das sorgt für einen schnellen und effizienten Entwicklungsprozess, da sich die Teammitglieder leicht an neue Entwicklungsprinzipien und -strukturen anpassen können.
- Das Framework ist dafür bekannt, dass es von Haus aus eine großartige Architektur für Unternehmensanwendungen bietet, was die Entwicklung hoch skalierbarer und wartbarer Unternehmensanwendungen zu einem Kinderspiel macht.
- Du kannst mit Nest.js mühelos Backend-Dienste wie RESTful APIs, GraphQL-Anwendungen, MVC-Anwendungen, Web Sockets, CLI und Cron-Jobs erstellen. Einige der Standardarchitekturen sind bereits in das Nest.js-Framework integriert.
- Da Nest.js moderne Technologien wie TypeScript, kugelsichere Architekturmuster, eine exzellente Dokumentation und einfache Unit-Tests verwendet, kannst du skalierbare und wartbare, unternehmenstaugliche Anwendungen erstellen.
- Nest.js wurde für den Aufbau großer monolithischer und Microservices-Anwendungen entwickelt, bei denen die Architektur bereits fertig ist und du nur noch deine Geschäftslogik entwickeln musst.
- Nest.js unterstützt eine große Anzahl von Modulen, die von der Community unterstützt werden, um spezifische Funktionen deiner Wahl zu entwickeln, von Konzepten wie TypeORM, Mongoose und GraphQL bis hin zu Logging, Validierung, Caching, WebSockets und vielem mehr.
Als Nächstes werden wir die Vor- und Nachteile von Nest.js untersuchen. Das wird dir helfen, deine Entscheidung für das Framework zu festigen, denn wir diskutieren sowohl die guten als auch die schlechten Seiten.
Vor- und Nachteile von Nest.js
Im Folgenden werden wir die Vor- und Nachteile von Nest.js aufzählen, damit du besser verstehst, warum es ein so beliebtes Framework im Node.js Ökosystem ist.
Die Vorteile
Einige der Vorteile von Nest.js sind:
- Leistungsstark, aber benutzerfreundlich: Das Framework ist so entwicklerfreundlich, dass selbst die komplexesten und leistungsfähigsten Funktionen einfach zu bedienen sind. Das Nest.js-Team hat das Framework so konzipiert, dass Entwickler/innen schnell loslegen und sich ausschließlich auf das Schreiben der Geschäftslogik konzentrieren können, während sich das Framework um andere wichtige Aspekte der Entwicklung kümmert, z. B. um die Sicherheit.
- Syntax im Stil von Angular (Backend): Angular ist ein sehr beliebtes Frontend-Framework mit einem Schwerpunkt auf Architektur und Strukturierung. Nest.js fungiert als Angular für das Backend, weil es den Angular-Stil und die Angular-Syntax verwendet, um dir zu helfen, dein Unternehmensprojekt zu strukturieren.
- TypeScript: Nest.js unterstützt TypeScript von Haus aus, was sich positiv auf die Leistung und das schnelle Schreiben wartbarer Anwendungen auswirkt, da es Kompilierfehler und Warnungen anzeigt. TypeScript lässt sich gut in VSCode integrieren, um eine zugängliche Entwicklungsumgebung zu schaffen.
- Gründliche Dokumentation: Nest.js verfügt über eine der besten Dokumentationen aller Frameworks, die sehr leicht zu verstehen ist. Es spart Zeit bei der Fehlersuche, wenn du einen Blick in die Dokumentation wirfst und sofort die Lösung für dein Problem findest.
- Gute Architektur und schnelle Entwicklung: Nest.js spart dir Zeit bei der Entwicklung deiner Anwendung, egal ob du dein erstes MVP oder die eigentliche Anwendung erstellst, denn es gibt dir von Anfang an eine solide Struktur und Architektur, mit der du arbeiten kannst, und verbessert so deine Entwicklungsprozesse.
Die Nachteile
Es gibt ein berühmtes Sprichwort: „Jeder Vorteil hat seine Nachteile“ – und Nest.js ist da keine Ausnahme. Also, lass uns die Nachteile von Nest.js erkunden.
- Schwierig für Neulinge: Nest.js kann für unerfahrene Entwickler/innen, die nicht aus dem Angular-Umfeld kommen, etwas schwierig zu erlernen und zu beherrschen sein. Da nicht jeder JavaScript-Entwickler TypeScript verwendet, kann das Framework auch für diese Gruppe von Entwicklern schwierig sein. Aber wie bei jeder anderen Technologie auch, braucht es Zeit und Übung.
- Mühsames Debugging: So viele Vorteile TypeScript auch hat, es bringt auch viele Probleme bei der Fehlersuche mit sich, vor allem für neuere Entwickler/innen in der TypeScript-Welt.
Da hast du es: die Vor- und Nachteile von Nest.js und wie sie deine Entscheidung für das Framework deiner Wahl beeinflussen können.
Als Nächstes üben wir den Aufbau einer RESTful API mit Nest.js, um das bisher Gelernte zu festigen. Lies weiter, um zu erfahren, wie du eine To-Do-API entwickelst, mit der Nutzer/innen ihre To-Do-Listen erstellen und verwalten können.
Baue deine erste Nest.js RESTful API
Es ist an der Zeit, all das, was wir über Nest.js gelernt haben, in die Praxis umzusetzen, indem wir unsere erste RESTful-API erstellen, um die Leistungsfähigkeit und Einfachheit zu demonstrieren, die sie mit sich bringt.
Wir beginnen damit, das Framework einzurichten und alle notwendigen Tools zu installieren, um es zum Laufen zu bringen.
1. Einrichten von Nest.js
Zuerst installieren wir das Nest CLI, um mit diesem Befehl neue Projekte zu erstellen:
npm i -g @nestjs/cliDanach erstellst du ein neues Projekt mit dem folgenden Befehl:
nest new nest-todo-api
cd nest-todo-api
npm run start:devJetzt, wo wir die Nest CLI installiert und unser neues Projekt erfolgreich erstellt haben, können wir unsere API erstellen.
Öffne das Projekt in einem beliebigen Code-Editor deiner Wahl. Wenn du localhost:3000 aufrufst, solltest du eine Willkommensnachricht erhalten, die zeigt, dass alles erfolgreich funktioniert.
Als Nächstes richten wir eine MongoDB-Datenbank ein, um eine Verbindung herzustellen und unsere Termindaten projektübergreifend zu verwalten.
Bevor wir loslegen, erstellen wir mit den folgenden Befehlen alle Dateien, die wir für die Erstellung der API benötigen:
nest generate module todos
nest generate controller todos
nest generate service todos2. Einrichten von MongoDB
Als Nächstes installieren und konfigurieren wir MongoDB für das Projekt, das wir zuvor erstellt haben.
Nachdem du MongoDB auf deinem lokalen Rechner installiert hast, führst du den folgenden Befehl aus, um die Mongoose-Bibliothek in unserem neu erstellten Projekt zu installieren:
npm install --save @nestjs/mongoose mongooseDas ist alles, was du tun musst.
Als Nächstes generieren wir die Dateien und importieren Mongoose, um mit dem Projekt und MongoDB zu kommunizieren.
Wir importieren Mongoose in unsere Anwendungsmoduldatei, bevor wir die anderen notwendigen Dateien erstellen:
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { MongooseModule } from '@nestjs/mongoose';
import { TodosModule } from './todos/todos.module';
@Module({
imports: [MongooseModule.forRoot('mongodb://localhost/todos), TodosModule],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}3. Das Schema erstellen
Als Nächstes erstellen wir das Datenbankschema für unsere Datenbank. In diesem Schema wird festgelegt, wie die Daten in unserer Datenbank dargestellt werden sollen.
Wir definieren es in unserer Datei todos.schema.ts:
import * as mongoose from 'mongoose';
export const ItemSchema = new mongoose.Schema({
title: String,
is_completed: Boolean,
description: String,
});4. Definieren von Interfaces
Als Nächstes erstellen wir eine Schnittstelle für die Typprüfung.
Wir definieren sie in unserer Datei interfaces/todo.interface.ts:
import { Document } from 'mongoose';
export interface Item extends Document {
id?: string;
title: string;
description?: string;
is_completed: boolean;
}5. Das DTO erstellen
Zum Schluss erstellen wir ein DTO (Data Transfer Object), das festlegt, wie die Daten über das Netzwerk von Objekt zu Objekt gesendet oder weitergegeben werden.
Es ist eine Basisklasse mit denselben Eigenschaften wie unser Schema:
// ./dto/create-todo.ts
export class CreateItemDto {
readonly title: string;
readonly description: string;
readonly is_completed: boolean;
}6. Modell/Service einrichten
Die Servicedatei ist für die Interaktion und Kommunikation mit der MongoDB-Datenbank zuständig. Sie wird zum Erstellen, Abrufen, Aktualisieren und Löschen von Datensätzen aus dem todos Schema verwendet, das wir zuvor erstellt haben.
Öffne deine Servicedatei und füge die folgenden Codes hinzu:
import { Injectable } from '@nestjs/common';
import { Todo } from './interfaces/todo.interface';
import { Model } from 'mongoose';
import { InjectModel } from '@nestjs/mongoose';
import { CreateTodoDto } from './dto/create-todo.dto';
@Injectable()
export class ItemsService {
constructor(@InjectModel('Todo') private readonly todoModel: Model) {}
async findAll(): Promise<Todo[]> {
return await this.todoModel.find();
}
async findOne(id: string): Promise {
return await this.todoModel.findOne({ _id: id });
}
async create(item: CreateItemDto): Promise {
const newTodo = new this.todoModel(item);
return await newTodo.save();
}
async delete(id: string): Promise {
return await this.todoModel.findByIdAndRemove(id);
}
async update(id: string, todo: CreateTodoDto): Promise {
return await this.todoModel.findByIdAndUpdate(id, todo, { new: true });
}
}Der obige Codeausschnitt stellt eine CRUD-Anwendung (Erstellen, Lesen, Aktualisieren, Löschen) für unsere API dar, die das Mongoose-Modell verwendet, um den Zugriff auf unsere zugrunde liegende MongoDB-Datenbank zu ermöglichen.
Als Nächstes erstellen wir unsere Controller-Datei, die die gesamte Logik steuert und mit dem oben erstellten Dienst kommuniziert.
7. Einrichten von Controllern
Der Controller ist für die Bearbeitung der Einkommensanfragen und die Rücksendung der Antworten an den Kunden verantwortlich.
Definieren wir unseren Todo Controller und fügen wir den folgenden Codeschnipsel ein:
import {
Controller,
Get,
Post,
Put,
Delete,
Body,
Param,
} from '@nestjs/common';
import { CreateTodoDto } from './dto/create-todo.dto';
import { TodosService } from './todos.service';
import { Todo } from './interfaces/todo.interface';
@Controller('items')
export class ItemsController {
constructor(private readonly todosService: TodosService) {}
@Get()
findAll(): Promise<Todo[]> {
return this.todosService.findAll();
}
@Get(':id')
findOne(@Param('id') id): Promise {
return this.todosService.findOne(id);
}
@Post()
create(@Body() createTodoDto: CreateTodoDto): Promise {
return this.todosService.create(createTodoDto);
}
@Delete(':id')
delete(@Param('id') id): Promise {
return this.todosService.delete(id);
}
@Put(':id')
update(@Body() updateTodoDto: CreateTodoDto, @Param('id') id): Promise {
return this.todosService.update(id, updateTodoDto);
}
}Das Framework verwendet Annotationen, um viele Funktionen hinter den Kulissen zu steuern – zum Beispiel, um das Routing-System des Frameworks zu steuern, indem verschiedene Annotationen für jede Route (@Put(), @Delete(), @Post(), @Get()) für die RESTful-APIs Put, Delete, Post und Get bereitgestellt werden.
8. Testen der API mit Postman
Zum Schluss testen wir unsere neu erstellte API mit Postman. Wir müssen den Entwicklungsserver starten, um sicherzustellen, dass alles ordnungsgemäß funktioniert, bevor wir es auf einen Produktionsserver übertragen.
npm run start:devDu kannst Postman herunterladen und ausführen, um deine RESTful-API zu testen.
Zusammenfassung
Nest.js ist ein leistungsfähiges Node.js-Framework und das beliebteste Typescript-Framework, das es derzeit gibt.
Es bietet dem Entwicklungsteam eine standardisierte Entwicklungsarchitektur und branchenübliche Best Practices. Mit ihm können Entwickler/innen wiederholte technische Prozesse abstrahieren und sich ausschließlich auf die Entwicklung der Geschäftslogik konzentrieren.
Diese Vorteile sind der Grund, warum bekannte Marken wie Adidas, Roche und andere das Framework für ihre Unternehmensanwendungen nutzen.
In diesem Artikel haben wir eine solide Grundlage für Nest.js gelegt und erklärt, warum du und dein Unternehmen den Umstieg auf Nest.js in Erwägung ziehen solltet. Außerdem haben wir ein einfaches RESTful-To-Do gebaut, um die Vorzüge des Frameworks praktisch zu demonstrieren.
Jetzt liegt es an dir, zu entscheiden, ob Nest.js das perfekte Framework für dich ist.
