ใช้ Claude Code พัฒนาและทดสอบ RESTful API ด้วย PostgreSQL

curl -fsSL https://claude.ai/install.sh | bash

irm https://claude.ai/install.ps1 | iex

curl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd

npx @z_ai/coding-helper

mkdir api-testing-demo
cd api-testing-demo
npm init -y

# Production Dependencies
npm install express cors @prisma/client @prisma/adapter-pg pg dotenv

# Development Dependencies
npm install -D typescript tsx prisma vitest supertest @types/supertest @types/express @types/pg @types/node

{
  "compilerOptions": {
    "module": "ESNext",
    "moduleResolution": "bundler",
    "target": "ES2023",
    "strict": true,
    "esModuleInterop": true,
    "ignoreDeprecations": "6.0",
    "resolveJsonModule": true,
    "skipLibCheck": true,
    "types": ["node"]
  }
}

{
  "type": "module"
}

{
  "scripts": {
    "start": "tsx index.ts"
  }
}

npm start

api-testing-demo/
├── prisma/
│   └── schema.prisma
├── lib/
│   └── prisma.ts
├── index.ts
├── prisma.config.ts
├── tsconfig.json
├── package.json
└── .env

npx prisma init --output ../generated/prisma

import "dotenv/config";
import { PrismaPg } from "@prisma/adapter-pg";
import { PrismaClient } from "../generated/prisma/client";

const connectionString = `${process.env.DATABASE_URL}`;

const adapter = new PrismaPg({ connectionString });
const prisma = new PrismaClient({ adapter });

export { prisma };

DATABASE_URL="postgresql://root:your_password@localhost:5433/test_db"

cd api-testing-demo
claude

Build a RESTful API using Express, TypeScript, Prisma ORM with PostgreSQL and ESM modules.

=== PROJECT STRUCTURE ===

api-testing-demo/
├── prisma/
│   └── schema.prisma
├── prisma.config.ts
├── lib/
│   └── prisma.ts
├── index.ts
├── tsconfig.json
├── package.json
└── .env

=== PRISMA SETUP ===

NOTE: .env, prisma.config.ts and lib/prisma.ts already exist — do NOT recreate or modify them.

prisma/schema.prisma:
- generator client: provider "prisma-client", output "../generated/prisma"
- datasource db: provider "postgresql" (no url field — use prisma.config.ts)
- User model: id (auto-increment), fname, lname, username (unique), email (unique), avatar (optional), createdAt (auto)

=== API ROUTES ===

- GET /          → 200, welcome message
- GET /users     → 200, return all users
- GET /users/:id → 200 (found) or 404 (not found)
- POST /users    → 201, create and return user
- PUT /users/:id → 200, update and return user
- DELETE /users/:id → 200, return success message

=== API RULES ===

- server runs on port 3333
- use Prisma Client from lib/prisma.ts for all database operations
- JSON responses only
- proper HTTP status codes: 200, 201, 404, 500
- centralized error handling
- export app for testing (don't start server when imported)
- use process.env.TEST_ENV to prevent server start during tests
- ESM compatible (import/export)
- no `any` type

=== OUTPUT ===

1. Complete code for every file
2. Commands to initialize Prisma, run migration, and start the server
3. All code must work together without modification

/init

# สร้างตารางในฐานข้อมูล
npx prisma migrate dev --name init

npx prisma generate

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
}

datasource db {
  provider = "postgresql"
}

model User {
  id        Int      @id @default(autoincrement())
  fname     String
  lname     String
  username  String   @unique
  email     String   @unique
  avatar    String?
  createdAt DateTime @default(now())
}

import "dotenv/config";
import express, { Request, Response, NextFunction } from "express";
import { prisma } from "./lib/prisma.js";

const app = express();
const PORT = 3333;

app.use(express.json());

interface ErrorResponse {
  error: string;
}

type AsyncHandler = (req: Request, res: Response, next: NextFunction) => Promise<void>;

const asyncHandler = (fn: AsyncHandler): AsyncHandler => {
  return (req: Request, res: Response, next: NextFunction) => {
    Promise.resolve(fn(req, res, next)).catch(next);
  };
};

