Configuración de PostgreSQL con TypeORM en aplicaciones NestJS

Contenido del curso

Fundamentos y Primer CRUD

Base de Datos y Persistencia con TypeORM

Autenticación y Autorización

Tu API Completa

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:17

Configuración de PostgreSQL con TypeORM en aplicaciones NestJS

Curso de Backend con NestJS

Clase 12 de 35

Clase 12 / 35

Recursos

Conectar una API de NestJS a PostgreSQL se vuelve mucho más simple cuando usas un ORM. En esta guía aprenderás cómo configurar TypeORM con NestJS y PostgreSQL, paso a paso, y cómo proteger tus credenciales con variables de entorno usando ConfigService. Es una pieza clave si estás construyendo una API con persistencia real y quieres seguir buenas prácticas desde el inicio.

Qué es un ORM y por qué usarlo en NestJS

Un ORM (Object Relational Mapper) te permite conectarte a tu base de datos siguiendo un patrón orientado a objetos. En vez de escribir SQL crudo, declaras entidades como clases y el framework se encarga de mapear tablas a objetos que puedes consultar desde tu código [00:08].

¿Qué es un ORM? Es una capa que traduce tablas de una base de datos relacional a objetos en tu lenguaje de programación. Así puedes leer, escribir y relacionar datos sin escribir SQL directamente.

Este patrón no es exclusivo de Node. Frameworks como Laravel en PHP o Django en Python tienen sus propios ORMs. En el ecosistema de NestJS, TypeORM es la opción más usada por su integración nativa, aunque también puedes elegir Prisma, MikroORM o Sequelize según tu proyecto [00:31].

Qué bases de datos soporta TypeORM

TypeORM es flexible y se conecta a múltiples motores. Entre los más comunes están:

MySQL y MariaDB.
PostgreSQL.
SQLite.
Microsoft SQL Server y Oracle.
MongoDB, si necesitas trabajar con NoSQL.

Esto te da libertad para cambiar de motor sin reescribir toda tu lógica de acceso a datos [01:05].

Cómo instalar TypeORM y el driver de PostgreSQL en NestJS

Para empezar necesitas dos dependencias: el módulo de NestJS para TypeORM y el driver nativo de PostgreSQL para Node, que se llama pg [02:15].

En la terminal, dentro de tu proyecto, ejecuta:

bash npm install --save @nestjs/typeorm typeorm pg

La documentación oficial de NestJS suele mostrar el ejemplo con MySQL, pero como vamos a usar Postgres, el driver correcto es pg. Si llegas a equivocarte de driver, el ORM te lanzará un error indicando que el paquete de conexión no está instalado [05:50].

Cómo configurar TypeOrmModule en el AppModule

La primera versión de la conexión vive en AppModule. Importas TypeOrmModule y usas forRoot con un objeto de configuración que indica el tipo de base, host, puerto, usuario, contraseña y nombre de la base [03:08].

Una configuración inicial se ve así:

typescript TypeOrmModule.forRoot({ type: 'postgres', host: 'localhost', port: 5432, username: 'bloguser', password: 'tu_password', database: 'myblogdb', autoLoadEntities: true, synchronize: true, })

Dos propiedades importantes acá: autoLoadEntities en true carga automáticamente las entidades que registres en tus módulos, y synchronize en true sincroniza el esquema con tus entidades. Esto último es útil en desarrollo, pero nunca lo dejes activo en producción porque puede modificar tus tablas sin aviso.

Si tu API corre fuera de Docker y la base sí está en un contenedor, el host correcto desde tu máquina sigue siendo localhost apuntando al puerto expuesto, normalmente el 5432 de PostgreSQL [04:12].

Cómo verificar que la conexión funciona

Al correr la aplicación, TypeORM imprime en consola un mensaje confirmando que las dependencias se inicializaron correctamente. Si las credenciales están mal, verás un error claro indicando que no pudo establecer conexión con la base [05:30].

