⛽
😂🤣😜😊/
NextJS 系列 之 drizzle-orm
Search

NextJS 系列 之 drizzle-orm

Date
Created
Mar 25, 2025 11:40 AM
Descrption
Tags
前端工程化
记录
notion image
如果你使用NextJS的全栈开发模式，那么就注定要接入db，那么一款好用的orm是必不可少的： 比较推荐的是drizzle-orm，相比type-orm更加轻量，配置和迁移起来都比较轻松；这里同时介绍使用postgres的情况下接入drizzle-orm：
以下是一个标准的项目结构：
notion image
Step 1 - Install node-postgres package
yarn add drizzle-orm pg dotenv
yarn add -D drizzle-kit tsx @types/pg
Step 2 - Setup connection variables
你需要创建一个环境变量的文件用来存放数据库的环境变量：
in= ***************************************
.env
Step 3 - Connect Drizzle ORM to the database
import 'server-only'

import { drizzle } from 'drizzle-orm/postgres-js'
import postgres from 'postgres'

const client = postgres(process.env.POSTGRES_URL!)
const db = drizzle(client)

export { db }
./src/db/index.ts
Step 4 - Create a table
import { InferSelectModel } from 'drizzle-orm'
import {
    json,
    pgTable,
    text,
    timestamp,
    uuid,
    varchar,
    integer,
    pgEnum,
    boolean,
} from 'drizzle-orm/pg-core'

// 订阅类型
export const subscriptionTypeEnum = pgEnum('subscriptionType', ['free', 'pro'])
// 订阅状态
export const statusEnum = pgEnum('status', ['active', 'inactive'])

// 用户
export const user = pgTable('User', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    email: varchar('email', { length: 64 }).notNull(),
    name: varchar('name', { length: 64 }).default(''),
    password: varchar('password', { length: 64 }),
})

export type User = InferSelectModel<typeof user>

// 聊天
export const chat = pgTable('Chat', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    createdAt: timestamp('createdAt').notNull(),
    title: text('title').notNull(),
    jd: text('jd').default(''),
    isFinished: boolean('isFinished').notNull().default(false),
    userId: uuid('userId')
        .notNull()
        .references(() => user.id),
})

export type Chat = InferSelectModel<typeof chat>

// 订阅
export const subscription = pgTable('Subscription', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    userId: uuid('userId')
        .notNull()
        .references(() => user.id),
    startAt: timestamp('startAt').notNull(),
    expiresAt: timestamp('expiresAt').notNull(),
    subscriptionType: subscriptionTypeEnum('subscriptionType').notNull(),
    status: statusEnum('status').notNull().default('active'),
    remain: integer('remain').notNull().default(0), // 剩余次数
    total: integer('total').notNull().default(1), // 总次数
})

export type Subscription = InferSelectModel<typeof subscription>

// 消息
export const message = pgTable('Message', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    chatId: uuid('chatId')
        .notNull()
        .references(() => chat.id, { onDelete: 'cascade' }),
    role: varchar('role').notNull(),
    content: json('content').notNull(),
    createdAt: timestamp('createdAt').notNull(),
})

export type Message = InferSelectModel<typeof message>

// 音频
export const audio = pgTable('Audio', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    messageId: uuid('messageId')
        .notNull()
        .references(() => message.id, { onDelete: 'cascade' }),
    url: varchar('url', { length: 256 }).notNull(),
})

export type Audio = InferSelectModel<typeof audio>

// 报告
export const report = pgTable('Report', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    chatId: uuid('chatId')
        .notNull()
        .references(() => chat.id, { onDelete: 'cascade' }),
    createdAt: timestamp('createdAt').notNull(),
    overallScore: integer('overallScore').notNull(),
    overallLevel: varchar('overallLevel', { length: 32 }).notNull(),
    overallSummary: text('overallSummary').notNull(),
    categories: json('categories').notNull(),
    strengths: json('strengths').notNull(),
    areasForImprovement: json('areasForImprovement').notNull(),
    questionsAndAnswers: json('questionsAndAnswers').notNull(),
})

