@goplusvn/core 0.1.57 → 0.1.59

package/src/branch-scope/scope.ts

@@ -0,0 +1,149 @@
+import {
+  NO_BRANCH_ACCESS,
+  type BranchScope,
+  type BranchScopeConfig,
+} from "./types";
+
+/**
+ * LỚP 1 — lọc tường minh. Page/route/service gọi `getBranchScope(session)` rồi
+ * nhét `scopedBranchWhere(scope)` vào `where`. Lớp 2 (branch-guard extension)
+ * là lưới an toàn cho chỗ quên, KHÔNG phải thay thế lớp này: guard chỉ chạm các
+ * model được khai và chỉ trong request đi qua apiHandler.
+ */
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+let configured: BranchScopeConfig<any> | null = null;
+
+export function configureBranchScope<TSession>(
+  config: BranchScopeConfig<TSession>,
+): void {
+  configured = config;
+}
+
+function requireConfigured() {
+  if (!configured) {
+    throw new Error(
+      "[branch-scope] chưa configureBranchScope(...) — gọi một lần ở composition root (src/lib/branch-scope.ts) rồi import phạm vi qua đúng file đó.",
+    );
+  }
+  return configured;
+}
+
+export function canViewAllBranches<TSession>(session: TSession): boolean {
+  return requireConfigured().canViewAll(session);
+}
+
+/**
+ * Phạm vi chi nhánh của user. Chưa được gán chi nhánh nào → sentinel, tức thấy
+ * 0 dòng — KHÔNG phải "thấy tất": mặc định an toàn là không thấy gì.
+ */
+export async function getBranchScope<TSession>(
+  session: TSession,
+): Promise<BranchScope> {
+  const config = requireConfigured();
+  if (config.canViewAll(session)) return { canViewAll: true };
+
+  const branchIds = await readAllowedBranchIds(config, session);
+
+  return {
+    canViewAll: false,
+    allowedBranchIds: branchIds.length > 0 ? branchIds : [NO_BRANCH_ACCESS],
+  };
+}
+
+async function readAllowedBranchIds<TSession>(
+  config: BranchScopeConfig<TSession>,
+  session: TSession,
+): Promise<string[]> {
+  if (config.getAllowedBranchIds) {
+    const ids = await config.getAllowedBranchIds(session);
+    return (ids ?? []).filter((id): id is string => Boolean(id));
+  }
+
+  const userId = config.getUserId(session);
+  if (!userId) return [];
+
+  if (!config.db) {
+    throw new Error(
+      "[branch-scope] configureBranchScope cần `db` (hoặc `getAllowedBranchIds`) để biết user thuộc chi nhánh nào.",
+    );
+  }
+  const rows = await config.db.userBranch.findMany({
+    where: { userId },
+    select: { branchId: true },
+  });
+  return rows
+    .map((row) => (row as { branchId?: string | null }).branchId)
+    .filter((id): id is string => Boolean(id));
+}
+
+/**
+ * Guard trang chi tiết: user có được xem bản ghi thuộc chi nhánh này không?
+ * Bản ghi không gắn chi nhánh (null — dữ liệu cũ hoặc dùng chung) thì ai vào
+ * được trang đều xem được.
+ */
+export function canAccessBranch(
+  scope: BranchScope,
+  branchId: string | null | undefined,
+): boolean {
+  if (scope.canViewAll) return true;
+  if (!branchId) return true;
+  return scope.allowedBranchIds!.includes(branchId);
+}
+
+/**
+ * Fragment `where` cho model có cột branchId: thuộc CN được phép HOẶC chưa gắn
+ * CN. `{}` khi xem được tất — nhét thẳng vào where là xong, không cần rẽ nhánh.
+ *
+ * `field` cho model scope qua quan hệ, ví dụ kho: `scopedBranchWhere(scope,
+ * "warehouse")` → `{ OR: [{ warehouse: { branchId: { in } } }, { warehouse: {
+ * branchId: null } }] }`.
+ */
+export function scopedBranchWhere(
+  scope: BranchScope,
+  relation?: string,
+): Record<string, unknown> {
+  if (scope.canViewAll) return {};
+  const ids = scope.allowedBranchIds!;
+  const inClause = { branchId: { in: ids } };
+  const nullClause = { branchId: null };
+  return relation
+    ? { OR: [{ [relation]: inClause }, { [relation]: nullClause }] }
+    : { OR: [inClause, nullClause] };
+}
+
+/**
+ * Kẹp bộ lọc chi nhánh client gửi lên vào trong phạm vi được phép. `undefined`
+ * = client không lọc gì (phạm vi đã do allowedBranchIds lo). Chọn toàn CN ngoài
+ * phạm vi → sentinel: thấy 0 dòng, chứ KHÔNG rơi về "không lọc".
+ */
+export function clampBranchFilter(
+  requested: string[] | string | null | undefined,
+  scope: BranchScope,
+): string[] | undefined {
+  const ids = normalizeIds(requested);
+  if (ids.length === 0) return undefined;
+  if (scope.canViewAll) return ids;
+  const valid = ids.filter((id) => scope.allowedBranchIds!.includes(id));
+  return valid.length > 0 ? valid : [NO_BRANCH_ACCESS];
+}
+
+/**
+ * Kẹp danh sách id client chọn vào danh sách được phép — dùng cho thực thể đi
+ * theo chi nhánh (kho, quầy, điểm bán). Ngoài danh sách → sentinel.
+ */
+export function clampIdFilter(
+  requested: string[] | string | null | undefined,
+  allowedIds: string[],
+): string[] {
+  const valid = normalizeIds(requested).filter((id) => allowedIds.includes(id));
+  return valid.length > 0 ? valid : [NO_BRANCH_ACCESS];
+}
+
+function normalizeIds(
+  requested: string[] | string | null | undefined,
+): string[] {
+  return (Array.isArray(requested) ? requested : [requested]).filter(
+    (id): id is string => Boolean(id && id.trim()),
+  );
+}

