Blog System

1// src/lib/blog/queries.ts
2import { prisma } from "@/lib/db";
3
4export async function getPublishedPosts(options?: {
5  limit?: number;
6  categorySlug?: string;
7  featured?: boolean;
8}) {
9  const { limit, categorySlug, featured } = options || {};
10
11  return prisma.blogPost.findMany({
12    where: {
13      published: true,
14      ...(categorySlug && { category: { slug: categorySlug } }),
15      ...(featured !== undefined && { featured }),
16    },
17    include: {
18      author: { select: { name: true, image: true } },
19      category: { select: { name: true, slug: true } },
20    },
21    orderBy: { publishedAt: "desc" },
22    take: limit,
23  });
24}
25
26// Get single post by slug
27export async function getPostBySlug(slug: string) {
28  const post = await prisma.blogPost.findUnique({
29    where: { slug },
30    include: {
31      author: { select: { name: true, image: true } },
32      category: { select: { name: true, slug: true } },
33    },
34  });
35
36  if (post) {
37    // Increment view count
38    await prisma.blogPost.update({
39      where: { id: post.id },
40      data: { viewCount: { increment: 1 } },
41    });
42  }
43
44  return post;
45}

1// src/app/blog/page.tsx
2import { getPublishedPosts } from "@/lib/blog/queries";
3import Link from "next/link";
4
5export default async function BlogPage() {
6  const posts = await getPublishedPosts();
7
8  return (
9    <div className="container py-12">
10      <h1 className="font-mono text-2xl font-semibold mb-8">
11        [ BLOG ]
12      </h1>
13
14      <div className="grid gap-6 md:grid-cols-2 lg:grid-cols-3">
15        {posts.map((post) => (
16          <Link key={post.id} href={`/blog/${post.slug}`}>
17            <article className="border border-border p-6 transition-colors">
18              {post.category && (
19                <span className="text-xs text-primary font-mono">
20                  {post.category.name}
21                </span>
22              )}
23              <h2 className="font-mono text-xs font-semibold mt-2">
24                {post.title}
25              </h2>
26              {post.excerpt && (
27                <p className="text-muted-foreground text-sm mt-2">
28                  {post.excerpt}
29                </p>
30              )}
31              <div className="flex items-center gap-4 mt-4 text-xs text-muted-foreground">
32                <span>{post.readTime} min read</span>
33                <span>{post.viewCount} views</span>
34              </div>
35            </article>
36          </Link>
37        ))}
38      </div>
39    </div>
40  );
41}

1// src/app/api/blog/posts/route.ts
2import { NextResponse } from "next/server";
3import { auth } from "@/lib/auth";
4import { createPost } from "@/lib/blog/queries";
5import { generateSlug, calculateReadTime } from "@/lib/blog/utils";
6
7export async function POST(req: Request) {
8  const session = await auth();
9
10  // Only admins can create posts
11  if (!session?.user || session.user.role !== "ADMIN") {
12    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
13  }
14
15  const body = await req.json();
16  const { title, content, excerpt, categoryId, featured, published } = body;
17
18  try {
19    const post = await createPost({
20      title,
21      slug: generateSlug(title),
22      content,
23      excerpt: excerpt || content.slice(0, 160) + "...",
24      categoryId,
25      featured: featured || false,
26      published: published || false,
27      authorId: session.user.id,
28      readTime: calculateReadTime(content),
29      publishedAt: published ? new Date() : null,
30    });
31
32    return NextResponse.json({ post });
33  } catch (error) {
34    console.error("Create post error:", error);
35    return NextResponse.json(
36      { error: "Failed to create post" },
37      { status: 500 }
38    );
39  }
40}

1// src/lib/blog/utils.ts
2
3// Generate URL-friendly slug from title
4export function generateSlug(title: string): string {
5  return title
6    .toLowerCase()
7    .replace(/[^a-z0-9]+/g, "-")
8    .replace(/^-+|-+$/g, "");
9}
10
11// Calculate read time (average 200 words per minute)
12export function calculateReadTime(content: string): number {
13  const words = content.trim().split(/\s+/).length;
14  return Math.ceil(words / 200);
15}
16
17// Format date for display
18export function formatDate(date: Date | string): string {
19  return new Date(date).toLocaleDateString("en-US", {
20    year: "numeric",
21    month: "long",
22    day: "numeric",
23  });
24}