0

Xây dựng bức tường lời chúc trên cây thông bằng Node.js: ẩn nội dung đến ngày mở, đặt đồ trang trí và chống XSS

Có một kiểu trang web nhỏ nhưng làm thì khá nhiều chuyện: chủ trang tạo một "cây thông", gửi link cho bạn bè, và mỗi người ghé vào sẽ treo lên cây một món đồ trang trí kèm vài dòng lời chúc. Lời chúc được niêm phong đến một ngày định trước rồi mới mở. Khi tự cài đặt, chúng tôi thấy có năm bài toán nhỏ: lưu dữ liệu, đặt đồ trang trí không đè nhau, giấu nội dung đến ngày mở mà không lộ qua API, chặn XSS và hạn chế spam.

Bài này là một hướng dẫn độc lập do nhóm Deco My Tree viết. Code minh hoạ không đại diện cho kiến trúc đang chạy trên sản phẩm. Để bài gọn hơn, ví dụ đơn giản hoá phần xác thực (người gửi có phiên đăng nhập), và để ngày mở lời chúc là một mốc có thể cấu hình (reveal_at). Trên sản phẩm hiện tại, lời chúc chữ tiêu chuẩn có thể gửi với tư cách khách sau khi xác minh, còn chủ cây đọc lời chúc từ ngày 25 tháng 12 theo múi giờ của cây. Một số quy tắc trong ví dụ khác với sản phẩm; đừng dùng bài này như tài liệu mô tả cách trang thật được xây. Code là bản rút gọn với Node.js (Express), PostgreSQL và SVG ở phía trình duyệt; các hàm thuần chúng tôi đã chạy thử bằng node --test.

1. Mô hình dữ liệu

Chúng tôi chia thành hai bảng chính. Cây có chủ sở hữu, token chia sẻ, thời điểm mở lời chúc (reveal_at) và thời điểm ngừng nhận (closes_at). Lời chúc thuộc về một cây, có số thứ tự slot, loại đồ trang trí, nội dung, và hai cờ do người viết chọn: ẩn tên và cho phép người khác đọc.

CREATE TABLE trees (
  id           BIGSERIAL PRIMARY KEY,
  owner_id     BIGINT NOT NULL REFERENCES users(id),
  share_token  TEXT NOT NULL UNIQUE,
  title        TEXT NOT NULL,
  reveal_at    TIMESTAMPTZ NOT NULL,      -- từ thời điểm này lời chúc mới được mở
  closes_at    TIMESTAMPTZ NOT NULL,      -- sau thời điểm này không nhận thêm
  wish_count   INT NOT NULL DEFAULT 0     -- dùng để cấp số thứ tự (slot)
);

CREATE TABLE wishes (
  id         BIGSERIAL PRIMARY KEY,
  tree_id    BIGINT NOT NULL REFERENCES trees(id) ON DELETE CASCADE,
  slot       INT NOT NULL,                -- thứ tự trên cây: 0, 1, 2, ...
  author_id  BIGINT NOT NULL REFERENCES users(id),
  ornament   TEXT NOT NULL,
  body       TEXT NOT NULL CHECK (char_length(body) BETWEEN 1 AND 1120),
  hide_name  BOOLEAN NOT NULL DEFAULT FALSE,
  is_public  BOOLEAN NOT NULL DEFAULT FALSE,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
  UNIQUE (tree_id, slot)
);

Cột wish_count là bộ đếm để cấp slot một cách nguyên tử (mục 6), còn UNIQUE (tree_id, slot) là lớp bảo vệ cuối nếu code cấp số có lỗi. Ràng buộc CHECK chỉ là chốt chặn rộng ở tầng cơ sở dữ liệu; giới hạn thật cho người dùng (280 ký tự) kiểm tra trong ứng dụng.

Về thời gian: dùng TIMESTAMPTZ và để chính PostgreSQL so với now(), tránh lỗi lệch múi giờ hay đồng hồ máy lệch đúng vào ngày mở.

2. Đặt đồ trang trí lên cây mà không chồng nhau

Cách ngây thơ nhất là chọn x, y ngẫu nhiên mỗi lần vẽ. Các món sẽ đè nhau và mỗi lần tải lại lại nhảy chỗ. Chúng tôi giải quyết bằng hai ý.

