สร้าง RESTful API + OpenAPI Document

mkdir express-typescript-openapi
cd express-typescript-openapi
npm init -y

# Production Dependencies
npm install express cors mysql2 swagger-ui-express

# Development Dependencies
npm install -D typescript @types/node @types/express @types/cors ts-node nodemon
npm install -D @types/swagger-ui-express

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "lib": ["ES2020"],
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "resolveJsonModule": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

{
  "scripts": {
    "dev": "nodemon src/index.ts",
    "build": "tsc",
    "start": "node dist/index.js"
  }
}

express-typescript-openapi/
├── src/
│   ├── config/
│   │   └── database.ts
│   ├── validators/
│   │   └── validator.ts
│   ├── routes/
│   │   └── users.route.ts
│   ├── index.ts
│   └── openapi.ts
├── package.json
└── tsconfig.json

-- สร้างตาราง Users
CREATE TABLE users (
  id INT AUTO_INCREMENT PRIMARY KEY,
  fname VARCHAR(255) NOT NULL,
  lname VARCHAR(255) NOT NULL,
  username VARCHAR(255) NOT NULL UNIQUE,
  email VARCHAR(255) NOT NULL UNIQUE,
  avatar VARCHAR(500),
  role VARCHAR(50) DEFAULT 'user',
  is_active BOOLEAN DEFAULT TRUE,
  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- เพิ่มข้อมูลตัวอย่าง
INSERT INTO users (fname, lname, username, email, avatar, role, is_active) VALUES
('Karn', 'Yong', 'karn.yong', 'karn@example.com', 'https://www.melivecode.com/users/1.png', 'user', TRUE),
('Ivy', 'Cal', 'ivy.cal', 'ivy@example.com', 'https://www.melivecode.com/users/2.png', 'admin', TRUE),
('Walter', 'Beau', 'walter.beau', 'walter@example.com', 'https://www.melivecode.com/users/3.png', 'user', TRUE);

import mysql, { PoolOptions } from 'mysql2/promise';

const access: PoolOptions = {
  host: 'localhost',
  port: 3307,          // CAMPP ใช้พอร์ต 3307
  user: 'root',
  password: '',        // CAMPP default ไม่มี password
  database: 'test_db',
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0
};

export const pool = mysql.createPool(access);

// Helper function สำหรับ query
export async function query(sql: string, params?: any[]) {
  const [rows] = await pool.execute(sql, params);
  return rows;
}

// User Type สำหรับกำหนดรูปแบบข้อมูล
export interface User {
  id?: number;
  fname: string;
  lname: string;
  username: string;
  email: string;
  avatar?: string;
  role: 'user' | 'admin';
  isActive: boolean;
  created_at?: Date;
}

// Type สำหรับการสร้าง User ใหม่ (ไม่มี id)
export type CreateUser = Omit<User, 'id' | 'created_at'> & {
  avatar?: string;
  role?: 'user' | 'admin';
  isActive?: boolean;
};

// Type สำหรับการอัปเดต User (ทุก field ไม่บังคับ)
export type UpdateUser = Partial<Omit<User, 'id' | 'created_at'>> & {
  id: number;
};

// Type สำหรับ Query Parameters
export interface UserQuery {
  page?: number;
  limit?: number;
  search?: string;
}

import { Request, Response, NextFunction, RequestHandler } from 'express';

// ฟังก์ชันตรวจสอบ Email
const isValidEmail = (email: string): boolean => {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
};

// ฟังก์ชันตรวจสอบ Username
const isValidUsername = (username: string): boolean => {
  const usernameRegex = /^[a-zA-Z0-9_]{3,50}$/;
  return usernameRegex.test(username);
};

// Validation Middleware สำหรับ Request Body
export const validateCreateUser = (): RequestHandler => {
  return (req: Request, res: Response, next: NextFunction) => {
    const { fname, lname, username, email, avatar, role, isActive } = req.body;
    const errors: string[] = [];

    // ตรวจสอบ fname
    if (!fname || typeof fname !== 'string' || fname.trim().length === 0) {
      errors.push('First name is required');
    } else if (fname.length > 100) {
      errors.push('First name must not exceed 100 characters');
    }

    // ตรวจสอบ lname
    if (!lname || typeof lname !== 'string' || lname.trim().length === 0) {
      errors.push('Last name is required');
    } else if (lname.length > 100) {
      errors.push('Last name must not exceed 100 characters');
    }

    // ตรวจสอบ username
    if (!username || typeof username !== 'string') {
      errors.push('Username is required');
    } else if (!isValidUsername(username)) {
      errors.push('Username must be 3-50 characters and contain only letters, numbers, and underscores');
    }

    // ตรวจสอบ email
    if (!email || typeof email !== 'string') {
      errors.push('Email is required');
    } else if (!isValidEmail(email)) {
      errors.push('Invalid email format');
    }

    // ตรวจสอบ avatar (ถ้ามี)
    if (avatar !== undefined && typeof avatar !== 'string') {
      errors.push('Avatar must be a string');
    }

    // ตรวจสอบ role (ถ้ามี)
    if (role !== undefined && !['user', 'admin'].includes(role)) {
      errors.push('Role must be either "user" or "admin"');
    }

    // ตรวจสอบ isActive (ถ้ามี)
    if (isActive !== undefined && typeof isActive !== 'boolean') {
      errors.push('isActive must be a boolean');
    }

    if (errors.length > 0) {
      return res.status(400).json({
        success: false,
        errors: errors.map(msg => ({ message: msg }))
      });
    }

    next();
  };
};

// Validation Middleware สำหรับ Update User
export const validateUpdateUser = (): RequestHandler => {
  return (req: Request, res: Response, next: NextFunction) => {
    const { fname, lname, username, email, avatar, role, isActive } = req.body;
    const errors: string[] = [];

    // ตรวจสอบ fname (ถ้ามี)
    if (fname !== undefined) {
      if (typeof fname !== 'string' || fname.trim().length === 0) {
        errors.push('First name must not be empty');
      } else if (fname.length > 100) {
        errors.push('First name must not exceed 100 characters');
      }
    }

    // ตรวจสอบ lname (ถ้ามี)
    if (lname !== undefined) {
      if (typeof lname !== 'string' || lname.trim().length === 0) {
        errors.push('Last name must not be empty');
      } else if (lname.length > 100) {
        errors.push('Last name must not exceed 100 characters');
      }
    }

    // ตรวจสอบ username (ถ้ามี)
    if (username !== undefined) {
      if (!isValidUsername(username)) {
        errors.push('Username must be 3-50 characters and contain only letters, numbers, and underscores');
      }
    }

    // ตรวจสอบ email (ถ้ามี)
    if (email !== undefined) {
      if (!isValidEmail(email)) {
        errors.push('Invalid email format');
      }
    }

    // ตรวจสอบ role (ถ้ามี)
    if (role !== undefined && !['user', 'admin'].includes(role)) {
      errors.push('Role must be either "user" or "admin"');
    }

    // ตรวจสอบ isActive (ถ้ามี)
    if (isActive !== undefined && typeof isActive !== 'boolean') {
      errors.push('isActive must be a boolean');
    }

    if (errors.length > 0) {
      return res.status(400).json({
        success: false,
        errors: errors.map(msg => ({ message: msg }))
      });
    }

    next();
  };
};

// Validation Middleware สำหรับ Query Parameters
export const validateQuery = (): RequestHandler => {
  return (req: Request, res: Response, next: NextFunction) => {
    const { page, limit, search } = req.query;

    // แปลงและตรวจสอบ page
    if (page !== undefined) {
      const pageNum = parseInt(page as string);
      if (isNaN(pageNum) || pageNum < 1) {
        return res.status(400).json({
          success: false,
          errors: [{ message: 'Page must be a positive number' }]
        });
      }
      req.query.page = pageNum.toString();
    } else {
      req.query.page = "1";
    }

    // แปลงและตรวจสอบ limit
    if (limit !== undefined) {
      const limitNum = parseInt(limit as string);
      if (isNaN(limitNum) || limitNum < 1) {
        return res.status(400).json({
          success: false,
          errors: [{ message: 'Limit must be a positive number' }]
        });
      }
      req.query.limit = limitNum.toString();
    } else {
      req.query.limit = "10";
    }

    next();
  };
};

// Validation Middleware สำหรับ URL Parameters
export const validateParams = (): RequestHandler => {
  return (req: Request, res: Response, next: NextFunction) => {
    const { id } = req.params;

    if (Array.isArray(id)) {
      return res.status(400).json({
        success: false,
        errors: [{ message: 'ID must be a single value' }]
      });
    }
    
    const idNum = parseInt(id);
    if (isNaN(idNum) || idNum < 1) {
      return res.status(400).json({
        success: false,
        errors: [{ message: 'ID must be a positive number' }]
      });
    }

    req.params.id = idNum.toString();
    next();
  };
};

import { Router, Request, Response } from 'express';
import { validateCreateUser, validateUpdateUser, validateQuery, validateParams } from '../validators/validator';
import { pool } from '../config/database';

const router = Router();

// GET /users - Get all users with pagination
router.get('/',
  validateQuery(),
  async (req: Request, res: Response) => {
    try {
      const { page, limit, search } = req.query as any;
      const pageNum = parseInt(page) || 1;
      const limitNum = parseInt(limit) || 10;

      let sql = 'SELECT * FROM users';
      let params: any[] = [];
      let countSql = 'SELECT COUNT(*) as total FROM users';
      let countParams: any[] = [];

      // Search filter
      if (search) {
        sql += ' WHERE fname LIKE ? OR lname LIKE ? OR email LIKE ?';
        countSql += ' WHERE fname LIKE ? OR lname LIKE ? OR email LIKE ?';
        const searchTerm = `%${search}%`;
        params = [searchTerm, searchTerm, searchTerm];
        countParams = [searchTerm, searchTerm, searchTerm];
      }

      // Get total count
      const [countRows] = await pool.query(countSql, countParams);
      const total = (countRows as any)[0].total;

      // Pagination
      sql += ' ORDER BY id LIMIT ? OFFSET ?';
      params.push(limitNum, (pageNum - 1) * limitNum);

      const [users] = await pool.query(sql, params);

      res.json({
        success: true,
        data: users,
        pagination: {
          page: pageNum,
          limit: limitNum,
          total,
          totalPages: Math.ceil(total / limitNum)
        }
      });
    } catch (error: any) {
      console.error('Error in GET /users:', error);
      res.status(500).json({
        success: false,
        message: 'Internal server error',
        error: error instanceof Error ? error.message : undefined
      });
    }
  }
);

// GET /users/:id - Get user by ID
router.get('/:id',
  validateParams(),
  async (req: Request, res: Response) => {
    try {
      const { id } = req.params;
      const [users] = await pool.query('SELECT * FROM users WHERE id = ?', [id]);
      const user = (users as any)[0];

      if (!user) {
        return res.status(404).json({
          success: false,
          message: 'User not found'
        });
      }

      res.json({
        success: true,
        data: user
      });
    } catch (error) {
      res.status(500).json({
        success: false,
        message: 'Internal server error',
        error: error instanceof Error ? error.message : undefined
      });
    }
  }
);

// POST /users - Create new user
router.post('/',
  validateCreateUser(),
  async (req: Request, res: Response) => {
    try {
      const { fname, lname, username, email, avatar, role, isActive } = req.body;

      const [insertResult] = await pool.query(
        'INSERT INTO users (fname, lname, username, email, avatar, role, is_active) VALUES (?, ?, ?, ?, ?, ?, ?)',
        [fname, lname, username, email, avatar || null, role || 'user', isActive !== undefined ? isActive : 1]
      ) as any;

      const insertId = insertResult.insertId;
      const [newUsers] = await pool.query('SELECT * FROM users WHERE id = ?', [insertId]);
      const newUser = (newUsers as any)[0];

      res.status(201).json({
        success: true,
        data: newUser,
        message: 'User created successfully'
      });
    } catch (error: any) {
      // Handle duplicate entry error
      if (error.code === 'ER_DUP_ENTRY') {
        return res.status(400).json({
          success: false,
          message: 'Username or email already exists'
        });
      }
      res.status(500).json({
        success: false,
        message: 'Internal server error',
        error: error.message
      });
    }
  }
);

// PUT /users/:id - Update user by ID
router.put('/:id',
  validateParams(),
  validateUpdateUser(),
  async (req: Request, res: Response) => {
    try {
      const { id } = req.params;
      const { fname, lname, username, email, avatar, role, isActive } = req.body;

      // Check if user exists
      const [existingUsers] = await pool.query('SELECT * FROM users WHERE id = ?', [id]) as any;
      const existingUser = (existingUsers as any)[0];

      if (!existingUser) {
        return res.status(404).json({
          success: false,
          message: 'User not found'
        });
      }

      // Build dynamic UPDATE query
      const updates: string[] = [];
      const params: any[] = [];

      if (fname !== undefined) {
        updates.push('fname = ?');
        params.push(fname);
      }
      if (lname !== undefined) {
        updates.push('lname = ?');
        params.push(lname);
      }
      if (username !== undefined) {
        updates.push('username = ?');
        params.push(username);
      }
      if (email !== undefined) {
        updates.push('email = ?');
        params.push(email);
      }
      if (avatar !== undefined) {
        updates.push('avatar = ?');
        params.push(avatar);
      }
      if (role !== undefined) {
        updates.push('role = ?');
        params.push(role);
      }
      if (isActive !== undefined) {
        updates.push('is_active = ?');
        params.push(isActive);
      }

      if (updates.length === 0) {
        return res.status(400).json({
          success: false,
          message: 'No fields to update'
        });
      }

      params.push(id); // Add id for WHERE clause

      await pool.query(
        `UPDATE users SET ${updates.join(', ')} WHERE id = ?`,
        params
      );

      // Get updated user
      const [updatedUsers] = await pool.query('SELECT * FROM users WHERE id = ?', [id]) as any;
      const updatedUser = (updatedUsers as any)[0];

      res.json({
        success: true,
        data: updatedUser,
        message: 'User updated successfully'
      });
    } catch (error: any) {
      // Handle duplicate entry error
      if (error.code === 'ER_DUP_ENTRY') {
        return res.status(400).json({
          success: false,
          message: 'Username or email already exists'
        });
      }
      res.status(500).json({
        success: false,
        message: 'Internal server error',
        error: error.message
      });
    }
  }
);

// DELETE /users/:id - Delete user by ID
router.delete('/:id',
  validateParams(),
  async (req: Request, res: Response) => {
    try {
      const { id } = req.params;

      // Check if user exists
      const [existingUsers] = await pool.query('SELECT * FROM users WHERE id = ?', [id]) as any;
      const existingUser = (existingUsers as any)[0];

      if (!existingUser) {
        return res.status(404).json({
          success: false,
          message: 'User not found'
        });
      }

      await pool.query('DELETE FROM users WHERE id = ?', [id]);

      res.json({
        success: true,
        message: 'User deleted successfully'
      });
    } catch (error: any) {
      res.status(500).json({
        success: false,
        message: 'Internal server error',
        error: error.message
      });
    }
  }
);

export default router;

export const openApiSpec = {
  openapi: '3.0.0',
  info: {
    title: 'Express + TypeScript + MySQL API',
    version: '1.0.0',
    description: 'RESTful API ด้วย Type Safety และ MySQL Integration',
    contact: {
      name: 'API Support',
      email: 'support@example.com'
    }
  },
  servers: [
    {
      url: 'http://localhost:3000',
      description: 'Development Server'
    }
  ],
  components: {
    schemas: {
      User: {
        type: 'object',
        properties: {
          id: { type: 'number', description: 'User ID' },
          fname: { type: 'string', minLength: 1, maxLength: 100, description: 'First name' },
          lname: { type: 'string', minLength: 1, maxLength: 100, description: 'Last name' },
          username: { type: 'string', minLength: 3, maxLength: 50, description: 'Username' },
          email: { type: 'string', format: 'email', description: 'Email address' },
          avatar: { type: 'string', format: 'uri', description: 'Avatar URL' },
          role: { type: 'string', enum: ['user', 'admin'], description: 'User role' },
          isActive: { type: 'boolean', description: 'Account status' }
        },
        required: ['fname', 'lname', 'username', 'email']
      },
      CreateUser: {
        type: 'object',
        properties: {
          fname: { type: 'string', minLength: 1, maxLength: 100 },
          lname: { type: 'string', minLength: 1, maxLength: 100 },
          username: { type: 'string', minLength: 3, maxLength: 50, pattern: '^[a-zA-Z0-9_]+$' },
          email: { type: 'string', format: 'email' },
          avatar: { type: 'string', format: 'uri' },
          role: { type: 'string', enum: ['user', 'admin'], default: 'user' },
          isActive: { type: 'boolean', default: true }
        },
        required: ['fname', 'lname', 'username', 'email']
      },
      UpdateUser: {
        type: 'object',
        properties: {
          fname: { type: 'string', minLength: 1, maxLength: 100 },
          lname: { type: 'string', minLength: 1, maxLength: 100 },
          username: { type: 'string', minLength: 3, maxLength: 50 },
          email: { type: 'string', format: 'email' },
          avatar: { type: 'string', format: 'uri' },
          role: { type: 'string', enum: ['user', 'admin'] },
          isActive: { type: 'boolean' }
        }
      },
      Error: {
        type: 'object',
        properties: {
          success: { type: 'boolean', example: false },
          message: { type: 'string' },
          errors: {
            type: 'array',
            items: {
              type: 'object',
              properties: {
                path: { type: 'string' },
                message: { type: 'string' }
              }
            }
          }
        }
      }
    },
    parameters: {
      UserId: {
        name: 'id',
        in: 'path',
        required: true,
        schema: { type: 'number' },
        description: 'User ID'
      }
    }
  },
  paths: {
    '/users': {
      get: {
        summary: 'Get all users',
        description: 'Retrieve a list of users with pagination and search',
        tags: ['Users'],
        parameters: [
          {
            name: 'page',
            in: 'query',
            schema: { type: 'number', default: 1 },
            description: 'Page number'
          },
          {
            name: 'limit',
            in: 'query',
            schema: { type: 'number', default: 10 },
            description: 'Items per page'
          },
          {
            name: 'search',
            in: 'query',
            schema: { type: 'string' },
            description: 'Search in name, username, or email'
          }
        ],
        responses: {
          '200': {
            description: 'Success',
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                  properties: {
                    success: { type: 'boolean' },
                    data: {
                      type: 'array',
                      items: { $ref: '#/components/schemas/User' }
                    },
                    pagination: {
                      type: 'object',
                      properties: {
                        page: { type: 'number' },
                        limit: { type: 'number' },
                        total: { type: 'number' },
                        totalPages: { type: 'number' }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      },
      post: {
        summary: 'Create new user',
        description: 'Create a new user account',
        tags: ['Users'],
        requestBody: {
          required: true,
          content: {
            'application/json': {
              schema: { $ref: '#/components/schemas/CreateUser' }
            }
          }
        },
        responses: {
          '201': {
            description: 'User created successfully',
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                  properties: {
                    success: { type: 'boolean' },
                    data: { $ref: '#/components/schemas/User' },
                    message: { type: 'string' }
                  }
                }
              }
            }
          },
          '400': {
            description: 'Validation error',
            content: {
              'application/json': {
                schema: { $ref: '#/components/schemas/Error' }
              }
            }
          }
        }
      }
    },
    '/users/{id}': {
      get: {
        summary: 'Get user by ID',
        description: 'Retrieve a specific user by ID',
        tags: ['Users'],
        parameters: [{ $ref: '#/components/parameters/UserId' }],
        responses: {
          '200': {
            description: 'Success',
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                  properties: {
                    success: { type: 'boolean' },
                    data: { $ref: '#/components/schemas/User' }
                  }
                }
              }
            }
          },
          '404': {
            description: 'User not found',
            content: {
              'application/json': {
                schema: { $ref: '#/components/schemas/Error' }
              }
            }
          }
        }
      },
      put: {
        summary: 'Update user',
        description: 'Update user information',
        tags: ['Users'],
        parameters: [{ $ref: '#/components/parameters/UserId' }],
        requestBody: {
          content: {
            'application/json': {
              schema: { $ref: '#/components/schemas/UpdateUser' }
            }
          }
        },
        responses: {
          '200': {
            description: 'User updated successfully',
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                  properties: {
                    success: { type: 'boolean' },
                    data: { $ref: '#/components/schemas/User' },
                    message: { type: 'string' }
                  }
                }
              }
            }
          },
          '404': {
            description: 'User not found'
          }
        }
      },
      delete: {
        summary: 'Delete user',
        description: 'Delete a user account',
        tags: ['Users'],
        parameters: [{ $ref: '#/components/parameters/UserId' }],
        responses: {
          '200': {
            description: 'User deleted successfully',
            content: {
              'application/json': {
                schema: {
                  type: 'object',
                  properties: {
                    success: { type: 'boolean' },
                    message: { type: 'string' }
                  }
                }
              }
            }
          },
          '404': {
            description: 'User not found'
          }
        }
      }
    }
  },
  tags: [
    {
      name: 'Users',
      description: 'User management endpoints'
    }
  ]
};

