@goplusvn/core 0.1.78 → 0.1.81

package/src/rbac/route-handlers.ts

@@ -13,12 +13,22 @@
 //     prisma, getSession, getCrudPermissions, schema: { userNameField: "fullName", ... },
 //   });
 
-import { getRolesData, type RoleServiceSchema } from "./role-service";
+import { getRolesData } from "./role-service";
 import { normalizeLandingPath } from "./landing-path";
 import {
   bumpPermissionsVersion,
   getPermissionsVersion,
 } from "./permissions-version";
+import {
+  DelegationError,
+  assertCanDeleteRole,
+  assertCanManageRole,
+  canManageRole,
+} from "../workspace/delegation";
+import { memberScopeWhere } from "../workspace/scope";
+
+import type { RoleQueryScope, RoleServiceSchema } from "./role-service";
+import type { DelegationActor } from "../workspace/delegation";
 
 type MaybePromise<T> = T | Promise<T>;
 
@@ -29,12 +39,81 @@ export interface RbacHandlerDeps {
   getCrudPermissions: (session: any, resource: string) => Promise<{ read?: boolean; create?: boolean; update?: boolean; delete?: boolean }>;
   /** Schema field-map when User/Role diverge from defaults. */
   schema?: RoleServiceSchema;
+  /**
+   * UỶ QUYỀN (app multi-tenant). Bỏ trống ⇒ handler chạy y như trước: quyền
+   * `role:create/update/delete` là toàn quyền trên MỌI vai trò.
+   *
+   * Truyền vào thì cùng bộ luật D1/D2/D4 của người dùng được áp cho vai trò:
+   * quản trị viên đơn vị chỉ thấy vai trò của đơn vị mình (+ vai trò dùng chung,
+   * chỉ đọc), tạo vai trò thì bị đóng dấu đơn vị và không nhét được quyền mà
+   * chính họ không có. Thiếu cửa này thì chặn *gán* vai trò mạnh là vô nghĩa —
+   * họ tự tạo một vai trò mạnh rồi gán.
+   */
+  getDelegationActor?: (session: any) => MaybePromise<DelegationActor | null>;
   onError?: (error: unknown, req: Request) => Response | Promise<Response>;
 }
 
 const json = (data: unknown, status = 200) =>
   new Response(JSON.stringify(data), { status, headers: { "content-type": "application/json" } });
 
