Beispielanwendung mit TypeORM und Express

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Ersteinrichtung

Erstellen wir eine einfache Anwendung namens "user", die Benutzer in der Datenbank speichert und es uns ermöglicht, Benutzer zu erstellen, zu aktualisieren, zu löschen sowie alle Benutzer oder einzelne Benutzer per ID über eine Web-API abzurufen.

Erstelle zunächst ein Verzeichnis namens "user":

mkdir user

Wechsle dann in das Verzeichnis und initialisiere ein neues Projekt:

cd user
npm init

Schließe den Initialisierungsprozess ab, indem du alle erforderlichen Anwendungsinformationen eingibst.

Jetzt müssen wir den TypeScript-Compiler installieren und einrichten. Installieren wir ihn zuerst:

npm i typescript --save-dev

Erstelle dann eine tsconfig.json-Datei mit der erforderlichen Konfiguration, damit die Anwendung kompiliert und ausgeführt werden kann. Erstelle sie mit deinem bevorzugten Editor und füge folgende Konfiguration ein:

{
    "compilerOptions": {
        "lib": ["es5", "es6", "dom"],
        "target": "es5",
        "module": "commonjs",
        "moduleResolution": "node",
        "emitDecoratorMetadata": true,
        "experimentalDecorators": true
    }
}

Erstelle nun den Hauptanwendungsendpunkt - app.ts im src-Verzeichnis:

mkdir src
cd src
touch app.ts

Füge eine einfache console.log-Anweisung ein:

console.log("Application is up and running")

Jetzt ist es Zeit, unsere Anwendung auszuführen. Dazu musst du dein TypeScript-Projekt zuerst kompilieren:

tsc

Nach erfolgreicher Kompilierung sollte eine src/app.js-Datei erzeugt worden sein. Führe sie mit folgendem Befehl aus:

node src/app.js

Du solltest die Meldung "Application is up and running" in der Konsole sehen, sobald du die Anwendung startest.

Du musst deine Dateien bei jeder Änderung neu kompilieren. Alternativ kannst du einen Datei-Watcher einrichten oder ts-node installieren, um die manuelle Kompilierung zu vermeiden.

Express zur Anwendung hinzufügen

Fügen wir Express zu unserer Anwendung hinzu. Installiere zuerst die benötigten Pakete:

npm install express
npm install @types/express --save-dev

• express ist die Express-Engine selbst. Sie ermöglicht es uns, eine Web-API zu erstellen.

• @types/express wird verwendet, um Typinformationen bei der Nutzung von Express zu erhalten.

Bearbeite nun die src/app.ts-Datei und füge Express-spezifische Logik hinzu:

import * as express from "express"
import { Request, Response } from "express"

// create and setup express app
const app = express()
app.use(express.json())

// register routes

app.get("/users", function (req: Request, res: Response) {
    // here we will have logic to return all users
})

app.get("/users/:id", function (req: Request, res: Response) {
    // here we will have logic to return user by id
})

app.post("/users", function (req: Request, res: Response) {
    // here we will have logic to save a user
})

app.put("/users/:id", function (req: Request, res: Response) {
    // here we will have logic to update a user by a given user id
})

app.delete("/users/:id", function (req: Request, res: Response) {
    // here we will have logic to delete a user by a given user id
})

// start express server
app.listen(3000)

Jetzt kannst du dein Projekt kompilieren und ausführen. Du solltest nun einen laufenden Express-Server mit funktionierenden Routen haben. Diese Routen liefern jedoch noch keine Inhalte zurück.

TypeORM zur Anwendung hinzufügen

Fügen wir abschließend TypeORM zur Anwendung hinzu. In diesem Beispiel verwenden wir den mysql-Treiber. Der Einrichtungsprozess für andere Treiber ist ähnlich.

Installiere zuerst die benötigten Pakete:

npm install typeorm reflect-metadata mysql

• typeorm ist das TypeORM-Paket selbst.

• reflect-metadata wird benötigt, damit Decorators korrekt funktionieren. Denke daran, es vor deinem TypeORM-Code zu importieren.

• mysql ist der zugrundeliegende Datenbanktreiber. Wenn du ein anderes Datenbanksystem verwendest, musst du das entsprechende Paket installieren.

Erstelle app-data-source.ts, wo wir die initialen Datenbankverbindungsoptionen konfigurieren:

import { DataSource } from "typeorm"

export const myDataSource = new DataSource({
    type: "mysql",
    host: "localhost",
    port: 3306,
    username: "test",
    password: "test",
    database: "test",
    entities: [__dirname + "/entities/**/*{.js,.ts}"],
    logging: true,
    synchronize: true,
})

Konfiguriere jede Option nach Bedarf. Weitere Informationen zu den Optionen findest du hier.

Erstelle eine Entity user.entity.ts im Ordner entities:

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

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

    @Column()
    firstName: string

    @Column()
    lastName: string
}

Passe src/app.ts an, um die Datenbankverbindung herzustellen und myDataSource zu verwenden:

import "reflect-metadata"

import * as express from "express"
import { Request, Response } from "express"
import { User } from "./entities/User"
import { myDataSource } from "./app-data-source.ts"

// establish database connection
try {
    await myDataSource.initialize()
    console.log("Data Source has been initialized!")
} catch (error) {
    console.error("Error during Data Source initialization:", error)
}

// create and setup express app
const app = express()
app.use(express.json())

// register routes
app.get("/users", async function (req: Request, res: Response) {
    const users = await myDataSource.getRepository(User).find()
    res.json(users)
})

app.get("/users/:id", async function (req: Request, res: Response) {
    const results = await myDataSource.getRepository(User).findOneBy({
        id: req.params.id,
    })
    return res.send(results)
})

app.post("/users", async function (req: Request, res: Response) {
    const user = await myDataSource.getRepository(User).create(req.body)
    const results = await myDataSource.getRepository(User).save(user)
    return res.send(results)
})

app.put("/users/:id", async function (req: Request, res: Response) {
    const user = await myDataSource.getRepository(User).findOneBy({
        id: req.params.id,
    })
    myDataSource.getRepository(User).merge(user, req.body)
    const results = await myDataSource.getRepository(User).save(user)
    return res.send(results)
})

app.delete("/users/:id", async function (req: Request, res: Response) {
    const results = await myDataSource.getRepository(User).delete(req.params.id)
    return res.send(results)
})

// start express server
app.listen(3000)

Jetzt sollte eine einfache Express-Anwendung mit Verbindung zur MySQL-Datenbank laufen.