package/src/branch-scope/types.ts

@@ -0,0 +1,57 @@
+/**
+ * Phạm vi dữ liệu theo chi nhánh — hợp đồng chung.
+ *
+ * Bài toán: app nhiều chi nhánh thì "danh sách phiếu thu" của kế toán CN A phải
+ * KHÁC của CN B, còn giám đốc thì thấy tất. Lọc bằng tay ở từng route là cách
+ * chắc chắn sẽ rò: chỉ cần một route mới quên `where branchId`.
+ */
+
+/**
+ * Sentinel cho "user chưa được gán chi nhánh nào" và "client lọc toàn chi nhánh
+ * ngoài phạm vi". Là một chuỗi KHÔNG BAO GIỜ khớp branchId thật, nên
+ * `branchId: { in: [NO_BRANCH_ACCESS] }` trả 0 dòng. Không dùng mảng rỗng: Prisma
+ * hiểu `in: []` là "không có gì khớp" ở vài chỗ nhưng `undefined`/bỏ mệnh đề ở
+ * chỗ khác — nhầm một lần là lộ toàn bộ dữ liệu.
+ */
+export const NO_BRANCH_ACCESS = "__NO_ACCESS__";
+
+export interface BranchScope {
+  canViewAll: boolean;
+  /** undefined khi canViewAll — ngược lại LUÔN ≥1 phần tử (sentinel nếu user chưa gán CN). */
+  allowedBranchIds?: string[];
+}
+
+/** Chỉ cần đúng phần delegate `user_branches` mà scope dùng tới. */
+export interface BranchScopeDb {
+  userBranch: {
+    findMany: (args: {
+      where: { userId: string };
+      select: { branchId: true };
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }) => Promise<any[]>;
+  };
+}
+
+export interface BranchScopeConfig<TSession = unknown> {
+  /**
+   * Nguồn mặc định của phạm vi: bảng `user_branches`. Bỏ trống được NẾU đã khai
+   * `getAllowedBranchIds`.
+   */
+  db?: BranchScopeDb;
+  /**
+   * Session đã mang sẵn danh sách chi nhánh (app nhồi vào lúc đăng nhập) thì
+   * khai ở đây — khỏi phải truy vấn user_branches mỗi lần cần phạm vi. Trả mảng
+   * rỗng/null = user chưa được gán chi nhánh nào (→ sentinel, thấy 0 dòng).
+   */
+  getAllowedBranchIds?: (
+    session: TSession,
+  ) => string[] | null | undefined | Promise<string[] | null | undefined>;
+  /** Lấy id user từ session của app. */
+  getUserId: (session: TSession) => string | null | undefined;
+  /**
+   * "Xem mọi chi nhánh" — app tự quyết: vai trò quản trị, hoặc quyền
+   * `view-all-branches` trên resource nào đó. Trả true thì scope bỏ qua luôn
+   * truy vấn user_branches.
+   */
+  canViewAll: (session: TSession) => boolean;
+}

