@goplusvn/core 0.1.76 → 0.1.78

package/src/workspace/__tests__/workspace-delegation.test.ts

@@ -352,7 +352,7 @@ describe("cổng tổng hợp", () => {
       assertCanCreateUser(actor, ["spa-qc"], [role()]),
     ).not.toThrow();
     expect(() => assertCanCreateUser(actor, [])).toThrow(
-      /ít nhất một không gian/,
+      /ít nhất một workspace/,
     );
     expect(() =>
       assertCanCreateUser(actor, ["spa-qc"], [role({ rank: 10 })]),

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

@@ -0,0 +1,407 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Đường GHI membership — nơi một admin khách hàng có thể tự bành trướng nếu
+// hàng rào hở.
+//
+// Mọi ca gọi thẳng handler như một client tự chế (curl), không đi qua giao diện:
+// trang có ẩn nút hay không là chuyện khác, hàng rào phải nằm ở đây. Ba đường
+// leo thang được soi riêng: hút người của tenant khác về nhánh mình (D5), tự
+// nâng chính mình (D3), và đẩy nạn nhân ra khỏi nhánh khác để chiếm (D7).
+
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { createWorkspaceMemberHandlers } from "../route-handlers";
+import { configureWorkspaces, resetWorkspaceConfig } from "../scope";
+import { subtreePrefix } from "../tree";
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+});
+
+/**
+ *   grp                (tập đoàn)
+ *   ├── 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)
+ */
+const WORKSPACES = [
+  { id: "grp", path: "/grp/" },
+  { id: "tanloc", path: "/grp/tanloc/" },
+  { id: "spa", path: "/grp/spa/" },
+  { id: "spa-qc", path: "/grp/spa/spa-qc/" },
+];
+
+interface FakeUser {
+  id: string;
+  name: string;
+  email: string;
+  isActive: boolean;
+  isProtected?: boolean;
+  permissionCeilingRoleId?: string | null;
+  workspaceIds: string[];
+}
+
+function fakeDb(users: FakeUser[]) {
+  const calls: { fn: string; args: any }[] = [];
+  const members = users.flatMap((u) =>
+    u.workspaceIds.map((workspaceId) => ({
+      userId: u.id,
+      workspaceId,
+      isAdmin: false,
+      isDefault: false,
+    })),
+  );
+
+  const findUser = (id: string) => users.find((u) => u.id === id) ?? null;
+
+  return {
+    calls,
+    members,
+    user: {
+      async findUnique(args: any) {
+        const u = findUser(args?.where?.id);
+        if (!u) return null;
+        return {
+          id: u.id,
+          isProtected: u.isProtected ?? false,
+          permissionCeilingRoleId: u.permissionCeilingRoleId ?? null,
+          userWorkspaces: members
+            .filter((m) => m.userId === u.id)
+            .map((m) => ({ workspaceId: m.workspaceId })),
+        };
+      },
+      async findMany(args: any) {
+        calls.push({ fn: "user.findMany", args });
+        // Không mô phỏng lại engine Prisma — ca kiểm tra `where` gửi xuống, còn
+        // ở đây chỉ cần trả một tập ổn định để handler chạy hết đường.
+        return users
+          .filter(
+            (u) =>
+              !members.some(
+                (m) => m.userId === u.id && m.workspaceId === "spa-qc",
+              ),
+          )
+          .map((u) => ({
+            id: u.id,
+            name: u.name,
+            email: u.email,
+            isActive: u.isActive,
+          }));
+      },
+    },
+    userWorkspace: {
+      async findMany(args: any) {
+        calls.push({ fn: "userWorkspace.findMany", args });
+        return members
+          .filter((m) => m.workspaceId === args?.where?.workspaceId)
+          .map((m) => ({
+            isAdmin: m.isAdmin,
+            isDefault: m.isDefault,
+            user: findUser(m.userId),
+          }));
+      },
+      async upsert(args: any) {
+        calls.push({ fn: "userWorkspace.upsert", args });
+        const { userId, workspaceId } = args.where.userId_workspaceId;
+        const found = members.find(
+          (m) => m.userId === userId && m.workspaceId === workspaceId,
+        );
+        if (found) Object.assign(found, args.update);
+        else members.push({ userId, workspaceId, ...args.create });
+        return { userId, workspaceId };
+      },
+      async updateMany(args: any) {
+        calls.push({ fn: "userWorkspace.updateMany", args });
+        return { count: 0 };
+      },
+      async deleteMany(args: any) {
+        calls.push({ fn: "userWorkspace.deleteMany", args });
+        const before = members.length;
+        for (let i = members.length - 1; i >= 0; i -= 1) {
+          const m = members[i];
+          if (
+            m.userId === args.where.userId &&
+            m.workspaceId === args.where.workspaceId
+          ) {
+            members.splice(i, 1);
+          }
+        }
+        return { count: before - members.length };
+      },
+    },
+    async $transaction(fn: any) {
+      return fn(this);
+    },
+  };
+}
+
+type Session = { userId: string; adminOf: string[]; viewAll?: boolean };
+
+/** Quản trị viên phía khách hàng: quản trị nhánh `spa` (và con cháu). */
+const customerAdmin: Session = { userId: "u-spa-admin", adminOf: ["spa"] };
+/** Vận hành Tấn Lộc — toàn quyền, miễn D1–D7. */
+const opsAdmin: Session = { userId: "u-ops", adminOf: [], viewAll: true };
+
+function configure(db: ReturnType<typeof fakeDb>) {
+  void db;
+  configureWorkspaces<Session>({
+    canViewAll: (session) => Boolean(session?.viewAll),
+    getUserId: (session) => session?.userId ?? null,
+    getMemberships: (session) =>
+      (session?.adminOf ?? []).map((workspaceId) => ({
+        workspaceId,
+        isAdmin: true,
+      })),
+    expandDescendants: async (rootIds) => {
+      const prefixes = WORKSPACES.filter((w) => rootIds.includes(w.id)).map(
+        (w) => subtreePrefix(w.path),
+      );
+      return WORKSPACES.filter((w) =>
+        prefixes.some((p) => w.path.startsWith(p)),
+      ).map((w) => w.id);
+    },
+  });
+}
+
+const deps = (db: any, session: Session | null) => ({
+  prisma: db,
+  getSession: () => session,
+  canManageAll: (s: Session) => Boolean(s?.viewAll),
+});
+
+const ctx = (id: string) => ({ params: { id } });
+
+const postReq = (body: unknown) =>
+  new Request("http://test/api/workspaces/x/members", {
+    method: "POST",
+    body: JSON.stringify(body),
+  });
+
+const deleteReq = (userId: string) =>
+  new Request(`http://test/api/workspaces/x/members?userId=${userId}`, {
+    method: "DELETE",
+  });
+
+const baseUsers = (): FakeUser[] => [
+  {
+    id: "u-qc",
+    name: "Nhân viên QC",
+    email: "qc@spa.vn",
+    isActive: true,
+    workspaceIds: ["spa"],
+  },
+  {
+    id: "u-tanloc",
+    name: "Nhân viên Tấn Lộc",
+    email: "nv@tanloc.vn",
+    isActive: true,
+    workspaceIds: ["tanloc"],
+  },
+  {
+    id: "u-orphan",
+    name: "Chưa gán",
+    email: "orphan@x.vn",
+    isActive: true,
+    workspaceIds: [],
+  },
+  {
+    id: "u-spa-admin",
+    name: "Admin Spartronics",
+    email: "admin@spa.vn",
+    isActive: true,
+    workspaceIds: ["spa"],
+  },
+];
+
+describe("gán người vào không gian — đường hợp lệ", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("admin nhánh gán được người của chính nhánh mình xuống phòng ban con", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-qc" }), ctx("spa-qc"));
+
+    expect(res.status).toBe(201);
+    expect(
+      db.members.some((m) => m.userId === "u-qc" && m.workspaceId === "spa-qc"),
+    ).toBe(true);
+  });
+
+  it("đặt cờ mặc định thì HẠ cờ mặc định cũ — mỗi người chỉ một không gian mặc định", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    await POST(postReq({ userId: "u-qc", isDefault: true }), ctx("spa-qc"));
+
+    const cleared = db.calls.find((c) => c.fn === "userWorkspace.updateMany");
+    expect(cleared).toBeDefined();
+    expect(cleared!.args.where).toMatchObject({
+      userId: "u-qc",
+      isDefault: true,
+      NOT: { workspaceId: "spa-qc" },
+    });
+  });
+
+  it("gán lại người đã ở trong = đổi cờ, không đẻ bản ghi trùng", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      postReq({ userId: "u-qc", isAdmin: true }),
+      ctx("spa"),
+    );
+
+    expect(res.status).toBe(200);
+    expect(
+      db.members.filter((m) => m.userId === "u-qc" && m.workspaceId === "spa"),
+    ).toHaveLength(1);
+    expect(
+      db.members.find((m) => m.userId === "u-qc" && m.workspaceId === "spa")
+        ?.isAdmin,
+    ).toBe(true);
+  });
+});
+
+describe("gán người vào không gian — ba đường leo thang", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("D1 — không gán được vào nhánh ngoài phạm vi quản trị", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-qc" }), ctx("tanloc"));
+
+    expect(res.status).toBe(403);
+    expect(
+      db.members.some((m) => m.workspaceId === "tanloc" && m.userId === "u-qc"),
+    ).toBe(false);
+  });
+
+  it("D5 — không hút được người của tenant khác về nhánh mình", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-tanloc" }), ctx("spa"));
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D5_NOT_FULLY_OWNED" });
+  });
+
+  it("D5 — người chưa thuộc không gian nào thì admin nhánh KHÔNG tự nhận về", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(postReq({ userId: "u-orphan" }), ctx("spa"));
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D5_NOT_FULLY_OWNED" });
+  });
+
+  it("nhưng vận hành toàn quyền thì gán được người chưa thuộc đâu cả", async () => {
+    const { POST } = createWorkspaceMemberHandlers(deps(db, opsAdmin) as any);
+    const res = await POST(postReq({ userId: "u-orphan" }), ctx("spa"));
+
+    expect(res.status).toBe(201);
+  });
+
+  it("D3 — không tự sửa membership của chính mình", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      postReq({ userId: "u-spa-admin", isAdmin: true }),
+      ctx("spa-qc"),
+    );
+
+    expect(res.status).toBe(403);
+    expect(await res.json()).toMatchObject({ code: "D3_SELF_ESCALATION" });
+  });
+});
+
+describe("gỡ người khỏi không gian", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("chặn gỡ không gian CUỐI CÙNG — gỡ xong thì chính mình cũng hết đụng được", async () => {
+    const { DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await DELETE(deleteReq("u-qc"), ctx("spa"));
+
+    expect(res.status).toBe(400);
+    expect(db.members.some((m) => m.userId === "u-qc")).toBe(true);
+  });
+
+  it("gỡ được khi người đó còn không gian khác trong phạm vi", async () => {
+    const { POST, DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    await POST(postReq({ userId: "u-qc" }), ctx("spa-qc"));
+    const res = await DELETE(deleteReq("u-qc"), ctx("spa"));
+
+    expect(res.status).toBe(200);
+    expect(
+      db.members.some((m) => m.userId === "u-qc" && m.workspaceId === "spa"),
+    ).toBe(false);
+  });
+
+  it("không gỡ được người thuộc nhánh ngoài phạm vi", async () => {
+    const { DELETE } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await DELETE(deleteReq("u-tanloc"), ctx("tanloc"));
+
+    expect(res.status).toBe(403);
+    expect(db.members.some((m) => m.userId === "u-tanloc")).toBe(true);
+  });
+});
+
+describe("tìm ứng viên để thêm", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  it("chỉ tìm trong nhánh QUẢN TRỊ được, và loại người đã ở trong", async () => {
+    const { GET } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await GET(
+      new Request("http://test/api/workspaces/x/members?candidates=1&q=nh"),
+      ctx("spa-qc"),
+    );
+    expect(res.status).toBe(200);
+
+    const call = db.calls.find((c) => c.fn === "user.findMany");
+    const and = call!.args.where.AND;
+    // Ràng buộc phạm vi phải bám `adminIds` (spa + spa-qc), KHÔNG phải allowedIds.
+    expect(JSON.stringify(and[0])).toContain("spa-qc");
+    expect(JSON.stringify(and[0])).not.toContain("tanloc");
+    expect(and[1]).toMatchObject({
+      userWorkspaces: { none: { workspaceId: "spa-qc" } },
+    });
+  });
+
+  it("người thường (không quản trị nhánh nào) không tìm được ứng viên", async () => {
+    const plain: Session = { userId: "u-plain", adminOf: [] };
+    const { GET } = createWorkspaceMemberHandlers(deps(db, plain) as any);
+    const res = await GET(
+      new Request("http://test/api/workspaces/x/members?candidates=1"),
+      ctx("spa"),
+    );
+
+    expect(res.status).toBe(403);
+  });
+});

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

