دمج قاعدة البيانات مع Prisma

# تثبيت Prisma CLI كتبعية تطوير
npm install -D prisma

# تثبيت Prisma Client
npm install @prisma/client

# تهيئة Prisma
npx prisma init

# .env
# PostgreSQL
DATABASE_URL="postgresql://user:password@localhost:5432/mydb?schema=public"

# MySQL
DATABASE_URL="mysql://user:password@localhost:3306/mydb"

# SQLite (للتطوير)
DATABASE_URL="file:./dev.db"

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

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

model User {
  id            String    @id @default(cuid())
  email         String    @unique
  name          String?
  hashedPassword String?
  image         String?
  role          Role      @default(USER)
  createdAt     DateTime  @default(now())
  updatedAt     DateTime  @updatedAt

  posts         Post[]
  comments      Comment[]
  sessions      Session[]
  accounts      Account[]

  @@map("users")
}

model Post {
  id          String    @id @default(cuid())
  title       String
  slug        String    @unique
  content     String    @db.Text
  excerpt     String?
  published   Boolean   @default(false)
  views       Int       @default(0)
  authorId    String
  categoryId  String?
  createdAt   DateTime  @default(now())
  updatedAt   DateTime  @updatedAt

  author      User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
  category    Category? @relation(fields: [categoryId], references: [id])
  comments    Comment[]
  tags        PostTag[]

  @@index([authorId])
  @@index([categoryId])
  @@index([slug])
  @@map("posts")
}

model Category {
  id          String   @id @default(cuid())
  name        String   @unique
  slug        String   @unique
  description String?
  createdAt   DateTime @default(now())

  posts       Post[]

  @@map("categories")
}

model Comment {
  id          String   @id @default(cuid())
  content     String   @db.Text
  postId      String
  authorId    String
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt

  post        Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
  author      User     @relation(fields: [authorId], references: [id], onDelete: Cascade)

  @@index([postId])
  @@index([authorId])
  @@map("comments")
}

model Tag {
  id          String    @id @default(cuid())
  name        String    @unique
  slug        String    @unique
  createdAt   DateTime  @default(now())

  posts       PostTag[]

  @@map("tags")
}

model PostTag {
  postId      String
  tagId       String

  post        Post     @relation(fields: [postId], references: [id], onDelete: Cascade)
  tag         Tag      @relation(fields: [tagId], references: [id], onDelete: Cascade)

  @@id([postId, tagId])
  @@map("post_tags")
}

enum Role {
  USER
  ADMIN
  MODERATOR
}

// نماذج Auth.js
model Account {
  id                String  @id @default(cuid())
  userId            String
  type              String
  provider          String
  providerAccountId String
  refresh_token     String? @db.Text
  access_token      String? @db.Text
  expires_at        Int?
  token_type        String?
  scope             String?
  id_token          String? @db.Text
  session_state     String?

  user User @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@unique([provider, providerAccountId])
  @@map("accounts")
}

model Session {
  id           String   @id @default(cuid())
  sessionToken String   @unique
  userId       String
  expires      DateTime
  user         User     @relation(fields: [userId], references: [id], onDelete: Cascade)

  @@map("sessions")
}

# إنشاء ترحيل
npx prisma migrate dev --name init

# هذا يفعل ثلاثة أشياء:
# 1. ينشئ ملفات ترحيل SQL في prisma/migrations
# 2. يطبق الترحيل على قاعدة البيانات
# 3. يولد Prisma Client

# تطبيق الترحيلات في الإنتاج
npx prisma migrate deploy

# إعادة تعيين قاعدة البيانات (التطوير فقط)
npx prisma migrate reset

<!-- lib/prisma.ts -->
import { PrismaClient } from '@prisma/client'

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

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

if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma

<!-- lib/actions/post-actions.ts -->
'use server'

import { prisma } from '@/lib/prisma'
import { revalidatePath } from 'next/cache'

