RESTful API การยืนยันตัวตน ด้วย JWT และกำหนดสิทธิ์ RBAC

mkdir jwt-rbac-demo
cd jwt-rbac-demo
npm init -y

npm install express jsonwebtoken bcryptjs cors body-parser
npm install @prisma/client
npm install -D prisma

npx prisma init

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

generator client {
  provider = "prisma-client-js"
}

model User {
  id        Int      @id @default(autoincrement())
  username  String   @unique
  password  String
  role      Role     @default(READER)
  articles  Article[]
}

model Article {
  id        Int      @id @default(autoincrement())
  title     String
  content   String
  authorId  Int
  author    User     @relation(fields: [authorId], references: [id])
  createdAt DateTime @default(now())
}

enum Role {
  ADMIN
  EDITOR
  READER
}

DATABASE_URL="mysql://root:@localhost:3306/jwt_rbac_demo"
JWT_ACCESS_TOKEN_SECRET="supersecretaccesstoken"

npx prisma migrate dev --name init
npx prisma generate

// password.js
const bcrypt = require('bcryptjs');
const hashedPassword = bcrypt.hashSync("admin", 10);
console.log(hashedPassword);

node password.js

npx prisma studio

// นำเข้า modules ที่จำเป็น
const express = require("express");          // Web framework สำหรับ Node.js
const jwt = require("jsonwebtoken");         // ไลบรารีสำหรับสร้างและตรวจสอบ JWT tokens
const bcrypt = require("bcryptjs");           // ไลบรารีสำหรับเข้ารหัสรหัสผ่าน
const bodyParser = require("body-parser");   // Middleware เพื่อแยกวิเคราะห์ JSON request bodies
const cors = require("cors");                // Middleware เพื่อเปิดใช้งาน Cross-Origin Resource Sharing
const { PrismaClient } = require("@prisma/client"); // Prisma ORM client

// เริ่มต้น Prisma client สำหรับการดำเนินการฐานข้อมูล
const prisma = new PrismaClient();

// เริ่มต้น Express application
const app = express();

// การตั้งค่า Middleware
app.use(bodyParser.json()); // แยกวิเคราะห์ JSON payloads ที่เข้ามา
app.use(cors());            // เปิดใช้งาน CORS สำหรับทุก routes

// JWT secrets จาก environment variables
// ค่าเหล่านี้ควรเป็น string ที่แข็งแกร่งและสุ่มใน production
const ACCESS_TOKEN_SECRET = process.env.JWT_ACCESS_TOKEN_SECRET;

// เริ่มต้น server
const PORT = 4000;
app.listen(PORT, () => {
  console.log(`Server running at http://localhost:${PORT}`);
  console.log(`Prisma Studio: npx prisma studio`);
});

# สร้าง Prisma client (รันหลังจากเปลี่ยน schema)
npx prisma generate

# เริ่มต้น server พร้อม environment variables ที่โหลดแล้ว
node --env-file=.env index.js

// POST /register - สร้างบัญชีผู้ใช้ใหม่
app.post("/register", async (req, res) => {
  // ดึงข้อมูลผู้ใช้จาก request body
  const { username, password, role } = req.body;
  
  // เข้ารหัสรหัสผ่านด้วย bcrypt (salt rounds = 10)
  // rounds ที่สูงขึ้น = ปลอดภัยมากขึ้นแต่ช้าลง
  const hashedPassword = await bcrypt.hash(password, 10);

  try {
    // สร้างผู้ใช้ใหม่ในฐานข้อมูลโดยใช้ Prisma
    const user = await prisma.user.create({
      data: { 
        username,                    // ชื่อผู้ใช้ที่ไม่ซ้ำ
        password: hashedPassword,    // รหัสผ่านที่เข้ารหัสแล้ว (ไม่เก็บข้อความธรรมดา!)
        role                         // Role ของผู้ใช้: ADMIN, EDITOR, หรือ READER
      },
    });
    
    // ส่งคืน response สำเร็จ (ไม่รวมข้อมูลที่ละเอียดอ่อนเช่นรหัสผ่าน)
    res.json({ 
      message: "User registration successful", 
      user: { 
        id: user.id,
        username: user.username, 
        role: user.role 
      }
    });
  } catch (err) {
    // จัดการข้อผิดพลาดของฐานข้อมูล (เช่น ชื่อผู้ใช้ซ้ำ)
    res.status(400).json({ 
      message: "User registration failed",
      error: err.message 
    });
  }
});