Ý thứ nhất, dùng bộ sinh số ngẫu nhiên có seed (mulberry32), với seed lấy từ id cây và số trang. Cùng cây, cùng trang thì luôn ra cùng một bố cục, nên không cần lưu toạ độ vào cơ sở dữ liệu.

Ý thứ hai, ném điểm theo kiểu "dart throwing": ném một điểm ngẫu nhiên trong hình tam giác, nếu nó gần điểm đã có hơn khoảng cách tối thiểu r thì bỏ và ném lại. Đây là bản đơn giản của thuật toán Poisson-disc (bản đầy đủ của Bridson nhanh hơn khi có hàng nghìn điểm), nhưng với khoảng 12 món mỗi trang thì cách đơn giản này là đủ. Nếu thử nhiều lần mà hết chỗ, ta nới r ra một chút để vòng lặp luôn kết thúc.

// Sinh số ngẫu nhiên có seed: cùng seed thì luôn ra cùng dãy số
export function hashSeed(str) {
  let h = 2166136261;
  for (const ch of str) {
    h ^= ch.codePointAt(0);
    h = Math.imul(h, 16777619);
  }
  return h >>> 0;
}

export function mulberry32(seed) {
  let a = seed >>> 0;
  return () => {
    a = (a + 0x6d2b79f5) >>> 0;
    let t = a;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// Cây là một hình tam giác cân: đỉnh ở giữa phía trên, đáy ở phía dưới
export const TREE = { width: 400, height: 480, top: 40, bottom: 440, halfBase: 170 };

export function insideTree(x, y, margin = 18, t = TREE) {
  if (y < t.top + margin * 2 || y > t.bottom - margin) return false;
  const progress = (y - t.top) / (t.bottom - t.top); // 0 ở đỉnh, 1 ở đáy
  const half = t.halfBase * progress - margin;
  return Math.abs(x - t.width / 2) <= half;
}

// "Dart throwing": ném điểm ngẫu nhiên, bỏ điểm nào gần điểm cũ hơn r.
// Đây là bản đơn giản của Poisson-disc, đủ dùng khi mỗi trang chỉ có ~12 món.
export function placeOrnaments(seed, count, { minDist = 64, tries = 60 } = {}) {
  const rand = mulberry32(hashSeed(seed));
  const points = [];
  let r = minDist;
  while (points.length < count) {
    let placed = false;
    for (let i = 0; i < tries; i++) {
      const x = rand() * TREE.width;
      const y = TREE.top + rand() * (TREE.bottom - TREE.top);
      if (!insideTree(x, y)) continue;
      if (points.every((p) => Math.hypot(p.x - x, p.y - y) >= r)) {
        points.push({ x: Math.round(x), y: Math.round(y) });
        placed = true;
        break;
      }
    }
    if (!placed) r *= 0.92; // hết chỗ thì nới khoảng cách một chút
  }
  return points;
}

export const PAGE_SIZE = 12;

// Luôn sinh đủ PAGE_SIZE vị trí rồi lấy `count` điểm đầu,
// nhờ vậy khi có thêm món mới, các món cũ không bị nhảy chỗ.
export function positionsForPage(treeId, page, count = PAGE_SIZE) {
  return placeOrnaments(`${treeId}:${page}`, PAGE_SIZE).slice(0, count);
}

Ở hàm cuối, chúng tôi luôn sinh đủ 12 vị trí rồi lấy count điểm đầu. Vì các điểm được chọn tuần tự theo một dãy cố định, các món cũ giữ nguyên chỗ khi có món mới (test ở cuối bài kiểm tra đúng điều này).

Phía trình duyệt, vẽ SVG khá ngắn; điều đáng chú ý là chỉ gán chuỗi bằng textContent (lý do ở mục 4).

import { positionsForPage, PAGE_SIZE } from "./placement.mjs";

const SVG_NS = "http://www.w3.org/2000/svg";

export function renderPage(svg, treeId, wishes) {
  if (wishes.length === 0) return;
  const page = Math.floor(wishes[0].slot / PAGE_SIZE);
  const spots = positionsForPage(treeId, page, PAGE_SIZE);

  for (const w of wishes) {
    const { x, y } = spots[w.slot % PAGE_SIZE];
    const g = document.createElementNS(SVG_NS, "g");
    g.setAttribute("transform", `translate(${x} ${y})`);

    const ball = document.createElementNS(SVG_NS, "circle");
    ball.setAttribute("r", "14");
    ball.dataset.ornament = w.ornament;

    // Chỉ dùng textContent: trình duyệt tự coi chuỗi là chữ thường, không phân tích HTML
    const title = document.createElementNS(SVG_NS, "title");
    title.textContent = w.locked ? `${w.authorName} đã gửi một lời chúc` : `${w.authorName}: ${w.body}`;

    g.append(ball, title);
    svg.append(g);
  }
}

Cây mới chưa có lời chúc thì wishes rỗng. Hàm kiểm tra điều này trước, để không đọc wishes[0].slot.

3. Ẩn lời chúc đến ngày mở: quyết định ở server

Đây là chỗ dễ sai nhất. Một cách làm thường gặp là trả toàn bộ lời chúc về trình duyệt, rồi dùng JavaScript hiển thị "đã khoá" nếu chưa tới ngày. Cách này hỏng ngay khi ai đó mở tab Network hoặc gọi API bằng curl: nội dung đã nằm sẵn trong JSON.

Nguyên tắc: nội dung chưa được phép đọc thì không bao giờ rời khỏi server. Thuộc tính body phải vắng mặt trong JSON, không phải có mặt với giá trị rỗng.

Luồng truy vấn lời chúc: server quyết định có trả body hay không

Quy tắc đọc trong ví dụ của chúng tôi như sau: người viết luôn đọc được lời chúc của chính mình; trước reveal_at không ai khác đọc được, kể cả chủ cây; sau reveal_at, chủ cây đọc được tất cả, còn người lạ chỉ đọc được những lời chúc mà người viết đã cho phép công khai. Nếu người viết chọn ẩn tên thì mọi người khác, kể cả chủ cây, chỉ thấy "Ẩn danh". Dưới đây là hàm thuần để dễ viết test:

// wish: { id, authorId, authorName, hideName, isPublic, ornament, slot, body, createdAt: Date }
// tree: { ownerId, revealAt: Date }
export function canReadBody(wish, viewerId, tree, now = new Date()) {
  if (viewerId != null && wish.authorId === viewerId) return true; // người viết luôn đọc được
  if (now < tree.revealAt) return false;                            // chưa tới ngày mở
  if (viewerId != null && tree.ownerId === viewerId) return true;   // chủ cây
  return wish.isPublic;                                             // người viết cho phép công khai
}

export function toWishDto(wish, viewerId, tree, now = new Date()) {
  const mine = viewerId != null && wish.authorId === viewerId;
  const dto = {
    id: String(wish.id),
    ornament: wish.ornament,
    slot: wish.slot,
    authorName: wish.hideName && !mine ? "Ẩn danh" : wish.authorName,
    createdAt: wish.createdAt.toISOString(),
    locked: true,
  };
  if (canReadBody(wish, viewerId, tree, now)) {
    dto.locked = false;
    dto.body = wish.body; // chỉ khi được phép mới có thuộc tính body
  }
  return dto;
}

Trong endpoint thật (mục 6), chúng tôi đưa luôn quyết định này vào câu SQL để cột body chưa được phép đọc không bao giờ được nạp vào bộ nhớ ứng dụng. Hàm JavaScript ở trên là bản "đặc tả" của quy tắc để test và đối chiếu; hai nơi cần giữ khớp nhau, nên có thêm test tích hợp cho câu SQL.

Hai bẫy nhỏ đáng nhắc. Thứ nhất, trong SQL, NULL làm các phép so sánh thông thường trả về NULL: author_id <> NULL không phải TRUE, nên với khách chưa đăng nhập, ta cần IS DISTINCT FROM. Thứ hai, phản hồi phụ thuộc vào người xem và thời điểm, nên đặt Cache-Control: private, no-store; nếu CDN lưu lại phản hồi "đã khoá" thì sau ngày mở mọi người vẫn thấy khoá.

4. Làm sạch nội dung để tránh XSS

Lời chúc do người lạ nhập, sau đó được hiển thị cho người khác, đúng định nghĩa của stored XSS. Chúng tôi áp dụng ba lớp.

Lớp đầu tiên là kiểm tra đầu vào: chuẩn hoá Unicode về NFC, bỏ các ký tự điều khiển, ký tự đổi chiều chữ (U+202E có thể làm đảo ngược cả dòng chữ) và ký tự rộng bằng 0, gộp nhiều dòng trống, rồi từ chối nếu quá dài thay vì cắt lén. Chúng tôi đếm theo code point bằng [...s].length để một emoji không bị tính thành hai ký tự. Chúng tôi cố ý không xoá U+200D, vì nó là chất kết dính trong các emoji ghép như 👨‍👩‍👧.

Lớp thứ hai, và quan trọng hơn, là mã hoá khi xuất ra. Chúng tôi lưu nguyên văn lời chúc trong cơ sở dữ liệu và chỉ escape ở nơi hiển thị. Escape trước khi lưu dễ gây escape hai lần và khó dùng lại cho ngữ cảnh khác. Trên trình duyệt, cách chắc nhất là textContent như ở hàm renderPage. Khi buộc phải ghép HTML phía server (ví dụ trang chia sẻ có thẻ og:description), dùng escapeHtml bên dưới.

// Ký tự điều khiển, ký tự đổi chiều chữ (bidi) và ký tự rộng bằng 0
const BAD = /[\u0000-\u0009\u000B-\u001F\u007F-\u009F\u200B\u200E\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g;

export function cleanWish(input, maxChars = 280) {
  if (typeof input !== "string") return null;
  const s = input
    .normalize("NFC")
    .replace(/\r\n?/g, "\n")
    .replace(BAD, "")
    .replace(/\n{3,}/g, "\n\n")
    .trim();
  if (s.length === 0) return null;
  if ([...s].length > maxChars) return null; // đếm theo code point, không cắt lén
  return s;
}

const HTML_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
export function escapeHtml(s) {
  return s.replace(/[&<>"']/g, (c) => HTML_ESCAPES[c]);
}

Lớp thứ ba là phòng thủ chiều sâu: thêm header Content-Security-Policy chặn script nội tuyến (script-src 'self'). Nó không thay thế hai lớp trên, nhưng nếu một ngày ai đó lỡ dùng innerHTML, thiệt hại sẽ nhỏ hơn nhiều.

5. Giới hạn tần suất cho người gửi

Một đường link công khai thì sớm muộn cũng có người gửi hàng trăm lời chúc rác. Chúng tôi dùng thuật toán token bucket: mỗi khoá (ở đây là địa chỉ IP kết hợp token cây) có một "xô" chứa tối đa 3 token, hồi lại 1 token mỗi 20 giây. Gửi một lời chúc tốn 1 token; hết token thì trả 429 kèm Retry-After. Token bucket cho phép gửi dồn vài lần liên tiếp rồi mới chậm lại, tự nhiên hơn với người dùng thật so với cửa sổ cố định.

export class TokenBucketLimiter {
  constructor({ capacity, refillPerSec, maxKeys = 10_000, now = () => Date.now() }) {
    this.capacity = capacity;
    this.refillPerSec = refillPerSec;
    this.maxKeys = maxKeys;
    this.now = now;
    this.buckets = new Map(); // key -> { tokens, last }
  }

  take(key, cost = 1) {
    const t = this.now();
    let b = this.buckets.get(key);
    if (!b) b = { tokens: this.capacity, last: t };
    // cộng lại token theo thời gian đã trôi qua
    b.tokens = Math.min(this.capacity, b.tokens + ((t - b.last) / 1000) * this.refillPerSec);
    b.last = t;

    const ok = b.tokens >= cost;
    if (ok) b.tokens -= cost;

    this.buckets.delete(key);   // xoá rồi set lại để key này nằm cuối Map
    this.buckets.set(key, b);
    if (this.buckets.size > this.maxKeys) {
      this.buckets.delete(this.buckets.keys().next().value); // bỏ key cũ nhất
    }
    const retryAfterSec = ok ? 0 : Math.ceil((cost - b.tokens) / this.refillPerSec);
    return { ok, retryAfterSec };
  }
}

Lưu ý khi đưa lên thật: bộ nhớ trong chỉ đúng khi chạy một tiến trình, nhiều bản sao thì chuyển trạng thái sang Redis. Sau reverse proxy phải cấu hình app.set("trust proxy", ...), nếu không req.ip luôn là địa chỉ proxy và mọi người dùng chung một xô. maxKeys giới hạn kích thước Map để việc đổi IP liên tục không làm tràn bộ nhớ.

6. Cấp slot nguyên tử và phân trang

Khi cây đầy, ta cần sang "trang" mới. Chúng tôi gắn mỗi lời chúc với slot tăng dần: trang p gồm các slot từ 12p đến 12p + 11, và nó cũng chính là chỉ số vị trí trong hàm positionsForPage ở mục 2.

Để cấp slot mà hai người gửi cùng lúc không bị trùng, chúng tôi không dùng SELECT COUNT(*) + 1 (dễ bị race condition). Thay vào đó, UPDATE trees SET wish_count = wish_count + 1 ... RETURNING vừa tăng bộ đếm vừa trả giá trị trong một câu lệnh, trong cùng transaction với INSERT. PostgreSQL khoá dòng cây khi cập nhật nên các giao dịch xếp hàng nhau; cùng câu lệnh đó kiểm tra luôn closes_at > now().

Với phân trang, chúng tôi dùng con trỏ (keyset) thay cho OFFSET: client gửi lại slot cuối cùng đã nhận, server trả các slot lớn hơn. Cách này nhanh dù có nhiều lời chúc và không trùng hay sót khi có lời chúc mới chen vào lúc người dùng đang lật trang. Con trỏ là dữ liệu từ ngoài vào nên phải kiểm tra chặt khi giải mã.

export function encodeCursor(id) {
  return Buffer.from(JSON.stringify({ id: String(id) })).toString("base64url");
}

export function decodeCursor(cursor) {
  try {
    const { id } = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
    if (!/^\d{1,18}$/.test(id)) return null;
    const n = Number(id);
    // SQL dùng $2::int (32-bit), chỉ nhận 0..2147483647
    if (!Number.isInteger(n) || n < 0 || n > 2147483647) return null;
    return id;
  } catch {
    return null;
  }
}

Vì câu SQL bên dưới ép kiểu $2::int (số nguyên 32-bit, tối đa 2147483647), decodeCursor còn kiểm tra 0 ≤ id ≤ 2147483647. Chỉ kiểm tra độ dài chữ số thì giá trị như 2147483648 vẫn lọt, nhưng truy vấn sẽ báo lỗi vượt phạm vi.

Cuối cùng là hai endpoint ghép mọi thứ lại với nhau. Chú ý hai điểm: truy vấn dùng tham số ($1, $2, ...), không bao giờ ghép chuỗi người dùng vào SQL (hằng số limit là số do chúng tôi đặt nên mới nội suy); và GET lấy limit + 1 dòng để biết còn trang sau hay không mà không cần thêm một truy vấn COUNT.

import express from "express";
import { cleanWish } from "./sanitize.mjs";
import { TokenBucketLimiter } from "./ratelimit.mjs";
import { encodeCursor, decodeCursor } from "./pagination.mjs";

const ORNAMENTS = new Set(["bell", "bauble", "candy-cane", "snowflake", "star"]);
const postLimiter = new TokenBucketLimiter({ capacity: 3, refillPerSec: 1 / 20 }); // 3 lần, sau đó 1 lần / 20 giây

export function wishRouter(db) {
  const router = express.Router();
  router.use(express.json({ limit: "4kb" }));

  router.post("/trees/:token/wishes", async (req, res) => {
    const gate = postLimiter.take(`${req.ip}:${req.params.token}`);
    if (!gate.ok) {
      res.set("Retry-After", String(gate.retryAfterSec));
      return res.status(429).json({ error: "too_many_requests" });
    }

    const body = cleanWish(req.body?.body);
    const ornament = req.body?.ornament;
    if (body === null || !ORNAMENTS.has(ornament)) {
      return res.status(400).json({ error: "invalid_input" });
    }

    const client = await db.connect();
    try {
      await client.query("BEGIN");
      // Cấp số thứ tự (slot) nguyên tử, hai người gửi cùng lúc không bao giờ trùng slot
      const { rows } = await client.query(
        `UPDATE trees SET wish_count = wish_count + 1
          WHERE share_token = $1 AND closes_at > now()
          RETURNING id, wish_count - 1 AS slot`,
        [req.params.token]
      );
      if (rows.length === 0) {
        await client.query("ROLLBACK");
        return res.status(404).json({ error: "tree_not_found_or_closed" });
      }
      await client.query(
        `INSERT INTO wishes (tree_id, slot, author_id, ornament, body, hide_name, is_public)
         VALUES ($1, $2, $3, $4, $5, $6, $7)`,
        [rows[0].id, rows[0].slot, req.user.id, ornament, body,
         req.body.hideName === true, req.body.isPublic === true]
      );
      await client.query("COMMIT");
      res.status(201).json({ slot: rows[0].slot });
    } catch (err) {
      await client.query("ROLLBACK");
      throw err;
    } finally {
      client.release();
    }
  });

  router.get("/trees/:token/wishes", async (req, res) => {
    const after = req.query.cursor ? decodeCursor(String(req.query.cursor)) : "-1";
    if (after === null) return res.status(400).json({ error: "bad_cursor" });
    const limit = 12;

    const { rows } = await db.query(
      `SELECT w.id, w.slot, w.ornament, w.created_at,
              CASE WHEN w.hide_name AND w.author_id IS DISTINCT FROM $3::bigint
                   THEN NULL ELSE u.display_name END AS author_name,
              CASE WHEN w.author_id = $3::bigint
                     OR (now() >= t.reveal_at AND (t.owner_id = $3::bigint OR w.is_public))
                   THEN w.body END AS body
         FROM wishes w
         JOIN trees t ON t.id = w.tree_id
         JOIN users u ON u.id = w.author_id
        WHERE t.share_token = $1 AND w.slot > $2::int
        ORDER BY w.slot
        LIMIT ${limit + 1}`,
      [req.params.token, after, req.user?.id ?? null]
    );

    const hasMore = rows.length > limit;
    const page = rows.slice(0, limit).map((r) => ({
      slot: r.slot,
      ornament: r.ornament,
      authorName: r.author_name ?? "Ẩn danh",
      createdAt: r.created_at,
      locked: r.body === null,
      ...(r.body === null ? {} : { body: r.body }),
    }));

    res.set("Cache-Control", "private, no-store"); // kết quả phụ thuộc người xem và thời điểm
    res.json({
      wishes: page,
      nextCursor: hasMore ? encodeCursor(page[page.length - 1].slot) : null,
    });
  });

  return router;
}

Như đã nói ở đầu bài, ví dụ này giả định người gửi có phiên đăng nhập nhẹ (req.user do middleware xác thực đặt trước đó, phần này chúng tôi lược bỏ) cho gọn luồng. Sản phẩm thật cho phép gửi lời chúc chữ tiêu chuẩn với tư cách khách sau khi xác minh; nếu muốn mô phỏng điều đó, hãy thay bằng cookie khách và bảng riêng.

Chạy thử

Các hàm thuần test rất nhanh bằng bộ chạy test có sẵn của Node, tập trung vào các trường hợp biên: lộ nội dung trước ngày mở, emoji ghép, token bucket sau khi hồi, con trỏ bị sửa tay.

import test from "node:test";
import assert from "node:assert/strict";
import { placeOrnaments, positionsForPage, insideTree, PAGE_SIZE } from "./placement.mjs";
import { toWishDto } from "./gating.mjs";
import { cleanWish, escapeHtml } from "./sanitize.mjs";
import { TokenBucketLimiter } from "./ratelimit.mjs";
import { encodeCursor, decodeCursor } from "./pagination.mjs";
import { renderPage } from "./render.mjs";

test("vị trí nằm trong cây, không chồng nhau, ổn định", () => {
  const a = positionsForPage("abc", 0);
  assert.equal(a.length, PAGE_SIZE);
  assert.ok(a.every((p) => insideTree(p.x, p.y, 0)));
  let min = Infinity;
  for (let i = 0; i < a.length; i++)
    for (let j = i + 1; j < a.length; j++) min = Math.min(min, Math.hypot(a[i].x - a[j].x, a[i].y - a[j].y));
  assert.ok(min >= 64 * 0.5, `min=${min}`);
  assert.deepEqual(a, positionsForPage("abc", 0));
  assert.deepEqual(positionsForPage("abc", 0, 5), a.slice(0, 5));
  assert.notDeepEqual(a, positionsForPage("abc", 1));
});

test("nhiều seed vẫn luôn đủ điểm", () => {
  for (let i = 0; i < 200; i++) assert.equal(placeOrnaments("t" + i, 12).length, 12);
});

const tree = { ownerId: 1, revealAt: new Date("2026-12-25T00:00:00Z") };
const wish = { id: 9n, authorId: 2, authorName: "Lan", hideName: false, isPublic: false, ornament: "bell", slot: 0, body: "Chúc bạn vui", createdAt: new Date("2026-12-01T00:00:00Z") };
const before = new Date("2026-12-10T00:00:00Z"), after = new Date("2026-12-26T00:00:00Z");

test("không lộ body trước ngày mở, kể cả cho chủ cây", () => {
  const dto = toWishDto(wish, 1, tree, before);
  assert.equal(dto.locked, true);
  assert.ok(!("body" in dto));
  assert.ok(!JSON.stringify(dto).includes("Chúc"));
});
test("sau ngày mở", () => {
  assert.equal(toWishDto(wish, 1, tree, after).body, "Chúc bạn vui");
  assert.equal(toWishDto(wish, 3, tree, after).locked, true);
  assert.equal(toWishDto(wish, null, tree, after).locked, true);
  assert.equal(toWishDto({ ...wish, isPublic: true }, null, tree, after).locked, false);
  assert.equal(toWishDto(wish, 2, tree, before).body, "Chúc bạn vui");
});
test("ẩn danh", () => {
  const w = { ...wish, hideName: true };
  assert.equal(toWishDto(w, 1, tree, after).authorName, "Ẩn danh");
  assert.equal(toWishDto(w, 2, tree, after).authorName, "Lan");
});

test("làm sạch", () => {
  assert.equal(cleanWish("  xin chào\u202E  "), "xin chào");
  assert.equal(cleanWish(""), null);
  assert.equal(cleanWish(42), null);
  assert.equal(cleanWish("a".repeat(281)), null);
  assert.equal(cleanWish("a".repeat(280)).length, 280);
  assert.equal(cleanWish("👨‍👩‍👧").length, 8); // ZWJ trong emoji được giữ
  assert.equal(cleanWish("a\n\n\n\nb"), "a\n\nb");
  assert.equal(escapeHtml(`<img src=x onerror="alert(1)">&'`), "&lt;img src=x onerror=&quot;alert(1)&quot;&gt;&amp;&#39;");
});

test("token bucket", () => {
  let t = 0;
  const l = new TokenBucketLimiter({ capacity: 3, refillPerSec: 1 / 20, now: () => t });
  assert.ok(l.take("k").ok && l.take("k").ok && l.take("k").ok);
  const r = l.take("k");
  assert.equal(r.ok, false);
  assert.equal(r.retryAfterSec, 20);
  t = 20_000;
  assert.equal(l.take("k").ok, true);
  assert.equal(l.take("k").ok, false);
  assert.ok(l.take("other").ok);
});
test("giới hạn số key", () => {
  const l = new TokenBucketLimiter({ capacity: 1, refillPerSec: 1, maxKeys: 2 });
  l.take("a"); l.take("b"); l.take("c");
  assert.equal(l.buckets.size, 2);
  assert.ok(!l.buckets.has("a"));
});

test("cursor", () => {
  assert.equal(decodeCursor(encodeCursor(41)), "41");
  assert.equal(decodeCursor("@@@"), null);
  assert.equal(decodeCursor(Buffer.from(JSON.stringify({ id: "1; DROP" })).toString("base64url")), null);
  assert.equal(decodeCursor(encodeCursor(2147483647)), "2147483647");
  assert.equal(decodeCursor(encodeCursor(2147483648)), null);
});

test("cây trống không đọc wishes[0]", () => {
  const svg = { append() { throw new Error("không được gọi"); } };
  assert.equal(renderPage(svg, "t", []), undefined);
});

Chạy bằng node --test test.mjs.

Kết luận

Những điều chúng tôi rút ra sau khi làm một bức tường lời chúc kiểu này:

  1. Dữ liệu chưa được phép đọc không được rời khỏi server; "ẩn bằng JavaScript" không phải là bảo mật.
  2. Vị trí đồ trang trí nên sinh từ seed cố định và sinh đủ cả trang, để bố cục ổn định giữa các lần tải.
  3. Lưu nguyên văn, escape khi xuất ra, và ưu tiên textContent thay cho innerHTML.
  4. Token bucket đơn giản nhưng phải nhớ giới hạn bộ nhớ và cấu hình trust proxy.
  5. Cấp số thứ tự bằng một câu UPDATE ... RETURNING trong transaction, và phân trang bằng con trỏ.

All rights reserved

Viblo
Hãy đăng ký một tài khoản Viblo để nhận được nhiều bài viết thú vị hơn.
Đăng kí