Zod validation: kiểm tra dữ liệu đầu vào cho API đơn hàng

don-hang-moc/
  package.json
  src/orders.ts
  src/don-mau.ts
  src/order-schema.ts
  src/order-server.ts
  src/order-schema.test.ts
  ban-ngay-tho/order-server.ts
  ban-ngay-tho/thu.ts
  thu-zod.ts

{
  "name": "don-hang-moc",
  "private": true,
  "type": "module",
  "dependencies": { "zod": "4.6.7" },
  "devDependencies": { "vitest": "5.1.0" }
}

export type Customer = { name: string; phone: string };
export type OrderItem = { name: string; price: number; quantity: number };
export type Order = {
  id: number;
  createdAt: string;
  source: "web" | "may-cu";
  // Đơn từ máy bán hàng cũ (source "may-cu") bán tại quầy có thể không có khách hàng.
  customer?: Customer;
  items: OrderItem[];
};

// Menu của Mộc không có món nào dưới 1.000đ. Giá nhỏ hơn gần như chắc chắn là dữ liệu hỏng,
// ví dụ "35.000" bị mất dấu ngoặc kép trong JSON nên thành số 35.
export const MIN_PRICE = 1000;

// "35.000" → 35000. Định dạng lạ, hoặc giá không phải số nguyên từ MIN_PRICE trở lên, thì báo lỗi, không đoán.
export function parsePrice(raw: number | string): number {
  const price = typeof raw === "number" ? raw : parsePriceText(raw);
  if (!Number.isInteger(price) || price < MIN_PRICE) throw new Error(`Giá không hợp lệ: ${quoteIfText(raw)}`);
  return price;
}

function parsePriceText(raw: string): number {
  const text = raw.trim();
  // Nhóm nghìn bằng dấu chấm. Khớp: "35.000", "1.250.000". Không khớp: "35,000", "35.00", "3500.000".
  if (/^\d{1,3}(\.\d{3})+$/.test(text)) return Number(text.replaceAll(".", ""));
  if (/^\d+$/.test(text)) return Number(text);
  throw new Error(`Giá không hợp lệ: ${quoteIfText(raw)}`);
}

// Chuỗi trong ngoặc kép, số thì giữ nguyên, để thông báo lỗi phân biệt được "35" với 35.
const quoteIfText = (raw: number | string) => (typeof raw === "string" ? `"${raw}"` : String(raw));

export function customerLabel(order: Order): string {
  if (!order.customer) return "KHÁCH TẠI QUẦY";
  return order.customer.name.toUpperCase();
}