{
  "username": "admin2",
  "password": "admin123",
  "role": "ADMIN"
}

{
  "username": "editor1",
  "password": "password123",
  "role": "EDITOR"
}

{
  "username": "reader1",
  "password": "reader123",
  "role": "READER"
}

// POST /login - เข้าสู่ระบบและรับ JWT tokens
app.post("/login", async (req, res) => {
  try {
    // ดึงข้อมูลผู้ใช้จาก request body
    const { username, password } = req.body;

    // ตรวจสอบ input
    if (!username || !password) {
      return res.status(400).json({ 
        message: "Username and password are required" 
      });
    }

    // ค้นหาผู้ใช้ในฐานข้อมูลด้วย username
    const user = await prisma.user.findUnique({ 
      where: { username } 
    });

    // ตรวจสอบว่าผู้ใช้มีอยู่และรหัสผ่านถูกต้อง
    if (!user || !await bcrypt.compare(password, user.password)) {
      return res.status(401).json({ 
        message: "Invalid username or password" 
      });
    }

    // สร้าง JWT payload (ข้อมูลที่จะเก็บใน token)
    const tokenPayload = {
      id: user.id,
      username: user.username,
      role: user.role
    };

    // สร้าง access token (อายุ 15 นาที)
    const accessToken = jwt.sign(
      tokenPayload,
      ACCESS_TOKEN_SECRET,
      { expiresIn: "15m" }
    );

    // ส่งคืน response สำเร็จพร้อม tokens
    res.json({
      message: "Login successful",
      accessToken,
      user: {
        id: user.id,
        username: user.username,
        role: user.role
      }
    });

  } catch (err) {
    console.error('Login error:', err);
    res.status(500).json({ 
      message: "Login failed",
      error: err.message 
    });
  }
});

{
  "username": "admin",
  "password": "admin"
}

{
  "username": "editor1",
  "password": "password123"
}

{
  "username": "reader1",
  "password": "reader123"
}

/**
 * Middleware เพื่อยืนยันตัวตน JWT tokens
 * ดึงและตรวจสอบ Bearer token จาก Authorization header
 * แนบข้อมูลผู้ใช้ที่ถอดรหัสแล้วไปยัง req.user เพื่อใช้ใน middleware/routes ต่อไป
 */
function authenticateToken(req, res, next) {
  // รับ Authorization header (รูปแบบ: "Bearer <token>")
  const authHeader = req.headers["authorization"];
  
  // ดึง token จากรูปแบบ "Bearer <token>"
  // authHeader?.split(" ")[1] รับส่วน token หลัง "Bearer "
  const token = authHeader && authHeader.split(" ")[1];
  
  // ตรวจสอบว่า token มีอยู่
  if (!token) {
    return res.status(401).json({ 
      message: "Access denied. No token provided.",
      hint: "Include 'Authorization: Bearer <token>' header"
    });
  }

  // ตรวจสอบลายเซ็นและการหมดอายุของ token
  jwt.verify(token, ACCESS_TOKEN_SECRET, (err, user) => {
    if (err) {
      // Token ไม่ถูกต้องหรือหมดอายุ
      const message = err.name === 'TokenExpiredError' 
        ? "Token has expired. Please refresh your token."
        : "Invalid token. Please log in again.";
        
      return res.status(403).json({ 
        message,
        error: err.name
      });
    }
    
    // Token ถูกต้อง - แนบข้อมูลผู้ใช้ไปยัง request object
    // สิ่งนี้ทำให้ข้อมูลผู้ใช้พร้อมใช้งานใน middleware/routes ต่อไป
    req.user = user;
    
    // ดำเนินการต่อไปยัง middleware/route handler ถัดไป
    next();
  });
}