package/src/storage/__tests__/keys.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  InvalidStorageKeyError,
+  assertSafeKey,
+  contentTypeFor,
+  fileExtension,
+  isSafeKey,
+  safeFileName,
+} from "../keys";
+
+describe("assertSafeKey", () => {
+  // Key đến từ URL `/api/files/<key>` — người dùng điều khiển hoàn toàn.
+  it.each([
+    "../../etc/passwd",
+    "uploads/../../secret.pdf",
+    "/etc/passwd",
+    "uploads\\win.pdf",
+    "uploads/a\0b.pdf",
+    "",
+  ])("từ chối %j", (key) => {
+    expect(() => assertSafeKey(key)).toThrow(InvalidStorageKeyError);
+    expect(isSafeKey(key)).toBe(false);
+  });
+
+  it("cho qua key thường", () => {
+    expect(assertSafeKey("uploads/20260801/hoa_don_123.pdf")).toBe(
+      "uploads/20260801/hoa_don_123.pdf",
+    );
+  });
+});
+
+describe("safeFileName", () => {
+  it("giữ dấu tiếng Việt", () => {
+    expect(safeFileName("Hợp đồng số 12.pdf")).toBe("Hợp_đồng_số_12.pdf");
+  });
+
+  it("bỏ đường dẫn đính kèm trong tên", () => {
+    expect(safeFileName("../../evil.png")).toBe("evil.png");
+    expect(safeFileName("C:\\Users\\a\\b.png")).toBe("b.png");
+  });
+
+  it("hạ chữ thường phần mở rộng", () => {
+    expect(safeFileName("BAO_CAO.XLSX")).toBe("BAO_CAO.xlsx");
+  });
+
+  it("tên rỗng vẫn ra tên dùng được", () => {
+    expect(safeFileName("")).toBe("file");
+  });
+});
+
+describe("fileExtension / contentTypeFor", () => {
+  it("lấy đuôi ở phần tên cuối, không phải ở thư mục", () => {
+    expect(fileExtension("a.pdf/b")).toBe("");
+    expect(fileExtension("uploads/2026/bao-cao.XLSX")).toBe("xlsx");
+  });
+
+  it("đuôi lạ trả undefined để nơi gọi tự quyết", () => {
+    expect(contentTypeFor("a.exe")).toBeUndefined();
+    expect(contentTypeFor("a.pdf")).toBe("application/pdf");
+  });
+});

package/src/storage/__tests__/no-aws-in-barrel.test.ts

@@ -0,0 +1,45 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+/**
+ * Ratchet: `@goerp/core/storage` phải chạy được khi app KHÔNG cài aws-sdk.
+ *
+ * Bẫy đã trả giá một lần ở proxy-gate: bundler phân giải TĨNH cả
+ * `await import()`, nên chỉ cần một dòng import gói không cài trong nhánh chết
+ * là app gãy build bằng "Module not found". Driver S3 phải ở `storage/s3/`
+ * (subpath riêng), tuyệt đối không rò vào barrel.
+ */
+
+// Đọc theo cwd: môi trường test là jsdom nên import.meta.url là URL http,
+// fileURLToPath sẽ ném "URL must be of scheme file".
+const STORAGE_DIR = resolve(process.cwd(), "src/storage");
+
+function filesInBarrel(dir: string, acc: string[] = []): string[] {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    // `s3/` là nơi ĐƯỢC PHÉP dùng aws-sdk; __tests__ không vào bundle app.
+    if (entry.isDirectory()) {
+      if (entry.name === "s3" || entry.name === "__tests__") continue;
+      filesInBarrel(join(dir, entry.name), acc);
+      continue;
+    }
+    if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+      acc.push(join(dir, entry.name));
+    }
+  }
+  return acc;
+}
+
+describe("barrel storage không kéo theo aws-sdk", () => {
+  it("không file nào ngoài storage/s3 nhắc tới @aws-sdk/@smithy", () => {
+    const offenders = filesInBarrel(STORAGE_DIR).filter((file) => {
+      const source = readFileSync(file, "utf8")
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/^\s*\/\/.*$/gm, "");
+      return /["'](@aws-sdk|@smithy)\//.test(source);
+    });
+
+    expect(offenders).toEqual([]);
+  });
+});