app.get("/", (_req: Request, res: Response) => {
  res.status(200).json({ message: "Welcome to the API" });
});

app.get("/users", asyncHandler(async (_req: Request, res: Response) => {
  const users = await prisma.user.findMany();
  res.status(200).json(users);
}));

app.get("/users/:id", asyncHandler(async (req: Request, res: Response) => {
  const id = Number(req.params.id);

  if (isNaN(id)) {
    res.status(400).json({ error: "Invalid user ID" } as ErrorResponse);
    return;
  }

  const user = await prisma.user.findUnique({
    where: { id },
  });

  if (!user) {
    res.status(404).json({ error: "User not found" } as ErrorResponse);
    return;
  }

  res.status(200).json(user);
}));

app.post("/users", asyncHandler(async (req: Request, res: Response) => {
  const { fname, lname, username, email, avatar } = req.body;

  if (!fname || !lname || !username || !email) {
    res.status(400).json({ error: "Missing required fields: fname, lname, username, email" } as ErrorResponse);
    return;
  }

  const user = await prisma.user.create({
    data: {
      fname,
      lname,
      username,
      email,
      avatar: avatar ?? null,
    },
  });

  res.status(201).json(user);
}));

app.put("/users/:id", asyncHandler(async (req: Request, res: Response) => {
  const id = Number(req.params.id);

  if (isNaN(id)) {
    res.status(400).json({ error: "Invalid user ID" } as ErrorResponse);
    return;
  }

  const { fname, lname, username, email, avatar } = req.body;

  const user = await prisma.user.update({
    where: { id },
    data: {
      ...(fname !== undefined && { fname }),
      ...(lname !== undefined && { lname }),
      ...(username !== undefined && { username }),
      ...(email !== undefined && { email }),
      ...(avatar !== undefined && { avatar: avatar ?? null }),
    },
  });

  res.status(200).json(user);
}));

app.delete("/users/:id", asyncHandler(async (req: Request, res: Response) => {
  const id = Number(req.params.id);

  if (isNaN(id)) {
    res.status(400).json({ error: "Invalid user ID" } as ErrorResponse);
    return;
  }

  await prisma.user.delete({
    where: { id },
  });

  res.status(200).json({ message: "User deleted successfully" });
}));

app.use((err: Error, _req: Request, res: Response, _next: NextFunction) => {
  console.error(err);
  res.status(500).json({ error: "Internal server error" } as ErrorResponse);
});

if (!process.env.TEST_ENV) {
  app.listen(PORT, () => {
    console.log(`Server running on http://localhost:${PORT}`);
  });
}

export default app;

npm start

# GET - ตรวจสอบว่า API ทำงาน
curl http://localhost:3333/

# GET - ดึงข้อมูล users ทั้งหมด
curl http://localhost:3333/users

# POST - สร้าง user ใหม่
curl -X POST http://localhost:3333/users \
  -H "Content-Type: application/json" \
  -d '{"fname":"John","lname":"Doe","username":"johndoe","email":"john@example.com","avatar":"https://example.com/avatar.jpg"}'

# GET - ดึงข้อมูล user ตาม ID (เปลี่ยน 1 เป็น ID ที่ได้จากการสร้าง)
curl http://localhost:3333/users/1

# PUT - อัปเดตข้อมูล user
curl -X PUT http://localhost:3333/users/1 \
  -H "Content-Type: application/json" \
  -d '{"fname":"Jane","lname":"Smith"}'

# DELETE - ลบ user
curl -X DELETE http://localhost:3333/users/1

# GET - ตรวจสอบว่า API ทำงาน
curl http://localhost:3333/

# GET - ดึงข้อมูล users ทั้งหมด
curl http://localhost:3333/users

# POST - สร้าง user ใหม่
curl -X POST http://localhost:3333/users ^
  -H "Content-Type: application/json" ^
  -d "{\"fname\":\"John\",\"lname\":\"Doe\",\"username\":\"johndoe\",\"email\":\"john@example.com\",\"avatar\":\"https://example.com/avatar.jpg\"}"

