guias3 de enero de 2026·8 min de lectura

PostgreSQL para Devs TypeScript: Lo Esencial para tu Proyecto Next.js

guía práctica de PostgreSQL para desarrolladores TypeScript. Setup con Docker, conexión con Prisma/Drizzle, queries esenciales y tipos type-safe desde tu schema.

PostgreSQL para Devs TypeScript: Lo Esencial para tu Proyecto Next.js

PostgreSQL es la base de datos más deseada entre desarrolladores según el Stack Overflow Survey 2025 -- 47% quieren usarla. Y tiene sentido: es gratuita, potente, y con el ORM correcto te da tipos TypeScript automaticos desde tu schema.

Esta guía cubre lo que necesitas como dev fullstack para integrar PostgreSQL en tu proyecto Next.js. Sin teoria de DBA, sin optimización prematura. Lo práctico.

Setup con Docker Compose

No instales PostgreSQL en tu maquina. Usa Docker y todos en tu equipo trabajan con la misma versión:

yaml

# docker-compose.yml
services:
  db:
    image: postgres:17-alpine
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: miapp
    volumes:
      - postgres_data:/var/lib/postgresql/data
 
volumes:
  postgres_data:

bash

docker compose up -d

Listo. PostgreSQL corriendo en localhost:5432. Los datos persisten en el volumen aunque reinicies el contenedor.

Tu connection string para el .env:

bash

DATABASE_URL="postgresql://postgres:postgres@localhost:5432/miapp"

Si necesitas Docker para tu app Next.js completa, revisa la guía de Docker para Next.js donde cubrimos multi-stage build y standalone output.

Conectar con Prisma o Drizzle

Tienes dos opciones solidas. Si no sabes cuál elegir, tenemos una comparativa completa de Prisma vs Drizzle.

Opción A: Prisma

bash

npm install prisma @prisma/client
npx prisma init

Define tu schema en prisma/schema.prisma:

prisma

model User {
  id        Int      @id @default(autoincrement())
  email     String   @unique
  name      String?
  posts     Post[]
  createdAt DateTime @default(now())
}
 
model Post {
  id        Int      @id @default(autoincrement())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  Int
}

bash

npx prisma db push

Prisma genera tipos TypeScript automáticamente. Tu editor sabe exactamente que campos tiene cada modelo.

Opción B: Drizzle

bash

npm install drizzle-orm postgres
npm install -D drizzle-kit

Define tu schema en TypeScript directamente:

typescript

// src/db/schema.ts
import { pgTable, serial, text, boolean, timestamp, integer } from "drizzle-orm/pg-core";
 
export const users = pgTable("users", {
  id: serial("id").primaryKey(),
  email: text("email").notNull().unique(),
  name: text("name"),
  createdAt: timestamp("created_at").defaultNow(),
});
 
export const posts = pgTable("posts", {
  id: serial("id").primaryKey(),
  title: text("title").notNull(),
  content: text("content"),
  published: boolean("published").default(false),
  authorId: integer("author_id").references(() => users.id),
});

Con Drizzle el schema ES TypeScript, así que los tipos ya estan ahi sin generar nada extra.

Queries esenciales

Estas son las operaciones que vas a usar el 90% del tiempo. Ejemplos con Prisma porque es el más común, pero Drizzle es similar.

CRUD básico

typescript

// Crear
const user = await prisma.user.create({
  data: { email: "rod@ejemplo.com", name: "Rod" },
});
 
// Leer uno
const user = await prisma.user.findUnique({
  where: { email: "rod@ejemplo.com" },
});
 
// Leer varios con filtro
const posts = await prisma.post.findMany({
  where: { published: true },
  orderBy: { createdAt: "desc" },
  take: 10,
});
 
// Actualizar
await prisma.user.update({
  where: { id: 1 },
  data: { name: "Rod Alexanderson" },
});
 
// Eliminar
await prisma.post.delete({ where: { id: 5 } });

Relaciones (JOINs)

typescript

// Traer usuario con sus posts (JOIN automático)
const userWithPosts = await prisma.user.findUnique({
  where: { id: 1 },
  include: { posts: true },
});
 
// Traer posts con datos del autor
const posts = await prisma.post.findMany({
  where: { published: true },
  include: {
    author: { select: { name: true, email: true } },
  },
});