@@ -121,6 +121,15 @@ function fakeDb() {
         return rows.filter((r) => r.parentId === args?.where?.parentId).length;
       },
     },
+    // GET đếm quản trị bằng `groupBy` riêng: `_count` của Prisma không lọc được
+    // theo cờ `isAdmin`. Chỉ `spa` có một quản trị — để test phân biệt được
+    // "đếm thật" với "trả 0 cho mọi nút".
+    userWorkspace: {
+      async groupBy(args: any) {
+        calls.push({ fn: "userWorkspace.groupBy", args });
+        return [{ workspaceId: "spa", _count: { _all: 1 } }];
+      },
+    },
   };
 }
 
@@ -214,6 +223,32 @@ describe("workspace route handlers — GET", () => {
     ]);
   });
 
+  /**
+   * Cây tải lại sau mỗi lần thêm/sửa phải mang ĐỦ những gì trang server render
+   * đã có. Thiếu `kindLabel` thì huy hiệu cấp lặng lẽ biến mất, thiếu
+   * `adminCount` thì cột "quản trị" tụt về 0 — cả hai đều không đỏ ở đâu cả,
+   * người dùng chỉ thấy số tự nhiên đổi sau một thao tác không liên quan.
+   */
+  it("trả kèm kindLabel và adminCount cho cây tải lại", async () => {
+    const { GET } = createWorkspaceCollectionHandlers({
+      ...(deps(db, opsAdmin) as any),
+      kinds: [
+        { key: "unit", label: "Đơn vị" },
+        { key: "department", label: "Bộ phận" },
+      ],
+    });
+    const tree = await (
+      await GET(new Request("http://test/api/workspaces"))
+    ).json();
+
+    const spa = tree[0].children.find((c: any) => c.id === "spa");
+    expect(spa.kindLabel).toBe("Đơn vị");
+    expect(spa.adminCount).toBe(1);
+    // Nút không có quản trị nào phải là 0, không phải `undefined`.
+    expect(spa.children[0].adminCount).toBe(0);
+    expect(spa.children[0].kindLabel).toBe("Bộ phận");
+  });
+
   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"));

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

