Form đăng ký email trong Next.js: nhận bản tin không tốn phí

Làm form đăng ký email trong Next.js với Supabase: vì sao không nên cho trình duyệt ghi thẳng vào bảng, hàm subscribe thay thế, ô bẫy robot và hủy đăng ký.

Muốn làm form đăng ký email cho blog mà không trả tiền cho dịch vụ nào, bạn cần ba thứ: một bảng lưu email mà người lạ không đọc được, một hàm duy nhất để trình duyệt thêm email vào, và vài lớp lọc robot. Bài này làm cả ba trên Next.js và Supabase, đúng như blog này đang chạy.

Người đọc đến rồi đi, và mình cần giữ lại cái gì?

Ở bài trước, blog đã đếm được bài nào được đọc, và mình nhận ra một chuyện: người đọc xong rồi đi thường không quay lại, vì blog chưa có cách nào để họ ở lại nhận bài mới. Cách đơn giản nhất là cho họ để lại địa chỉ email.

Nghe thì dễ. Một ô nhập, một nút gửi, một bảng trong database. Nhưng ô nhập đó nằm ở trang công khai, nên ai cũng gọi được nó, kể cả những đoạn code tự động. Và thứ nó chứa là địa chỉ email của người khác, loại dữ liệu mình không muốn làm lộ ra dù chỉ một dòng. Cho nên câu hỏi thật của bài này không phải "lưu email thế nào", mà là "làm sao để ai cũng thêm được email, nhưng không ai đọc được danh sách".

Mình cũng đặt một ràng buộc: không dùng dịch vụ trả phí. Blog này chưa gửi email nào, chỉ cần thu và giữ danh sách, nên một bảng trong Supabase là đủ. Chuyện gửi thư bằng dịch vụ nào, và danh sách xuất ra ra sao, mình nói ở cuối bài.

Để bạn làm theo được mà không cần Supabase, mình dùng PGlite, một bản Postgres thật chạy ngay trong Node.js. Bạn cần Node.js 22.18 trở lên. Tạo thư mục moc-ban-tin với cấu trúc sau:

Cấu trúc thư mục
moc-ban-tin/
  package.json
  moi-truong.sql
  migration.sql
  chay.ts
  thu-robot.ts
  src/ban-tin.ts
package.json
{
  "name": "blog-mini-12-ban-tin",
  "private": true,
  "type": "module",
  "dependencies": { "@electric-sql/pglite": "0.3.14" }
}

Supabase có sẵn hai vai trò database là anon (người chưa đăng nhập, dùng khóa công khai) và authenticated (người đã đăng nhập), cùng hàm auth.jwt() đọc token của người gọi. Postgres thường không có, nên file moi-truong.sql dựng lại vừa đủ để chạy được migration thật của blog:

moi-truong.sql
-- Dựng lại vừa đủ "môi trường Supabase" để chạy được migration thật của blog trên Postgres thường:
-- hai vai trò anon và authenticated, và hàm auth.jwt() (trong Supabase nó đọc token của người gọi).
create role anon nologin;
create role authenticated nologin;
grant usage on schema public to anon, authenticated;

create schema auth;
grant usage on schema auth to anon, authenticated;
create function auth.jwt() returns jsonb language sql stable as $$ select '{}'::jsonb $$;
grant execute on function auth.jwt() to anon, authenticated;

Cách đầu tiên: cho trình duyệt ghi thẳng vào bảng

Cách mà hầu hết hướng dẫn chỉ tới đầu tiên là tạo bảng, bật Row Level Security (RLS, mình đã nói về nó ở bài về RLS), rồi thêm policy cho phép vai trò anon thêm dòng. Để form báo được "email này đã đăng ký rồi", nhiều ví dụ thêm luôn policy cho phép đọc. Mình viết đúng như vậy rồi cho ba người đăng ký, sau đó thử đọc bảng bằng vai trò anon, tức là chỉ với thứ mà bất kỳ ai mở trang cũng có.

Đoạn đầu của chay.ts làm việc này. Hàm dungMoiTruong tạo một database mới và chạy moi-truong.sql:

chay.ts (phần 1)
// Hai cách làm bảng đăng ký bản tin, chạy trên Postgres thật (PGlite chạy ngay trong Node, không cần Supabase).
// Chạy: node chay.ts
import { PGlite } from "@electric-sql/pglite";
import { readFileSync } from "node:fs";

