TypeORM com Express

Express é uma das estruturas JavaScript populares para criar aplicativos da web. Vamos aprender como usarTypeORM junto com a estrutura expressa neste capítulo.

Criação de um aplicativo simples

TypeORM CLI fornece uma opção fácil para criar um aplicativo da web expresso funcional completo (aplicativo Restful API) integrado com TypeORM. O comando CLI para criar o aplicativo é o seguinte -

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

O comando acima criará um novo aplicativo da web na pasta typeorm-express-sample. A estrutura do aplicativo é a seguinte -

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

Aqui,

Como sabemos, ormconfig.json é o TypeORMarquivo de configuração. O código é o seguinte,

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

Aqui, altere a configuração do banco de dados para corresponder à configuração do banco de dados local.

package.json arquivo é a configuração principal do aplicativo.

tsconfig.json arquivo contém a configuração relacionada ao TypeScript.

entity pasta contém o TypeORMmodelos. Um modelo de usuário padrão será criado pela CLI e é o seguinte -

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

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

controllerpasta contém os controladores express. CLI cria um controlador de API de usuário padrão com adicionar / listar / excluir detalhes de usuário. O código é o seguinte -

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

Aqui,

all método é usado para buscar todos os usuários do banco de dados.

one método é usado para buscar um único usuário do banco de dados usando user id

save método é usado para salvar as informações do usuário no banco de dados.

delete método é usado para excluir o usuário do banco de dados usando user id

routes.ts arquivo mapeia os métodos do controlador do usuário para a URL adequada e o código é o seguinte -

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

Aqui,

/ users url é mapeado para o controlador do usuário. Cada verbo post, get e delete são mapeados para métodos diferentes.

Finalmente, index.tsé o nosso principal ponto de entrada do aplicativo da web. O código-fonte é o seguinte -

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

Aqui, o aplicativo configura as rotas, insira dois usuários e, a seguir, inicia o aplicativo da web na porta 3000 . Podemos acessar o aplicativo emhttp://localhost:3000

Para executar o aplicativo, siga as etapas abaixo -

Vamos instalar os pacotes necessários usando o comando abaixo -

npm install

Resultado

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

Execute o comando abaixo para iniciar o aplicativo.

npm start

Resultado

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

Vamos acessar nossa API de aplicativo da web usando o comando curl conforme abaixo -

curl http://localhost:3000/users

Aqui,

curl é um aplicativo de linha de comando para acessar o aplicativo da web a partir do prompt de comando. Ele suporta todos os verbos HTTP, como get, post, delete, etc.,

Resultado

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

Para buscar o primeiro registro, podemos usar o comando abaixo -

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

Resultado

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

Para excluir um registro de usuário, podemos usar o comando abaixo -

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

Como vimos neste capítulo, TypeORM pode ser facilmente integrado ao aplicativo expresso.