export type Report = InferSelectModel<typeof report>

// 评估
export const evaluate = pgTable('Evaluate', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    chatId: uuid('chatId')
        .notNull()
        .references(() => chat.id, { onDelete: 'cascade' }),
    messageId: uuid('messageId')
        .notNull()
        .references(() => message.id),
    question: text('question').notNull(),
    answer: text('answer').notNull(),
    feedback: text('feedback').notNull(),
})

export type Evaluate = InferSelectModel<typeof evaluate>

// 简历
export const resume = pgTable('Resume', {
    id: uuid('id').primaryKey().notNull().defaultRandom(),
    userId: uuid('userId')
        .notNull()
        .references(() => user.id),
    chatId: uuid('chatId'),
    url: varchar('url', { length: 256 }).notNull(),
    name: varchar('name', { length: 64 }).default(''),
    createdAt: timestamp('createdAt').notNull().defaultNow(),
})

export type Resume = InferSelectModel<typeof resume>
.src/db/schema.ts
你应该创建一个schema的文件用来描述你的表结构
Step 5 - Setup Drizzle config file
import { config } from 'dotenv'
import { defineConfig } from 'drizzle-kit'

config({
    path: '.env.local',
})

export default defineConfig({
    schema: './src/lib/db/schema.ts',
    out: './src/lib/db/migrations',
    dialect: 'postgresql',
    dbCredentials: {
        // biome-ignore lint: Forbidden non-null assertion.
        url: process.env.POSTGRES_URL!,
    },
})
 drizzle.config.ts
最后请在你的 drizzle.config.ts文件中列出你的文件的目录
Step 6 - Applying changes to the database
notion image
以下是对命令的一些解释：

1. npx drizzle-kit push — 直接应用更改到数据库

  • 使用场景：当你想要快速将你的数据库模式（schema）更改应用到数据库中，特别是在 本地开发环境中进行快速测试时。此命令会根据你当前的模型直接同步数据库，使得不需要管理迁移文件。
  • 优点：操作简单，适合在开发初期或小型项目中使用，可以节省时间，不需要编写和应用迁移文件。
  • 缺点：在生产环境或较为复杂的项目中不推荐使用，因为它不生成迁移文件，可能导致无法追溯的更改。
适用场景：
  • 你在本地开发时进行快速实验和原型设计。
  • 在没有复杂数据或生产环境时，你只需要测试和验证数据库更改。

2. npx drizzle-kit generate — 生成迁移文件

  • 使用场景：当你修改了数据库模式（比如更改表结构、添加字段等），希望生成迁移文件，并且打算在后续的开发中应用这些迁移。该命令会基于当前数据库模式和模型之间的差异，生成一个迁移文件。
  • 优点：生成的迁移文件可以记录数据库模式的变化，并且可以在团队协作时共享和应用。
  • 缺点：迁移文件是手动生成的，可能需要一些额外的管理，尤其是当多次修改数据库模式时。
适用场景：
  • 你在团队中开发项目，需要记录数据库的变化并共享给团队成员。
  • 需要在生产环境中迁移数据库模式时，希望确保数据库变更是可控的。

3. npx drizzle-kit migrate — 应用迁移到数据库

  • 使用场景：当你已经生成了迁移文件并希望将这些更改应用到数据库时，使用此命令。它会基于你生成的迁移文件执行数据库模式的变更，保证数据库和你的代码保持同步。
  • 优点：迁移文件可以被版本控制，适用于团队协作和生产环境，能够清晰地跟踪数据库变更的历史。
  • 缺点：相对而言，迁移过程会更为复杂，需要你管理和应用迁移文件。
适用场景：
  • 当你在生产环境中应用数据库变更时。
  • 在团队协作中应用和共享数据库变更。
  • 需要保持数据库状态和代码状态一致时。