/**
 * Middleware factory เพื่อตรวจสอบ roles ที่อนุญาต
 * ส่งคืน middleware function ที่ตรวจสอบ role ของผู้ใช้เทียบกับ allowed roles
 * ต้องใช้หลัง authenticateToken middleware เสมอเนื่องจากต้องการ req.user
 * 
 * @param {...string} allowedRoles - Roles ที่อนุญาตให้เข้าถึง (เช่น 'ADMIN', 'EDITOR')
 * @returns {Function} Express middleware function
 */
function authorizeRoles(...allowedRoles) {
  return (req, res, next) => {
    // ตรวจสอบว่าผู้ใช้ถูกยืนยันตัวตนแล้ว (จาก authenticateToken middleware)
    if (!req.user) {
      return res.status(401).json({ 
        message: "Authentication required. Please log in first." 
      });
    }

    // ตรวจสอบว่า role ของผู้ใช้อยู่ใน allowed roles
    if (!allowedRoles.includes(req.user.role)) {
      return res.status(403).json({ 
        message: "Access forbidden. Insufficient permissions.",
        required: allowedRoles,
        userRole: req.user.role
      });
    }

    // Role ของผู้ใช้ได้รับอนุญาต - ดำเนินการต่อ
    next();
  };
}

// Role เดียว
app.get('/admin', authenticateToken, authorizeRoles('ADMIN'), handler);

// หลาย roles
app.post('/articles', authenticateToken, authorizeRoles('ADMIN', 'EDITOR'), handler);

// ผู้ใช้ที่ยืนยันตัวตนแล้วทุกคน (ไม่ต้องตรวจสอบ role)
app.get('/profile', authenticateToken, handler);

// ตัวอย่าง 1: Route เฉพาะ admin
app.post("/admin-only", 
  authenticateToken,           // ก่อน: ตรวจสอบ JWT token
  authorizeRoles("ADMIN"),     // สอง: ตรวจสอบ role
  (req, res) => {
    res.json({ 
      message: "Access granted to Admin",
      user: req.user.username    // ข้อมูลผู้ใช้พร้อมใช้งานจาก token
    });
  }
);

// ตัวอย่าง 2: Route หลาย role (ผู้สร้างเนื้อหา)
app.post("/create-content",
  authenticateToken,
  authorizeRoles("ADMIN", "EDITOR"),
  (req, res) => {
    res.json({ message: "Permission granted to create content" });
  }
);

// ตัวอย่าง 3: Route สาธารณะ (ไม่ต้องใช้ middleware)
app.get("/public", (req, res) => {
  res.json({ message: "This is public information" });
});

// ตัวอย่าง 4: ยืนยันตัวตนแต่ role ใดก็ได้
app.get("/profile",
  authenticateToken,           // ต้องยืนยันตัวตนเท่านั้น
  (req, res) => {
    res.json({ 
      profile: {
        id: req.user.id,
        username: req.user.username,
        role: req.user.role
      }
    });
  }
);

// POST /articles - สร้าง article ใหม่
// สิทธิ์: ADMIN และ EDITOR สามารถสร้าง articles ได้
app.post("/articles", 
  authenticateToken,                    // ตรวจสอบ JWT token
  authorizeRoles("ADMIN", "EDITOR"),   // ตรวจสอบ role ของผู้ใช้
  async (req, res) => {
    try {
      // ดึงข้อมูล article จาก request body
      const { title, content } = req.body;
      
      // สร้าง article ในฐานข้อมูล
      // authorId มาจากผู้ใช้ที่ยืนยันตัวตนแล้ว (req.user.id)
      const article = await prisma.article.create({
        data: { 
          title, 
          content, 
          authorId: req.user.id  // เชื่อม article กับผู้ใช้ที่ยืนยันตัวตนแล้ว
        },
        // รวมข้อมูลผู้เขียนใน response
        include: {
          author: {
            select: {
              id: true,
              username: true,
              role: true
              // ไม่รวมรหัสผ่านเพื่อความปลอดภัย
            }
          }
        }
      });
      
      // ส่งคืน article ที่สร้างแล้วพร้อมข้อมูลผู้เขียน
      res.status(201).json({
        message: "Article created successfully",
        article
      });
      
    } catch (err) {
      console.error('Create article error:', err);
      res.status(500).json({
        message: "Failed to create article",
        error: err.message
      });
    }
  }
);