export async function createPost(data: {
  title: string
  slug: string
  content: string
  excerpt?: string
  authorId: string
  categoryId?: string
  published?: boolean
}) {
  try {
    const post = await prisma.post.create({
      data: {
        title: data.title,
        slug: data.slug,
        content: data.content,
        excerpt: data.excerpt,
        published: data.published ?? false,
        author: {
          connect: { id: data.authorId }
        },
        ...(data.categoryId && {
          category: {
            connect: { id: data.categoryId }
          }
        })
      },
      include: {
        author: {
          select: {
            id: true,
            name: true,
            email: true,
          }
        },
        category: true,
      }
    })

    revalidatePath('/blog')
    return { success: true, post }
  } catch (error) {
    console.error('خطأ في إنشاء المنشور:', error)
    return { success: false, error: 'فشل إنشاء المنشور' }
  }
}

// الإنشاء مع العلاقات (متعدد إلى متعدد)
export async function createPostWithTags(data: {
  title: string
  slug: string
  content: string
  authorId: string
  tagIds: string[]
}) {
  try {
    const post = await prisma.post.create({
      data: {
        title: data.title,
        slug: data.slug,
        content: data.content,
        author: {
          connect: { id: data.authorId }
        },
        tags: {
          create: data.tagIds.map(tagId => ({
            tag: {
              connect: { id: tagId }
            }
          }))
        }
      },
      include: {
        tags: {
          include: {
            tag: true
          }
        }
      }
    })

    revalidatePath('/blog')
    return { success: true, post }
  } catch (error) {
    return { success: false, error: 'فشل إنشاء المنشور' }
  }
}

<!-- lib/queries/post-queries.ts -->
import { prisma } from '@/lib/prisma'
import { cache } from 'react'

// الحصول على منشور واحد (مخزن مؤقتاً)
export const getPostBySlug = cache(async (slug: string) => {
  return await prisma.post.findUnique({
    where: { slug },
    include: {
      author: {
        select: {
          id: true,
          name: true,
          email: true,
          image: true,
        }
      },
      category: true,
      comments: {
        include: {
          author: {
            select: {
              id: true,
              name: true,
              image: true,
            }
          }
        },
        orderBy: {
          createdAt: 'desc'
        }
      },
      tags: {
        include: {
          tag: true
        }
      }
    }
  })
})

// الحصول على جميع المنشورات مع الترقيم والتصفية
export async function getPosts({
  page = 1,
  limit = 10,
  categoryId,
  authorId,
  published = true,
  searchQuery,
}: {
  page?: number
  limit?: number
  categoryId?: string
  authorId?: string
  published?: boolean
  searchQuery?: string
}) {
  const skip = (page - 1) * limit

  const where = {
    ...(published !== undefined && { published }),
    ...(categoryId && { categoryId }),
    ...(authorId && { authorId }),
    ...(searchQuery && {
      OR: [
        { title: { contains: searchQuery, mode: 'insensitive' as const } },
        { content: { contains: searchQuery, mode: 'insensitive' as const } },
      ]
    })
  }

  const [posts, total] = await Promise.all([
    prisma.post.findMany({
      where,
      skip,
      take: limit,
      orderBy: {
        createdAt: 'desc'
      },
      include: {
        author: {
          select: {
            id: true,
            name: true,
            image: true,
          }
        },
        category: true,
        _count: {
          select: {
            comments: true
          }
        }
      }
    }),
    prisma.post.count({ where })
  ])

  return {
    posts,
    pagination: {
      total,
      pages: Math.ceil(total / limit),
      currentPage: page,
      perPage: limit,
    }
  }
}

// استعلامات التجميع
export async function getPostStats(authorId: string) {
  const stats = await prisma.post.aggregate({
    where: { authorId },
    _count: {
      id: true
    },
    _sum: {
      views: true
    },
    _avg: {
      views: true
    }
  })

  return stats
}

<!-- lib/actions/post-actions.ts -->
export async function updatePost(
  id: string,
  data: {
    title?: string
    slug?: string
    content?: string
    excerpt?: string
    published?: boolean
    categoryId?: string | null
  }
) {
  try {
    const post = await prisma.post.update({
      where: { id },
      data: {
        ...(data.title && { title: data.title }),
        ...(data.slug && { slug: data.slug }),
        ...(data.content && { content: data.content }),
        ...(data.excerpt !== undefined && { excerpt: data.excerpt }),
        ...(data.published !== undefined && { published: data.published }),
        ...(data.categoryId !== undefined && {
          category: data.categoryId
            ? { connect: { id: data.categoryId } }
            : { disconnect: true }
        })
      }
    })

    revalidatePath('/blog')
    revalidatePath(`/blog/${post.slug}`)
    return { success: true, post }
  } catch (error) {
    return { success: false, error: 'فشل تحديث المنشور' }
  }
}