总结：

  • npx drizzle-kit push 适用于开发初期和本地开发中快速测试数据库更改。
  • npx drizzle-kit generate 和 npx drizzle-kit migrate 适用于生产环境或团队开发中，通过生成和应用迁移文件来管理数据库模式的变化，确保数据库变更是可追溯和可管理的。
Step 7 - Seed and Query the database
最后你就可以使用orm来查询数据了：
import 'server-only'

import { db } from '..'
import { Subscription, subscription, user, User } from '../schema'
import { eq, gte, lte, and } from 'drizzle-orm'
import { genSaltSync, hashSync } from 'bcrypt-ts'

export async function getUser(email: string): Promise<Array<User>> {
    try {
        return await db.select().from(user).where(eq(user.email, email))
    } catch (error) {
        console.error('Failed to get user from database')
        throw error
    }
}

export async function getUserById(id: string): Promise<Array<User>> {
    return await db.select().from(user).where(eq(user.id, id))
}

export async function createUser(email: string, password: string) {
    const salt = genSaltSync(10)
    const hash = hashSync(password, salt)

    try {
        return await db.insert(user).values({ email, password: hash, name: '' })
    } catch (error) {
        console.error('Failed to create user in database')
        throw error
    }
}

export async function updateUser(userId: string, name: string, email: string) {
    return await db.update(user).set({ name, email }).where(eq(user.id, userId))
}

// 获取当前有效的订阅
export async function getActiveSubscription(
    userId: string
): Promise<Subscription | null> {
    const now = new Date() // 获取当前时间
    const activeSubscription = await db
        .select()
        .from(subscription)
        .where(
            and(
                eq(subscription.userId, userId),
                eq(subscription.status, 'active'),
                lte(subscription.startAt, now),
                gte(subscription.expiresAt, now)
            )
        )
        .limit(1) // 确保只取一条有效的订阅记录

    if (activeSubscription.length === 0) {
        return null
    }

    return activeSubscription[0]
}

// 创建订阅
export async function createSubscription(
    userId: string,
    subscriptionType: 'free' | 'pro'
) {
    const now = new Date()
    const proExpiresAt = new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000) // 30天
    const freeExpiresAt = new Date(
        now.getTime() + 10 * 365 * 24 * 60 * 60 * 1000
    ) // 10年
    await db.insert(subscription).values({
        userId,
        startAt: now,
        expiresAt: subscriptionType === 'free' ? freeExpiresAt : proExpiresAt,
        subscriptionType,
        status: 'active',
        remain: subscriptionType === 'free' ? 1 : 10,
        total: subscriptionType === 'free' ? 1 : 10,
    })
}

// 使用了一次次数
export async function decreaseOneTime(userId: string) {
    const sub = await getActiveSubscription(userId)
    if (!sub) {
        return
    }
    if (sub.remain <= 0) {
        return null
    }
    await db
        .update(subscription)
        .set({ remain: sub.remain - 1 })
        .where(eq(subscription.id, sub.id))

    return sub
}

// 是否还有次数
export async function hasOneTime(userId: string) {
    const sub = await getActiveSubscription(userId)
    return sub?.remain && sub.remain > 0
}

// 取消订阅
export async function cancelSubscription(subscriptionId: string) {
    await db
        .update(subscription)
        .set({ status: 'inactive' })
        .where(eq(subscription.id, subscriptionId))
}

// 重新激活订阅
export async function reactivateSubscription(subscriptionId: string) {
    const now = new Date()
    await db
        .update(subscription)
        .set({
            status: 'active',
            startAt: now,
            expiresAt: new Date(now.getTime() + 30 * 24 * 60 * 60 * 1000),
        }) // 重新设置有效期为一个月
        .where(eq(subscription.id, subscriptionId))
}
./src/db/user/index.ts
notion image
我建议你每张表的查询语句都放在一起，这样比较好管理；
 
Copyright 2025 JY