@@ -199,7 +199,7 @@ describe("createWorkspace", () => {
         kind: "department",
         parentId: "spa-qc",
       }),
-    ).rejects.toThrow(/không được có không gian con/);
+    ).rejects.toThrow(/không được có workspace con/);
   });
 
   it("kind ngoài childKinds của cha thì chặn", async () => {

package/src/workspace/components/scope-level-select.tsx

@@ -22,8 +22,8 @@ import type { ScopeLevel } from "../types";
 const HINTS: Record<ScopeLevel, string> = {
   none: "Không thấy gì",
   own: "Chỉ bản ghi do chính mình tạo",
-  workspace: "Đúng không gian được gán",
-  subtree: "Không gian được gán và cấp dưới",
+  workspace: "Đúng workspace được gán",
+  subtree: "Workspace được gán và cấp dưới",
   all: "Toàn hệ thống",
 };
 
@@ -35,14 +35,14 @@ export interface ScopeLevelSelectProps {
    * dropdown thay vì để họ chọn rồi server mới từ chối.
    */
   maxLevel?: ScopeLevel;
-  /** Nhãn thay cho "Không gian" theo app: "Chi nhánh", "Đơn vị", "Phòng ban". */
+  /** Nhãn thay cho "Workspace" theo app: "Chi nhánh", "Đơn vị", "Phòng ban". */
   kindLabel?: string;
   disabled?: boolean;
   className?: string;
   id?: string;
 }
 
-/** Nhãn nấc, đã thay chữ "Không gian" bằng nhãn của app. */
+/** Nhãn nấc, đã thay chữ "Workspace" bằng nhãn của app. */
 export function scopeLevelLabel(level: ScopeLevel, kindLabel?: string): string {
   const base = SCOPE_LEVEL_LABELS[level];
   if (!kindLabel) return base;