{
  "title": "Test Article from Admin",
  "content": "This is article content created by Admin"
}

{
  "title": "Article from Editor",
  "content": "Editor can create articles"
}

{
  "title": "Attempted creation by Reader",
  "content": "This should fail"
}

// GET /articles - ดึงข้อมูล articles ทั้งหมด
// สิทธิ์: ผู้ใช้ที่ยืนยันตัวตนแล้วทุกคนสามารถอ่าน articles ได้
app.get("/articles", 
  authenticateToken,    // ต้องยืนยันตัวตนเท่านั้น ไม่จำกัด role
  async (req, res) => {
    try {
      // ดึง articles ทั้งหมดจากฐานข้อมูล
      const articles = await prisma.article.findMany({ 
        include: { 
          author: {
            select: {
              id: true,
              username: true,
              role: true
              // ไม่รวมรหัสผ่านเพื่อความปลอดภัย
            }
          }
        }
      });
      
      // ส่งคืน articles ทั้งหมด
      res.json({
        articles,
        total: articles.length
      });
      
    } catch (err) {
      console.error('Fetch articles error:', err);
      res.status(500).json({
        message: "Failed to fetch articles",
        error: err.message
      });
    }
  }
);

{
  "articles": [
    {
      "id": 1,
      "title": "Test Article from Admin",
      "content": "This is article content created by Admin",
      "authorId": 1,
      "createdAt": "2025-07-27T10:00:00.000Z",
      "author": {
        "id": 1,
        "username": "admin",
        "role": "ADMIN"
      }
    }
  ],
  "total": 1
}

// PUT /articles/:id - แก้ไข article ที่มีอยู่
// สิทธิ์: ADMIN และ EDITOR สามารถแก้ไข articles ได้
app.put("/articles/:id", 
  authenticateToken, 
  authorizeRoles("ADMIN", "EDITOR"), 
  async (req, res) => {
    try {
      // ดึง article ID จาก URL parameters
      const { id } = req.params;
      const { title, content } = req.body;
      
      // เตรียมข้อมูลการอัปเดต (รวมเฉพาะฟิลด์ที่ระบุ)
      const updateData = {};
      if (title !== undefined) updateData.title = title;
      if (content !== undefined) updateData.content = content;
      
      // อัปเดต article ในฐานข้อมูล
      const updatedArticle = await prisma.article.update({
        where: { id: parseInt(id) },
        data: updateData,
        include: {
          author: {
            select: {
              id: true,
              username: true,
              role: true
            }
          }
        }
      });
      
      res.json({
        message: "Article updated successfully",
        article: updatedArticle
      });
      
    } catch (err) {
      console.error('Update article error:', err);
      res.status(500).json({
        message: "Failed to update article",
        error: err.message
      });
    }
  }
);

{
  "title": "Article edited by Admin",
  "content": "Content updated by Admin"
}

{
  "title": "Updated article title",
  "content": "Updated article content"
}

{
  "title": "Reader attempting to edit"
}

{
  "title": "Only changing the title"
}

// DELETE /articles/:id - ลบ article
// สิทธิ์: เฉพาะ ADMIN เท่านั้นที่สามารถลบ articles ได้
app.delete("/articles/:id", 
  authenticateToken, 
  authorizeRoles("ADMIN"),
  async (req, res) => {
    try {
      const { id } = req.params;
      await prisma.article.delete({ where: { id: parseInt(id) } });
      res.json({ message: "Article deleted successfully" });
    } catch (err) {
      res.status(500).json({ message: "Failed to delete article" });
    }
  }
);