Full-Stack Next.js 15 & Prisma ORM: Database Migrations, Server Actions & Zod Validation

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

enum UserRole {
  USER
  AUTHOR
  ADMIN
}

model User {
  id        String    @id @default(cuid())
  email     String    @unique
  name      String?
  role      UserRole  @default(USER)
  articles  Article[]
  createdAt DateTime  @default(now())
  updatedAt DateTime  @updatedAt

  @@index([email])
}

model Article {
  id          String   @id @default(cuid())
  slug        String   @unique
  title       String
  content     String   @db.Text
  published   Boolean  @default(false)
  authorId    String
  author      User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  @@index([slug])
  @@index([authorId])
}

# Generate SQL migration and execute against PostgreSQL
npx prisma migrate dev --name init_users_and_articles

import { PrismaClient } from "@prisma/client";

const globalForPrisma = globalThis as unknown as {
  prisma: PrismaClient | undefined;
};

export const db =
  globalForPrisma.prisma ??
  new PrismaClient({
    log: process.env.NODE_ENV === "development" ? ["query", "error", "warn"] : ["error"],
  });

if (process.env.NODE_ENV !== "production") globalForPrisma.prisma = db;

import { z } from "zod";

export const CreateArticleSchema = z.object({
  title: z
    .string()
    .min(5, "Title must be at least 5 characters")
    .max(120, "Title must be under 120 characters"),
  slug: z
    .string()
    .min(3)
    .max(100)
    .regex(/^[a-z0-9-]+$/, "Slug can only contain lowercase letters, numbers, and hyphens"),
  content: z.string().min(50, "Content must be at least 50 characters"),
  published: z.boolean().default(false),
});

export type CreateArticleInput = z.infer<typeof CreateArticleSchema>;

"use server";

import { db } from "@/lib/prisma";
import { CreateArticleSchema } from "@/lib/validations/article";
import { revalidatePath } from "next/cache";

export type ActionState = {
  success: boolean;
  message?: string;
  errors?: Record<string, string[]>;
};

export async function createArticleAction(
  prevState: ActionState,
  formData: FormData
): Promise<ActionState> {
  // 1. Extract and validate form data
  const rawData = {
    title: formData.get("title"),
    slug: formData.get("slug"),
    content: formData.get("content"),
    published: formData.get("published") === "on",
  };

  const validation = CreateArticleSchema.safeParse(rawData);

  if (!validation.success) {
    return {
      success: false,
      errors: validation.error.flatten().fieldErrors,
    };
  }

  // 2. Insert into PostgreSQL via Prisma
  try {
    const existing = await db.article.findUnique({
      where: { slug: validation.data.slug },
    });

    if (existing) {
      return {
        success: false,
        message: "An article with this slug already exists.",
      };
    }

    await db.article.create({
      data: {
        ...validation.data,
        authorId: "demo-user-id", // Replace with authenticated session user ID
      },
    });

    // 3. Revalidate ISR cache for the blog listing page
    revalidatePath("/blog");

    return {
      success: true,
      message: "Article published successfully!",
    };
  } catch (error) {
    console.error("Database mutation error:", error);
    return {
      success: false,
      message: "Database error occurred while creating article.",
    };
  }
}