// التحديث مع العلاقات
export async function updatePostTags(postId: string, tagIds: string[]) {
  try {
    await prisma.post.update({
      where: { id: postId },
      data: {
        tags: {
          deleteMany: {}, // إزالة جميع العلامات الموجودة
          create: tagIds.map(tagId => ({
            tag: {
              connect: { id: tagId }
            }
          }))
        }
      }
    })

    revalidatePath('/blog')
    return { success: true }
  } catch (error) {
    return { success: false, error: 'فشل تحديث العلامات' }
  }
}

// زيادة عدد المشاهدات
export async function incrementPostViews(slug: string) {
  await prisma.post.update({
    where: { slug },
    data: {
      views: {
        increment: 1
      }
    }
  })
}

<!-- lib/actions/post-actions.ts -->
export async function deletePost(id: string) {
  try {
    await prisma.post.delete({
      where: { id }
    })

    revalidatePath('/blog')
    return { success: true }
  } catch (error) {
    return { success: false, error: 'فشل حذف المنشور' }
  }
}

// الحذف الناعم (باستخدام حقل deletedAt)
export async function softDeletePost(id: string) {
  try {
    await prisma.post.update({
      where: { id },
      data: {
        deletedAt: new Date()
      }
    })

    revalidatePath('/blog')
    return { success: true }
  } catch (error) {
    return { success: false, error: 'فشل حذف المنشور' }
  }
}

// الحذف الجماعي
export async function deletePostsByAuthor(authorId: string) {
  try {
    const result = await prisma.post.deleteMany({
      where: { authorId }
    })

    revalidatePath('/blog')
    return { success: true, count: result.count }
  } catch (error) {
    return { success: false, error: 'فشل حذف المنشورات' }
  }
}

export async function createUserWithProfile(data: {
  email: string
  name: string
  password: string
  bio?: string
}) {
  try {
    const hashedPassword = await bcrypt.hash(data.password, 12)

    const result = await prisma.$transaction(async (tx) => {
      // إنشاء المستخدم
      const user = await tx.user.create({
        data: {
          email: data.email,
          name: data.name,
          hashedPassword,
        }
      })

      // إنشاء الملف الشخصي
      const profile = await tx.profile.create({
        data: {
          userId: user.id,
          bio: data.bio || ''
        }
      })

      // إنشاء الإعدادات الافتراضية
      const settings = await tx.settings.create({
        data: {
          userId: user.id,
          theme: 'light',
          emailNotifications: true,
        }
      })

      return { user, profile, settings }
    })

    return { success: true, data: result }
  } catch (error) {
    return { success: false, error: 'فشل إنشاء المستخدم' }
  }
}

// التصفية المعقدة مع العلاقات المتداخلة
export async function searchPosts(query: string) {
  return await prisma.post.findMany({
    where: {
      OR: [
        { title: { contains: query, mode: 'insensitive' } },
        { content: { contains: query, mode: 'insensitive' } },
        {
          author: {
            name: { contains: query, mode: 'insensitive' }
          }
        },
        {
          tags: {
            some: {
              tag: {
                name: { contains: query, mode: 'insensitive' }
              }
            }
          }
        }
      ],
      published: true,
    },
    include: {
      author: true,
      category: true,
      tags: {
        include: { tag: true }
      }
    },
    orderBy: [
      { views: 'desc' },
      { createdAt: 'desc' }
    ],
    take: 20
  })
}

// SQL خام للاستعلامات المعقدة
export async function getPopularPostsByViews() {
  return await prisma.$queryRaw`
    SELECT p.*, u.name as author_name, COUNT(c.id) as comment_count
    FROM posts p
    LEFT JOIN users u ON p.author_id = u.id
    LEFT JOIN comments c ON p.id = c.post_id
    WHERE p.published = true
    GROUP BY p.id, u.name
    ORDER BY p.views DESC, comment_count DESC
    LIMIT 10
  `
}

# تشغيل Prisma Studio
npx prisma studio

# يفتح http://localhost:5555