รู้จักกับ Drizzle ORM ผ่าน Next.js

version: '3.8'

services:
  postgres:
    image: postgres:17
    container_name: my_postgres
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5432:5432"
    restart: unless-stopped

volumes:
  postgres_data:

CREATE TABLE users (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL UNIQUE,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO users (name, email)
VALUES
('Jane Smith', 'janesmith@example.com'),
('Alice Johnson', 'alicej@example.com'),
('Bob Brown', 'bobbrown@example.com');

.
├── README.md
├── app
│   ├── api
│   │   └── users
│   │       └── route.ts
│   └── page.tsx
├── db
│   ├── index.ts
│   └── schema.ts
├── docker-compose.yml
└── .env

// นำเข้า function drizzle จาก drizzle-orm สำหรับ PostgreSQL
import { drizzle } from 'drizzle-orm/node-postgres'
// นำเข้า class Pool จาก pg สำหรับการจัดการการเชื่อมต่อฐานข้อมูล
import { Pool } from 'pg'

// สร้าง pool การเชื่อมต่อฐานข้อมูลใหม่
const pool = new Pool({
  // ใช้ connection string จาก environment variable (ที่เก็บใน .env)
  connectionString: process.env.DATABASE_URL,
})

// สร้างและส่งออก Object ฐานข้อมูลที่ใช้ drizzle กับ pool ที่สร้างขึ้น
export const db = drizzle(pool)

DATABASE_URL=postgresql://myuser:mypassword@localhost:5432/mydatabase

// นำเข้า function และประเภทข้อมูลที่จำเป็นจาก drizzle-orm
import { pgTable, serial, varchar, timestamp } from 'drizzle-orm/pg-core'

// กำหนดโครงสร้างตาราง 'users' ในฐานข้อมูล PostgreSQL
export const users = pgTable('users', {
  // column id: เป็น primary key, ใช้ serial สำหรับการเพิ่มค่าอัตโนมัติ
  id: serial('id').primaryKey(),

  // column name: เก็บชื่อผู้ใช้, ความยาวสูงสุด 100 ตัวอักษร, ไม่สามารถเป็นค่าว่างได้
  name: varchar('name', { length: 100 }).notNull(),

  // column email: เก็บอีเมลผู้ใช้, ความยาวสูงสุด 100 ตัวอักษร, ไม่สามารถเป็นค่าว่างและต้องไม่ซ้ำกัน
  email: varchar('email', { length: 100 }).notNull().unique(),

  // column createdAt: เก็บเวลาที่สร้างบัญชีผู้ใช้, ค่าเริ่มต้นคือเวลาปัจจุบัน
  createdAt: timestamp('created_at').defaultNow(),
})

// นำเข้า module ฐานข้อมูล
import { db } from '@/db'
// นำเข้า schema มาของตารางผู้ใช้
import { users } from '@/db/schema'

// function GET สำหรับดึงข้อมูลผู้ใช้ทั้งหมด
export async function GET() {
  try {
    // ดึงข้อมูลผู้ใช้ทั้งหมดจากฐานข้อมูล
    const allUsers = await db.select().from(users)
    // ส่งข้อมูลผู้ใช้กลับเป็น JSON response
    return Response.json(allUsers)
  } catch (error) {
    console.error('Error fetching users:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

// นำเข้า module db และ schema ของ users จากโฟลเดอร์ db ที่ตั้งไว้ในโปรเจค
import { db } from '@/db'
import { users } from '@/db/schema'

// สร้าง interface CreateUserRequest เพื่อกำหนดโครงสร้างของข้อมูลที่ต้องการรับเมื่อสร้าง user
interface CreateUserRequest {
  name: string
  email: string
}

export async function GET() {
  try {
    const allUsers = await db.select().from(users)
    return Response.json(allUsers)
  } catch (error) {
    console.error('Error fetching users:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

// function POST สำหรับสร้าง user ใหม่ path POST /api/users
export async function POST(request: Request) {
  try {
    // รับและแปลงข้อมูล JSON ที่ส่งมาใน request body ให้อยู่ในรูปแบบ CreateUserRequest
    const body: CreateUserRequest = await request.json()
    const { name, email } = body

    // ตรวจสอบว่า name และ email มีค่าหรือไม่
    if (!name || !email) {
      return Response.json(
        { error: 'Name and email are required' },
        { status: 400 }
      )
    }

    // ถ้ามีค่า name และ email จะทำการ insert ข้อมูลลงตาราง users
    const newUser = await db.insert(users).values({ name, email }).returning()

    // ส่งข้อมูล user ที่ถูกสร้างขึ้นกลับไปใน response พร้อมสถานะ 201 (created)
    return Response.json(newUser[0], { status: 201 })
  } catch (error) {
    console.error('Error creating user:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

import { db } from '@/db'
import { users } from '@/db/schema'
import { eq } from 'drizzle-orm'

// สร้าง interface UpdateUserBody เพื่อกำหนดโครงสร้างของข้อมูลที่ต้องการรับเมื่อ update user
interface UpdateUserBody {
  name?: string
  email?: string
}

export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  try {
    // แปลง id จาก string เป็น integer จาก parameter ที่รับเข้ามา
    const id = parseInt(params.id)

    // ดึงข้อมูล user จากฐานข้อมูล
    const [user] = await db
      .select()
      .from(users)
      .where(eq(users.id, id))
      .limit(1)

    // ถ้าไม่พบ user ให้ส่ง response แจ้ง error
    if (!user) {
      return Response.json({ error: 'User not found' }, { status: 404 })
    }

    // ส่ง response กลับไปพร้อมข้อมูล
    return Response.json(user)
  } catch (error) {
    // จัดการกรณีเกิด error
    console.error('Error fetching user:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

export async function PUT(
  request: Request,
  { params }: { params: { id: string } }
) {
  try {
    // แปลง id จาก string เป็น integer
    const id = parseInt(params.id)
    // รับข้อมูลที่ต้องการอัพเดทจาก request body
    const body: UpdateUserBody = await request.json()
    const { name, email } = body

    // ตรวจสอบว่ามีข้อมูลที่จะอัพเดทหรือไม่
    if (!name && !email) {
      return Response.json(
        { error: 'Name or email is required for update' },
        { status: 400 }
      )
    }

    // สร้าง object สำหรับเก็บข้อมูลที่จะอัพเดท
    const updateData: { name?: string; email?: string } = {}
    if (name) updateData.name = name
    if (email) updateData.email = email

    // อัพเดทข้อมูล user ในฐานข้อมูล
    const [updatedUser] = await db
      .update(users)
      .set(updateData)
      .where(eq(users.id, id))
      .returning()

    // ถ้าไม่พบ user ให้ส่ง response แจ้ง error
    if (!updatedUser) {
      return Response.json({ error: 'User not found' }, { status: 404 })
    }

    // ส่ง response กลับไปพร้อมข้อมูล user ที่อัพเดทแล้ว
    return Response.json(updatedUser)
  } catch (error) {
    // จัดการกรณีเกิด error
    console.error('Error updating user:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

export async function DELETE(
  request: Request,
  { params }: { params: { id: string } }
) {
  try {
    // แปลง id จาก string เป็น integer
    const id = parseInt(params.id)
    // ลบข้อมูล user จากฐานข้อมูล
    const [deletedUser] = await db
      .delete(users)
      .where(eq(users.id, id))
      .returning()

    // ถ้าไม่พบ user ให้ส่ง response แจ้ง error
    if (!deletedUser) {
      return Response.json({ error: 'User not found' }, { status: 404 })
    }

    // ส่ง response แจ้งว่าลบข้อมูลสำเร็จ
    return Response.json({ message: 'User deleted successfully' })
  } catch (error) {
    // จัดการกรณีเกิด error
    console.error('Error deleting user:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

CREATE TABLE posts (
    id SERIAL PRIMARY KEY,
    title VARCHAR(200) NOT NULL,
    content TEXT NOT NULL,
    user_id INT REFERENCES users(id),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

// นำเข้า function ต่างๆ จาก Drizzle ORM ที่ใช้สร้าง schema สำหรับ PostgreSQL
import {
  pgTable,     // function ที่ใช้สร้าง table schema
  serial,      // ชนิดข้อมูล serial สำหรับ auto-increment (เป็น primary key ได้)
  varchar,     // ชนิดข้อมูล varchar สำหรับ string ที่กำหนดความยาวสูงสุด
  timestamp,   // ชนิดข้อมูล timestamp สำหรับเก็บวันเวลา
  text,        // ชนิดข้อมูล text สำหรับ string ที่ไม่จำกัดความยาว
  integer,     // ชนิดข้อมูล integer สำหรับตัวเลขจำนวนเต็ม
} from 'drizzle-orm/pg-core'

// users table ถูกสร้างเหมือนเดิม
export const users = /* เหมือนเดิม */

// สร้าง posts table ด้วย function pgTable โดยกำหนดชื่อ table ว่า 'posts'
export const posts = pgTable('posts', {
  // column id เป็น serial (auto-increment) และกำหนดให้เป็น primary key
  id: serial('id').primaryKey(),

  // column title เป็น varchar กำหนดความยาวสูงสุด 200 และห้ามเป็น null
  title: varchar('title', { length: 200 }).notNull(),

  // column content เป็น text และห้ามเป็น null
  content: text('content').notNull(),

  // column userId เป็น integer และเป็น foreign key ที่อ้างอิงไปยัง id ของตาราง users
  userId: integer('user_id').references(() => users.id),

  // column createdAt เป็น timestamp และมีค่า default เป็น CURRENT_TIMESTAMP
  createdAt: timestamp('created_at').defaultNow(),
})

// นำเข้า db object ที่เชื่อมต่อกับฐานข้อมูล และ schema ของตาราง posts
import { db } from '@/db'
import { posts } from '@/db/schema'

// กำหนด interface CreatePostRequest เพื่ออธิบายรูปแบบข้อมูลที่ใช้ในการสร้าง post
interface CreatePostRequest {
  title: string  // กำหนดว่า title ต้องเป็น string
  content: string  // กำหนดว่า content ต้องเป็น string
  userId: number  // กำหนดว่า userId ต้องเป็น number
}

// function POST สำหรับสร้าง post ใหม่
export async function POST(request: Request) {
  try {
    // รับข้อมูล JSON จาก request body และแปลงให้อยู่ในรูปแบบของ CreatePostRequest
    const body: CreatePostRequest = await request.json()
    const { title, content, userId } = body // แยกค่าของ title, content และ userId จาก body

    // ตรวจสอบว่าทุก field (title, content, userId) มีค่าหรือไม่
    if (!title || !content || !userId) {
      // ถ้าขาดฟิลด์ใดฟิลด์หนึ่ง ส่ง response แจ้งว่าข้อมูลไม่สมบูรณ์ (status 400)
      return Response.json(
        { error: 'Title, content, and userId are required' },
        { status: 400 }
      )
    }

    // ถ้าข้อมูลสมบูรณ์ ทำการ insert post ใหม่ลงในตาราง posts ด้วยค่า title, content, userId
    const [newPost] = await db.insert(posts).values({ title, content, userId }).returning()

    // ส่งข้อมูลของ post ที่ถูกสร้างใหม่กลับไปใน response พร้อมสถานะ 201 (created)
    return Response.json(newPost, { status: 201 })
  } catch (error) {
    // หากเกิดข้อผิดพลาด แสดงข้อความ error ใน console
    console.error('Error creating post:', error)

    // ส่ง response แจ้งว่ามีปัญหา internal server error
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

// นำเข้า db object ที่เชื่อมต่อกับฐานข้อมูล, schema ของตาราง posts และ users และ function eq จาก Drizzle ORM
import { db } from '@/db'
import { posts, users } from '@/db/schema'
import { eq } from 'drizzle-orm'

// function GET สำหรับดึงข้อมูล post path GET /api/posts/:id
export async function GET(
  request: Request,  // รับ request object
  { params }: { params: { id: string } }  // รับค่า params จาก URL โดยมี id ของ post เป็น string
) {
  try {
    // แปลง id จาก string เป็น number เพื่อใช้ในการ query
    const id = parseInt(params.id)

    // ทำการ query ข้อมูลจากฐานข้อมูล โดยเลือก post และข้อมูลผู้ใช้ที่เกี่ยวข้อง
    const [result] = await db
      .select({
        post: posts, // ดึงข้อมูลทั้งหมดจากตาราง posts
        user: {      // ดึงเฉพาะบาง column จากตาราง users
          id: users.id,   // ดึง user id
          name: users.name,  // ดึงชื่อผู้ใช้
          email: users.email,  // ดึงอีเมลผู้ใช้
        },
      })
      .from(posts)  // ทำการ query จากตาราง posts เป็นหลัก
      .leftJoin(users, eq(posts.userId, users.id))  // เชื่อมข้อมูล users ผ่าน userId ของ posts และ id ของ users (LEFT JOIN)
      .where(eq(posts.id, id))  // เงื่อนไขในการ query คือ post id ต้องตรงกับ id ที่ได้รับจาก params
      .limit(1)  // จำกัดผลลัพธ์ให้ได้เพียงแค่ 1 แถว

    // ถ้าไม่พบผลลัพธ์ (ไม่มี post ที่ตรงกับ id นั้น)
    if (!result) {
      return Response.json({ error: 'Post not found' }, { status: 404 })  // ส่ง response แจ้งว่าไม่พบ post
    }

    // ถ้าพบผลลัพธ์ ส่งข้อมูล post และข้อมูลผู้ใช้ที่เกี่ยวข้องกลับไปใน response
    return Response.json(result)
  } catch (error) {
    // ถ้ามีข้อผิดพลาดเกิดขึ้น แสดงข้อความ error ใน console
    console.error('Error fetching post:', error)

    // ส่ง response แจ้งว่าเกิดปัญหา internal server error
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

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

export async function GET(
  request: Request,
  { params }: { params: { id: string } }
) {
  try {
    // แปลง id จาก string เป็น integer
    const id = parseInt(params.id)

    // ดึงข้อมูล user และ posts โดยใช้ join
    const userWithPosts = await db
      .select({
        // เลือกข้อมูล user ที่ต้องการ
        user: {
          id: users.id,
          name: users.name,
          email: users.email,
          createdAt: users.createdAt,
        },
        // เลือกข้อมูล posts ที่ต้องการ
        posts: {
          id: posts.id,
          title: posts.title,
          content: posts.content,
          createdAt: posts.createdAt,
        },
      })
      .from(users)
      // ใช้ leftJoin เพื่อรวมข้อมูล posts กับ users
      .leftJoin(posts, eq(users.id, posts.userId))
      // กรองเฉพาะ user ที่มี id ตรงกับที่ระบุ
      .where(eq(users.id, id))

    // ตรวจสอบว่าพบ user หรือไม่
    if (userWithPosts.length === 0) {
      return Response.json({ error: 'User not found' }, { status: 404 })
    }

    // จัดรูปแบบข้อมูลให้เหมาะสม
    const result = {
      // ดึงข้อมูล user จากผลลัพธ์แรก
      user: userWithPosts[0].user,
      // กรองและแปลงข้อมูล posts
      posts: userWithPosts
        // กรองเฉพาะ posts ที่มี id (ไม่เป็น null)
        .filter((row) => row.posts?.id != null)
        // แปลงให้เหลือเฉพาะข้อมูล posts
        .map((row) => row.posts),
    }

    // ส่งผลลัพธ์กลับเป็น JSON
    return Response.json(result)
  } catch (error) {
    // จัดการกับข้อผิดพลาด
    console.error('Error fetching user:', error)
    return Response.json({ error: 'Internal Server Error' }, { status: 500 })
  }
}

// นำเข้า type Config จาก drizzle-kit เพื่อใช้ในการกำหนดรูปแบบของการตั้งค่าการเชื่อมต่อฐานข้อมูล
import type { Config } from 'drizzle-kit'

export default {
  // ระบุไฟล์ schema ที่ใช้กำหนดโครงสร้างฐานข้อมูล (ในที่นี้คือ schema.ts ในโฟลเดอร์ db)
  schema: './db/schema.ts',

  // ระบุโฟลเดอร์ที่ไฟล์ migration จะถูกสร้างและจัดเก็บ (ในที่นี้คือโฟลเดอร์ drizzle)
  out: './drizzle',

  // ระบุประเภทของฐานข้อมูลที่ใช้ (ในที่นี้คือ postgresql)
  dialect: 'postgresql'
} satisfies Config  // ทำให้แน่ใจว่า object นี้ตรงกับรูปแบบที่กำหนดใน type Config ของ drizzle-kit

npx drizzle-kit generate

CREATE TABLE IF NOT EXISTS "posts" (
  "id" serial PRIMARY KEY NOT NULL,
  "title" varchar(200) NOT NULL,
  "content" text NOT NULL,
  "user_id" integer,
  "created_at" timestamp DEFAULT now()
);
--> statement-breakpoint
CREATE TABLE IF NOT EXISTS "users" (
  "id" serial PRIMARY KEY NOT NULL,
  "name" varchar(100) NOT NULL,
  "email" varchar(100) NOT NULL,
  "created_at" timestamp DEFAULT now(),
  CONSTRAINT "users_email_unique" UNIQUE("email")
);
--> statement-breakpoint
DO $$ BEGIN
 ALTER TABLE "posts" ADD CONSTRAINT "posts_user_id_users_id_fk" FOREIGN KEY ("user_id") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;
EXCEPTION
 WHEN duplicate_object THEN null;
END $$;

import type { Config } from 'drizzle-kit'

export default {
  schema: './db/schema.ts',
  out: './drizzle',
  dialect: 'postgresql',
  dbCredentials: {
    url: 'postgresql://myuser:mypassword@localhost:5432/mydatabase',
  },
} satisfies Config