¿Para qué sirve synchronize: true en TypeORM? Sincroniza automáticamente tu esquema de base de datos con las entidades de tu código. Úsalo solo en desarrollo, nunca en producción.

Por qué mover las credenciales a variables de entorno

Dejar el password directamente en el código de TypeScript tiene dos problemas serios. El primero es de seguridad: ese código suele subirse a un repositorio remoto y puede ser visto por otros desarrolladores. El segundo es de flexibilidad: cada vez que despliegues a otro entorno (staging, producción) tendrías que tocar el código en lugar de cambiar una configuración [07:10].

La solución es usar un archivo .env, que está ignorado por git, junto con un módulo de configuración tipado.

Qué variables definir en el archivo .env

Para una conexión a PostgreSQL necesitas cinco variables claras y reutilizables:

POSTGRES_HOST con valor localhost.
POSTGRES_PORT con valor 5432.
POSTGRES_DB con el nombre de la base, por ejemplo myblogdb.
POSTGRES_USER con el usuario, como bloguser.
POSTGRES_PASSWORD con la contraseña.

Una buena práctica es mantener un archivo .env.example sin valores reales, solo con los nombres de las variables, para que cualquier persona que clone el repo sepa qué configurar [07:55].

Después mapeas esas variables en tu interfaz tipada de entorno. Todas son string, excepto el puerto que es number.

Cómo usar forRootAsync con ConfigService en TypeORM

Desde AppModule no puedes inyectar dependencias por constructor porque no es una clase de servicio. Para resolverlo, cambias forRoot por forRootAsync, que acepta una función useFactory capaz de recibir dependencias [08:40].

La configuración queda así:

typescript TypeOrmModule.forRootAsync({ inject: [ConfigService], useFactory: (configService: ConfigService<EnvVars>) => ({ type: 'postgres', host: configService.get('POSTGRES_HOST', { infer: true }), port: configService.get('POSTGRES_PORT', { infer: true }), username: configService.get('POSTGRES_USER', { infer: true }), password: configService.get('POSTGRES_PASSWORD', { infer: true }), database: configService.get('POSTGRES_DB', { infer: true }), autoLoadEntities: true, synchronize: true, }), })

Usar la opción { infer: true } activa la inferencia de tipos. Si te equivocas escribiendo el nombre de una variable, TypeScript te avisa de inmediato en lugar de fallar silenciosamente en runtime [09:50].

¿Cuándo usar forRootAsync en NestJS? Cuando tu configuración depende de otros servicios, como ConfigService. Te permite inyectar dependencias y construir la configuración de forma dinámica.

Un detalle fácil de pasar por alto: la propiedad para inyectar dependencias se llama inject, no imports. Confundir ese nombre genera un error al levantar la app [10:45].

Con esta configuración, tu código ya no tiene credenciales quemadas. En local lees del .env, y en producción inyectas las variables reales desde el servidor o el orquestador. Esa es la forma correcta de conectar NestJS a PostgreSQL con TypeORM y mantener tu API segura y portable.

¿Ya tienes tu conexión funcionando? Cuéntame en los comentarios qué motor de base de datos estás usando y si prefieres TypeORM o Prisma para tu próximo proyecto.

Cayo Legal

Hace un año

Refactorice un poco el código de inicialización de la base de datos

app.module.ts

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { DatabaseModule } from './core/database/database.module';
import { configOptions } from './core/config/config.options';

@Module({
  imports: [ConfigModule.forRoot(configOptions), DatabaseModule],
})
export class AppModule {}

core/database/database.module.ts

import { Module } from '@nestjs/common';
import { ConfigType } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { AppConfigType, APP_CONFIG } from '../config/config.loader';