async function dungMoiTruong() {
  const db = new PGlite();
  await db.exec(readFileSync("moi-truong.sql", "utf8"));
  return db;
}

const loi = async (viec: () => Promise<unknown>) => {
  try {
    await viec();
    return "không lỗi";
  } catch (e) {
    const err = e as { message: string; code?: string };
    return `lỗi ${err.code}: ${err.message}`;
  }
};

// ---------- Cách 1: cho trình duyệt ghi thẳng vào bảng ----------
console.log("=== Cách 1: bảng cho vai trò anon insert và select thẳng ===");
{
  const db = await dungMoiTruong();
  await db.exec(`
    create table public.subscribers (id bigint generated always as identity primary key, email text unique not null);
    alter table public.subscribers enable row level security;
    create policy "ai cũng thêm được" on public.subscribers for insert to anon with check (true);
    create policy "ai cũng đọc được"  on public.subscribers for select to anon using (true);
    grant insert, select on public.subscribers to anon;
  `);
  await db.exec("set role anon");
  for (const email of ["an@example.com", "binh@example.com", "chi@example.com"]) {
    await db.query("insert into public.subscribers (email) values ($1)", [email]);
  }
  // Một người lạ, chỉ có khóa công khai của trang, đọc cả danh sách:
  const lo = await db.query("select email from public.subscribers order by id");
  console.log("Người lạ đọc được:", lo.rows.map((r) => (r as { email: string }).email).join(", "));
}

Phần hai của file này nói sau. Mình chạy toàn bộ chay.ts và lấy dòng đầu:

node chay.ts (phần đầu của kết quả)
=== Cách 1: bảng cho vai trò anon insert và select thẳng ===
Người lạ đọc được: an@example.com, binh@example.com, chi@example.com

Đây là điều khiến mình không dùng cách này. Bất kỳ ai cũng có khóa công khai của trang, vì nó nằm ngay trong mã JavaScript gửi về trình duyệt. Chỉ cần một dòng truy vấn là họ lấy được cả danh sách email của người đăng ký. Điều đó đúng với mọi dự án dùng cách này, không riêng ví dụ của mình.

Vậy bỏ policy đọc đi thì sao? Mình thử luôn. Bảng chỉ còn policy cho anon thêm dòng, và cột email có ràng buộc duy nhất để không trùng:

chay.ts (phần 1b, chèn sau phần 1)
// ---------- Cách 1b: bỏ policy đọc đi cho an toàn? ----------
console.log("\n=== Cách 1b: bỏ policy đọc, chỉ cho insert ===");
{
  const db = await dungMoiTruong();
  await db.exec(`
    create table public.subscribers (id bigint generated always as identity primary key, email text unique not null);
    alter table public.subscribers enable row level security;
    create policy "ai cũng thêm được" on public.subscribers for insert to anon with check (true);
    grant insert on public.subscribers to anon;
  `);
  await db.exec("set role anon");
  await db.query("insert into public.subscribers (email) values ('an@example.com')");
  console.log("anon đọc bảng:", await loi(() => db.query("select email from public.subscribers")));
  console.log("anon thêm email đã có:", await loi(() => db.query("insert into public.subscribers (email) values ('an@example.com')")));
  console.log("anon thêm email mới:", await loi(() => db.query("insert into public.subscribers (email) values ('moi@example.com')")));
}
node chay.ts (đoạn 1b)
=== Cách 1b: bỏ policy đọc, chỉ cho insert ===
anon đọc bảng: lỗi 42501: permission denied for table subscribers
anon thêm email đã có: lỗi 23505: duplicate key value violates unique constraint "subscribers_email_key"
anon thêm email mới: không lỗi

Danh sách đúng là không đọc được nữa. Nhưng nhìn hai dòng cuối: thêm một email đã có thì database trả lỗi trùng, còn thêm email mới thì im lặng. Chỉ bằng cách thử gửi một địa chỉ cụ thể, ai đó biết được địa chỉ đó đã đăng ký hay chưa. Với blog này, mình muốn cả hai thứ đều không lộ: không đọc được danh sách, và cũng không dò được từng địa chỉ.

Cách của blog: bảng đóng, chỉ mở một hàm