import express, { Application } from 'express';
import cors from 'cors';
import swaggerUi from 'swagger-ui-express';
import { openApiSpec } from './openapi';
import userRoutes from './routes/users.route';

const app: Application = express();
const PORT = process.env.PORT || 3000;

// Middleware
app.use(cors());
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Routes
app.get('/', (req, res) => {
  res.json({
    message: 'Welcome to Express + TypeScript + MySQL API',
    docs: '/api-docs',
    version: '1.0.0'
  });
});

// API Routes
app.use('/users', userRoutes);

// Swagger UI
app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(openApiSpec, {
  customSiteTitle: 'API Documentation',
  customCss: '.swagger-ui .topbar { display: none }',
  swaggerOptions: {
    persistAuthorization: true,
    displayRequestDuration: true,
    docExpansion: 'list',
    filter: true,
    showRequestHeaders: true
  }
}));

// Error Handler
app.use((err: any, req: express.Request, res: express.Response, next: express.NextFunction) => {
  console.error(err.stack);
  res.status(500).json({
    success: false,
    message: 'Internal server error',
    error: process.env.NODE_ENV === 'development' ? err.message : undefined
  });
});

// Start Server
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
  console.log(`API Documentation: http://localhost:${PORT}/api-docs`);
});

npm run dev

