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?
  password  String
  posts     Post[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt
}

model Post {
  id        String   @id @default(cuid())
  title     String
  content   String?
  published Boolean  @default(false)
  author    User     @relation(fields: [authorId], references: [id])
  authorId  String
  tags      Tag[]
  createdAt DateTime @default(now())
  updatedAt DateTime @updatedAt

  @@index([authorId])
}

model Tag {
  id    String @id @default(cuid())
  name  String @unique
  posts Post[]
}

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
}

'use server'

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

// 创建
export async function createUser(data: {
  email: string
  name: string
  password: string
}) {
  const user = await prisma.user.create({
    data: {
      email: data.email,
      name: data.name,
      password: data.password, // 实际应该哈希处理
    },
  })

  revalidatePath('/users')
  return user
}

// 查询
export async function getUsers() {
  return prisma.user.findMany({
    select: {
      id: true,
      email: true,
      name: true,
      createdAt: true,
      _count: {
        select: { posts: true },
      },
    },
    orderBy: { createdAt: 'desc' },
  })
}

// 查询单个
export async function getUser(id: string) {
  return prisma.user.findUnique({
    where: { id },
    include: {
      posts: {
        where: { published: true },
        orderBy: { createdAt: 'desc' },
      },
    },
  })
}

// 更新
export async function updateUser(
  id: string,
  data: { name?: string; email?: string }
) {
  const user = await prisma.user.update({
    where: { id },
    data,
  })

  revalidatePath('/users')
  revalidatePath(`/users/${id}`)
  return user
}

// 删除
export async function deleteUser(id: string) {
  await prisma.user.delete({
    where: { id },
  })

  revalidatePath('/users')
}

import { pgTable, text, timestamp, boolean, uuid } from 'drizzle-orm/pg-core'
import { relations } from 'drizzle-orm'

export const users = pgTable('users', {
  id: uuid('id').defaultRandom().primaryKey(),
  email: text('email').notNull().unique(),
  name: text('name'),
  password: text('password').notNull(),
  createdAt: timestamp('created_at').defaultNow().notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
})

export const posts = pgTable('posts', {
  id: uuid('id').defaultRandom().primaryKey(),
  title: text('title').notNull(),
  content: text('content'),
  published: boolean('published').default(false).notNull(),
  authorId: uuid('author_id')
    .notNull()
    .references(() => users.id),
  createdAt: timestamp('created_at').defaultNow().notNull(),
  updatedAt: timestamp('updated_at').defaultNow().notNull(),
})

export const tags = pgTable('tags', {
  id: uuid('id').defaultRandom().primaryKey(),
  name: text('name').notNull().unique(),
})

export const postsToTags = pgTable('posts_to_tags', {
  postId: uuid('post_id')
    .notNull()
    .references(() => posts.id),
  tagId: uuid('tag_id')
    .notNull()
    .references(() => tags.id),
})

// 定义关系
export const usersRelations = relations(users, ({ many }) => ({
  posts: many(posts),
}))

export const postsRelations = relations(posts, ({ one, many }) => ({
  author: one(users, {
    fields: [posts.authorId],
    references: [users.id],
  }),
  tags: many(postsToTags),
}))

import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'
import * as schema from './schema'

const connectionString = process.env.DATABASE_URL!

// 连接池配置
const client = postgres(connectionString, {
  max: 10,
  idle_timeout: 20,
  connect_timeout: 10,
})

export const db = drizzle(client, { schema })

import type { Config } from 'drizzle-kit'

export default {
  schema: './db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: {
    url: process.env.DATABASE_URL!,
  },
} satisfies Config

'use server'

import { db } from '@/db'
import { users, posts } from '@/db/schema'
import { eq, desc } from 'drizzle-orm'
import { revalidatePath } from 'next/cache'

// 创建
export async function createUser(data: {
  email: string
  name: string
  password: string
}) {
  const [user] = await db
    .insert(users)
    .values({
      email: data.email,
      name: data.name,
      password: data.password,
    })
    .returning()

  revalidatePath('/users')
  return user
}

// 查询所有
export async function getUsers() {
  return db.select().from(users).orderBy(desc(users.createdAt))
}

// 查询单个
export async function getUser(id: string) {
  const [user] = await db.select().from(users).where(eq(users.id, id))
  return user
}

// 更新
export async function updateUser(
  id: string,
  data: { name?: string; email?: string }
) {
  const [user] = await db
    .update(users)
    .set({ ...data, updatedAt: new Date() })
    .where(eq(users.id, id))
    .returning()

  revalidatePath('/users')
  return user
}

// 删除
export async function deleteUser(id: string) {
  await db.delete(users).where(eq(users.id, id))
  revalidatePath('/users')
}

# 直接连接（用于迁移）
DATABASE_URL="postgresql://user:password@host:5432/db"

# 连接池（用于应用）
DATABASE_URL_POOLED="postgresql://user:password@pooler.host:6543/db?pgbouncer=true"

// Next.js 15.x
import { prisma } from '@/lib/prisma'
import Link from 'next/link'

export default async function UsersPage() {
  const users = await prisma.user.findMany({
    select: {
      id: true,
      name: true,
      email: true,
      _count: { select: { posts: true } },
    },
    orderBy: { createdAt: 'desc' },
  })

  return (
    <div>
      <h1 className="text-2xl font-bold mb-4">用户列表</h1>
      <ul className="space-y-2">
        {users.map((user) => (
          <li key={user.id} className="p-4 border rounded">
            <Link href={`/users/${user.id}`}>
              <h2 className="font-medium">{user.name || '未命名'}</h2>
              <p className="text-gray-500">{user.email}</p>
              <p className="text-sm">{user._count.posts} 篇文章</p>
            </Link>
          </li>
        ))}
      </ul>
    </div>
  )
}

import { z } from 'zod'

export const createUserSchema = z.object({
  email: z.string().email('无效的邮箱格式'),
  name: z.string().min(2, '名称至少 2 个字符').max(50),
  password: z.string().min(8, '密码至少 8 个字符'),
})

export const updateUserSchema = createUserSchema.partial()

export type CreateUserInput = z.infer<typeof createUserSchema>
export type UpdateUserInput = z.infer<typeof updateUserSchema>

'use server'

import { prisma } from '@/lib/prisma'
import { createUserSchema, updateUserSchema } from '@/lib/validations/user'
import { hash } from 'bcryptjs'

export async function createUser(formData: FormData) {
  const rawData = {
    email: formData.get('email'),
    name: formData.get('name'),
    password: formData.get('password'),
  }

  const result = createUserSchema.safeParse(rawData)

  if (!result.success) {
    return { errors: result.error.flatten().fieldErrors }
  }

  const hashedPassword = await hash(result.data.password, 12)

  try {
    const user = await prisma.user.create({
      data: {
        ...result.data,
        password: hashedPassword,
      },
    })

    return { user }
  } catch (error) {
    if ((error as any).code === 'P2002') {
      return { errors: { email: ['邮箱已被注册'] } }
    }
    throw error
  }
}