# GET - ดึงข้อมูล user ตาม ID (เปลี่ยน 1 เป็น ID ที่ได้จากการสร้าง)
curl http://localhost:3333/users/1

# PUT - อัปเดตข้อมูล user
curl -X PUT http://localhost:3333/users/1 ^
  -H "Content-Type: application/json" ^
  -d "{\"fname\":\"Jane\",\"lname\":\"Smith\"}"

# DELETE - ลบ user
curl -X DELETE http://localhost:3333/users/1

import { defineConfig } from "vitest/config";

export default defineConfig({
  test: {
    environment: "node",
    setupFiles: ["./vitest.setup.ts"],
  },
});

// Load environment variables for testing
import "dotenv/config";
import { afterAll } from "vitest";

// Set test environment variable
process.env.TEST_ENV = "true";

// Close Prisma connection after all tests complete
import { prisma } from "./lib/prisma";

afterAll(async () => {
  await prisma.$disconnect();
});

{
  "scripts": {
    "test": "vitest run",
    "test:watch": "vitest",
    "test:coverage": "vitest run --coverage",
    "test:ui": "vitest --ui",
    "start": "tsx index.ts"
  }
}

Create tests/api.test.ts using Vitest and Supertest to test the Express API in index.ts.

=== SETUP ===
- import { describe, it, expect, beforeAll } from "vitest"
- import { default as supertest } from "supertest"
- import type { Express } from "express"
- define TypeScript types: User, CreateUserRequest
- load the app with dynamic import in beforeAll(), type as Express
- no `any` type

=== TEST CASES ===
Use nested describe() for each endpoint. Tests run sequentially sharing createdUserId.
- GET / → 200, verify welcome message
- POST /users → 201, create user with unique username/email (use Date.now()), save createdUserId
- GET /users/:id → 200, verify created user data
- PUT /users/:id → 200, update user, verify updated data
- DELETE /users/:id → 200, verify deletion message
- GET /users/:id after deletion → 404

=== ASSERTIONS ===
- use toMatchObject() to verify multiple properties at once
- use toEqual() for exact object matching
- use toMatch() with regex for dynamic values
- use toBeDefined() to check field existence

=== RULES ===
- ESM compatible (import/export)
- production-quality TypeScript

import { describe, it, expect, beforeAll } from "vitest";
import supertest from "supertest";
import type { Express } from "express";

// Types matching the API structure
interface User {
  id: number;
  fname: string;
  lname: string;
  username: string;
  email: string;
  avatar: string | null;
  createdAt: string;
}

interface ErrorResponse {
  error: string;
}

interface CreateUserRequest {
  fname: string;
  lname: string;
  username: string;
  email: string;
  avatar?: string;
}

interface UpdateUserRequest {
  fname?: string;
  lname?: string;
  username?: string;
  email?: string;
  avatar?: string;
}

interface WelcomeResponse {
  message: string;
}

let app: Express;
let request: supertest.Agent;

// Shared state between tests
let createdUserId: number;

// Unique data using timestamp for test isolation
const timestamp = Date.now();
const testUser: CreateUserRequest = {
  fname: "Test",
  lname: "User",
  username: `testuser_${timestamp}`,
  email: `testuser_${timestamp}@example.com`,
  avatar: "https://example.com/avatar.png",
};

beforeAll(async () => {
  // Dynamic import to get the Express app
  const module = await import("../index.js");
  app = module.default;
  request = supertest(app);
});