{
  "success": true,
  "data": [
    {
      "id": 1,
      "fname": "Karn",
      "lname": "Yong",
      "username": "karn.yong",
      "email": "karn@example.com",
      "avatar": "https://www.melivecode.com/users/1.png",
      "role": "user",
      "isActive": true,
      "created_at": "2026-04-21T10:00:00.000Z"
    },
    {
      "id": 2,
      "fname": "Ivy",
      "lname": "Cal",
      "username": "ivy.cal",
      "email": "ivy@example.com",
      "avatar": "https://www.melivecode.com/users/2.png",
      "role": "admin",
      "isActive": true,
      "created_at": "2026-04-21T10:00:00.000Z"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 10,
    "total": 3,
    "totalPages": 1
  }
}

{
  "success": true,
  "data": {
    "id": 1,
    "fname": "Karn",
    "lname": "Yong",
    "username": "karn.yong",
    "email": "karn@example.com",
    "avatar": "https://www.melivecode.com/users/1.png",
    "role": "user",
    "isActive": true,
    "created_at": "2026-04-21T10:00:00.000Z"
  }
}

{
  "fname": "Test",
  "lname": "User",
  "username": "test.user",
  "email": "test@example.com",
  "avatar": "https://www.melivecode.com/users/99.png",
  "role": "user"
}

{
  "success": true,
  "data": {
    "id": 4,
    "fname": "Test",
    "lname": "User",
    "username": "test.user",
    "email": "test@example.com",
    "avatar": "https://www.melivecode.com/users/99.png",
    "role": "user",
    "isActive": true,
    "created_at": "2026-04-21T11:30:00.000Z"
  },
  "message": "User created successfully"
}

{
  "fname": "Karn",
  "lname": "Yong",
  "role": "admin"
}

{
  "success": true,
  "data": {
    "id": 1,
    "fname": "Karn",
    "lname": "Yong",
    "username": "karn.yong",
    "email": "karn@example.com",
    "avatar": "https://www.melivecode.com/users/1.png",
    "role": "admin",
    "isActive": true,
    "created_at": "2026-04-21T10:00:00.000Z"
  },
  "message": "User updated successfully"
}

{
  "success": true,
  "message": "User deleted successfully"
}

{
  "fname": "Karn",
  "lname": "Yong",
  "username": "karn.yong",
  "email": "invalid-email"
}

{
  "success": false,
  "errors": [
    {
      "message": "Invalid email format"
    }
  ]
}

{
  "fname": "Karn",
  "lname": "Yong",
  "username": "ab",
  "email": "karn@example.com"
}

{
  "success": false,
  "errors": [
    {
      "message": "Username must be 3-50 characters and contain only letters, numbers, and underscores"
    }
  ]
}

{
  "fname": "Karn"
}

{
  "success": false,
  "errors": [
    {
      "message": "Last name is required"
    },
    {
      "message": "Username is required"
    },
    {
      "message": "Email is required"
    }
  ]
}

{
  "fname": "Karn",
  "lname": "Yong",
  "username": "karn.yong",
  "email": "karn@example.com",
  "role": "superadmin"
}

{
  "success": false,
  "errors": [
    {
      "message": "Role must be either \"user\" or \"admin\""
    }
  ]
}

{
  "success": false,
  "errors": [
    {
      "message": "Page must be a positive number"
    }
  ]
}

{
  "success": false,
  "errors": [
    {
      "message": "ID must be a positive number"
    }
  ]
}