TypeORM con Express

Express es uno de los marcos de JavaScript más populares para crear aplicaciones web. Aprendamos a usarTypeORM junto con el marco expreso en este capítulo.

Creando una aplicación simple

TypeORM CLI proporciona una opción fácil para crear una aplicación web rápida de trabajo completa (aplicación Restful API) integrada con TypeORM. El comando CLI para crear la aplicación es el siguiente:

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

El comando anterior creará una nueva aplicación web en la carpeta typeorm-express-sample. La estructura de la aplicación es la siguiente:

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

Aquí,

Tal como lo conocemos, ormconfig.json es el TypeORMarchivo de configuración. El código es el siguiente,

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

Aquí, cambie la configuración de la base de datos para que coincida con la configuración de su base de datos local.

package.json archivo es la configuración principal de la aplicación.

tsconfig.json El archivo contiene la configuración relacionada con TypeScript.

entity carpeta contiene el TypeORMmodelos. Un modelo de usuario predeterminado será creado por CLI y es el siguiente:

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

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

controllercarpeta contiene los controladores express. CLI crea un controlador de API de usuario predeterminado con agregar / listar / eliminar detalles de usuario. El código es el siguiente:

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

Aquí,

all El método se utiliza para recuperar todos los usuarios de la base de datos.

one El método se usa para buscar un solo usuario de la base de datos usando user id

save El método se utiliza para guardar la información del usuario en la base de datos.

delete El método se utiliza para eliminar al usuario de la base de datos utilizando user id

routes.ts El archivo asigna los métodos del controlador de usuario a la URL adecuada y el código es el siguiente:

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

Aquí,

/ users url se asigna al controlador de usuario. Cada publicación, obtención y eliminación de verbos se asignan a diferentes métodos.

Finalmente, index.tses nuestro principal punto de entrada a la aplicación web. El código fuente es el siguiente:

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

Aquí, la aplicación configura las rutas, inserta dos usuarios y luego inicia la aplicación web en el puerto 3000 . Podemos acceder a la aplicación enhttp://localhost:3000

Para ejecutar la aplicación, siga los pasos a continuación:

Instalemos los paquetes necesarios usando el siguiente comando:

npm install

Salida

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

Ejecute el siguiente comando para iniciar la aplicación.

npm start

Salida

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

Permítanos acceder a nuestra API de aplicación web usando el comando curl como se muestra a continuación:

curl http://localhost:3000/users

Aquí,

curl es una aplicación de línea de comandos para acceder a la aplicación web desde el símbolo del sistema. Es compatible con todos los verbos HTTP como obtener, publicar, eliminar, etc.

Salida

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

Para obtener el primer registro, podemos usar el siguiente comando:

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

Salida

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

Para eliminar un registro de usuario, podemos usar el siguiente comando:

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

Como vimos en este capítulo, TypeORM se puede integrar fácilmente en la aplicación express.