Esempio di utilizzo di TypeORM con Express

Traduzione Beta Non Ufficiale

Questa pagina è stata tradotta da PageTurner AI (beta). Non ufficialmente approvata dal progetto. Hai trovato un errore? Segnala problema →

Configurazione iniziale

Creiamo una semplice applicazione chiamata "user" che memorizza gli utenti nel database e ci permette di creare, aggiornare, rimuovere ed ottenere la lista di tutti gli utenti, oltre ad un singolo utente tramite ID tramite web API.

Per prima cosa, crea una directory chiamata "user":

mkdir user

Quindi entra nella directory e crea un nuovo progetto:

cd user
npm init

Completa il processo di inizializzazione inserendo tutte le informazioni richieste per l'applicazione.

Ora dobbiamo installare e configurare il compilatore TypeScript. Installiamolo:

npm i typescript --save-dev

Poi creiamo un file tsconfig.json contenente la configurazione necessaria per la compilazione e l'esecuzione dell'applicazione. Crealo con il tuo editor preferito e inserisci la seguente configurazione:

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

Ora creiamo il main endpoint dell'applicazione - app.ts dentro la directory src:

mkdir src
cd src
touch app.ts

Aggiungiamo un semplice console.log al suo interno:

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

È ora di eseguire la nostra applicazione. Per farlo, devi prima compilare il progetto TypeScript:

tsc

Dopo la compilazione, dovresti avere un file src/app.js generato. Puoi eseguirlo con:

node src/app.js

Dovresti vedere il messaggio "Application is up and running" nella console subito dopo l'esecuzione.

Devi ricompilare i file ogni volta che apporti modifiche. In alternativa, puoi configurare un watcher o installare ts-node per evitare la compilazione manuale.

Aggiunta di Express all'applicazione

Aggiungiamo Express alla nostra applicazione. Installiamo prima i pacchetti necessari:

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

• express è il motore di Express stesso. Ci permette di creare una web API

• @types/express serve per avere informazioni sui tipi quando si utilizza Express

Modifichiamo il file src/app.ts aggiungendo la logica di Express:

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)

Ora puoi compilare ed eseguire il progetto. Dovresti avere un server Express attivo con rotte funzionanti, anche se queste rotte non restituiscono ancora contenuto.

Aggiunta di TypeORM all'applicazione

Infine, aggiungiamo TypeORM all'applicazione. In questo esempio useremo il driver mysql. Il processo è simile per altri driver.

Installiamo prima i pacchetti richiesti:

npm install typeorm reflect-metadata mysql

• typeorm è il pacchetto TypeORM stesso

• reflect-metadata è necessario per far funzionare correttamente i decoratori. Ricorda di importarlo prima del tuo codice TypeORM

• mysql è il driver del database sottostante. Se stai utilizzando un altro sistema di database, devi installare il pacchetto appropriato

Creiamo app-data-source.ts dove configuriamo le opzioni di connessione al database:

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,
})

Configura ogni opzione secondo le tue esigenze. Maggiori informazioni sulle opzioni qui.

Creiamo un'entità user.entity.ts nella cartella entities:

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

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

    @Column()
    firstName: string

    @Column()
    lastName: string
}

Modifichiamo src/app.ts per stabilire la connessione al database e iniziare a usare myDataSource:

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)

Ora dovresti avere un'applicazione Express di base connessa a un database MySQL funzionante.