Blog này làm khác. Bảng subscribers đóng hoàn toàn với anon: không insert, không select. Thứ duy nhất anon được làm là gọi hai hàm, subscribe() để đăng ký và unsubscribe() để hủy. Hai hàm này chạy với quyền của người tạo ra chúng (security definer), nên chúng ghi được vào bảng dù người gọi thì không. Đây là migration thật, nguyên văn từ repo của blog:

migration.sql (migration thật của blog)
-- Newsletter sign-ups.
--
--   * Readers never touch the table directly: they call public.subscribe() / public.unsubscribe(),
--     which validate input and can be called with the publishable key. Nobody but authors can read
--     the list, so the form cannot be used to find out whether an address is subscribed.
--   * Authors (app_metadata.role = 'author') read, update and delete rows in /admin/ban-tin.
--   * Single opt-in for now: no email is sent yet. Each row has an unsubscribe token for the links
--     future emails will carry.

create table public.subscribers (
  id bigint generated always as identity primary key,
  email text not null
    constraint subscribers_email_format check (
      char_length(email) between 3 and 254
      and email = lower(email)
      and email ~ '^[^@[:space:]]+@[^@[:space:]]+\.[^@[:space:]]+$'
    ),
  source text not null default '' constraint subscribers_source_length check (char_length(source) <= 120),
  status text not null default 'subscribed' constraint subscribers_status_known check (status in ('subscribed', 'unsubscribed')),
  unsubscribe_token uuid not null default gen_random_uuid() unique,
  created_at timestamptz not null default now(),
  unsubscribed_at timestamptz
);

comment on table public.subscribers is 'Newsletter sign-ups. Written only through public.subscribe() / public.unsubscribe().';

create unique index subscribers_email_key on public.subscribers (email);
create index subscribers_created_at_idx on public.subscribers (created_at desc);

alter table public.subscribers enable row level security;

create policy "Authors can read subscribers" on public.subscribers for select to authenticated
  using ((select auth.jwt() -> 'app_metadata' ->> 'role') = 'author');
create policy "Authors can update subscribers" on public.subscribers for update to authenticated
  using ((select auth.jwt() -> 'app_metadata' ->> 'role') = 'author')
  with check ((select auth.jwt() -> 'app_metadata' ->> 'role') = 'author');
create policy "Authors can delete subscribers" on public.subscribers for delete to authenticated
  using ((select auth.jwt() -> 'app_metadata' ->> 'role') = 'author');

revoke all on public.subscribers from anon, authenticated;
grant select, update, delete on public.subscribers to authenticated;

-- Sign up (or sign up again after unsubscribing). Returns nothing either way, so callers cannot
-- tell whether the address was already on the list.
create or replace function public.subscribe(p_email text, p_source text default '')
returns void
language plpgsql
security definer
set search_path = ''
as $$
declare
  v_email text := lower(btrim(coalesce(p_email, '')));
begin
  if char_length(v_email) not between 3 and 254 or v_email !~ '^[^@[:space:]]+@[^@[:space:]]+\.[^@[:space:]]+$' then
    raise exception 'invalid email' using errcode = '22023';
  end if;

  -- Crude flood guard for a public endpoint: a personal blog never sees 30 sign-ups a minute.
  if (select count(*) from public.subscribers where created_at > now() - interval '1 minute') >= 30 then
    raise exception 'too many sign-ups, try again later' using errcode = '53400';
  end if;

  insert into public.subscribers (email, source)
  values (v_email, left(coalesce(p_source, ''), 120))
  on conflict (email) do update
    set status = 'subscribed', unsubscribed_at = null
    where public.subscribers.status = 'unsubscribed';
end;
$$;

-- Unsubscribe from a link. True when the token exists (already unsubscribed counts as success).
create or replace function public.unsubscribe(p_token uuid)
returns boolean
language plpgsql
security definer
set search_path = ''
as $$
begin
  update public.subscribers
    set status = 'unsubscribed', unsubscribed_at = coalesce(unsubscribed_at, now())
    where unsubscribe_token = p_token;
  return found;
end;
$$;

revoke all on function public.subscribe(text, text) from public;
revoke all on function public.unsubscribe(uuid) from public;
grant execute on function public.subscribe(text, text) to anon, authenticated;
grant execute on function public.unsubscribe(uuid) to anon, authenticated;

