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 mysql2

-- สร้างตาราง Users
CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  username VARCHAR(255) NOT NULL UNIQUE,
  password VARCHAR(255) NOT NULL,
  role ENUM('ADMIN', 'EDITOR', 'READER') DEFAULT 'READER',
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- สร้างตาราง Articles
CREATE TABLE articles (
  id INT AUTO_INCREMENT PRIMARY KEY,
  title VARCHAR(255) NOT NULL,
  content TEXT NOT NULL,
  author_id INT NOT NULL,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
  FOREIGN KEY (author_id) REFERENCES users(id) ON DELETE CASCADE
);

DB_HOST=localhost
DB_PORT=3307
DB_USER=root
DB_PASSWORD=
DB_NAME=jwt_rbac_demo
JWT_ACCESS_TOKEN_SECRET=supersecretaccesstoken

// seed-admin.js
const bcrypt = require('bcryptjs');
const mysql = require('mysql2/promise');

async function seedAdmin() {
  const connection = await mysql.createConnection({
    host: process.env.DB_HOST || 'localhost',
    port: process.env.DB_PORT || 3307,
    user: process.env.DB_USER || 'root',
    password: process.env.DB_PASSWORD || '',
    database: process.env.DB_NAME || 'jwt_rbac_demo'
  });

  const hashedPassword = bcrypt.hashSync("admin", 10);

  await connection.execute(
    'INSERT INTO users (username, password, role) VALUES (?, ?, ?)',
    ['admin', hashedPassword, 'ADMIN']
  );

  console.log('Admin user created successfully!');
  await connection.end();
}

seedAdmin().catch(console.error);

node --env-file=.env seed-admin.js

// นำเข้า 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 mysql = require("mysql2/promise");     // MySQL driver พร้อม Promise support

// สร้าง MySQL connection pool
// การใช้ pool ช่วยให้จัดการ connection ได้อย่างมีประสิทธิภาพ
const pool = mysql.createPool({
  host: process.env.DB_HOST || 'localhost',
  port: process.env.DB_PORT || 3307,
  user: process.env.DB_USER || 'root',
  password: process.env.DB_PASSWORD || '',
  database: process.env.DB_NAME || 'jwt_rbac_demo',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
});

// เริ่มต้น 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(`MySQL connected via CAMPP at localhost:${process.env.DB_PORT || 3307}`);
});

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

