@goplusvn/core 0.1.75 → 0.1.76

package/src/workspace/__tests__/workspace-route-handlers.test.ts

@@ -0,0 +1,414 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Kiểm tra tầng CƯỠNG CHẾ, không phải tầng hiển thị.
+//
+// Trang cây đã ẩn nút ở nhánh ngoài phạm vi, nhưng ẩn nút không phải hàng rào.
+// Mọi ca ở đây gọi thẳng handler như một client tự chế: không đi qua UI, không
+// tin gì từ client. Sai ở đây là rò dữ liệu chéo khách hàng một cách IM LẶNG —
+// không ném lỗi, không log, chỉ là ai đó thấy thứ không được thấy.
+
+import { beforeEach, describe, expect, it } from "vitest";
+
+import {
+  createWorkspaceCollectionHandlers,
+  createWorkspaceItemHandlers,
+  createWorkspaceMoveHandler,
+} from "../route-handlers";
+import { configureWorkspaces, resetWorkspaceConfig } from "../scope";
+import { subtreePrefix } from "../tree";
+
+// Singleton cấu hình — reset trước mọi ca để một test không thừa hưởng cây của
+// test trước (hook cấp gốc chạy trước hook trong `describe`).
+beforeEach(() => {
+  resetWorkspaceConfig();
+});
+
+/**
+ * Cây mẫu theo đúng bài toán spartronics:
+ *
+ *   grp                  (tập đoàn — chỉ toàn quyền đụng tới)
+ *   ├── tanloc           (nhà ăn Tấn Lộc — vận hành)
+ *   └── spa              (Spartronics — khách hàng)
+ *       └── spa-qc       (phòng QC của khách hàng)
+ */
+function seedRows() {
+  return [
+    {
+      id: "grp",
+      code: "GRP",
+      name: "Tập đoàn",
+      kind: "org",
+      parentId: null,
+      path: "/grp/",
+      depth: 1,
+      isActive: true,
+    },
+    {
+      id: "tanloc",
+      code: "TL",
+      name: "Nhà ăn Tấn Lộc",
+      kind: "unit",
+      parentId: "grp",
+      path: "/grp/tanloc/",
+      depth: 2,
+      isActive: true,
+    },
+    {
+      id: "spa",
+      code: "SPA",
+      name: "Spartronics",
+      kind: "unit",
+      parentId: "grp",
+      path: "/grp/spa/",
+      depth: 2,
+      isActive: true,
+    },
+    {
+      id: "spa-qc",
+      code: "SPA-QC",
+      name: "Spartronics QC",
+      kind: "department",
+      parentId: "spa",
+      path: "/grp/spa/spa-qc/",
+      depth: 3,
+      isActive: true,
+    },
+  ];
+}
+
+interface Call {
+  fn: string;
+  args: any;
+}
+
+/**
+ * Prisma giả — ghi lại mọi lời gọi để test soi được `where`/`data` thật sự gửi
+ * xuống DB, chứ không chỉ soi thứ handler trả về.
+ */
+function fakeDb() {
+  const rows = seedRows();
+  const calls: Call[] = [];
+
+  return {
+    calls,
+    rows,
+    workspace: {
+      async findMany(args: any = {}) {
+        calls.push({ fn: "findMany", args });
+        const startsWith = args?.where?.path?.startsWith;
+        const list = startsWith
+          ? rows.filter((r) => r.path.startsWith(startsWith))
+          : rows;
+        return list.map((r) => ({ ...r, _count: { members: 2 } }));
+      },
+      async findUnique(args: any) {
+        calls.push({ fn: "findUnique", args });
+        return rows.find((r) => r.id === args?.where?.id) ?? null;
+      },
+      async create(args: any) {
+        calls.push({ fn: "create", args });
+        const row = { isActive: true, ...args.data };
+        rows.push(row);
+        return row;
+      },
+      async update(args: any) {
+        calls.push({ fn: "update", args });
+        const row = rows.find((r) => r.id === args?.where?.id);
+        if (row) Object.assign(row, args.data);
+        return row;
+      },
+      async count(args: any = {}) {
+        calls.push({ fn: "count", args });
+        return rows.filter((r) => r.parentId === args?.where?.parentId).length;
+      },
+    },
+  };
+}
+
+type Session = { userId: string; memberships: string[]; viewAll?: boolean };
+
+/** Quản trị viên phía khách hàng: chỉ nhánh `spa`. */
+const customerAdmin: Session = { userId: "u-spa", memberships: ["spa"] };
+/** Vận hành Tấn Lộc — toàn quyền. */
+const opsAdmin: Session = { userId: "u-ops", memberships: [], viewAll: true };
+/** Người dùng thường của khách hàng: thuộc `spa` nhưng KHÔNG quản trị. */
+const customerUser: Session = { userId: "u-plain", memberships: [] };
+
+function configure(db: ReturnType<typeof fakeDb>) {
+  configureWorkspaces<Session>({
+    canViewAll: (session) => Boolean(session?.viewAll),
+    getUserId: (session) => session?.userId ?? null,
+    getMemberships: (session) =>
+      (session?.memberships ?? []).map((workspaceId) => ({
+        workspaceId,
+        isAdmin: true,
+      })),
+    expandDescendants: async (rootIds) => {
+      const prefixes = db.rows
+        .filter((r) => rootIds.includes(r.id))
+        .map((r) => subtreePrefix(r.path));
+      return db.rows
+        .filter((r) => prefixes.some((p) => r.path.startsWith(p)))
+        .map((r) => r.id);
+    },
+  });
+}
+
+function deps(db: ReturnType<typeof fakeDb>, session: Session | null) {
+  return {
+    prisma: db as any,
+    getSession: () => session,
+    canManageAll: (s: Session) => Boolean(s?.viewAll),
+  };
+}
+
+const post = (body: unknown) =>
+  new Request("http://test/api/workspaces", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
+const patch = (body: unknown) =>
+  new Request("http://test/api/workspaces/x", {
+    method: "PATCH",
+    body: JSON.stringify(body),
+  });
+
+describe("workspace route handlers — GET", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb();
+    configure(db);
+  });
+
+  it("lọc ở SERVER: admin khách hàng không nhận được nhánh của tenant khác", async () => {
+    const { GET } = createWorkspaceCollectionHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await GET(new Request("http://test/api/workspaces"));
+    const tree = await res.json();
+
+    // Chỉ còn `spa` (thành nút gốc vì cha `grp` đã bị lọc) và con của nó.
+    expect(tree).toHaveLength(1);
+    expect(tree[0].id).toBe("spa");
+    expect(tree[0].children.map((c: any) => c.id)).toEqual(["spa-qc"]);
+
+    // Không có mẩu nào của Tấn Lộc / tập đoàn lọt vào payload.
+    const raw = JSON.stringify(tree);
+    expect(raw).not.toContain("tanloc");
+    expect(raw).not.toContain("Tấn Lộc");
+    expect(raw).not.toContain("grp");
+  });
+
+  it("toàn quyền thì thấy cả cây", async () => {
+    const { GET } = createWorkspaceCollectionHandlers(
+      deps(db, opsAdmin) as any,
+    );
+    const tree = await (
+      await GET(new Request("http://test/api/workspaces"))
+    ).json();
+    expect(tree).toHaveLength(1);
+    expect(tree[0].id).toBe("grp");
+    expect(tree[0].children.map((c: any) => c.id).sort()).toEqual([
+      "spa",
+      "tanloc",
+    ]);
+  });
+
+  it("chưa đăng nhập → 401, không chạm DB", async () => {
+    const { GET } = createWorkspaceCollectionHandlers(deps(db, null) as any);
+    const res = await GET(new Request("http://test/api/workspaces"));
+    expect(res.status).toBe(401);
+    expect(db.calls).toHaveLength(0);
+  });
+});
+
+describe("workspace route handlers — POST", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb();
+    configure(db);
+  });
+
+  it("nút GỐC chỉ dành cho toàn quyền — admin khách hàng bị chặn", async () => {
+    const { POST } = createWorkspaceCollectionHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      post({ code: "X", name: "Tổ chức song song", parentId: null }),
+    );
+    expect(res.status).toBe(403);
+    // Chặn TRƯỚC khi ghi: không có dòng nào được tạo.
+    expect(db.calls.some((c) => c.fn === "create")).toBe(false);
+  });
+
+  it("toàn quyền tạo được nút gốc", async () => {
+    const { POST } = createWorkspaceCollectionHandlers(
+      deps(db, opsAdmin) as any,
+    );
+    const res = await POST(post({ code: "X", name: "Tổ chức mới" }));
+    expect(res.status).toBe(201);
+  });
+
+  it("tạo con dưới nhánh NGOÀI phạm vi quản trị → 403", async () => {
+    const { POST } = createWorkspaceCollectionHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      post({ code: "TL-2", name: "Bếp 2", parentId: "tanloc" }),
+    );
+    expect(res.status).toBe(403);
+    expect(db.calls.some((c) => c.fn === "create")).toBe(false);
+  });
+
+  it("tạo con trong nhánh mình quản trị → 201, path tính từ cha", async () => {
+    const { POST } = createWorkspaceCollectionHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      post({ code: "SPA-KHO", name: "Kho", parentId: "spa" }),
+    );
+    expect(res.status).toBe(201);
+    const created = await res.json();
+    expect(created.path.startsWith("/grp/spa/")).toBe(true);
+    expect(created.depth).toBe(3);
+  });
+
+  it("thành viên thường (không được uỷ quyền) không tạo được gì", async () => {
+    const { POST } = createWorkspaceCollectionHandlers(
+      deps(db, customerUser) as any,
+    );
+    const res = await POST(post({ code: "A", name: "A", parentId: "spa" }));
+    expect(res.status).toBe(403);
+  });
+});
+
+describe("workspace route handlers — PATCH / DELETE", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb();
+    configure(db);
+  });
+
+  it("PATCH ngoài phạm vi → 403", async () => {
+    const { PATCH } = createWorkspaceItemHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await PATCH(patch({ name: "Đổi tên" }), {
+      params: { id: "tanloc" },
+    });
+    expect(res.status).toBe(403);
+    expect(db.calls.some((c) => c.fn === "update")).toBe(false);
+  });
+
+  it("PATCH KHÔNG nhận path/depth/parentId từ body — sửa tay là làm hỏng cây", async () => {
+    const { PATCH } = createWorkspaceItemHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await PATCH(
+      patch({
+        name: "Spartronics VN",
+        path: "/grp/",
+        depth: 1,
+        parentId: "grp",
+      }),
+      { params: { id: "spa" } },
+    );
+    expect(res.status).toBe(200);
+
+    const update = db.calls.find((c) => c.fn === "update");
+    expect(update?.args.data).toEqual({ name: "Spartronics VN" });
+    // Cây trong DB không hề suy chuyển.
+    expect(db.rows.find((r) => r.id === "spa")?.path).toBe("/grp/spa/");
+  });
+
+  it("DELETE là ngừng hoạt động CẢ NHÁNH, không xoá cứng", async () => {
+    const { DELETE } = createWorkspaceItemHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const before = db.rows.length;
+    const res = await DELETE(
+      new Request("http://test/api/workspaces/spa", { method: "DELETE" }),
+      { params: { id: "spa" } },
+    );
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ deactivated: 2 });
+    expect(db.rows).toHaveLength(before);
+    expect(db.rows.find((r) => r.id === "spa")?.isActive).toBe(false);
+    expect(db.rows.find((r) => r.id === "spa-qc")?.isActive).toBe(false);
+    expect(db.rows.find((r) => r.id === "tanloc")?.isActive).toBe(true);
+  });
+
+  it("DELETE ngoài phạm vi → 403", async () => {
+    const { DELETE } = createWorkspaceItemHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await DELETE(
+      new Request("http://test/api/workspaces/tanloc", { method: "DELETE" }),
+      { params: { id: "tanloc" } },
+    );
+    expect(res.status).toBe(403);
+    expect(db.rows.find((r) => r.id === "tanloc")?.isActive).toBe(true);
+  });
+});
+
+describe("workspace route handlers — move", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb();
+    configure(db);
+  });
+
+  it("nguồn trong phạm vi nhưng ĐÍCH ngoài phạm vi → 403", async () => {
+    const { POST } = createWorkspaceMoveHandler(deps(db, customerAdmin) as any);
+    const res = await POST(post({ newParentId: "tanloc" }), {
+      params: { id: "spa-qc" },
+    });
+    expect(res.status).toBe(403);
+    // Không có dòng nào bị repath.
+    expect(db.calls.some((c) => c.fn === "update")).toBe(false);
+    expect(db.rows.find((r) => r.id === "spa-qc")?.parentId).toBe("spa");
+  });
+
+  it("chuyển lên GỐC chỉ dành cho toàn quyền — nếu không, admin nhánh tự tách thành tenant riêng", async () => {
+    const { POST } = createWorkspaceMoveHandler(deps(db, customerAdmin) as any);
+    const res = await POST(post({ newParentId: null }), {
+      params: { id: "spa" },
+    });
+    expect(res.status).toBe(403);
+    expect(db.rows.find((r) => r.id === "spa")?.parentId).toBe("grp");
+  });
+
+  it("cả hai đầu trong phạm vi → chuyển được, con cháu repath theo", async () => {
+    db.rows.push({
+      id: "spa-kho",
+      code: "SPA-KHO",
+      name: "Kho",
+      kind: "department",
+      parentId: "spa",
+      path: "/grp/spa/spa-kho/",
+      depth: 3,
+      isActive: true,
+    });
+    const { POST } = createWorkspaceMoveHandler(deps(db, customerAdmin) as any);
+    const res = await POST(post({ newParentId: "spa-qc" }), {
+      params: { id: "spa-kho" },
+    });
+    expect(res.status).toBe(200);
+
+    const moved = db.rows.find((r) => r.id === "spa-kho");
+    expect(moved?.path).toBe("/grp/spa/spa-qc/spa-kho/");
+    expect(moved?.depth).toBe(4);
+    expect(moved?.parentId).toBe("spa-qc");
+  });
+
+  it("chu trình (chuyển vào chính con cháu của mình) → 400 kèm câu tiếng Việt", async () => {
+    const { POST } = createWorkspaceMoveHandler(deps(db, customerAdmin) as any);
+    const res = await POST(post({ newParentId: "spa-qc" }), {
+      params: { id: "spa" },
+    });
+    // `spa` ngoài adminIds? Không — admin của `spa` gồm cả con cháu, nên qua
+    // được cửa quyền và dừng ở luật cây.
+    expect(res.status).toBe(400);
+    expect(String((await res.json()).error)).toMatch(/chu trình|chính nó|con/i);
+  });
+});