Migration này khá dài, nhưng có vài chỗ đáng đọc kỹ. Đầu tiên là revoke all on public.subscribers from anon, authenticated rồi chỉ grant select, update, delete lại cho authenticated. RLS lọc dòng, còn grant quyết định vai trò đó có được chạm vào bảng hay không. Mình dùng cả hai, để nếu một policy lỡ sai thì anon vẫn không có quyền ở lớp dưới. Policy cho tác giả đọc kiểm tra app_metadata.role = 'author', đúng với cách bài về Supabase Auth phân quyền.

Thứ hai là hàm subscribe trả về void trong mọi trường hợp. Dù email mới hay đã có trong danh sách, người gọi nhận cùng một kết quả. Nếu hàm báo "email này đã đăng ký rồi", ai đó sẽ dùng form để dò xem một người cụ thể có trong danh sách hay không. Câu on conflict ... where status = 'unsubscribed' còn làm một việc nhỏ mà hữu ích: người đã hủy rồi muốn đăng ký lại thì được bật lại, còn người đang đăng ký mà gửi lần nữa thì không có gì thay đổi.

Thứ ba là dòng set search_path = ''. Hàm security definer chạy với quyền cao hơn người gọi, nên nếu nó tìm tên bảng theo một đường dẫn mà người gọi chỉnh được thì có thể bị lừa dùng bảng giả. Đặt đường dẫn rỗng và luôn viết public.subscribers đầy đủ là cách tránh chuyện đó, và là lý do mọi tên bảng trong hàm đều có tiền tố public..

Giờ chạy phần hai của chay.ts. Nó nạp đúng migration.sql ở trên rồi thử các thao tác bằng vai trò anon:

chay.ts (phần 2)
// ---------- Cách 2: migration thật của blog ----------
console.log("\n=== Cách 2: migration thật của blog (chỉ gọi hàm subscribe) ===");
{
  const db = await dungMoiTruong();
  await db.exec(readFileSync("migration.sql", "utf8"));
  await db.exec("set role anon");

  console.log("anon select trực tiếp:", await loi(() => db.query("select * from public.subscribers")));
  console.log("anon đăng ký 'An@Example.com ':", await loi(() => db.query("select public.subscribe($1, $2)", ["An@Example.com ", "/bai-viet/lam-blog-ca-nhan-0d"])));
  console.log("anon đăng ký lại 'an@example.com':", await loi(() => db.query("select public.subscribe($1)", ["an@example.com"])));
  console.log("anon đăng ký email sai 'khong-phai-email':", await loi(() => db.query("select public.subscribe($1)", ["khong-phai-email"])));

  await db.exec("reset role");
  const hang = (await db.query("select email, source, status, unsubscribe_token from public.subscribers")).rows as {
    email: string; source: string; status: string; unsubscribe_token: string;
  }[];
  console.log("Tác giả thấy:", hang.map(({ email, source, status }) => ({ email, source, status })));

  await db.exec("set role anon");
  console.log("Hủy đăng ký bằng token:", (await db.query("select public.unsubscribe($1) as ok", [hang[0].unsubscribe_token])).rows);
  await db.exec("reset role");
  console.log("Trạng thái sau khi hủy:", (await db.query("select status, unsubscribed_at is not null as co_gio_huy from public.subscribers")).rows);

  await db.exec("set role anon");
  await db.query("select public.subscribe($1)", ["an@example.com"]);
  await db.exec("reset role");
  console.log("Đăng ký lại sau khi hủy:", (await db.query("select status, unsubscribed_at from public.subscribers")).rows);

  // Chặn tràn: 30 lượt trong một phút là đủ, lượt thứ 31 bị từ chối.
  await db.exec("set role anon");
  let tuChoiLanThu = 0;
  for (let i = 2; i <= 40; i++) {
    const kq = await loi(() => db.query("select public.subscribe($1)", [`nguoi${i}@example.com`]));
    if (kq !== "không lỗi") {
      tuChoiLanThu = i;
      console.log(`Lượt đăng ký thứ ${i} trong một phút:`, kq);
      break;
    }
  }
  await db.exec("reset role");
  console.log("Số dòng trong bảng:", (await db.query("select count(*)::int as n from public.subscribers")).rows, "(lượt bị từ chối:", tuChoiLanThu + ")");
}
node chay.ts (phần còn lại của kết quả)
=== Cách 2: migration thật của blog (chỉ gọi hàm subscribe) ===
anon select trực tiếp: lỗi 42501: permission denied for table subscribers
anon đăng ký 'An@Example.com ': không lỗi
anon đăng ký lại 'an@example.com': không lỗi
anon đăng ký email sai 'khong-phai-email': lỗi 22023: invalid email
Tác giả thấy: [
  {
    email: 'an@example.com',
    source: '/bai-viet/lam-blog-ca-nhan-0d',
    status: 'subscribed'
  }
]
Hủy đăng ký bằng token: [ { ok: true } ]
Trạng thái sau khi hủy: [ { status: 'unsubscribed', co_gio_huy: true } ]
Đăng ký lại sau khi hủy: [ { status: 'subscribed', unsubscribed_at: null } ]
Lượt đăng ký thứ 31 trong một phút: lỗi 53400: too many sign-ups, try again later
Số dòng trong bảng: [ { n: 30 } ] (lượt bị từ chối: 31)