// POST /register - สร้างบัญชีผู้ใช้ใหม่
app.post("/register", async (req, res) => {
  // ดึงข้อมูลผู้ใช้จาก request body
  const { username, password, role } = req.body;

  // ตรวจสอบข้อมูลที่จำเป็น
  if (!username || !password) {
    return res.status(400).json({
      message: "Username and password are required"
    });
  }

  // เข้ารหัสรหัสผ่านด้วย bcrypt (salt rounds = 10)
  // rounds ที่สูงขึ้น = ปลอดภัยมากขึ้นแต่ช้าลง
  const hashedPassword = await bcrypt.hash(password, 10);

  try {
    // สร้างผู้ใช้ใหม่ในฐานข้อมูลโดยใช้ raw SQL
    const userRole = role || 'READER'; // ค่าเริ่มต้นเป็น READER
    const [result] = await pool.execute(
      'INSERT INTO users (username, password, role) VALUES (?, ?, ?)',
      [username, hashedPassword, userRole]
    );

    // ดึงข้อมูลผู้ใช้ที่เพิ่งสร้าง
    const [rows] = await pool.execute(
      'SELECT id, username, role FROM users WHERE id = ?',
      [result.insertId]
    );

    const user = rows[0];

    // ส่งคืน response สำเร็จ (ไม่รวมข้อมูลที่ละเอียดอ่อนเช่นรหัสผ่าน)
    res.status(201).json({
      message: "User registration successful",
      user: {
        id: user.id,
        username: user.username,
        role: user.role
      }
    });
  } catch (err) {
    // จัดการข้อผิดพลาดของฐานข้อมูล (เช่น ชื่อผู้ใช้ซ้ำ)
    if (err.code === 'ER_DUP_ENTRY') {
      return res.status(400).json({
        message: "Username already exists"
      });
    }
    res.status(500).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 [rows] = await pool.execute(
      'SELECT id, username, password, role FROM users WHERE username = ?',
      [username]
    );

    const user = rows[0];

    // ตรวจสอบว่าผู้ใช้มีอยู่และรหัสผ่านถูกต้อง
    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;

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

      // สร้าง article ในฐานข้อมูล
      // authorId มาจากผู้ใช้ที่ยืนยันตัวตนแล้ว (req.user.id)
      const [result] = await pool.execute(
        'INSERT INTO articles (title, content, author_id) VALUES (?, ?, ?)',
        [title, content, req.user.id]
      );

      // ดึงข้อมูล article ที่เพิ่งสร้างพร้อมข้อมูลผู้เขียน
      const [rows] = await pool.execute(
        `SELECT a.id, a.title, a.content, a.created_at,
                u.id as author_id, u.username, u.role
         FROM articles a
         JOIN users u ON a.author_id = u.id
         WHERE a.id = ?`,
        [result.insertId]
      );

      const article = rows[0];

      // จัดรูปแบบ response
      const responseArticle = {
        id: article.id,
        title: article.title,
        content: article.content,
        createdAt: article.created_at,
        authorId: article.author_id,
        author: {
          id: article.author_id,
          username: article.username,
          role: article.role
        }
      };

      // ส่งคืน article ที่สร้างแล้วพร้อมข้อมูลผู้เขียน
      res.status(201).json({
        message: "Article created successfully",
        article: responseArticle
      });

    } 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 [rows] = await pool.execute(
        `SELECT a.id, a.title, a.content, a.created_at, a.author_id,
                u.id as author_id, u.username, u.role
         FROM articles a
         JOIN users u ON a.author_id = u.id
         ORDER BY a.created_at DESC`
      );

      // จัดรูปแบบข้อมูล articles
      const articles = rows.map(row => ({
        id: row.id,
        title: row.title,
        content: row.content,
        createdAt: row.created_at,
        authorId: row.author_id,
        author: {
          id: row.author_id,
          username: row.username,
          role: row.role
        }
      }));

      // ส่งคืน 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 updateFields = [];
      const updateValues = [];

      if (title !== undefined) {
        updateFields.push('title = ?');
        updateValues.push(title);
      }
      if (content !== undefined) {
        updateFields.push('content = ?');
        updateValues.push(content);
      }

      // ถ้าไม่มีฟิลด์ที่จะอัปเดต
      if (updateFields.length === 0) {
        return res.status(400).json({
          message: "No fields to update"
        });
      }

      updateValues.push(parseInt(id)); // เพิ่ม id สำหรับ WHERE clause

      // อัปเดต article ในฐานข้อมูล
      await pool.execute(
        `UPDATE articles SET ${updateFields.join(', ')} WHERE id = ?`,
        updateValues
      );

      // ดึงข้อมูล article ที่อัปเดตพร้อมข้อมูลผู้เขียน
      const [rows] = await pool.execute(
        `SELECT a.id, a.title, a.content, a.created_at,
                u.id as author_id, u.username, u.role
         FROM articles a
         JOIN users u ON a.author_id = u.id
         WHERE a.id = ?`,
        [parseInt(id)]
      );

      if (rows.length === 0) {
        return res.status(404).json({
          message: "Article not found"
        });
      }

      const article = rows[0];

      // จัดรูปแบบ response
      const responseArticle = {
        id: article.id,
        title: article.title,
        content: article.content,
        createdAt: article.created_at,
        authorId: article.author_id,
        author: {
          id: article.author_id,
          username: article.username,
          role: article.role
        }
      };

      res.json({
        message: "Article updated successfully",
        article: responseArticle
      });

    } 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"
}

// DELETE /articles/:id - ลบ article
// สิทธิ์: เฉพาะ ADMIN เท่านั้นที่สามารถลบ articles ได้
app.delete("/articles/:id",
  authenticateToken,
  authorizeRoles("ADMIN"),
  async (req, res) => {
    try {
      const { id } = req.params;

      // ตรวจสอบว่า article มีอยู่จริง
      const [rows] = await pool.execute(
        'SELECT id FROM articles WHERE id = ?',
        [parseInt(id)]
      );

      if (rows.length === 0) {
        return res.status(404).json({
          message: "Article not found"
        });
      }

      // ลบ article
      await pool.execute(
        'DELETE FROM articles WHERE id = ?',
        [parseInt(id)]
      );

      res.json({ message: "Article deleted successfully" });
    } catch (err) {
      console.error('Delete article error:', err);
      res.status(500).json({
        message: "Failed to delete article",
        error: err.message
      });
    }
  }
);