Arbeit mit Datenbanken in TypeScript: PostgreSQL und MongoDB

Einführung in die Arbeit mit Datenbanken in TypeScript

TypeScript ist eine streng typisierte Erweiterung von JavaScript, die statische Typisierung und moderne Sprachfunktionen hinzufügt. Bei der Entwicklung von serverseitigen Anwendungen in TypeScript besteht häufig die Notwendigkeit, mit Datenbanken zu interagieren. Zwei der beliebtesten Lösungen sind das relationale DBMS PostgreSQL und die dokumentenorientierte MongoDB. In diesem Artikel werden wir uns ansehen, wie man mit beiden Datenbanken in TypeScript effektiv arbeitet, unter Verwendung bewährter Bibliotheken und Best Practices.

Einrichtung der Umgebung und Installation von Abhängigkeiten

Stellen Sie vor dem Start sicher, dass Node.js und npm installiert sind. Erstellen Sie ein neues Projekt und installieren Sie die erforderlichen Pakete:

mkdir typescript-db-examplecd typescript-db-examplenpm init -ynpm install typescript ts-node @types/node --save-devnpx tsc --init

Für die Arbeit mit PostgreSQL verwenden wir TypeORM — ein leistungsstarkes ORM mit TypeScript-Unterstützung. Für MongoDB — Mongoose.

npm install typeorm reflect-metadata pgnpm install mongoose

Arbeit mit PostgreSQL über TypeORM

Konfiguration der Verbindung zu PostgreSQL

TypeORM unterstützt Dekorateure und Active Record. Erstellen wir eine data-source.ts-Datei für die Konfiguration:

import { DataSource } from "typeorm";

export const AppDataSource = new DataSource({    type: "postgres",    host: "localhost",    port: 5432,    username: "your_username",    password: "your_password",    database: "test_db",    synchronize: true,    logging: false,    entities: ["src/entity/**/*.ts"],    migrations: [],    subscribers: [],});

Erstellen einer Entität

Definieren wir ein Benutzermodell mithilfe von Dekorateuren:

import { Entity, PrimaryGeneratedColumn, Column } from "typeorm";

@Entity()export class User {    @PrimaryGeneratedColumn()    id: number;

    @Column()    firstName: string;

    @Column()    lastName: string;

    @Column({ unique: true })    email: string;

    @Column({ default: true })    isActive: boolean;}

CRUD-Operationen mit PostgreSQL

Führen wir grundlegende Datenbankoperationen durch:

import { AppDataSource } from "./data-source";import { User } from "./entity/User";

async function main() {    await AppDataSource.initialize();    const userRepository = AppDataSource.getRepository(User);

    // CREATE (ERSTELLEN)    const newUser = userRepository.create({        firstName: "Ivan",        lastName: "Petrov",        email: "ivan@example.com"    });    await userRepository.save(newUser);

    // READ (LESEN)    const users = await userRepository.find();    console.log("All users (Alle Benutzer):", users);

    // UPDATE (AKTUALISIEREN)    const userToUpdate = await userRepository.findOneBy({ id: 1 });    if (userToUpdate) {        userToUpdate.isActive = false;        await userRepository.save(userToUpdate);    }

    // DELETE (LÖSCHEN)    await userRepository.delete({ id: 1 });}

main().catch(console.error);

Arbeit mit MongoDB über Mongoose

Verbindung zu MongoDB herstellen

Mongoose bietet ein praktisches Schema und eine Validierung für MongoDB. Richten wir die Verbindung ein:

import mongoose, { Schema, Document, Model } from "mongoose";

const MONGO_URI = "mongodb://localhost:27017/test";

mongoose.connect(MONGO_URI)    .then(() => console.log("Connected to MongoDB (Mit MongoDB verbunden)"))    .catch(err => console.error("Connection error (Verbindungsfehler):", err));

Definieren des Schemas und des Modells

Erstellen wir ein Interface für TypeScript und ein Mongoose-Schema:

// Interface für TypeScriptinterface IUser extends Document {    firstName: string;    lastName: string;    email: string;    createdAt: Date;}

// Mongoose-Schemaconst userSchema = new Schema({    firstName: { type: String, required: true },    lastName: { type: String, required: true },    email: { type: String, required: true, unique: true },    createdAt: { type: Date, default: Date.now }});

// Modelexport const UserModel: Model = mongoose.model("User", userSchema);

CRUD-Operationen mit MongoDB

Führen wir grundlegende Operationen mit MongoDB durch:

import { UserModel } from "./models/User";

async function main() {    // CREATE (ERSTELLEN)    const newUser = new UserModel({        firstName: "Ivan",        lastName: "Petrov",        email: "ivan@example.com"    });    await newUser.save();

    // READ (LESEN)    const users = await UserModel.find();    console.log("All users (Alle Benutzer):", users);

    // UPDATE (AKTUALISIEREN)    await UserModel.updateOne({ _id: newUser._id }, { isActive: false });

    // DELETE (LÖSCHEN)    await UserModel.deleteOne({ _id: newUser._id });}

main().catch(console.error);

Fazit

In diesem Artikel haben wir uns die Grundlagen der Arbeit mit PostgreSQL und MongoDB in TypeScript angesehen. TypeORM bietet eine praktische Abstraktion für relationale Datenbanken mit Unterstützung für Dekorateure und automatische Migrationserstellung. Mongoose wiederum bietet ein flexibles Schema-System und Validierung für MongoDB. Die Wahl zwischen diesen Lösungen hängt von den spezifischen Anforderungen Ihres Projekts ab: PostgreSQL ist besser geeignet für strukturierte Daten mit komplexen Beziehungen, während MongoDB ideal für flexible Dokumentschemata und schnelles Prototyping ist.