Hãy đọc từng dòng. Vai trò anon đọc thẳng bảng thì bị từ chối với mã 42501, trái với cách đầu tiên. Đăng ký An@Example.com (có chữ hoa và dấu cách thừa) thành công, và bảng lưu an@example.com, vì hàm tự đổi chữ thường và cắt khoảng trắng. Đăng ký lại cùng địa chỉ không báo gì, và tác giả vẫn chỉ thấy một dòng, nên không ai dò được ai đã đăng ký. Email sai dạng bị từ chối với mã 22023. Hủy bằng token hoạt động, và đăng ký lại sau đó đưa trạng thái về subscribed. Cuối cùng, lượt thứ 31 trong một phút bị chặn với mã 53400, và bảng dừng ở 30 dòng.

Một điều mình muốn nói thẳng về chốt chặn 30 lượt mỗi phút: nó thô. Nó đếm toàn bộ lượt đăng ký, không đếm theo người, nên một đoạn code gửi 30 yêu cầu trong một phút sẽ khiến người thật đăng ký trong phút đó bị từ chối. Trong code của blog, chính comment cũng gọi nó là "crude flood guard". Mình chấp nhận vì blog cá nhân không bao giờ có 30 người đăng ký một phút, và khi chuyện đó xảy ra thì kiểu gì cũng cần xem xét. Nếu dự án của bạn đông hơn, bạn nên giới hạn theo địa chỉ IP ở một lớp phía trước.

Form phía trang: ô bẫy robot và thời gian điền

Database đã đủ chắc để không lộ danh sách và không bị nhồi vô hạn, nhưng mình vẫn không muốn nó nhận hàng nghìn email rác mà robot tự điền. Có hai cách rẻ để lọc, cả hai đều chạy trong Server Action của form trước khi gọi database.

Cách thứ nhất là ô bẫy (honeypot): một ô nhập có tên nghe hợp lý, ví dụ website, được giấu khỏi người thật bằng CSS và khỏi người dùng đọc màn hình bằng aria-hidden. Người thật không thấy nên không điền. Robot quét HTML thấy một ô, và thường điền hết mọi ô nó gặp. Cách thứ hai là thời gian: khi form hiện ra, trang ghi lại mốc giờ vào một ô ẩn. Người thật điền email mất vài giây, robot gửi trong vài mili giây, nên lượt gửi nhanh hơn 1,5 giây bị coi là của máy.

Hai quy tắc này nằm trong src/ban-tin.ts, là các hàm thuần để test được. Mình để cả file ở đây:

src/ban-tin.ts
// Quy tắc đăng ký bản tin dùng chung cho form và Server Action. Toàn hàm thuần nên test được.
// Cùng ý với src/lib/newsletter.ts của blog Tech Notes (bản rút gọn, bỏ phần xuất CSV và thống kê).
// Database áp lại đúng quy tắc email này trong hàm subscribe().

export const MAX_EMAIL_LENGTH = 254;
const EMAIL = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;

/** Người điền form mất vài giây, robot mất vài mili giây: nhanh hơn mức này thì bỏ qua. */
export const MIN_FILL_MS = 1500;

export function normalizeEmail(value: string): string {
  return value.trim().toLowerCase();
}

/** Email sai ở đâu, dưới dạng mã thông báo để form tra câu chữ theo ngôn ngữ người đọc. */
export function emailProblem(value: string): "emailMissing" | "emailInvalid" | null {
  const email = normalizeEmail(value);
  if (!email) return "emailMissing";
  if (email.length > MAX_EMAIL_LENGTH || !EMAIL.test(email)) return "emailInvalid";
  return null;
}

