TypeORM avec Express

Express est l'un des frameworks JavaScript les plus populaires pour créer une application Web. Apprenons à utiliserTypeORM avec le cadre express dans ce chapitre.

Créer une application simple

TypeORM La CLI fournit une option simple pour créer une application Web express fonctionnelle complète (application API Restful) intégrée à TypeORM. La commande CLI pour créer l'application est la suivante -

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

La commande ci-dessus créera une nouvelle application Web dans le dossier typeorm-express-sample. La structure de l'application est la suivante -

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

Ici,

Comme nous le savons, ormconfig.json est le TypeORMfichier de configuration. Le code est comme suit,

{ 
   "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" 
   } 
}

Ici, modifiez le paramètre de base de données pour qu'il corresponde à votre paramètre de base de données locale.

package.json fichier est la configuration principale de l'application.

tsconfig.json Le fichier contient la configuration relative à TypeScript.

entity le dossier contient le TypeORMdes modèles. Un modèle utilisateur par défaut sera créé par CLI et il se présente comme suit -

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

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

controllerLe dossier contient les contrôleurs express. La CLI crée un contrôleur d'API utilisateur par défaut avec ajouter / répertorier / supprimer les détails de l'utilisateur. Le code est le suivant -

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

Ici,

all est utilisée pour récupérer tous les utilisateurs de la base de données.

one est utilisée pour extraire un seul utilisateur de la base de données en utilisant user id

save est utilisée pour enregistrer les informations utilisateur dans la base de données.

delete est utilisée pour supprimer l'utilisateur de la base de données en utilisant user id

routes.ts Le fichier mappe les méthodes du contrôleur utilisateur à l'URL appropriée et le code est le suivant -

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

Ici,

L'URL / users est mappée au contrôleur utilisateur. Chaque poste de verbe, obtenir et supprimer sont mappés à différentes méthodes.

Finalement, index.tsest le principal point d'entrée de notre application Web. Le code source est le suivant -

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

Ici, l'application configure les routes, insère deux utilisateurs puis lance l'application Web sur le port 3000 . Nous pouvons accéder à l'application surhttp://localhost:3000

Pour exécuter l'application, suivez les étapes ci-dessous -

Laissez-nous installer les packages nécessaires en utilisant la commande ci-dessous -

npm install

Production

npm notice created a lockfile as package-lock.json. You should commit this file. 
npm WARN [email protected] 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

Exécutez la commande ci-dessous pour démarrer l'application.

npm start

Production

> [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

Laissez-nous accéder à notre API d'application Web en utilisant la commande curl comme ci-dessous -

curl http://localhost:3000/users

Ici,

curl est une application de ligne de commande pour accéder à une application Web à partir d'une invite de commande. Il prend en charge tous les verbes HTTP tels que get, post, delete, etc.,

Production

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

Pour récupérer le premier enregistrement, nous pouvons utiliser la commande ci-dessous -

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

Production

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

Pour supprimer un enregistrement utilisateur, nous pouvons utiliser la commande ci-dessous -

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

Comme nous l'avons vu dans ce chapitre, TypeORM peut être facilement intégré dans une application express.