Prisma para JavaScript (Node.js): guía completa con ejemplos

Prisma es un ORM (Object-Relational Mapping) moderno para Node.js y TypeScript que transforma por completo la forma de trabajar con bases de datos. A diferencia de los ORM tradicionales, Prisma ofrece un modelo de datos declarativo, generación automática de un cliente con seguridad de tipos y una potente herramienta de migraciones. Si estás cansado de escribir consultas SQL manualmente, lidiar con confusiones de tipos de datos y configuraciones complejas de ORM, Prisma será tu solución ideal.

¿Para qué sirve Prisma? En primer lugar, garantiza la seguridad de tipos a nivel de base de datos. Esto significa que los errores relacionados con tipos de campo incorrectos o relaciones faltantes se detectarán en tiempo de compilación, no en tiempo de ejecución. En segundo lugar, Prisma proporciona una API intuitiva para operaciones CRUD, filtrado, ordenamiento y agregación de datos. En tercer lugar, genera automáticamente documentación sobre tu esquema de datos y facilita la gestión de cambios mediante migraciones.

Prisma es compatible con las principales bases de datos relacionales: PostgreSQL, MySQL, SQLite, SQL Server y MongoDB (en modo Documento). Gracias a su arquitectura, es ideal tanto para proyectos pequeños como para aplicaciones empresariales. En este artículo, analizaremos en detalle la instalación, los métodos principales y ejemplos reales de uso de Prisma en el entorno Node.js.

Instalación

La instalación de Prisma consta de dos pasos: instalar la CLI (Command Line Interface) e inicializar el proyecto. Ejecuta los siguientes comandos en la terminal de tu proyecto:

npm install prisma --save-dev
npm install @prisma/client

Después de la instalación, inicializa Prisma en el proyecto:

npx prisma init

Este comando creará el directorio prisma con el archivo schema.prisma y un archivo .env para las variables de entorno. En el archivo .env, especifica la cadena de conexión a tu base de datos. Por ejemplo, para PostgreSQL:

DATABASE_URL="postgresql://usuario:contraseña@localhost:5432/mibd"

Para MySQL:

DATABASE_URL="mysql://usuario:contraseña@localhost:3306/mibd"

Para SQLite (base de datos de archivo):

DATABASE_URL="file:./dev.db"

Inicio rápido: ejemplo mínimo funcional

Vamos a crear un modelo de usuario simple y realizar operaciones básicas. Edita el archivo prisma/schema.prisma:

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite" // o "postgresql", "mysql"
  url      = env("DATABASE_URL")
}

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  name  String?
  posts Post[]
}

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

Ahora ejecuta la migración para crear las tablas en la base de datos:

npx prisma migrate dev --name init

Después de una migración exitosa, genera el Prisma Client:

npx prisma generate

Ahora crea un archivo index.js y escribe un script simple:

// index.js
const { PrismaClient } = require('@prisma/client');

const prisma = new PrismaClient();

async function main() {
  // Creamos un nuevo usuario
  const user = await prisma.user.create({
    data: {
      email: 'alicia@ejemplo.com',
      name: 'Alicia',
    },
  });
  console.log('Usuario creado:', user);

  // Creamos un post para el usuario
  const post = await prisma.post.create({
    data: {
      title: 'Mi primer post',
      content: '¡Hola, mundo desde Prisma!',
      authorId: user.id,
    },
  });
  console.log('Post creado:', post);

  // Consultamos todos los usuarios con sus posts
  const usersWithPosts = await prisma.user.findMany({
    include: { posts: true },
  });
  console.log('Usuarios con posts:', JSON.stringify(usersWithPosts, null, 2));
}

main()
  .catch((e) => {
    console.error(e);
    process.exit(1);
  })
  .finally(async () => {
    await prisma.$disconnect();
  });

Ejecuta el script con Node.js:

node index.js

Verás cómo se crean los registros y se muestran en la consola. ¡Felicidades, acabas de usar Prisma por primera vez!

Métodos principales de Prisma Client

Prisma Client ofrece una amplia gama de métodos para interactuar con tu base de datos. Aquí tienes los más importantes:

1. create - Crear registros

Crea uno o varios registros en una tabla.