export function orderTotal(order: Order): number {
  return order.items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

// Danh sách cho trang quản lý: mỗi đơn một dòng gồm mã, tên khách (in hoa) và tổng tiền.
export function listOrders(orders: Order[]) {
  return orders.map((order) => ({
    id: order.id,
    khach: customerLabel(order),
    tong: orderTotal(order),
  }));
}

import type { Order } from "./orders.ts";

// Hai đơn có sẵn để thử máy chủ: một đơn từ website, một đơn tại quầy không có thông tin khách.
export const DON_MAU: Order[] = [
  {
    id: 1041,
    createdAt: "2026-11-03T08:12:00+07:00",
    source: "web",
    customer: { name: "Nguyễn An", phone: "0901000001" },
    items: [
      { name: "Cà phê sữa", price: 29000, quantity: 2 },
      { name: "Bánh mì trứng", price: 25000, quantity: 1 },
    ],
  },
  {
    id: 1043,
    createdAt: "2026-11-03T10:05:00+07:00",
    source: "may-cu",
    items: [{ name: "Cà phê đen", price: 25000, quantity: 1 }],
  },
];

import { createServer, type Server, type ServerResponse } from "node:http";

import { listOrders, type Order } from "../src/orders.ts";

const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
const TEXT_HEADERS = { "content-type": "text/plain; charset=utf-8" };

// Bản đầu tiên của POST /don-hang: tin hoàn toàn vào dữ liệu gửi lên.
export function createOrderServer(orders: Order[]): Server {
  return createServer(async (request, response) => {
    if (request.url === "/don-hang" && request.method === "POST") return receiveOrder(request, response, orders);
    if (request.url === "/don-hang") return sendOrderList(response, orders);
    response.writeHead(404).end();
  });
}

async function receiveOrder(request: AsyncIterable<Buffer>, response: ServerResponse, orders: Order[]): Promise<void> {
  let body = "";
  for await (const chunk of request) body += chunk;
  const data = JSON.parse(body);
  const order = { id: Math.max(...orders.map((o) => o.id)) + 1, createdAt: new Date().toISOString(), source: "web", ...data } as Order;
  orders.push(order);
  response.writeHead(201, JSON_HEADERS).end(JSON.stringify({ id: order.id }));
}

function sendOrderList(response: ServerResponse, orders: Order[]): void {
  try {
    const orderListJson = JSON.stringify(listOrders(orders), null, 2);
    response.writeHead(200, JSON_HEADERS).end(orderListJson);
  } catch (error) {
    console.error(error);
    response.writeHead(500, TEXT_HEADERS).end("Lỗi máy chủ");
  }
}

// Gửi lần lượt các đơn "website" vào máy chủ bản đầu tiên, sau mỗi đơn đọc lại danh sách.
import type { AddressInfo } from "node:net";

import { DON_MAU } from "../src/don-mau.ts";
import { createOrderServer } from "./order-server.ts";

const server = createOrderServer([...DON_MAU]);
await new Promise<void>((resolve) => server.listen(0, resolve));
const goc = `http://localhost:${(server.address() as AddressInfo).port}/don-hang`;

const khach = { name: "Phạm Dung", phone: "0901000010" };
const CAC_DON: [string, unknown][] = [
  ["đơn đúng", { customer: khach, items: [{ name: "Cà phê sữa", price: 29000, quantity: 2 }] }],
  ["số lượng là chữ", { customer: khach, items: [{ name: "Cà phê sữa", price: 29000, quantity: "hai" }] }],
  ["khách thiếu tên", { customer: { phone: "0901000011" }, items: [{ name: "Bạc xỉu", price: 32000, quantity: 1 }] }],
];

console.error = () => {}; // tắt dòng lỗi của máy chủ để kết quả gọn
for (const [ten, don] of CAC_DON) {
  const gui = await fetch(goc, { method: "POST", body: JSON.stringify(don) });
  const danhSach = await fetch(goc);
  const cuoi = (await danhSach.text()).split("\n").slice(-6).join(" ").replace(/\s+/g, " ");
  console.log(`${ten}: POST trả ${gui.status}; sau đó GET trả ${danhSach.status}${danhSach.ok ? ` ...${cuoi}` : ""}`);
}
server.close();

đơn đúng: POST trả 201; sau đó GET trả 200 ... { "id": 1044, "khach": "PHẠM DUNG", "tong": 58000 } ]
số lượng là chữ: POST trả 201; sau đó GET trả 200 ... { "id": 1045, "khach": "PHẠM DUNG", "tong": null } ]
khách thiếu tên: POST trả 201; sau đó GET trả 500

import { z } from "zod";

import { parsePrice } from "./orders.ts";

// Giá có thể là số (đơn từ web) hoặc chuỗi "35.000" (máy cũ). Dùng lại parsePrice của tập 2, và biến lỗi của nó
// thành lỗi của Zod để thông báo gắn đúng vào ô "price".
const priceSchema = z.union([z.number("Giá phải là số hoặc chuỗi"), z.string("Giá phải là số hoặc chuỗi")]).transform((raw, ctx) => {
  try {
    return parsePrice(raw);
  } catch (error) {
    ctx.issues.push({ code: "custom", message: (error as Error).message, input: raw });
    return z.NEVER;
  }
});

// Thông báo tiếng Việt cho hai lỗi mà Zod tự phát hiện ở mức đối tượng: trường lạ và sai kiểu. Lỗi khác dùng thông báo mặc định.
const objectError = (issue: { code: string; keys?: string[] }) => {
  if (issue.code === "unrecognized_keys") return `Không nhận trường: ${issue.keys?.join(", ")}`;
  if (issue.code === "invalid_type") return "Phải là một đối tượng JSON";
  return undefined;
};

const customerSchema = z.strictObject({
  name: z.string("Tên khách phải là chữ").trim().min(1, "Tên khách không được để trống").max(80, "Tên khách tối đa 80 ký tự"),
  phone: z.string("Số điện thoại phải là chữ").regex(/^0\d{9}$/, "Số điện thoại gồm 10 chữ số, bắt đầu bằng 0"),
}, { error: objectError });

const itemSchema = z.strictObject({
  name: z.string("Tên món phải là chữ").trim().min(1, "Tên món không được để trống"),
  price: priceSchema,
  quantity: z.number("Số lượng phải là số").int("Số lượng phải là số nguyên").min(1, "Số lượng tối thiểu là 1").max(50, "Số lượng tối đa là 50"),
}, { error: objectError });