describe("API Integration Tests", () => {
  describe("GET /", () => {
    it("should return 200 and welcome message", async () => {
      const response = await request.get("/").expect(200);

      expect(response.body).toMatchObject<WelcomeResponse>({
        message: "Welcome to the API",
      });
    });
  });

  describe("POST /users", () => {
    it("should return 201 and create user with unique username/email", async () => {
      const response = await request.post("/users").send(testUser).expect(201);

      expect(response.body).toMatchObject<User>({
        fname: testUser.fname,
        lname: testUser.lname,
        username: testUser.username,
        email: testUser.email,
        avatar: testUser.avatar,
      });

      expect(response.body.id).toBeDefined();
      expect(response.body.createdAt).toBeDefined();

      // Store the created user ID for subsequent tests
      createdUserId = response.body.id;
    });

    it("should return 400 when required fields are missing", async () => {
      const incompleteUser = { fname: "Only" };

      const response = await request.post("/users").send(incompleteUser).expect(400);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Missing required fields: fname, lname, username, email",
      });
    });
  });

  describe("GET /users/:id", () => {
    it("should return 200 and the created user data", async () => {
      const response = await request.get(`/users/${createdUserId}`).expect(200);

      expect(response.body).toEqual<User>({
        id: createdUserId,
        fname: testUser.fname,
        lname: testUser.lname,
        username: testUser.username,
        email: testUser.email,
        avatar: testUser.avatar,
        createdAt: response.body.createdAt,
      });
    });

    it("should return 404 when user does not exist", async () => {
      const nonExistentId = 999999;

      const response = await request.get(`/users/${nonExistentId}`).expect(404);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "User not found",
      });
    });

    it("should return 400 when ID is invalid", async () => {
      const response = await request.get("/users/invalid").expect(400);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Invalid user ID",
      });
    });
  });

  describe("PUT /users/:id", () => {
    it("should return 200 and update user data", async () => {
      const updateData: UpdateUserRequest = {
        fname: "Updated",
        lname: "Name",
        avatar: null,
      };

      const response = await request.put(`/users/${createdUserId}`).send(updateData).expect(200);

      expect(response.body).toMatchObject<User>({
        id: createdUserId,
        fname: updateData.fname,
        lname: updateData.lname,
        username: testUser.username,
        email: testUser.email,
        avatar: updateData.avatar ?? null,
      });
    });

    it("should return 400 when ID is invalid", async () => {
      const response = await request.put("/users/invalid").send({ fname: "Test" }).expect(400);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Invalid user ID",
      });
    });
  });

  describe("DELETE /users/:id", () => {
    it("should return 200 and delete user", async () => {
      const response = await request.delete(`/users/${createdUserId}`).expect(200);

      expect(response.body).toEqual({
        message: "User deleted successfully",
      });
    });

    it("should return 400 when ID is invalid", async () => {
      const response = await request.delete("/users/invalid").expect(400);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Invalid user ID",
      });
    });

    it("should return 404 when trying to get deleted user", async () => {
      const response = await request.get(`/users/${createdUserId}`).expect(404);

      expect(response.body).toMatchObject<ErrorResponse>({
        error: "User not found",
      });
    });
  });

  describe("GET /users", () => {
    it("should return 200 and array of users", async () => {
      const response = await request.get("/users").expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body).toBeDefined();
    });
  });
});

# รันการทดสอบครั้งเดียว
npm test

 ✓ tests/api.test.ts (12 tests) 435ms
   ✓ API Integration Tests (12)
     ✓ GET / (1)
       ✓ should return 200 and welcome message 20ms
     ✓ POST /users (2)
       ✓ should return 201 and create user with unique username/email 253ms
       ✓ should return 400 when required fields are missing 4ms
     ✓ GET /users/:id (3)
       ✓ should return 200 and the created user data 17ms
       ✓ should return 404 when user does not exist 5ms
       ✓ should return 400 when ID is invalid 3ms
     ✓ PUT /users/:id (2)
       ✓ should return 200 and update user data 8ms
       ✓ should return 400 when ID is invalid 3ms
     ✓ DELETE /users/:id (3)
       ✓ should return 200 and delete user 7ms
       ✓ should return 400 when ID is invalid 3ms
       ✓ should return 404 when trying to get deleted user 3ms
     ✓ GET /users (1)
       ✓ should return 200 and array of users 6ms

 Test Files  1 passed (1)
      Tests  12 passed (12)
   Start at  14:01:37
   Duration  2.60s (transform 95ms, setup 245ms, import 1.08s, tests 435ms, environment 0ms)

Add error handling test cases to tests/api.test.ts for the Express API in index.ts.

=== TEST CASES ===

Add a new describe("Error Handling Tests") block with beforeAll to load the app:

- POST /users with incomplete data (missing lname, username, email) → 400 Bad Request
- GET /users/999999 (non-existent user) → 404, verify "User not found"
- POST /users with duplicate email → 500
  - create a user first, then create another with same email but different username

=== RULES ===

- follow the same coding style as existing tests in the file
- use the same import style and TypeScript types
- use supertest (not request) as variable name
- use response.status (not response.statusCode)
- use toMatchObject() and toEqual() for assertions
- no `any` type

describe("Error Handling Tests", () => {
  let app: Express;
  let request: supertest.Agent;

  beforeAll(async () => {
    const module = await import("../index.js");
    app = module.default;
    request = supertest(app);
  });

  describe("POST /users - incomplete data", () => {
    it("should return 400 when lname, username, and email are missing", async () => {
      const incompleteUser = { fname: "Only" };

      const response = await request.post("/users").send(incompleteUser);

      expect(response.status).toBe(400);
      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Missing required fields: fname, lname, username, email",
      });
    });

    it("should return 400 when only fname and lname are provided", async () => {
      const incompleteUser: Partial<CreateUserRequest> = { fname: "Test", lname: "User" };

      const response = await request.post("/users").send(incompleteUser);

      expect(response.status).toBe(400);
      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Missing required fields: fname, lname, username, email",
      });
    });
  });

  describe("GET /users/:id - non-existent user", () => {
    it("should return 404 when user does not exist", async () => {
      const nonExistentId = 999999;

      const response = await request.get(`/users/${nonExistentId}`);

      expect(response.status).toBe(404);
      expect(response.body).toMatchObject<ErrorResponse>({
        error: "User not found",
      });
    });
  });

  describe("POST /users - duplicate email", () => {
    it("should return 500 when creating user with duplicate email", async () => {
      const timestamp = Date.now();
      const firstUser: CreateUserRequest = {
        fname: "First",
        lname: "User",
        username: `first_${timestamp}`,
        email: `duplicate_${timestamp}@example.com`,
      };

      // Create first user
      await request.post("/users").send(firstUser).expect(201);

      // Try to create second user with same email but different username
      const duplicateUser: CreateUserRequest = {
        fname: "Second",
        lname: "User",
        username: `second_${timestamp}`,
        email: `duplicate_${timestamp}@example.com`, // Same email
      };

      const response = await request.post("/users").send(duplicateUser);

      expect(response.status).toBe(500);
      expect(response.body).toMatchObject<ErrorResponse>({
        error: "Internal server error",
      });
    });
  });
});

 ✓ tests/api.test.ts (16 tests) 380ms
   ✓ API Integration Tests (12)
     ✓ GET / (1)
       ✓ should return 200 and welcome message 21ms
     ✓ POST /users (2)
       ✓ should return 201 and create user with unique username/email 132ms
       ✓ should return 400 when required fields are missing 5ms
     ✓ GET /users/:id (3)
       ✓ should return 200 and the created user data 17ms
       ✓ should return 404 when user does not exist 7ms
       ✓ should return 400 when ID is invalid 5ms
     ✓ PUT /users/:id (2)
       ✓ should return 200 and update user data 10ms
       ✓ should return 400 when ID is invalid 8ms
     ✓ DELETE /users/:id (3)
       ✓ should return 200 and delete user 11ms
       ✓ should return 400 when ID is invalid 4ms
       ✓ should return 404 when trying to get deleted user 4ms
     ✓ GET /users (1)
       ✓ should return 200 and array of users 7ms
   ✓ Error Handling Tests (4)
     ✓ POST /users - incomplete data (2)
       ✓ should return 400 when lname, username, and email are missing 4ms
       ✓ should return 400 when only fname and lname are provided 4ms
     ✓ GET /users/:id - non-existent user (1)
       ✓ should return 404 when user does not exist 5ms
     ✓ POST /users - duplicate email (1)
       ✓ should return 500 when creating user with duplicate email 17ms

 Test Files  1 passed (1)
      Tests  16 passed (16)
   Start at  14:04:49
   Duration  853ms (transform 88ms, setup 199ms, import 95ms, tests 380ms, environment 0ms)

npm run test:coverage