ORM de Prisma - Acceso a base de datos con seguridad de tipos con cliente generado automáticamente y migraciones

npm install prisma @prisma/client
npx prisma init

// prisma/schema.prisma
generator client {
  provider = "prisma-client-js"
}
 
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}
 
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
  createdAt DateTime @default(now())
}

npx prisma migrate dev --name init
npx prisma generate

// lib/prisma.ts
import { PrismaClient } from "@prisma/client";
 
const globalForPrisma = globalThis as unknown as { prisma: PrismaClient };
 
export const prisma = globalForPrisma.prisma ?? new PrismaClient();
 
if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = prisma;

// app/posts/page.tsx (Server Component)
import { prisma } from "@/lib/prisma";
 
export default async function PostsPage() {
  const posts = await prisma.post.findMany({
    where: { published: true },
    include: { author: { select: { name: true, email: true } } },
    orderBy: { createdAt: "desc" },
    take: 20,
  });
 
  return (
    <div className="max-w-3xl mx-auto p-6">
      <h1 className="text-2xl font-bold mb-6">Publicaciones publicadas</h1>
      {posts.map((post) => (
        <article key={post.id} className="border-b py-4">
          <h2 className="text-xl font-semibold">{post.title}</h2>
          <p className="text-gray-600 text-sm">
            por {post.author.name ?? "Anónimo"}
          </p>
          {post.content && <p className="mt-2">{post.content}</p>}
        </article>
      ))}
    </div>
  );
}

// app/posts/actions.ts
"use server";
import { prisma } from "@/lib/prisma";
import { revalidatePath } from "next/cache";
 
export async function createPost(formData: FormData) {
  const title = formData.get("title") as string;
  const content = formData.get("content") as string;
  const authorId = Number(formData.get("authorId"));
 
  await prisma.post.create({
    data: { title, content, authorId, published: false },
  });
 
  revalidatePath("/posts");
}
 
export async function publishPost(postId: number) {
  await prisma.post.update({
    where: { id: postId },
    data: { published: true },
  });
 
  revalidatePath("/posts");
}
 
export async function deletePost(postId: number) {
  await prisma.post.delete({ where: { id: postId } });
  revalidatePath("/posts");
}

// app/posts/new/page.tsx
"use client";
import { createPost } from "../actions";
 
export default function NewPostPage() {
  return (
    <form action={createPost} className="max-w-md mx-auto p-6 space-y-4">
      <input type="hidden" name="authorId" value="1" />
      <div>
        <label className="block text-sm font-medium">Título</label>
        <input
          name="title"
          required
          className="w-full border rounded px-3 py-2"
        />
      </div>
      <div>
        <label className="block text-sm font-medium">Contenido</label>
        <textarea
          name="content"
          rows={5}
          className="w-full border rounded px-3 py-2"
        />
      </div>
      <button
        type="submit"
        className="bg-blue-600 text-white px-4 py-2 rounded"
      >
        Crear publicación
      </button>
    </form>
  );
}

const results = await prisma.post.findMany({
  where: {
    AND: [
      { published: true },
      { title: { contains: searchQuery, mode: "insensitive" } },
    ],
  },
  skip: (page - 1) * pageSize,
  take: pageSize,
  orderBy: { createdAt: "desc" },
});
 
const total = await prisma.post.count({
  where: { published: true },
});

const [post, user] = await prisma.$transaction([
  prisma.post.create({ data: { title: "Hello", authorId: 1 } }),
  prisma.user.update({
    where: { id: 1 },
    data: { name: "Updated Name" },
  }),
]);
 
// Interactive transaction
await prisma.$transaction(async (tx) => {
  const user = await tx.user.findUnique({ where: { id: 1 } });
  if (!user) throw new Error("User not found");
  await tx.post.create({ data: { title: "Hello", authorId: user.id } });
});

const user = await prisma.user.upsert({
  where: { email: "alice@example.com" },
  update: { name: "Alice Updated" },
  create: { email: "alice@example.com", name: "Alice" },
});

const results = await prisma.$queryRaw<
  { id: number; title: string }[]
>`SELECT id, title FROM "Post" WHERE "published" = true LIMIT ${limit}`;

import { Prisma } from "@prisma/client";
 
type PostWithAuthor = Prisma.PostGetPayload<{
  include: { author: true };
}>;
 
function renderPost(post: PostWithAuthor) {
  return `${post.title} by ${post.author.name}`;
}