/**
 * True nếu lượt gửi trông như của máy: ô ẩn "website" bị điền, hoặc form được gửi nhanh một cách khó tin.
 * Robot vẫn nhận câu trả lời bình thường nên chúng không biết mình bị lọc.
 */
export function looksAutomated({ honeypot, startedAt, now }: { honeypot: string; startedAt: string; now: number }): boolean {
  if (honeypot.trim()) return true;
  const started = Number(startedAt);
  if (!Number.isFinite(started) || started <= 0) return false; // không có mốc giờ từ JavaScript thì không phạt người dùng
  const elapsed = now - started;
  return elapsed >= 0 && elapsed < MIN_FILL_MS;
}

/** Nơi đăng ký xảy ra (một đường dẫn trên site), lưu lại để biết trang nào kéo được người đăng ký. */
export function signupSource(value: string): string {
  return /^\/[\w\-/]*$/.test(value) ? value.slice(0, 120) : "";
}

Điều mình thích nhất ở looksAutomated là hai dòng chú thích. Robot vẫn nhận câu trả lời bình thường, vì nếu server báo "bạn là robot" thì kẻ viết robot biết ngay phải sửa gì. Và nếu lượt gửi không có mốc giờ nào (người dùng tắt JavaScript chẳng hạn) thì mình không phạt, vì chặn nhầm một người thật tệ hơn để lọt một robot. Để thấy các quy tắc này quyết định ra sao, thu-robot.ts đưa vào năm lượt gửi giả với mốc giờ cố định:

thu-robot.ts
// Năm lượt gửi form giả, để xem bộ lọc robot (ô ẩn "website" và thời gian điền) quyết định thế nào.
// Chạy: node thu-robot.ts
import { emailProblem, looksAutomated, signupSource } from "./src/ban-tin.ts";

const BAY_GIO = 1_700_000_000_000; // một mốc thời gian cố định để kết quả lặp lại được

const CAC_LUOT: { ten: string; email: string; website: string; started: string; nguon: string }[] = [
  { ten: "người thật, điền sau 8 giây", email: "an@example.com", website: "", started: String(BAY_GIO - 8000), nguon: "/bai-viet/lam-blog-ca-nhan-0d" },
  { ten: "robot điền ô ẩn", email: "spam@example.com", website: "http://quang-cao.example", started: String(BAY_GIO - 8000), nguon: "/" },
  { ten: "robot gửi sau 40 ms", email: "spam2@example.com", website: "", started: String(BAY_GIO - 40), nguon: "/" },
  { ten: "người bật chặn JavaScript (không có mốc giờ)", email: "binh@example.com", website: "", started: "", nguon: "/lo-trinh" },
  { ten: "email thiếu tên miền", email: "chi@", website: "", started: String(BAY_GIO - 8000), nguon: "/" },
];

for (const luot of CAC_LUOT) {
  const loiEmail = emailProblem(luot.email);
  const may = looksAutomated({ honeypot: luot.website, startedAt: luot.started, now: BAY_GIO });
  const ketQua = loiEmail ? `báo lỗi cho người dùng: ${loiEmail}` : may ? "nhận như bình thường nhưng KHÔNG lưu" : "lưu vào database";
  console.log(`${luot.ten.padEnd(46)} -> ${ketQua}  (nguồn: ${JSON.stringify(signupSource(luot.nguon))})`);
}
console.log("\nNguồn lạ bị bỏ:", JSON.stringify(signupSource("https://kẻ-xấu.example/?x=<script>")));
node thu-robot.ts
người thật, điền sau 8 giây                    -> lưu vào database  (nguồn: "/bai-viet/lam-blog-ca-nhan-0d")
robot điền ô ẩn                                -> nhận như bình thường nhưng KHÔNG lưu  (nguồn: "/")
robot gửi sau 40 ms                            -> nhận như bình thường nhưng KHÔNG lưu  (nguồn: "/")
người bật chặn JavaScript (không có mốc giờ)   -> lưu vào database  (nguồn: "/lo-trinh")
email thiếu tên miền                           -> báo lỗi cho người dùng: emailInvalid  (nguồn: "/")

Nguồn lạ bị bỏ: ""