+/** DelegationError → 403 kèm mã bất biến; lỗi khác trả về cho `fail` xử lý. */
+const delegationDenied = (e: unknown) =>
+  e instanceof DelegationError ? json({ error: e.message, code: e.code }, 403) : null;
+
+/**
+ * Phạm vi đọc vai trò của một người thao tác. Export vì TRANG danh sách vai trò
+ * (server component) phải nạp đúng bộ dữ liệu mà API sẽ trả — lệch nhau thì
+ * lần render đầu hiện vai trò của đơn vị khác rồi mới biến mất sau khi SWR chạy.
+ */
+export function roleScopeOf(actor: DelegationActor | null): RoleQueryScope | undefined {
+  if (!actor) return undefined;
+  return {
+    canManageAll: actor.canManageAll,
+    adminWorkspaceIds: actor.scope.adminIds,
+    userWhere: actor.canManageAll ? undefined : memberScopeWhere(actor.scope),
+  };
+}
+
+/**
+ * Quyền trong vai trò đi trên dây dưới dạng `"action:resource"` (khuôn của
+ * `RoleListPage`), còn tầng uỷ quyền nói `"resource:action"`. Đổi chiều ở đúng
+ * một chỗ — trộn hai khuôn thì mọi phép so quyền lặng lẽ trả về "không khớp",
+ * tức hàng rào D2 vẫn xanh nhưng không chặn gì.
+ */
+function toResourceAction(permissions: readonly string[]): string[] {
+  return permissions
+    .map((p) => {
+      const [actionCode, resourceCode] = p.split(":");
+      return actionCode && resourceCode ? `${resourceCode}:${actionCode}` : null;
+    })
+    .filter((p): p is string => Boolean(p));
+}
+
+/** Cột uỷ quyền chỉ tồn tại ở app đã migrate — ghi mù là ném `Unknown argument`. */
+const hasRoleField = (prisma: any, field: string) => Boolean(prisma?.role?.fields?.[field]);
+
+/** Đọc vai trò trong DB về khuôn `DelegationRole` cho cổng D1/D2/D4. */
+async function loadRoleForDelegation(prisma: any, id: string) {
+  const role = await prisma.role.findUnique({
+    where: { id },
+    include: { rolePermissions: { select: { resourceCode: true, actionCode: true } } },
+  });
+  if (!role) return null;
+  return {
+    role,
+    delegation: {
+      id: role.id,
+      code: role.code,
+      rank: typeof role.rank === "number" ? role.rank : 100,
+      isSystem: Boolean(role.isSystem),
+      workspaceId: role.workspaceId ?? null,
+      permissions: (role.rolePermissions ?? []).map(
+        (p: any) => `${p.resourceCode}:${p.actionCode}`,
+      ),
+    },
+  };
+}
+
 // permissions "action:resource" → RolePermission rows {roleCode,resourceCode,actionCode}.
 async function writePermissions(tx: any, roleCode: string, permissions: string[]) {
   await tx.rolePermission.deleteMany({ where: { roleCode } });
@@ -59,9 +138,26 @@ function landingPathData(prisma: any, body: any) {
   return { landingPath: normalizeLandingPath(body.landingPath) };
 }
 
+// ── Nấc cô lập dữ liệu theo vai trò (`Role.dataScope`) ─────────────────────
+const SCOPE_LEVELS = ["none", "own", "workspace", "subtree", "all"] as const;
+
+/**
+ * CHỈ VAI VẬN HÀNH đổi được nấc này. Nếu để quản trị viên đơn vị tự đặt, họ chỉ
+ * cần tạo một vai trò `all` rồi tự gán — cô lập dữ liệu biến thành tuỳ chọn.
+ * `actor === null` (app chưa bật uỷ quyền) thì giữ hành vi cũ: ai sửa vai trò
+ * được thì sửa được cột này.
+ */
+function dataScopeData(prisma: any, body: any, actor: DelegationActor | null) {
+  if (!hasRoleField(prisma, "dataScope") || !("dataScope" in (body ?? {}))) return {};
+  if (actor && !actor.canManageAll) return {};
+  const raw = body.dataScope;
+  if (raw === null || raw === "") return { dataScope: null };
+  return SCOPE_LEVELS.includes(raw) ? { dataScope: raw } : {};
+}
+
 // GET (list, schema-tolerant) + POST (create + permissions) for /api/roles.
 export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
-  const { prisma, getSession, getCrudPermissions, schema, onError } = deps;
+  const { prisma, getSession, getCrudPermissions, schema, getDelegationActor, onError } = deps;
   const fail = (e: unknown, req: Request) => (onError ? onError(e, req) : json({ error: "Internal error" }, 500));
 
   async function GET(req: Request) {
@@ -71,6 +167,7 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
       const perms = await getCrudPermissions(session, "role");
       if (!perms.read) return json({ error: "Forbidden" }, 403);
       const sp = new URL(req.url).searchParams;
+      const actor = getDelegationActor ? await getDelegationActor(session) : null;
       const result = await getRolesData(
         prisma,
         {
@@ -80,6 +177,7 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
           status: sp.get("status")?.trim() || undefined,
         },
         schema,
+        roleScopeOf(actor),
       );
       return json(result);
     } catch (e) {
@@ -98,6 +196,29 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
       const name = (body.name ?? "").trim();
       if (!code || !name) return json({ error: "Thiếu mã hoặc tên vai trò" }, 400);
       const permissions: string[] = Array.isArray(body.permissions) ? body.permissions : [];
+
+      // Cổng uỷ quyền: đóng dấu đơn vị + ép cấp thấp hơn người tạo + chặn quyền
+      // vượt trần. Chỉ chạy khi app khai `getDelegationActor`.
+      const stamp: Record<string, unknown> = {};
+      const actor = getDelegationActor ? await getDelegationActor(session) : null;
+      if (actor) {
+        try {
+          const gate = assertCanManageRole(actor, null, {
+            code,
+            workspaceId: body.workspaceId ?? undefined,
+            rank: typeof body.rank === "number" ? body.rank : undefined,
+            isSystem: Boolean(body.isSystem),
+            permissions: toResourceAction(permissions),
+          });
+          if (hasRoleField(prisma, "workspaceId")) stamp.workspaceId = gate.workspaceId;
+          if (hasRoleField(prisma, "rank")) stamp.rank = gate.rank;
+        } catch (e) {
+          const denied = delegationDenied(e);
+          if (denied) return denied;
+          throw e;
+        }
+      }
+
       const role = await prisma.$transaction(async (tx: any) => {
         const created = await tx.role.create({
           data: {
@@ -105,7 +226,9 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
             name,
             description: body.description ?? null,
             status: body.status ?? "active",
+            ...stamp,
             ...landingPathData(prisma, body),
+            ...dataScopeData(prisma, body, actor),
           },
         });
         await writePermissions(tx, created.code, permissions);
@@ -123,7 +246,7 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
 
 // GET + PUT (update + replace permissions) + DELETE (guarded by user count) for /api/roles/[id].
 export function createRoleItemHandlers(deps: RbacHandlerDeps) {
-  const { prisma, getSession, getCrudPermissions, onError } = deps;
+  const { prisma, getSession, getCrudPermissions, getDelegationActor, onError } = deps;
   const fail = (e: unknown, req: Request) => (onError ? onError(e, req) : json({ error: "Internal error" }, 500));
   type Ctx = { params: Promise<{ id: string }> };
 
@@ -134,11 +257,17 @@ export function createRoleItemHandlers(deps: RbacHandlerDeps) {
       if (!session) return json({ error: "Unauthorized" }, 401);
       const perms = await getCrudPermissions(session, "role");
       if (!perms.read) return json({ error: "Forbidden" }, 403);
-      const role = await prisma.role.findUnique({
-        where: { id },
-        include: { rolePermissions: { select: { resourceCode: true, actionCode: true } } },
-      });
-      if (!role) return json({ error: "Not found" }, 404);
+      const loaded = await loadRoleForDelegation(prisma, id);
+      if (!loaded) return json({ error: "Not found" }, 404);
+      const { role } = loaded;
+      // Vai trò ngoài phạm vi thì coi như KHÔNG TỒN TẠI: trả 403 ở đây là xác
+      // nhận "có vai trò id này", đủ để dò danh sách vai trò của đơn vị khác.
+      const viewer = getDelegationActor ? await getDelegationActor(session) : null;
+      if (viewer && !viewer.canManageAll) {
+        const ws = loaded.delegation.workspaceId;
+        const visible = !ws || viewer.scope.adminIds.includes(ws);
+        if (!visible) return json({ error: "Not found" }, 404);
+      }
       return json({
         id: role.id,
         code: role.code,
@@ -146,6 +275,10 @@ export function createRoleItemHandlers(deps: RbacHandlerDeps) {
         description: role.description ?? "",
         status: role.status,
         landingPath: role.landingPath ?? null,
+        dataScope: role.dataScope ?? null,
+        workspaceId: role.workspaceId ?? null,
+        isSystem: Boolean(role.isSystem),
+        canManage: viewer ? canManageRole(viewer, loaded.delegation) : undefined,
         permissions: role.rolePermissions.map((p: any) => `${p.actionCode}:${p.resourceCode}`),
       });
     } catch (e) {
@@ -161,9 +294,44 @@ export function createRoleItemHandlers(deps: RbacHandlerDeps) {
       const perms = await getCrudPermissions(session, "role");
       if (!perms.update) return json({ error: "Forbidden" }, 403);
       const body = await req.json();
-      const existing = await prisma.role.findUnique({ where: { id } });
-      if (!existing) return json({ error: "Not found" }, 404);
+      const loaded = await loadRoleForDelegation(prisma, id);
+      if (!loaded) return json({ error: "Not found" }, 404);
+      const existing = loaded.role;
       const permissions: string[] = Array.isArray(body.permissions) ? body.permissions : [];
+
+      // Vai trò hệ thống / vai trò dùng chung / vai trò đơn vị khác: chặn ở đây.
+      // Không có cổng này thì quản trị viên đơn vị chỉ cần MỞ vai trò "Quản trị
+      // hệ thống" rồi bấm lưu là tự nâng cấp mình.
+      const stamp: Record<string, unknown> = {};
+      const actor = getDelegationActor ? await getDelegationActor(session) : null;
+      if (actor) {
+        try {
+          const gate = assertCanManageRole(actor, loaded.delegation, {
+            code: existing.code,
+            // Client KHÔNG gửi trường ⇒ giữ nguyên chủ sở hữu. Gửi ⇒ cổng uỷ
+            // quyền quyết: vai vận hành đổi được tuỳ ý, quản trị đơn vị chỉ
+            // chuyển được trong nhánh mình (D1 ném nếu ra ngoài).
+            workspaceId:
+              body.workspaceId !== undefined
+                ? body.workspaceId
+                : loaded.delegation.workspaceId,
+            rank: typeof body.rank === "number" ? body.rank : loaded.delegation.rank,
+            permissions: toResourceAction(permissions),
+          });
+          if (hasRoleField(prisma, "rank")) stamp.rank = gate.rank;
+          // Chỉ ghi khi client CÓ ý đổi: `gate.workspaceId` luôn có giá trị, ghi
+          // vô điều kiện là mọi lần sửa vai trò đều đóng dấu lại — vai trò dùng
+          // chung do vai vận hành sửa sẽ lặng lẽ rơi vào một đơn vị.
+          if (body.workspaceId !== undefined && hasRoleField(prisma, "workspaceId")) {
+            stamp.workspaceId = gate.workspaceId;
+          }
+        } catch (e) {
+          const denied = delegationDenied(e);
+          if (denied) return denied;
+          throw e;
+        }
+      }
+
       const role = await prisma.$transaction(async (tx: any) => {
         const updated = await tx.role.update({
           where: { id },
@@ -171,7 +339,9 @@ export function createRoleItemHandlers(deps: RbacHandlerDeps) {
             name: (body.name ?? existing.name).trim(),
             description: body.description ?? existing.description,
             status: body.status ?? existing.status,
+            ...stamp,
             ...landingPathData(prisma, body),
+            ...dataScopeData(prisma, body, actor),
           },
         });
         await writePermissions(tx, updated.code, permissions);
@@ -192,6 +362,18 @@ export function createRoleItemHandlers(deps: RbacHandlerDeps) {
       if (!session) return json({ error: "Unauthorized" }, 401);
       const perms = await getCrudPermissions(session, "role");
       if (!perms.delete) return json({ error: "Forbidden" }, 403);
+      const loaded = await loadRoleForDelegation(prisma, id);
+      if (!loaded) return json({ error: "Not found" }, 404);
+      const actor = getDelegationActor ? await getDelegationActor(session) : null;
+      if (actor) {
+        try {
+          assertCanDeleteRole(actor, loaded.delegation);
+        } catch (e) {
+          const denied = delegationDenied(e);
+          if (denied) return denied;
+          throw e;
+        }
+      }
       const role = await prisma.role.findUnique({ where: { id }, include: { _count: { select: { userRoles: true } } } });
       if (!role) return json({ error: "Not found" }, 404);
       if (role._count.userRoles > 0)

package/src/rbac/types.ts

@@ -20,6 +20,21 @@ export type Role = {
   updatedAt: string;
   createdBy?: string | null | undefined;
   updatedBy?: string | null | undefined;
+  /** App multi-tenant: đơn vị sở hữu vai trò; `null` = vai trò dùng chung. */
+  workspaceId?: string | null;
+  /**
+   * Tên đơn vị sở hữu — server giải sẵn để thẻ vai trò khỏi phải tra cây. `null`
+   * khi vai trò dùng chung; trường VẮNG MẶT khi app không bật multi-tenant (khác
+   * hẳn `null`, đừng gộp hai trường hợp).
+   */
+  workspaceName?: string | null;
+  isSystem?: boolean;
+  rank?: number;
+  /**
+   * Người đang xem có SỬA/XOÁ được vai trò này không — server tính, client chỉ
+   * vẽ theo. `undefined` = app không xét uỷ quyền (hành vi cũ, coi như được).
+   */
+  canManage?: boolean;
 };
 
 export type Permission = {

package/src/user/user-service.ts

@@ -1,5 +1,7 @@
+import { assignableRoles } from "../workspace/delegation";
 import { memberScopeWhere } from "../workspace/scope";
 
+import type { DelegationActor, DelegationRole } from "../workspace/delegation";
 import type { WorkspaceScope } from "../workspace/types";
 import type { CrudResponse } from "../types";
 
@@ -441,6 +443,61 @@ export async function getActiveRoles(db: UserPrismaClient) {
   return roles;
 }
 
+/**
+ * Vai trò mà NGƯỜI ĐANG THAO TÁC được phép gán — dùng cho ô chọn vai trò trong
+ * hộp thoại người dùng.
+ *
+ * `getActiveRoles` trả về mọi vai trò đang hoạt động, kể cả "Quản trị hệ thống".
+ * Bản thân việc gán đã bị `assertCanCreateUser` chặn ở tầng API, nên đây không
+ * phải lỗ hổng — nhưng nó là cái bẫy giao diện: quản trị viên đơn vị chọn vai
+ * trò, bấm lưu, rồi mới ăn 403. Danh sách này lọc trước bằng CHÍNH luật D4
+ * (`assignableRoles`), nên thứ hiện ra là thứ lưu được.
+ *
+ * App chưa có cột `rank` (một tổ chức, không uỷ quyền) rơi về `getActiveRoles`.
+ */
+export async function getAssignableRoles(
+  db: UserPrismaClient,
+  actor: DelegationActor | null,
+) {
+  if (!actor || actor.canManageAll || !db.role.fields?.rank) {
+    return getActiveRoles(db);
+  }
+
+  const rows = await db.role.findMany({
+    where: { status: "active" },
+    select: {
+      id: true,
+      code: true,
+      name: true,
+      status: true,
+      rank: true,
+      isSystem: db.role.fields?.isSystem ? true : undefined,
+      workspaceId: db.role.fields?.workspaceId ? true : undefined,
+      rolePermissions: { select: { resourceCode: true, actionCode: true } },
+    },
+    orderBy: { name: "asc" },
+  });
+
+  const candidates: (DelegationRole & { name: string; status: string })[] = rows.map((r: any) => ({
+    id: r.id,
+    code: r.code,
+    name: r.name,
+    status: r.status,
+    rank: r.rank,
+    isSystem: Boolean(r.isSystem),
+    workspaceId: r.workspaceId ?? null,
+    permissions: (r.rolePermissions ?? []).map(
+      (p: any) => `${p.resourceCode}:${p.actionCode}`,
+    ),
+  }));
+
+  return assignableRoles(actor, candidates).map((r) => ({
+    code: r.code,
+    name: r.name,
+    status: r.status,
+  }));
+}
+
 /**
  * Get all active departments for filter dropdown
  */

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

@@ -10,8 +10,12 @@ import {
   assertNotSelf,
   assertRoleAssignable,
   assertWorkspacesInScope,
+  assertCanDeleteRole,
+  assertCanManageRole,
   assignableRoles,
   canDelegateUsers,
+  canManageRole,
+  defaultRoleWorkspaceIdFor,
   DelegationError,
   isDangerousPermission,
 } from "../delegation";
@@ -24,6 +28,7 @@ import type {
   DelegationActor,
   DelegationRole,
   DelegationTarget,
+  RoleDraft,
 } from "../delegation";
 
 /**
@@ -361,3 +366,100 @@ describe("cổng tổng hợp", () => {
     expect(() => assertCanCreateUser(opsAdmin(), [])).not.toThrow();
   });
 });
+
+describe("Quản trị VAI TRÒ — cổng tạo/sửa/xoá", () => {
+  const draft = (over: Partial<RoleDraft> = {}): RoleDraft => ({
+    code: "TO_TRUONG",
+    permissions: ["meal-order:view"],
+    ...over,
+  });
+
+  it("tạo vai trò trong nhánh mình: được đóng dấu workspace + giữ rank", () => {
+    const gate = assertCanManageRole(customerAdmin(), null, draft({ rank: 80 }));
+    expect(gate.workspaceId).toBe("spa");
+    expect(gate.rank).toBe(80);
+  });
+
+  it("không tự tạo được vai trò DÙNG CHUNG (workspaceId null)", () => {
+    // Cửa hậu kinh điển: vai trò không mang dấu đơn vị thì đơn vị khác cũng gán
+    // được — admin nhánh vừa ghi vào không gian của cả hệ thống.
+    const actor = customerAdmin({
+      scope: createWorkspaceScope({
+        canViewAll: false,
+        rootIds: ["spa"],
+        allowedIds: ["spa"],
+        adminIds: [],
+      }),
+    });
+    expect(() => assertCanManageRole(actor, null, draft())).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("không tạo được vai trò ngang hoặc mạnh hơn chính mình", () => {
+    try {
+      assertCanManageRole(customerAdmin(), null, draft({ rank: 50 }));
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D2_EXCEEDS_CEILING");
+    }
+  });
+
+  it("không nhét được quyền quản trị hệ thống vào vai trò mới (D4)", () => {
+    try {
+      assertCanManageRole(
+        customerAdmin(),
+        null,
+        draft({ rank: 80, permissions: ["role:create"] }),
+      );
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D4_DANGEROUS_ROLE");
+    }
+  });
+
+  it("không cấp được quyền mà chính mình không có (D2)", () => {
+    try {
+      assertCanManageRole(
+        customerAdmin(),
+        null,
+        draft({ rank: 80, permissions: ["payroll:view"] }),
+      );
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D2_EXCEEDS_CEILING");
+      expect((error as DelegationError).message).toContain("payroll:view");
+    }
+  });
+
+  it("vai trò dùng chung: THẤY nhưng không sửa, không xoá", () => {
+    const shared = role({ rank: 100, workspaceId: null });
+    expect(canManageRole(customerAdmin(), shared)).toBe(false);
+    expect(() =>
+      assertCanManageRole(customerAdmin(), shared, draft({ rank: 100 })),
+    ).toThrow(DelegationError);
+    expect(() => assertCanDeleteRole(customerAdmin(), shared)).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("vai trò của đơn vị khác / vai trò hệ thống đều không sửa được", () => {
+    expect(
+      canManageRole(customerAdmin(), role({ workspaceId: "tanloc" })),
+    ).toBe(false);
+    expect(
+      canManageRole(customerAdmin(), role({ workspaceId: "spa", isSystem: true })),
+    ).toBe(false);
+    expect(canManageRole(customerAdmin(), role({ workspaceId: "spa-qc" }))).toBe(
+      true,
+    );
+  });
+
+  it("nhóm vận hành miễn mọi luật", () => {
+    expect(canManageRole(opsAdmin(), role({ isSystem: true }))).toBe(true);
+    expect(() =>
+      assertCanManageRole(opsAdmin(), null, draft({ permissions: ["role:create"] })),
+    ).not.toThrow();
+    expect(defaultRoleWorkspaceIdFor(opsAdmin())).toBeNull();
+  });
+});

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

@@ -118,12 +118,16 @@ function fakeDb(users: FakeUser[]) {
         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);
-          }
+          if (m.userId !== args.where.userId) continue;
+          // Hai dạng `where` mà handler thực sự gửi xuống: gỡ ĐÚNG một nút
+          // (đường xoá một người) và gỡ MỌI nút khác (đường chuyển hàng loạt).
+          const matches =
+            args.where.workspaceId !== undefined
+              ? m.workspaceId === args.where.workspaceId
+              : args.where.NOT?.workspaceId !== undefined
+                ? m.workspaceId !== args.where.NOT.workspaceId
+                : true;
+          if (matches) members.splice(i, 1);
         }
         return { count: before - members.length };
       },
@@ -405,3 +409,66 @@ describe("tìm ứng viên để thêm", () => {
     expect(res.status).toBe(403);
   });
 });
+
+describe("gán HÀNG LOẠT", () => {
+  let db: ReturnType<typeof fakeDb>;
+  beforeEach(() => {
+    db = fakeDb(baseUsers());
+    configure(db);
+  });
+
+  const wsOf = (userId: string) =>
+    db.members.filter((m) => m.userId === userId).map((m) => m.workspaceId);
+
+  it('mode "move" GỠ mọi không gian cũ — nếu không thì cô lập là giả', async () => {
+    const { POST } = createWorkspaceMemberHandlers(deps(db, opsAdmin) as any);
+    const res = await POST(
+      postReq({ userIds: ["u-qc", "u-tanloc"], mode: "move" }),
+      ctx("spa-qc"),
+    );
+
+    expect(res.status).toBe(200);
+    await expect(res.json()).resolves.toMatchObject({ changed: 2, failed: [] });
+    // Còn giữ membership cũ là người đó vẫn thấy dữ liệu nhánh cũ (phạm vi là
+    // HỢP các không gian), tức bấm gán xong mà không đổi gì.
+    expect(wsOf("u-qc")).toEqual(["spa-qc"]);
+    expect(wsOf("u-tanloc")).toEqual(["spa-qc"]);
+  });
+
+  it('mode "add" giữ nguyên nơi cũ', async () => {
+    const { POST } = createWorkspaceMemberHandlers(deps(db, opsAdmin) as any);
+    const res = await POST(
+      postReq({ userIds: ["u-qc"], mode: "add" }),
+      ctx("spa-qc"),
+    );
+
+    expect(res.status).toBe(200);
+    expect(wsOf("u-qc").sort()).toEqual(["spa", "spa-qc"]);
+  });
+
+  it("người ngoài phạm vi bị loại RIÊNG, không kéo đổ cả mẻ", async () => {
+    const { POST } = createWorkspaceMemberHandlers(
+      deps(db, customerAdmin) as any,
+    );
+    const res = await POST(
+      // `u-tanloc` thuộc nhánh Tấn Lộc — admin khách hàng không sở hữu (D7).
+      postReq({ userIds: ["u-qc", "u-tanloc"] }),
+      ctx("spa-qc"),
+    );
+
+    expect(res.status).toBe(200);
+    const payload = await res.json();
+    expect(payload.changed).toBe(1);
+    expect(payload.failed).toHaveLength(1);
+    expect(payload.failed[0].userId).toBe("u-tanloc");
+    // Nạn nhân KHÔNG bị đẩy khỏi nhánh cũ — đó chính là đường chiếm người mà D7 chặn.
+    expect(wsOf("u-tanloc")).toEqual(["tanloc"]);
+    expect(wsOf("u-qc")).toEqual(["spa-qc"]);
+  });
+
+  it("danh sách rỗng → 400 chứ không im lặng báo thành công", async () => {
+    const { POST } = createWorkspaceMemberHandlers(deps(db, opsAdmin) as any);
+    const res = await POST(postReq({ userIds: [] }), ctx("spa-qc"));
+    expect(res.status).toBe(400);
+  });
+});