// Crear un solo usuario
const user = await prisma.user.create({
  data: {
    email: 'juan@ejemplo.com',
    name: 'Juan Pérez',
  },
});

// Crear múltiples usuarios
const users = await prisma.user.createMany({
  data: [
    { email: 'ana@ejemplo.com', name: 'Ana García' },
    { email: 'carlos@ejemplo.com', name: 'Carlos López' },
  ],
});

2. findUnique - Buscar por identificador único

Busca un registro por su clave primaria o campo único.

const user = await prisma.user.findUnique({
  where: { email: 'juan@ejemplo.com' },
});

3. findMany - Buscar múltiples registros

Obtiene varios registros con opciones de filtrado, ordenamiento y paginación.

// Todos los usuarios
const allUsers = await prisma.user.findMany();

// Con filtros y ordenamiento
const filteredUsers = await prisma.user.findMany({
  where: { name: { contains: 'Juan' } },
  orderBy: { email: 'asc' },
  take: 10,
  skip: 0,
});

4. update - Actualizar registros

Actualiza uno o varios registros existentes.

// Actualizar un usuario
const updatedUser = await prisma.user.update({
  where: { id: 1 },
  data: { name: 'Juan Actualizado' },
});

// Actualizar múltiples usuarios
const updatedUsers = await prisma.user.updateMany({
  where: { name: { contains: 'Antiguo' } },
  data: { name: 'Nuevo Nombre' },
});

5. delete - Eliminar registros

Elimina uno o varios registros.

// Eliminar un usuario
const deletedUser = await prisma.user.delete({
  where: { id: 1 },
});

// Eliminar múltiples usuarios
const deletedUsers = await prisma.user.deleteMany({
  where: { email: { endsWith: '@temporal.com' } },
});

6. count - Contar registros

Cuenta el número de registros que coinciden con un filtro.

const totalUsers = await prisma.user.count();
const activeUsers = await prisma.user.count({
  where: { posts: { some: { published: true } } },
});

7. aggregate - Agregaciones

Realiza operaciones de agregación como suma, promedio, mínimo y máximo.

const aggregation = await prisma.post.aggregate({
  _count: { id: true },
  _avg: { authorId: true },
  _max: { id: true },
});

Relaciones y consultas avanzadas

Prisma facilita el trabajo con relaciones entre tablas. Puedes incluir, filtrar y anidar relaciones fácilmente:

// Obtener usuarios con sus posts
const usersWithPosts = await prisma.user.findMany({
  include: {
    posts: {
      where: { published: true },
      orderBy: { title: 'asc' },
    },
  },
});

// Filtrar por relación
const usersWithPublishedPosts = await prisma.user.findMany({
  where: {
    posts: {
      some: { published: true },
    },
  },
});

// Crear un usuario con posts anidados
const userWithPosts = await prisma.user.create({
  data: {
    email: 'maria@ejemplo.com',
    name: 'María Rodríguez',
    posts: {
      create: [
        { title: 'Post 1', content: 'Contenido del post 1' },
        { title: 'Post 2', content: 'Contenido del post 2' },
      ],
    },
  },
  include: { posts: true },
});

Migraciones y gestión del esquema

Prisma incluye un potente sistema de migraciones. Aquí tienes los comandos esenciales:

# Crear una nueva migración
npx prisma migrate dev --name nombre_de_migracion

# Aplicar migraciones en producción
npx prisma migrate deploy

# Restablecer la base de datos (¡cuidado! borra datos)
npx prisma migrate reset

# Ver el estado de las migraciones
npx prisma migrate status

Conclusión

Prisma es una herramienta extraordinaria que simplifica drásticamente el trabajo con bases de datos en Node.js. Su seguridad de tipos, API intuitiva y potentes herramientas de migración lo convierten en una opción superior frente a ORM tradicionales como Sequelize o TypeORM. Ya sea que estés construyendo una API REST, una aplicación GraphQL o un microservicio, Prisma te ayudará a escribir código más limpio, seguro y mantenible.

¿Listo para probarlo? Instala Prisma hoy mismo y descubre cómo puede transformar tu flujo de trabajo con bases de datos. ¡Tu futuro yo te lo agradecerá!