Filtros comunes

typescript

// búsqueda parcial (LIKE)
const results = await prisma.post.findMany({
  where: { title: { contains: "nextjs", mode: "insensitive" } },
});
 
// múltiples condiciones
const results = await prisma.post.findMany({
  where: {
    AND: [
      { published: true },
      { createdAt: { gte: new Date("2026-01-01") } },
    ],
  },
});

Todo esto es type-safe. Si escribes mal un campo, TypeScript te avisa antes de correr el código.

Tipos type-safe desde tu schema

Esta es la parte donde PostgreSQL + TypeScript brillan juntos. Con Prisma, después de definir tu schema, corres:

bash

npx prisma generate

Esto genera tipos que puedes importar en cualquier parte:

typescript

import type { User, Post } from "@prisma/client";
 
// TypeScript sabe exactamente que tiene User
function formatUser(user: User): string {
  return `${user.name} (${user.email})`;
}

Con Drizzle es aun más directo porque el schema ya es TypeScript:

typescript

import type { InferSelectModel } from "drizzle-orm";
import { users } from "./schema";
 
type User = InferSelectModel<typeof users>;

En ambos casos, si cambias tu schema de base de datos, los tipos se actualizan y TypeScript te marca todos los lugares donde necesitas ajustar tu código. Zero sorpresas en runtime.

Siguiente paso

Si tu proyecto necesita autenticación, revisa la guía de Auth.js v5 con Next.js que usa PostgreSQL como adapter. Y si quieres una alternativa hosted que incluye PostgreSQL + auth + storage, la guía de Supabase con Next.js cubre todo el setup.

#postgresql#typescript#nextjs#prisma#drizzle#base-de-datos

Preguntas frecuentes

¿Cuál es la mejor forma de conectar PostgreSQL con Next.js?

Usa un ORM como Prisma o Drizzle. Prisma es más fácil de aprender y tiene mejor documentación. Drizzle es más ligero y te da más control sobre las queries. Ambos generan tipos TypeScript automáticamente desde tu schema.

¿Necesito saber SQL para usar PostgreSQL con TypeScript?

Lo básico si: SELECT, INSERT, UPDATE, DELETE, JOINs y filtros con WHERE. Un ORM te abstrae mucho, pero entender qué pasa por debajo te ayuda a debuggear y optimizar cuando algo es lento.

¿Cómo levanto PostgreSQL para desarrollo local?

Con Docker Compose. Un archivo de 10 líneas te levanta PostgreSQL con datos persistentes. No necesitas instalar nada en tu maquina, y todos en tu equipo usan la misma versión.

¿Prisma o Drizzle para PostgreSQL?

Prisma si quieres algo que funcione rápido con buena documentación y migraciones automaticas. Drizzle si prefieres queries más cercanas a SQL y un bundle más liviano. Tenemos una comparativa detallada en el blog.

Articulos relacionados

Next.js 16: guía de Migración y Novedades

Migra tu proyecto de Next.js 15 a 16. Novedades principales, breaking changes, y pasos para actualizar sin romper tu app.

Testing en Next.js con Vitest y Playwright

Configura testing en tu proyecto Next.js. Unit tests con Vitest, E2E con Playwright, y como integrarlos en tu pipeline de CI/CD.

Tailwind CSS 4: Migración desde v3

Migra tu proyecto de Tailwind CSS 3 a 4. Cambios principales, nuevo sistema de configuración, CSS-first config y como actualizar sin romper tu app.

Blog

Artículos Recientes

Server Components vs Client Components

App Router vs Pages Router en NextJS

Supabase con NextJS: Guia desde Cero

Seguridad en Aplicaciones NextJS

Validacion con Zod y React Hook Form

Categorías

Tags Populares

Rod Alexanderson

Suscríbete al Newsletter

PostgreSQL para Devs TypeScript: Lo Esencial para tu Proyecto Next.js

PostgreSQL para Devs TypeScript: Lo Esencial para tu Proyecto Next.js

Setup con Docker Compose

Conectar con Prisma o Drizzle

Opción A: Prisma

Opción B: Drizzle

Queries esenciales

CRUD básico

Relaciones (JOINs)

Filtros comunes

Tipos type-safe desde tu schema

Siguiente paso

Preguntas frecuentes

Articulos relacionados