// Đơn do website gửi lên. strictObject từ chối trường lạ: website không được tự đặt id, source hay createdAt.
export const newOrderSchema = z.strictObject({
  customer: customerSchema,
  items: z.array(itemSchema, "Danh sách món phải là một mảng").min(1, "Đơn phải có ít nhất một món").max(20, "Một đơn có tối đa 20 món"),
}, { error: objectError });

// Kiểu TypeScript suy ra từ schema: không phải viết hai lần.
export type NewOrder = z.infer<typeof newOrderSchema>;

// Danh sách lỗi cho người gọi API: mỗi lỗi một dòng, nói rõ trường nào và sai gì.
export function listIssues(error: z.ZodError): { truong: string; loi: string }[] {
  return error.issues.map((issue) => ({ truong: issue.path.join(".") || "(cả đơn)", loi: issue.message }));
}

import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";

import { listIssues, newOrderSchema } from "./order-schema.ts";
import { listOrders, type Order } from "./orders.ts";

const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
const TEXT_HEADERS = { "content-type": "text/plain; charset=utf-8" };
const MAX_BODY_BYTES = 100_000;

// Máy chủ HTTP cho đơn hàng. Nhận đơn đã chuẩn hóa, không tự đọc file, không tự mở cổng.
export function createOrderServer(orders: Order[]): Server {
  return createServer(async (request, response) => {
    if (request.url === "/don-hang" && request.method === "POST") return receiveOrder(request, response, orders);
    if (request.url === "/don-hang") return sendOrderList(response, orders);
    response.writeHead(404).end();
  });
}

async function receiveOrder(request: IncomingMessage, response: ServerResponse, orders: Order[]): Promise<void> {
  const body = await readBody(request);
  if (body === null) return sendError(response, 413, "Nội dung gửi lên quá lớn");

  let data: unknown;
  try {
    data = JSON.parse(body);
  } catch {
    return sendError(response, 400, "Nội dung gửi lên không phải JSON hợp lệ");
  }

  const result = newOrderSchema.safeParse(data);
  if (!result.success) return sendError(response, 400, "Đơn hàng không hợp lệ", listIssues(result.error));

  const order: Order = {
    id: Math.max(0, ...orders.map((existing) => existing.id)) + 1,
    createdAt: new Date().toISOString(),
    source: "web",
    ...result.data,
  };
  orders.push(order);
  response.writeHead(201, JSON_HEADERS).end(JSON.stringify({ id: order.id }));
}

// Đọc tối đa MAX_BODY_BYTES; vượt quá thì trả null để bên gọi từ chối.
async function readBody(request: IncomingMessage): Promise<string | null> {
  let body = "";
  for await (const chunk of request) {
    body += chunk;
    if (body.length > MAX_BODY_BYTES) return null;
  }
  return body;
}

function sendError(response: ServerResponse, status: number, message: string, details?: unknown): void {
  response.writeHead(status, JSON_HEADERS).end(JSON.stringify({ loi: message, ...(details ? { chiTiet: details } : {}) }));
}

function sendOrderList(response: ServerResponse, orders: Order[]): void {
  try {
    const orderListJson = JSON.stringify(listOrders(orders), null, 2);
    response.writeHead(200, JSON_HEADERS).end(orderListJson);
  } catch (error) {
    console.error(error);
    response.writeHead(500, TEXT_HEADERS).end("Lỗi máy chủ");
  }
}

// Gửi các đơn hỏng vào máy chủ đã có Zod và in lỗi trả về. Chạy: node thu-zod.ts
import type { AddressInfo } from "node:net";

import { DON_MAU } from "./src/don-mau.ts";
import { createOrderServer } from "./src/order-server.ts";

const server = createOrderServer([...DON_MAU]);
await new Promise<void>((resolve) => server.listen(0, resolve));
const goc = `http://localhost:${(server.address() as AddressInfo).port}/don-hang`;

const khach = { name: "Phạm Dung", phone: "0901000010" };
const CAC_DON: [string, string][] = [
  ["đơn đúng", JSON.stringify({ customer: khach, items: [{ name: "Cà phê sữa", price: "29.000", quantity: 2 }] })],
  ["số lượng là chữ", JSON.stringify({ customer: khach, items: [{ name: "Cà phê sữa", price: 29000, quantity: "hai" }] })],
  ["khách thiếu tên, giá 35", JSON.stringify({ customer: { phone: "0901000011" }, items: [{ name: "Bạc xỉu", price: 35, quantity: 1 }] })],
  ["thiếu items, thừa trường id", JSON.stringify({ id: 1, customer: khach })],
  ["không phải JSON", "{customer:"],
];

