TypeORM für TypeScript: vollständige Anleitung mit Beispielen

Was ist TypeORM und warum wird es benötigt?

TypeORM ist eine leistungsstarke objektrelationale Bibliothek (ORM) für TypeScript und JavaScript, die mit verschiedenen Datenbanken arbeitet: PostgreSQL, MySQL, MariaDB, SQLite, MS SQL Server, Oracle und MongoDB (teilweise). Sie bietet eine bequeme Möglichkeit zur Interaktion mit relationalen Datenbanken durch einen objektorientierten Ansatz, der es Entwicklern ermöglicht, mit Tabellen wie mit Klassen und mit Datensätzen wie mit Objekten zu arbeiten.

Die Hauptgründe für die Verwendung von TypeORM:

• Typisierung: Vollständige Integration mit TypeScript gewährleistet strenge Typisierung und Autovervollständigung in der IDE.
• Deklarativer Ansatz: Definition des Datenbankschemas durch Decorators oder Schemata.
• Automatische Migrationen: Automatische Erstellung und Synchronisation des Datenbankschemas.
• Active Record und Data Mapper: Unterstützung beider gängiger Muster.
• Unterstützung von Beziehungen: One-to-One, One-to-Many, Many-to-Many.
• Query Builder: Flexibler Abfragegenerator für komplexe SQL-Abfragen.
• Plattformunabhängigkeit: Funktioniert mit Node.js, Browsern, React Native und Ionic.

Installation von TypeORM

Verwenden Sie npm (oder yarn) zur Installation von TypeORM und der erforderlichen Datenbanktreiber:

// Installation von TypeORM
npm install typeorm --save

// Installation von reflect-metadata (erforderlich für Decorators)
npm install reflect-metadata --save

// Installation des Treibers für PostgreSQL
npm install pg --save

// Installation des Treibers für MySQL/MariaDB
npm install mysql2 --save

// Installation des Treibers für SQLite
npm install sqlite3 --save

// Installation des Treibers für SQL Server
npm install mssql --save

// Installation des Treibers für MongoDB (experimentell)
npm install mongodb --save

Fügen Sie nach der Installation Folgendes in tsconfig.json hinzu:

{
  "compilerOptions": {
    "emitDecoratorMetadata": true,
    "experimentalDecorators": true
  }
}

Schnellstart mit einem Codebeispiel

Erstellen wir eine einfache Anwendung zur Benutzerverwaltung mit SQLite (erfordert keine Serverinstallation).

1. Erstellen Sie die Datei data-source.ts für die Verbindungskonfiguration:

import { DataSource } from "typeorm";
import { User } from "./entity/User";

export const AppDataSource = new DataSource({
    type: "sqlite",
    database: "database.sqlite",
    synchronize: true,
    logging: true,
    entities: [User],
    subscribers: [],
    migrations: [],
});

// Initialisierung der Verbindung
AppDataSource.initialize()
    .then(() => {
        console.log("Data Source has been initialized!");
    })
    .catch((err) => {
        console.error("Error during Data Source initialization:", err);
    });

2. Erstellen Sie die Entität User in der Datei entity/User.ts:

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

3. Erstellen Sie die Datei index.ts zur Demonstration der Funktionsweise:

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

async function main() {
    await AppDataSource.initialize();

    // Erstellen eines neuen Benutzers
    const user = new User();
    user.firstName = "Иван";
    user.lastName = "Петров";
    user.email = "ivan@example.com";
    user.isActive = true;

    // Speichern in der Datenbank
    await AppDataSource.manager