package/src/storage/__tests__/storage-service.test.ts

@@ -0,0 +1,312 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { createFileProxyHandler } from "../file-proxy";
+import {
+  clearStorageCache,
+  configureStorage,
+  deleteFile,
+  getFile,
+  getPresignedUrl,
+  getPublicUrl,
+  isRemoteStorageEnabled,
+  listObjects,
+  putFile,
+} from "../storage-service";
+import { createUploadHandler } from "../upload-handler";
+import { StorageNotFoundError, type StorageDriver } from "../types";
+
+/** DB giả: trả đúng các dòng system_configs mà engine hỏi. */
+function fakeDb(rows: Record<string, string> = {}) {
+  return {
+    systemConfig: {
+      findMany: vi.fn(async () =>
+        Object.entries(rows).map(([key, value]) => ({ key, value })),
+      ),
+    },
+  };
+}
+
+let dir: string;
+
+beforeEach(async () => {
+  dir = await mkdtemp(join(tmpdir(), "goerp-storage-"));
+});
+
+afterEach(async () => {
+  await rm(dir, { recursive: true, force: true });
+});
+
+describe("chế độ local (mặc định)", () => {
+  beforeEach(() => {
+    configureStorage({ db: fakeDb(), localDir: dir });
+  });
+
+  it("không có driver thì không hỏi DB làm gì", async () => {
+    const db = fakeDb({ STORAGE_TYPE: "s3" });
+    configureStorage({ db, localDir: dir });
+
+    expect(await isRemoteStorageEnabled()).toBe(false);
+    expect(db.systemConfig.findMany).not.toHaveBeenCalled();
+  });
+
+  it("ghi rồi đọc lại", async () => {
+    await putFile("uploads/2026/a.txt", Buffer.from("xin chào"), "text/plain");
+    expect((await getFile("uploads/2026/a.txt")).toString()).toBe("xin chào");
+  });
+
+  it("thiếu key → StorageNotFoundError (nơi gọi dịch thành 404)", async () => {
+    await expect(getFile("uploads/khong-co.pdf")).rejects.toBeInstanceOf(
+      StorageNotFoundError,
+    );
+  });
+
+  it("xoá là idempotent", async () => {
+    await putFile("a.txt", Buffer.from("x"), "text/plain");
+    await deleteFile("a.txt");
+    await expect(deleteFile("a.txt")).resolves.toBeUndefined();
+  });
+
+  it("liệt kê theo tiền tố", async () => {
+    await putFile("uploads/a.txt", Buffer.from("1"), "text/plain");
+    await putFile("uploads/sub/b.txt", Buffer.from("22"), "text/plain");
+    await putFile("khac/c.txt", Buffer.from("333"), "text/plain");
+
+    const keys = (await listObjects("uploads/")).map((o) => o.key).sort();
+    expect(keys).toEqual(["uploads/a.txt", "uploads/sub/b.txt"]);
+  });
+
+  it("không ký được URL → null để nơi gọi rơi về proxy", async () => {
+    expect(await getPresignedUrl("a.txt")).toBeNull();
+    expect(await getPublicUrl("uploads/a.txt")).toBe("/api/files/uploads/a.txt");
+  });
+
+  it("chặn traversal trước khi chạm đĩa", async () => {
+    await expect(getFile("../../../etc/passwd")).rejects.toThrow(
+      /Key không hợp lệ/,
+    );
+  });
+});
+
+describe("chế độ từ xa", () => {
+  const driver = (): StorageDriver => ({
+    put: vi.fn(async () => undefined),
+    get: vi.fn(async () => Buffer.from("từ s3")),
+    remove: vi.fn(async () => undefined),
+    presign: vi.fn(async () => "https://cdn.example/signed"),
+    list: vi.fn(async () => []),
+  });
+
+  it("STORAGE_TYPE=s3 + có driver → dùng driver", async () => {
+    const d = driver();
+    configureStorage({
+      db: fakeDb({
+        STORAGE_TYPE: '"s3"', // giá trị trong DB là JSON string
+        S3_ENDPOINT: '"http://minio:9000"',
+        S3_BUCKET: '"erp"',
+        S3_ACCESS_KEY: '"ak"',
+        S3_SECRET_KEY: '"sk"',
+      }),
+      driver: d,
+      localDir: dir,
+    });
+
+    expect(await isRemoteStorageEnabled()).toBe(true);
+    expect((await getFile("a.txt")).toString()).toBe("từ s3");
+    expect(await getPresignedUrl("a.txt")).toBe("https://cdn.example/signed");
+    expect(await getPublicUrl("a.txt")).toBe("http://minio:9000/erp/a.txt");
+  });
+
+  it("thiếu trường bắt buộc → cảnh báo rồi rơi về local, không sập request", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    configureStorage({
+      db: fakeDb({ STORAGE_TYPE: "s3", S3_ENDPOINT: "http://minio:9000" }),
+      driver: driver(),
+      localDir: dir,
+    });
+
+    expect(await isRemoteStorageEnabled()).toBe(false);
+    await putFile("a.txt", Buffer.from("local"), "text/plain");
+    expect((await getFile("a.txt")).toString()).toBe("local");
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it("requireRemote: mất cấu hình thì THROW chứ không âm thầm ghi đĩa container", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    configureStorage({
+      db: fakeDb({ STORAGE_TYPE: "local" }),
+      driver: driver(),
+      localDir: dir,
+      requireRemote: true,
+    });
+
+    await expect(putFile("a.txt", Buffer.from("x"), "text/plain")).rejects.toThrow(
+      /requireRemote/,
+    );
+    await expect(getFile("a.txt")).rejects.toThrow(/requireRemote/);
+    await expect(listObjects("")).rejects.toThrow(/requireRemote/);
+    warn.mockRestore();
+  });
+
+  it("clearCache() buộc đọc lại cấu hình", async () => {
+    const db = fakeDb({
+      STORAGE_TYPE: "s3",
+      S3_ENDPOINT: "http://minio:9000",
+      S3_BUCKET: "erp",
+      S3_ACCESS_KEY: "ak",
+      S3_SECRET_KEY: "sk",
+    });
+    configureStorage({ db, driver: driver(), localDir: dir });
+
+    await isRemoteStorageEnabled();
+    await isRemoteStorageEnabled();
+    expect(db.systemConfig.findMany).toHaveBeenCalledTimes(1);
+
+    clearStorageCache();
+    await isRemoteStorageEnabled();
+    expect(db.systemConfig.findMany).toHaveBeenCalledTimes(2);
+  });
+});
+
+describe("createFileProxyHandler", () => {
+  const req = () => new Request("http://x/api/files/a.pdf") as never;
+  const ctx = (key: string, session?: unknown) => ({
+    params: Promise.resolve({ key: key.split("/") }),
+    session,
+  });
+
+  beforeEach(async () => {
+    configureStorage({ db: fakeDb(), localDir: dir });
+    await putFile("uploads/bao cao.pdf", Buffer.from("%PDF"), "application/pdf");
+    await putFile("uploads/data.csv", Buffer.from("a,b"), "text/csv");
+  });
+
+  it("trả tập tin, pdf mở inline", async () => {
+    const res = await createFileProxyHandler()(req(), ctx("uploads/bao cao.pdf"));
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get("Content-Type")).toBe("application/pdf");
+    expect(res.headers.get("Content-Disposition")).toBe(
+      'inline; filename="bao%20cao.pdf"',
+    );
+    expect(res.headers.get("Cache-Control")).toBe("private, max-age=3600");
+  });
+
+  it("loại không xem được thì tải về", async () => {
+    const res = await createFileProxyHandler()(req(), ctx("uploads/data.csv"));
+    expect(res.headers.get("Content-Disposition")).toMatch(/^attachment;/);
+  });
+
+  it("authorize=false → 403 và KHÔNG đọc kho", async () => {
+    const res = await createFileProxyHandler({ authorize: () => false })(
+      req(),
+      ctx("uploads/bao cao.pdf"),
+    );
+    expect(res.status).toBe(403);
+  });
+
+  it("authorize trả mã riêng → dùng mã đó (404 để giấu sự tồn tại)", async () => {
+    const res = await createFileProxyHandler({
+      authorize: () => ({ status: 404, message: "Not found" }),
+    })(req(), ctx("uploads/bao cao.pdf"));
+    expect(res.status).toBe(404);
+  });
+
+  it("seam authorize nhận đúng key và session", async () => {
+    const authorize = vi.fn(() => true);
+    await createFileProxyHandler({ authorize })(
+      req(),
+      ctx("uploads/bao cao.pdf", { userId: "u1" }),
+    );
+    expect(authorize).toHaveBeenCalledWith(
+      expect.objectContaining({
+        key: "uploads/bao cao.pdf",
+        session: { userId: "u1" },
+      }),
+    );
+  });
+
+  it("key bẩn bị chặn TRƯỚC authorize (seam app hay lấy key đi tra DB)", async () => {
+    const authorize = vi.fn(() => true);
+    const res = await createFileProxyHandler({ authorize })(
+      req(),
+      ctx("../../etc/passwd"),
+    );
+    expect(res.status).toBe(400);
+    expect(authorize).not.toHaveBeenCalled();
+  });
+
+  it("traversal → 400, thiếu key → 400, không có tập tin → 404", async () => {
+    const handler = createFileProxyHandler();
+    expect((await handler(req(), ctx("../../etc/passwd"))).status).toBe(400);
+    expect((await handler(req(), { params: Promise.resolve({}) })).status).toBe(
+      400,
+    );
+    expect((await handler(req(), ctx("uploads/thieu.pdf"))).status).toBe(404);
+  });
+
+  it("rejectUnknownType chặn loại ngoài bảng (route công khai)", async () => {
+    const res = await createFileProxyHandler({
+      contentTypes: { png: "image/png" },
+      rejectUnknownType: true,
+    })(req(), ctx("uploads/bao cao.pdf"));
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("createUploadHandler", () => {
+  beforeEach(() => {
+    configureStorage({ db: fakeDb(), localDir: dir });
+  });
+
+  // Dựng request giả thay vì `new Request(body: FormData)`: môi trường test là
+  // jsdom nên File là của jsdom, còn Request.formData() lại do undici phân tích
+  // — undici không nhận File lạ và ném AssertionError trước khi vào handler.
+  const fakeFile = (name: string, content: string, type: string) => ({
+    name,
+    type,
+    size: Buffer.byteLength(content),
+    arrayBuffer: async () => Buffer.from(content),
+  });
+
+  const post = (file: unknown) =>
+    ({
+      formData: async () => ({ get: (key: string) => (key === "file" ? file : null) }),
+    }) as never;
+
+  it("lưu được và trả URL proxy — KHÔNG phải đường dẫn public", async () => {
+    const res = await createUploadHandler()(
+      post(fakeFile("Hợp đồng.pdf", "nội dung", "application/pdf")),
+    );
+    const body = (await res.json()) as { url: string; key: string };
+
+    expect(res.status).toBe(200);
+    expect(body.url).toMatch(
+      /^\/api\/files\/uploads\/\d{8}\/Hợp_đồng_\d+\.pdf$/,
+    );
+    expect((await getFile(body.key)).toString()).toBe("nội dung");
+  });
+
+  it("chặn đuôi không cho phép", async () => {
+    const res = await createUploadHandler()(
+      post(fakeFile("virus.exe", "MZ", "application/octet-stream")),
+    );
+    expect(res.status).toBe(415);
+  });
+
+  it("chặn tập tin quá lớn", async () => {
+    const res = await createUploadHandler({ maxBytes: 4 })(
+      post(fakeFile("a.txt", "quá dài", "text/plain")),
+    );
+    expect(res.status).toBe(413);
+  });
+
+  it("không có tập tin → 400", async () => {
+    const res = await createUploadHandler()(post(null));
+    expect(res.status).toBe(400);
+  });
+});