@Module({
  imports: [
    TypeOrmModule.forRootAsync({
      useFactory: (config: ConfigType<AppConfigType>) => {
        const { host, name, password, port, username } = config.db;
        return {
          database: name,
          entities: [],
          host,
          password,
          port,
          synchronize: true,
          type: 'postgres',
          username,
        };
      },
      inject: [APP_CONFIG.KEY],
    }),
  ],
})
export class DatabaseModule {}

core/config.options

import { ConfigModuleOptions } from '@nestjs/config';
import { APP_CONFIG } from './config.loader';
import { configSchema } from './config.schema';

export const configOptions: ConfigModuleOptions = {
  envFilePath: '.env',
  isGlobal: true,
  load: [APP_CONFIG],
  validationSchema: configSchema,
};

core/config.loader.ts

import { registerAs } from '@nestjs/config';

export const APP_CONFIG = registerAs('config', () => ({
  db: {
    name: process.env.DATABASE_NAME,
    port: Number(process.env.DATABASE_PORT),
    username: process.env.DATABASE_USERNAME,
    password: process.env.DATABASE_PASSWORD,
    host: process.env.DATABASE_HOST,
  },
}));

export type AppConfigType = typeof APP_CONFIG;

core/config.schema

import * as Joi from 'joi';

export const configSchema = Joi.object({
  DATABASE_NAME: Joi.string().required(),
  DATABASE_PORT: Joi.number().port().required(),
  DATABASE_USERNAME: Joi.string().required(),
  DATABASE_PASSWORD: Joi.string().required(),
  DATABASE_HOST: Joi.string().hostname().required(),
});

Robinson Ganchala

Hace 9 meses

Incluso mejor si usas:

export type AppConfigType = ConfigType<typeof APP_CONFIG>

@Module({
  imports: [
    TypeOrmModule.forRootAsync({
      useFactory: (config: AppConfigType) => {
        const { url } = config.db
        return {
          type: 'postgres',
          url,
        ...
        }
      },
      inject: [APP_CONFIG.KEY]
    })
  ]
})

Un poco más simple

Fundamentos y Primer CRUD

Crea una API RESTful con NestJS

Instalación del CLI de NestJS y primer proyecto con API

Creación de endpoints dinámicos para consultar usuarios en NestJS

Operaciones CRUD en APIs REST con Postman

Método PUT para actualizar usuarios con ID automático

Manejo de status codes HTTP en NestJS

DTOs y validación automática de datos en APIs con NestJS

Servicios y lógica de negocio en NestJS

Variables de entorno seguras en NestJS

Programación modular en NestJS con UserModule

Base de Datos y Persistencia con TypeORM

Configuración de PostgreSQL con Docker y Docker Compose

Configuración de PostgreSQL con TypeORM en aplicaciones NestJS

Creación de entidades ORM con decoradores en TypeScript

Repository Pattern con TypeORM en NestJS

Relaciones uno a uno entre usuarios y perfiles en PostgreSQL

Actualización de DTOs con mapped types en NestJS para perfil y usuario

Generación automática de módulos CRUD con NestJS y AI

Relación uno a muchos con TypeORM

CRUD de categorías con IA en NestJS

Relaciones many-to-many con TypeORM y validación de arrays

Reutilización de servicios entre módulos en NestJS

Migraciones en TypeORM sin perder datos

Cómo evitar perder datos al migrar columnas

Autenticación y Autorización

Hashing de contraseñas con Bcrypt en NestJS

Excluir campos sensibles con ClassTransformer

Autenticación local con Passport en NestJS

Endpoint de login con Passport en NestJS

Implementación de JSON Web Token para autenticación en NestJS

Rutas protegidas con JWT en NestJS

User ID automático desde JWT en NestJS

Tu API Completa

Autogenera resúmenes e imágenes con OpenAI en NestJS

Documentación automática de APIs con Swagger en NestJS

Preparar tu API NestJS para producción

Desplegar aplicación Node.js a producción con Railway y PostgreSQL

Desarrollo de API REST escalable con NestJS en producción

Configuración de PostgreSQL con TypeORM en aplicaciones NestJS