for (const [ten, noiDung] of CAC_DON) {
  const phanHoi = await fetch(goc, { method: "POST", body: noiDung });
  console.log(`${ten}: ${phanHoi.status} ${await phanHoi.text()}`);
}
console.log(`danh sách sau đó: ${(await fetch(goc)).status}`);
server.close();

đơn đúng: 201 {"id":1044}
số lượng là chữ: 400 {"loi":"Đơn hàng không hợp lệ","chiTiet":[{"truong":"items.0.quantity","loi":"Số lượng phải là số"}]}
khách thiếu tên, giá 35: 400 {"loi":"Đơn hàng không hợp lệ","chiTiet":[{"truong":"customer.name","loi":"Tên khách phải là chữ"},{"truong":"items.0.price","loi":"Giá không hợp lệ: 35"}]}
thiếu items, thừa trường id: 400 {"loi":"Đơn hàng không hợp lệ","chiTiet":[{"truong":"items","loi":"Danh sách món phải là một mảng"},{"truong":"(cả đơn)","loi":"Không nhận trường: id"}]}
không phải JSON: 400 {"loi":"Nội dung gửi lên không phải JSON hợp lệ"}
danh sách sau đó: 200

import { describe, expect, test } from "vitest";

import { listIssues, newOrderSchema } from "./order-schema.ts";

const customer = { name: "Phạm Dung", phone: "0901000010" };
const validItem = { name: "Cà phê sữa", price: 29000, quantity: 2 };

// Chạy schema và trả về danh sách lỗi dạng "trường: thông báo", để test đọc như đọc câu.
function errorsOf(input: unknown): string[] {
  const result = newOrderSchema.safeParse(input);
  return result.success ? [] : listIssues(result.error).map((issue) => `${issue.truong}: ${issue.loi}`);
}

describe("newOrderSchema", () => {
  test("nhận đơn đúng và giữ nguyên dữ liệu", () => {
    expect(newOrderSchema.parse({ customer, items: [validItem] })).toEqual({ customer, items: [validItem] });
  });

  test("giá dạng chuỗi của máy cũ được đổi thành số", () => {
    const order = newOrderSchema.parse({ customer, items: [{ ...validItem, price: "35.000" }] });
    expect(order.items[0].price).toBe(35000);
  });

  test("cắt khoảng trắng thừa ở tên khách", () => {
    expect(newOrderSchema.parse({ customer: { ...customer, name: "  An  " }, items: [validItem] }).customer.name).toBe("An");
  });

  test.each([
    ["số lượng là chữ", { customer, items: [{ ...validItem, quantity: "hai" }] }, "items.0.quantity: Số lượng phải là số"],
    ["số lượng lẻ", { customer, items: [{ ...validItem, quantity: 1.5 }] }, "items.0.quantity: Số lượng phải là số nguyên"],
    ["số lượng bằng 0", { customer, items: [{ ...validItem, quantity: 0 }] }, "items.0.quantity: Số lượng tối thiểu là 1"],
    ["giá 35 (mất ngoặc kép)", { customer, items: [{ ...validItem, price: 35 }] }, "items.0.price: Giá không hợp lệ: 35"],
    ["khách thiếu tên", { customer: { phone: "0901000010" }, items: [validItem] }, "customer.name: Tên khách phải là chữ"],
    ["số điện thoại ngắn", { customer: { ...customer, phone: "090100" }, items: [validItem] }, "customer.phone: Số điện thoại gồm 10 chữ số, bắt đầu bằng 0"],
    ["thiếu items", { customer }, "items: Danh sách món phải là một mảng"],
    ["items rỗng", { customer, items: [] }, "items: Đơn phải có ít nhất một món"],
    ["trường lạ id", { id: 1, customer, items: [validItem] }, "(cả đơn): Không nhận trường: id"],
    ["cả đơn không phải đối tượng", [], "(cả đơn): Phải là một đối tượng JSON"],
  ])("từ chối đơn có %s", (_ten, input, expectedError) => {
    expect(errorsOf(input)).toEqual([expectedError]);
  });

  test("báo cùng lúc mọi lỗi, không dừng ở lỗi đầu tiên", () => {
    const errors = errorsOf({ customer: { phone: "1" }, items: [{ ...validItem, quantity: 0 }] });
    expect(errors).toHaveLength(3);
  });
});

 Test Files  1 passed (1)
      Tests  14 passed (14)