Hai cách lọc này chỉ chặn được robot đơn giản. Một chương trình được viết riêng cho blog của bạn sẽ bỏ qua ô ẩn và chờ đủ hai giây rồi mới gửi. Mình xem chúng là lớp đầu tiên, rẻ và không làm phiền người dùng, và hai lớp còn lại là chốt chặn trong database ở trên và chính ràng buộc check của bảng. Nếu bạn gặp spam thật, bước tiếp theo thường là CAPTCHA hoặc xác nhận qua email. Mình chưa thêm vào blog vì danh sách hiện chưa bị tấn công.

Phần ráp lại nằm ở Server Action. Đây là code thật của blog (src/app/[lang]/(site)/newsletter-actions.ts), mình bỏ phần hủy đăng ký cho gọn. Nó chạy emailProblem trước để báo lỗi cho người dùng, rồi looksAutomated để lọc robot, rồi mới gọi hàm subscribe bằng vai trò công khai:

src/app/[lang]/(site)/newsletter-actions.ts (rút từ blog; chưa chạy được ngoài repo của blog)
/** Public sign-up. Runs as the anon role through public.subscribe(), which never reveals the list. */
export async function subscribeToNewsletter(_previous: SubscribeState, formData: FormData): Promise<SubscribeState> {
  const email = text(formData, "email");
  const problem = emailProblem(email);
  if (problem) return { status: "error", code: problem };

  // Bots get the same reply as people, so they cannot tell they were filtered.
  if (looksAutomated({ honeypot: text(formData, "website"), startedAt: text(formData, "started"), now: Date.now() })) return DONE;

  const env = getSupabaseEnv();
  if (!env) return { status: "error", code: "disabled" };

  const { error } = await createPublicClient(env).rpc("subscribe", {
    p_email: normalizeEmail(email),
    p_source: signupSource(text(formData, "source")),
  });
  if (error) {
    if (error.code === "22023") return { status: "error", code: "emailInvalid" };
    if (error.code === "53400") return { status: "error", code: "busy" };
    return { status: "error", code: "subscribeFailed" };
  }
  return DONE;
}

Dòng .rpc("subscribe", ...) gọi chính hàm SQL ở trên, và hai mã lỗi 22023, 53400 mà bạn thấy ở phần trước được dịch thành thông báo cho người đọc. Server Action không biết trang đang hiện ngôn ngữ nào, nên nó trả về một mã (emailInvalid, busy...) và form tra câu chữ trong từ điển của mình. Đây là một chi tiết của blog có hai ngôn ngữ, và bạn có thể trả thẳng một câu chữ nếu chỉ làm một ngôn ngữ.

Form phía trang là một Client Component dùng useActionState. Phần quan trọng của nó chỉ có hai đoạn: ô bẫy và mốc giờ. Mình rút đúng hai đoạn đó từ file src/components/newsletter-form.tsx của blog:

src/components/newsletter-form.tsx (rút từ blog, chưa chạy ngoài repo của blog)
// Khi form bắt đầu dùng được, ghi mốc giờ; lượt gửi quá nhanh bị coi là robot.
useEffect(() => {
  if (startedRef.current) startedRef.current.value = String(Date.now());
}, []);

// ...

<input defaultValue="" name="started" ref={startedRef} type="hidden" />
{/* Người thật để trống (ẩn khỏi họ và khỏi trình đọc màn hình); robot hay điền. */}
<div aria-hidden="true" className="newsletter-trap">
  <label>
    Website
    <input autoComplete="off" name="website" tabIndex={-1} type="text" />
  </label>
</div>

Hai thuộc tính tabIndex={-1} và autoComplete="off" có lý do của chúng. Người dùng bàn phím bấm Tab sẽ không nhảy vào ô bẫy, và trình duyệt không tự điền địa chỉ website của họ vào đó, nếu không chính người thật sẽ bị chặn. (Mình chép comment trong code theo ý nghĩa, còn code gốc của blog ghi bằng tiếng Anh.) Lớp CSS newsletter-trap của blog chịu trách nhiệm đưa ô ra khỏi tầm nhìn của người thật.

Còn hủy đăng ký và quyền riêng tư thì sao?

Người đăng ký phải rời đi được, và rời đi không cần đăng nhập. Mỗi dòng trong bảng có một unsubscribe_token, là một UUID ngẫu nhiên. Email gửi đi sau này sẽ mang đường dẫn kiểu /huy-dang-ky?token=..., và trang đó gọi hàm unsubscribe() với token. Token dài và ngẫu nhiên, nên không ai đoán được token của người khác, và hàm trả true ngay cả khi người đó đã hủy rồi, để người bấm hai lần không thấy lỗi.

