Ejemplo de uso de TypeORM con Express

Traducción Beta No Oficial

Esta página fue traducida por PageTurner AI (beta). No está respaldada oficialmente por el proyecto. ¿Encontraste un error? Reportar problema →

Configuración inicial

Creemos una aplicación simple llamada "user" que almacene usuarios en la base de datos y nos permita crear, actualizar, eliminar y obtener una lista de todos los usuarios, así como un usuario individual por ID dentro de una API web.

Primero, crea un directorio llamado "user":

mkdir user

Luego ingresa al directorio y crea un nuevo proyecto:

cd user
npm init

Completa el proceso de inicialización llenando toda la información requerida de la aplicación.

Ahora necesitamos instalar y configurar el compilador de TypeScript. Primero instalémoslo:

npm i typescript --save-dev

Luego creemos un archivo tsconfig.json que contiene la configuración necesaria para que la aplicación se compile y ejecute. Créalo usando tu editor favorito e ingresa la siguiente configuración:

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

Ahora creemos el punto de entrada principal de la aplicación - app.ts dentro del directorio src:

mkdir src
cd src
touch app.ts

Agreguemos un simple console.log dentro:

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

Ahora es momento de ejecutar nuestra aplicación. Para hacerlo, primero debes compilar tu proyecto de TypeScript:

tsc

Una vez compilado, deberías tener un archivo src/app.js generado. Puedes ejecutarlo usando:

node src/app.js

Deberías ver el mensaje "Application is up and running" en tu consola inmediatamente después de ejecutar la aplicación.

Debes compilar tus archivos cada vez que realices un cambio. Alternativamente, puedes configurar un watcher o instalar ts-node para evitar la compilación manual cada vez.

Agregando Express a la aplicación

Agreguemos Express a nuestra aplicación. Primero, instalemos los paquetes que necesitamos:

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

• express es el motor de Express en sí. Nos permite crear una API web

• @types/express se utiliza para tener información de tipos al usar express

Editemos el archivo src/app.ts y agreguemos lógica relacionada con 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)

Ahora puedes compilar y ejecutar tu proyecto. Deberías tener un servidor Express funcionando con rutas activas. Sin embargo, estas rutas aún no devuelven ningún contenido.

Agregando TypeORM a la aplicación

Finalmente, agreguemos TypeORM a la aplicación. En este ejemplo, usaremos el controlador mysql. El proceso de configuración para otros controladores es similar.

Instalemos primero los paquetes requeridos:

npm install typeorm reflect-metadata mysql

• typeorm es el paquete de TypeORM en sí

• reflect-metadata es necesario para que los decoradores funcionen correctamente. Recuerda importarlo antes de tu código de TypeORM

• mysql es el controlador de base de datos subyacente. Si estás usando un sistema de base de datos diferente, debes instalar el paquete apropiado

Creemos app-data-source.ts donde configuraremos las opciones iniciales de conexión a la base de datos:

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 cada opción según tus necesidades. Aprende más sobre las opciones aquí.

Creemos una entidad user.entity.ts en la carpeta entities:

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

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

    @Column()
    firstName: string

    @Column()
    lastName: string
}

Cambiemos src/app.ts para establecer la conexión a la base de datos y comenzar a usar 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)

Ahora deberías tener una aplicación Express básica conectada a una base de datos MySQL funcionando.