TypeORM con Express

Express è uno dei popolari framework JavaScript per creare applicazioni web. Impariamo come usareTypeORM insieme a Express Framework in questo capitolo.

Creazione di una semplice applicazione

TypeORM CLI fornisce un'opzione semplice per creare un'applicazione web rapida e funzionante completa (applicazione API Restful) integrata con TypeORM. Il comando CLI per creare l'applicazione è il seguente:

cd /path/to/workspace typeorm init --express --name typeorm-express-sample --database mysql

Il comando sopra creerà una nuova applicazione web nella cartella typeorm-express-sample. La struttura dell'applicazione è la seguente:

│ .gitignore 
│ ormconfig.json 
│ package.json 
│ README.md 
│ tsconfig.json 
│ └───src 
      │ index.ts 
      │ routes.ts 
      │ 
      ├───controller 
      │      UserController.ts 
      │ 
      ├───entity 
      │      User.ts 
      │ 
      └───migration

Qui,

Come sappiamo, ormconfig.json è il TypeORMfile di configurazione. Il codice è il seguente,

{ 
   "type": "mysql", 
   "host": "localhost", 
   "port": 3306, 
   "username": "test", 
   "password": "test", 
   "database": "test", 
   "synchronize": true, 
   "logging": false, 
   "entities": [
      "src/entity/**/*.ts" 
   ], 
   "migrations": [ "src/migration/**/*.ts" 
   ], 
   "subscribers": [ "src/subscriber/**/*.ts" 
   ], 
   "cli": { 
      "entitiesDir": "src/entity", "migrationsDir": "src/migration", "subscribersDir": "src/subscriber" 
   } 
}

Qui, modifica l'impostazione del database in modo che corrisponda all'impostazione del database locale.

package.json file è la configurazione principale dell'applicazione.

tsconfig.json file contiene la configurazione relativa a TypeScript.

entity la cartella contiene il file TypeORMModelli. Un modello utente predefinito verrà creato dalla CLI ed è il seguente:

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

@Entity() 
export class User { 
   
   @PrimaryGeneratedColumn() 
   id: number; 
   
   @Column() 
   firstName: string; 
   
   @Column() 
   lastName: string; 
   
   @Column() 
   age: number; 
}

controllercartella contiene i controller express. CLI crea un controller API utente predefinito con aggiungi / elenca / elimina i dettagli dell'utente. Il codice è il seguente:

import {getRepository} from "typeorm"; import {NextFunction, Request, Response} from "express"; import {User} from "../entity/User"; 

export class UserController {

   private userRepository = getRepository(User); 
   
   async all(request: Request, response: Response, next: NextFunction) { 
      return this.userRepository.find(); 
   } 
   
   async one(request: Request, response: Response, next: NextFunction) { 
      return this.userRepository.findOne(request.params.id); 
   } 
   
   async save(request: Request, response: Response, next: NextFunction) { 
      return this.userRepository.save(request.body); 
   } 
   
   async remove(request: Request, response: Response, next: NextFunction) { 
      let userToRemove = await this.userRepository.findOne(request.params.id); 
      await this.userRepository.remove(userToRemove); 
   } 
}

Qui,

all viene utilizzato per recuperare tutti gli utenti dal database.

one metodo viene utilizzato per recuperare un singolo utente dal database utilizzando user id

save viene utilizzato per salvare le informazioni dell'utente nel database.

delete metodo viene utilizzato per eliminare l'utente dal database utilizzando user id

routes.ts file mappa i metodi del controller utente all'URL corretto e il codice è il seguente:

import {UserController} from "./controller/UserController"; 

export const Routes = [{ 
      method: "get", 
      route: "/users", 
      controller: UserController, action: "all" 
   }, { 
      method: "get", 
      route: "/users/:id", controller: UserController, action: "one" 
   }, { 
      method: "post", 
      route: "/users", 
      controller: UserController, action: "save" 
   }, { 
      method: "delete", route: "/users/:id", controller: UserController,
      action: "remove" 
}];

Qui,

/ users url è mappato al controller utente. Ogni verbo post, get e delete viene mappato su metodi diversi.

Finalmente, index.tsè il nostro punto di ingresso principale dell'applicazione web. Il codice sorgente è il seguente:

import "reflect-metadata"; 
import {createConnection} from "typeorm"; 
import * as express from "express"; import * as bodyParser from "body-parser"; 
import {Request, Response} from "express"; 
import {Routes} from "./routes"; import {User} from "./entity/User"; 

createConnection().then(async connection => { 

   // create express app const app = express(); app.use(bodyParser.json()); 

   // register express routes from defined application routes Routes.forEach(route => { 
      (app as any)[route.method](route.route, (req:   Request, res: Response, next: Function) => { 
         const result = (new (route.controller as any))[route.action](req, res, next); 
         if (result instanceof Promise) { 
            result.then(result => result !== null && result !== undefined ? res.send(result) : undefined); 
         } else if (result !== null && result !== undefined) { 
            .json(result); 
         } 
      }); 
   }); 
      
   // setup express app here 
   // ... 
      
   // start express server app.listen(3000); 
      
   // insert new users for test await connection.manager.save(connection.manager.create(User, { 
      firstName: "Timber",
      lastName: "Saw", 
      age: 27 
   }));
   await connection.manager.save(connection.manager.create(User, { 
      firstName: "Phantom", 
      lastName: "Assassin", 
      age: 24 
   })); 
      
   console.log("Express server has started on port 3000. Open http://localhost:3000/users to see results"); 
}).catch(error => console.log(error));

Qui, l'applicazione configura le rotte, inserisce due utenti e quindi avvia l'applicazione web sulla porta 3000 . Possiamo accedere all'applicazione all'indirizzohttp://localhost:3000

Per eseguire l'applicazione, segui i passaggi seguenti:

Cerchiamo di installare i pacchetti necessari utilizzando il comando seguente:

npm install

Produzione

npm notice created a lockfile as package-lock.json. You should commit this file. 
npm WARN [email protected]0.0.1 No repository field. 
npm WARN [email protected] No license field. 

added 176 packages from 472 contributors and audited 351 packages in 11.965s 

3 packages are looking for funding  run `npm fund` for details 

found 0 vulnerabilities

Esegui il comando seguente per avviare l'applicazione.

npm start

Produzione

> [email protected] start /path/to/workspace/typeorm-express-sample 
> ts-node src/index.ts 

Express server has started on port 3000. Open http://localhost:3000/users to see results

Accediamo alla nostra API dell'applicazione Web utilizzando il comando curl come di seguito:

curl http://localhost:3000/users

Qui,

curl è un'applicazione a riga di comando per accedere all'applicazione web dal prompt dei comandi. Supporta tutti i verbi HTTP come get, post, delete, ecc.,

Produzione

[{"id":1,"firstName":"Timber","lastName":"Saw","age":27},{"id":2,"firstName":"Phantom","lastName":"Assassin","age":24}]

Per recuperare il primo record, possiamo usare il comando seguente:

curl http://localhost:3000/users/1

Produzione

{"id":1,"firstName":"Timber","lastName":"Saw","age":27}

Per eliminare un record utente, possiamo usare il comando seguente:

curl -X DELETE http://localhost:3000/users/1

Come abbiamo visto in questo capitolo, TypeORM può essere facilmente integrato in un'applicazione rapida.