Có một quyết định mình muốn nói rõ: blog đang dùng đăng ký một bước (single opt-in). Nghĩa là ai gõ email vào form là vào danh sách ngay, mà không phải bấm vào một link xác nhận trong thư. Nhiều hướng dẫn khuyên xác nhận hai bước, vì nó đảm bảo địa chỉ thật sự là của người đăng ký và lọc bớt robot, nhưng nó cần gửi thư, mà blog này chưa gửi email nào. Khi mình bắt đầu gửi bản tin, đây là chỗ phải làm lại. Khi làm, mình sẽ vẫn giữ ô bẫy và giới hạn tần suất đi kèm, vì xác nhận hai bước không phải thuốc chữa mọi chuyện.

Trên trang đăng ký, blog có một câu nói rõ email dùng để làm gì, và chính sách riêng tư của blog nằm ở trang chính sách riêng tư. Luật bảo vệ dữ liệu ở mỗi nơi khác nhau, và mình không phải luật sư, nên bạn đọc quy định ở nơi người đọc của bạn sống trước khi thu email. Về phía mình, mình chỉ thu địa chỉ email, nơi người đó đăng ký và thời điểm đăng ký. Không thu tên, không thu IP.

Khi cần gửi thư, tác giả xuất danh sách ra file CSV trong trang quản trị. Hàm subscribersCsv của blog chỉ lấy người còn đăng ký, mỗi người một dòng gồm email, thời điểm đăng ký và nơi đăng ký, để đưa vào bất kỳ công cụ gửi thư nào (Resend, Mailchimp hay công cụ khác). Vì vậy bạn không bị trói vào một dịch vụ: dữ liệu nằm trong database của chính bạn.

Giữ cho nó không hỏng bằng test

Một form đăng ký hỏng âm thầm là một chuyện khó thấy: không ai báo lỗi, danh sách chỉ không lớn lên. Mình có 12 test cho phần này, và các test về database chạy migration thật trên PGlite chứ không giả lập. Chúng kiểm các điều bài này đã nói: anon không đọc được bảng, đăng ký lại không lỗi và không thêm dòng, email sai bị từ chối với 22023, hủy rồi đăng ký lại thì thành subscribed, token lạ thì unsubscribe trả false, lượt thứ 31 bị chặn với 53400, ô bẫy và ngưỡng 1,5 giây của looksAutomated, và signupSource chỉ nhận đường dẫn trong site. Bạn chạy bằng node --test src/ban-tin.test.ts (file test nằm trong repo demo, bài này mình không dán).

node --test src/ban-tin.test.ts (phần tổng kết)
# tests 12
# pass 12
# fail 0

Còn giới hạn của bài thì mình nói thẳng. Một, PGlite chạy Postgres thật nhưng không phải Supabase, nên những thứ như cách Supabase gắn token vào auth.jwt() mình dựng lại bằng một hàm giả trả về {}. Điều đó đủ để chạy migration và kiểm quyền của anon, nhưng chưa kiểm được policy của tác giả với một token thật. Hai, form React và Server Action là code thật của blog, và mình chỉ trích chúng ra đây, chưa chạy chúng trong demo này vì chúng cần cả Next.js lẫn một dự án Supabase. Ba, hai lớp lọc robot chỉ chặn robot đơn giản, như đã nói.

Có người đăng ký rồi, và mình lại sợ sửa code

Blog giờ có chỗ để người đọc ở lại. Mỗi lần mình thêm một tính năng như thế này, code của blog dày hơn một chút, và mình bắt đầu thấy lo mỗi khi sửa. Sửa hàm kiểm tra email có làm hỏng form hủy đăng ký không? Đổi một dòng trong migration có làm tác giả mất quyền đọc danh sách không? Làm sao biết một thay đổi không phá chỗ khác trước khi nó lên trang thật là việc của các bài viết sau.

Bạn theo dõi cả hành trình ở Xây blog với Next.js và Supabase. Bài Row Level Security trong Supabase giải thích vì sao bảng này khóa quyền như vậy, và các câu hỏi về web nằm trong ngân hàng câu hỏi phỏng vấn. Tài liệu về các lớp quyền của Postgres nằm ở trang Row Security Policies của PostgreSQL.

Nhận bài tiếp theo qua email.

Một email mỗi tuần, chỉ khi có điều đáng đọc. Không spam.