@goplusvn/core 0.1.75 → 0.1.76

package/src/guardrails/rules/one-door.ts

@@ -70,6 +70,29 @@ export const oneDoorRules: GuardrailRule[] = [
       ctx.files.some((f) => /\b(getBranchScope|scopedBranchWhere)\s*\(/.test(ctx.readCode(f))),
   }),
 
+  singleDoorImport({
+    id: "one-door/workspace",
+    title: "chỉ file hạ tầng được import @goerp/core/workspace",
+    why:
+      "Cùng một engine, cùng một AsyncLocalStorage với branch-scope — chỉ tổng " +
+      "quát hơn (chi nhánh / đơn vị / phòng ban là một cây). Import thẳng lấy " +
+      "được hàm nhưng bỏ lỡ `configureWorkspaces()`, và ở module này 'bỏ lỡ' " +
+      "nghĩa là rò dữ liệu chéo không gian — im lặng, không exception.",
+    fix: "Import qua cửa của app (`@/lib/workspace` hoặc `@/lib/branch-scope`); composition root phải gọi `configureWorkspaces`.",
+    pattern: /from\s+["']@goerp\/core\/workspace["']/,
+    doors: (ctx) => ctx.options.doors.workspace,
+    mustConfigure: /configureWorkspaces\s*[<(]/,
+    mustConfigureName: "configureWorkspaces",
+    // Lớp 2 (`createScopeGuardExtension`) và các hàm cây thuần không cần
+    // singleton; chỉ lớp 1 mới cần, và thiếu thì nó NÉM.
+    mustConfigureWhen: (ctx) =>
+      ctx.files.some((f) =>
+        /\b(getWorkspaceScope|scopedWhere|scopeLevelWhere|workspaceScopeField)\s*\(/.test(
+          ctx.readCode(f),
+        ),
+      ),
+  }),
+
   forbidPattern({
     id: "one-door/export-no-window-open",
     title: "không window.open(...) tới endpoint /export",

package/src/guardrails/scanner.ts

@@ -79,6 +79,15 @@ export function resolveOptions(
         "lib/rbac/branch-scope.ts",
         "lib/prisma.ts",
       ],
+      // `lib/workspace.ts` đứng trước để app nào tách file riêng thì phép kiểm
+      // "cửa duy nhất phải gọi configureWorkspaces" nhìn đúng file đó.
+      workspace: options.doors?.workspace ??
+        options.doors?.branchScope ?? [
+          "lib/workspace.ts",
+          "lib/branch-scope.ts",
+          "lib/rbac/branch-scope.ts",
+          "lib/prisma.ts",
+        ],
     },
   };
 }

package/src/guardrails/types.ts

@@ -137,6 +137,12 @@ export interface GuardrailOptions {
     storage?: string[];
     /** File hạ tầng được import `@goerp/core/branch-scope`. */
     branchScope?: string[];
+    /**
+     * File hạ tầng được import `@goerp/core/workspace`. Mặc định gồm cả các cửa
+     * của `branchScope` — hai module chạy chung MỘT AsyncLocalStorage, nên app
+     * cắm chúng ở cùng một composition root là chuyện thường.
+     */
+    workspace?: string[];
   };
 }
 
@@ -149,6 +155,7 @@ export type ResolvedGuardrailOptions = GuardrailOptions &
       prisma: string;
       storage: string[];
       branchScope: string[];
+      workspace: string[];
     };
   };
 

package/src/user/__tests__/user-service-scope.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import {
+  configureWorkspaces,
+  createWorkspaceScope,
+  resetWorkspaceConfig,
+} from "../../workspace/scope";
+import {
+  getUsersData,
+  getUserStats,
+  getUsersWithDetails,
+} from "../user-service";
+import type { UserPrismaClient } from "../user-service";
+
+/**
+ * Lỗ hổng đang được vá ở đây: danh sách người dùng của core dựng `where` từ
+ * search/status/roleCode và KHÔNG có điều kiện phạm vi nào — admin nhánh của
+ * khách hàng A nhìn thấy toàn bộ người dùng của khách hàng B.
+ *
+ * Test soi thẳng `where` gửi xuống Prisma chứ không soi kết quả: kết quả là do
+ * DB giả trả, còn `where` mới là thứ chạy trên DB thật.
+ */
+function spyDb() {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const calls: { fn: string; where: any }[] = [];
+  const db = {
+    user: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      findMany: async (args: any) => {
+        calls.push({ fn: "user.findMany", where: args.where });
+        return [];
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      count: async (args?: any) => {
+        calls.push({ fn: "user.count", where: args?.where });
+        return 0;
+      },
+    },
+    role: { count: async () => 0, findMany: async () => [] },
+    department: { findMany: async () => [] },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    $transaction: async (args: any) => args,
+  } as unknown as UserPrismaClient;
+  return { db, calls };
+}
+
+const SCOPE_WHERE = {
+  userBranches: { some: { branchId: { in: ["spa", "spa-qc"] } } },
+};
+
+function scopeOfSpa() {
+  return createWorkspaceScope({
+    canViewAll: false,
+    rootIds: ["spa"],
+    allowedIds: ["spa", "spa-qc"],
+    adminIds: ["spa"],
+  });
+}
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+  configureWorkspaces({
+    getUserId: () => undefined,
+    canViewAll: () => false,
+    membershipRelation: "userBranches",
+    membershipField: "branchId",
+  });
+});
+
+describe("getUsersData", () => {
+  it("không truyền scope ⇒ where y hệt hôm nay (L2: additive)", async () => {
+    const { db, calls } = spyDb();
+    await getUsersData(db, { search: "an" });
+    expect(JSON.stringify(calls[0].where)).not.toContain("userBranches");
+  });
+
+  it("truyền scope ⇒ điều kiện phạm vi vào CẢ findMany lẫn count", async () => {
+    const { db, calls } = spyDb();
+    await getUsersData(db, { scope: scopeOfSpa() });
+    const find = calls.find((c) => c.fn === "user.findMany")!;
+    const count = calls.find((c) => c.fn === "user.count")!;
+    expect(find.where.AND).toContainEqual(SCOPE_WHERE);
+    expect(count.where.AND).toContainEqual(SCOPE_WHERE);
+  });
+
+  it("phạm vi cộng THÊM vào bộ lọc, không thay thế", async () => {
+    const { db, calls } = spyDb();
+    await getUsersData(db, {
+      search: "an",
+      status: "active",
+      scope: scopeOfSpa(),
+    });
+    expect(calls[0].where.AND).toHaveLength(3);
+    expect(calls[0].where.AND).toContainEqual(SCOPE_WHERE);
+  });
+
+  it("xem được tất ⇒ không thêm điều kiện", async () => {
+    const { db, calls } = spyDb();
+    await getUsersData(db, {
+      scope: createWorkspaceScope({ canViewAll: true }),
+    });
+    expect(JSON.stringify(calls[0].where)).not.toContain("userBranches");
+  });
+
+  it("adminOnly thu hẹp về nhánh được uỷ quyền", async () => {
+    const { db, calls } = spyDb();
+    await getUsersData(db, { scope: scopeOfSpa(), adminOnly: true });
+    expect(calls[0].where.AND).toContainEqual({
+      userBranches: { some: { branchId: { in: ["spa"] } } },
+    });
+  });
+});
+
+describe("getUsersWithDetails — kể cả các ô thống kê", () => {
+  it("MỌI truy vấn đếm đều mang phạm vi, không sót ô nào", async () => {
+    const { db, calls } = spyDb();
+    await getUsersWithDetails(db, { scope: scopeOfSpa() });
+    const userQueries = calls.filter((c) => c.fn.startsWith("user."));
+    expect(userQueries.length).toBeGreaterThan(3);
+    for (const call of userQueries) {
+      expect(JSON.stringify(call.where)).toContain("userBranches");
+    }
+  });
+
+  it("không có scope thì không truy vấn nào bị thêm điều kiện", async () => {
+    const { db, calls } = spyDb();
+    await getUsersWithDetails(db, {});
+    for (const call of calls) {
+      expect(JSON.stringify(call.where ?? {})).not.toContain("userBranches");
+    }
+  });
+});
+
+describe("getUserStats", () => {
+  it("đếm trong phạm vi khi được truyền scope", async () => {
+    const { db, calls } = spyDb();
+    await getUserStats(db, scopeOfSpa());
+    for (const call of calls.filter((c) => c.fn === "user.count")) {
+      expect(JSON.stringify(call.where)).toContain("userBranches");
+    }
+  });
+
+  it("không scope ⇒ đếm toàn hệ thống như cũ", async () => {
+    const { db, calls } = spyDb();
+    await getUserStats(db);
+    expect(calls.find((c) => c.fn === "user.count")!.where).toEqual({});
+  });
+});

package/src/user/user-service.ts

@@ -1,3 +1,6 @@
+import { memberScopeWhere } from "../workspace/scope";
+
+import type { WorkspaceScope } from "../workspace/types";
 import type { CrudResponse } from "../types";
 
 // Define the shape of the Prisma Client required by this service
@@ -16,6 +19,24 @@ export interface GetUsersParams {
   status?: string;
   roleCode?: string;
   departmentId?: string;
+  /**
+   * Phạm vi không gian của người ĐANG XEM. Bỏ trống = không lọc, giữ nguyên hành
+   * vi cũ cho app một-tổ-chức (luật L2: additive).
+   *
+   * App nhiều tổ chức PHẢI truyền: thiếu nó thì admin nhánh khách hàng A nhìn
+   * thấy toàn bộ người dùng của khách hàng B. Lọc ở tầng service chứ không ở
+   * tầng page — Entra từng thừa nhận đúng lỗi này (UI lọc, API thì không).
+   */
+  scope?: WorkspaceScope;
+  /** Chỉ hiện người dùng trong nhánh mình QUẢN TRỊ, không phải mọi nhánh nhìn được. */
+  adminOnly?: boolean;
+}
+
+/** Điều kiện phạm vi cho danh sách người dùng; `null` khi không phải lọc. */
+function scopeCondition(params: GetUsersParams): Record<string, unknown> | null {
+  if (!params.scope) return null;
+  const where = memberScopeWhere(params.scope, { adminOnly: params.adminOnly });
+  return Object.keys(where).length > 0 ? where : null;
 }
 
 export interface UserWithDetails {
@@ -82,6 +103,9 @@ export async function getUsersData(
     });
   }
 
+  const scoped = scopeCondition(params);
+  if (scoped) whereConditions.push(scoped);
+
   const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
 
   // ⚡ Bolt: Execute independent read queries concurrently to reduce latency
@@ -252,8 +276,15 @@ export async function getUsersWithDetails(
     });
   }
 
+  const scoped = scopeCondition(params);
+  if (scoped) whereConditions.push(scoped);
+
   const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
 
+  /** Đếm KHÔNG theo bộ lọc nhưng VẪN theo phạm vi. */
+  const scopedCount = (extra: Record<string, unknown>): any =>
+    scoped ? { AND: [extra, scoped] } : extra;
+
   // ⚡ Bolt: Execute independent read queries concurrently to reduce latency
   const [users, total, activeCount, rolesCount, customers, suppliers] =
     await Promise.all([
@@ -327,13 +358,22 @@ export async function getUsersWithDetails(
       db.user.count({ where }),
       db.user.count({ where: { ...where, isActive: true } }),
       db.role.count({ where: { status: "active" } }),
-      db.user.count({ where: { userType: "customer" } }).catch(() => 0),
-      db.user.count({ where: { userType: "supplier" } }).catch(() => 0),
+      // Hai ô thống kê này cố ý BỎ QUA bộ lọc tìm kiếm, nên phải tự cộng lại
+      // điều kiện phạm vi — không thì con số vẫn đếm cả người dùng của tổ chức
+      // khác. Rò một con số vẫn là rò.
+      db.user
+        .count({ where: scopedCount({ userType: "customer" }) })
+        .catch(() => 0),
+      db.user
+        .count({ where: scopedCount({ userType: "supplier" }) })
+        .catch(() => 0),
     ]);
 
-  // Get total users count (without filters)
-  const totalUsersCount = await db.user.count();
-  const totalActiveCount = await db.user.count({ where: { isActive: true } });
+  // Tổng số người dùng — bỏ bộ lọc nhưng KHÔNG bỏ phạm vi.
+  const totalUsersCount = await db.user.count({ where: scoped ?? {} });
+  const totalActiveCount = await db.user.count({
+    where: scopedCount({ isActive: true }),
+  });
   const employees = Math.max(0, totalUsersCount - customers - suppliers);
 
   // Transform data
@@ -420,13 +460,27 @@ export async function getActiveDepartments(db: UserPrismaClient) {
 /**
  * Get user statistics
  */
-export async function getUserStats(db: UserPrismaClient) {
+export async function getUserStats(
+  db: UserPrismaClient,
+  /** Bỏ trống = đếm toàn hệ thống (hành vi cũ). Truyền vào để đếm trong phạm vi. */
+  scope?: WorkspaceScope,
+) {
+  const scoped = scope ? scopeCondition({ scope }) : null;
+  const withScope = (extra?: Record<string, unknown>): any => {
+    if (!scoped) return extra ?? {};
+    return extra ? { AND: [extra, scoped] } : scoped;
+  };
+
   const [totalUsers, activeUsers, customers, suppliers, totalRoles] =
     await Promise.all([
-      db.user.count(),
-      db.user.count({ where: { isActive: true } }),
-      db.user.count({ where: { userType: "customer" } }).catch(() => 0),
-      db.user.count({ where: { userType: "supplier" } }).catch(() => 0),
+      db.user.count({ where: withScope() }),
+      db.user.count({ where: withScope({ isActive: true }) }),
+      db.user
+        .count({ where: withScope({ userType: "customer" }) })
+        .catch(() => 0),
+      db.user
+        .count({ where: withScope({ userType: "supplier" }) })
+        .catch(() => 0),
       db.role.count({ where: { status: "active" } }),
     ]);
 

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

@@ -0,0 +1,363 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import {
+  applyPermissionCeiling,
+  assertBoundaryIntact,
+  assertCanCreateUser,
+  assertCanUpdateUser,
+  assertFullyOwned,
+  assertNotProtected,
+  assertNotSelf,
+  assertRoleAssignable,
+  assertWorkspacesInScope,
+  assignableRoles,
+  canDelegateUsers,
+  DelegationError,
+  isDangerousPermission,
+} from "../delegation";
+import {
+  configureWorkspaces,
+  createWorkspaceScope,
+  resetWorkspaceConfig,
+} from "../scope";
+import type {
+  DelegationActor,
+  DelegationRole,
+  DelegationTarget,
+} from "../delegation";
+
+/**
+ * Bối cảnh: Tấn Lộc vận hành (toàn quyền), Spartronics là khách hàng chỉ quản
+ * trị nhánh `/spa/` của mình — gồm hai phòng ban con.
+ */
+function customerAdmin(over: Partial<DelegationActor> = {}): DelegationActor {
+  return {
+    userId: "u-spa-admin",
+    scope: createWorkspaceScope({
+      canViewAll: false,
+      rootIds: ["spa"],
+      allowedIds: ["spa", "spa-qc", "spa-kho"],
+      adminIds: ["spa", "spa-qc", "spa-kho"],
+    }),
+    canManageAll: false,
+    permissions: new Set([
+      "user:view",
+      "user:create",
+      "user:update",
+      "meal-order:view",
+      "meal-order:create",
+    ]),
+    rank: 50,
+    ...over,
+  };
+}
+
+function opsAdmin(): DelegationActor {
+  return {
+    userId: "u-ops",
+    scope: createWorkspaceScope({ canViewAll: true }),
+    canManageAll: true,
+    permissions: new Set(),
+    rank: 0,
+  };
+}
+
+function target(over: Partial<DelegationTarget> = {}): DelegationTarget {
+  return { id: "u-nv", workspaceIds: ["spa-qc"], ...over };
+}
+
+function role(over: Partial<DelegationRole> = {}): DelegationRole {
+  return {
+    id: "r-nv",
+    code: "NHAN_VIEN",
+    rank: 100,
+    permissions: ["meal-order:view", "meal-order:create"],
+    ...over,
+  };
+}
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+  configureWorkspaces({ getUserId: () => undefined, canViewAll: () => false });
+});
+
+describe("D1 — chứa trong nhánh", () => {
+  it("gán trong nhánh mình thì qua", () => {
+    expect(() =>
+      assertWorkspacesInScope(customerAdmin(), ["spa-qc", "spa-kho"]),
+    ).not.toThrow();
+  });
+
+  it("gán workspace ngoài nhánh thì NÉM, không lặng lẽ cắt bớt", () => {
+    try {
+      assertWorkspacesInScope(customerAdmin(), ["spa-qc", "tanloc"]);
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect(error).toBeInstanceOf(DelegationError);
+      expect((error as DelegationError).code).toBe("D1_OUT_OF_SCOPE");
+      expect((error as DelegationError).message).toContain("tanloc");
+    }
+  });
+
+  it("người không được uỷ quyền ở đâu cả thì chặn ngay", () => {
+    const nobody = customerAdmin({
+      scope: createWorkspaceScope({
+        canViewAll: false,
+        rootIds: ["spa"],
+        allowedIds: ["spa"],
+        adminIds: [],
+      }),
+    });
+    expect(() => assertWorkspacesInScope(nobody, ["spa"])).toThrow(
+      /không được uỷ quyền/,
+    );
+    expect(canDelegateUsers(nobody)).toBe(false);
+  });
+
+  it("toàn quyền đi qua mọi thứ", () => {
+    expect(() =>
+      assertWorkspacesInScope(opsAdmin(), ["bat-ky", "cai-gi-do"]),
+    ).not.toThrow();
+    expect(canDelegateUsers(opsAdmin())).toBe(true);
+  });
+});
+
+describe("D3 — không tự nâng", () => {
+  it("sửa chính mình thì chặn", () => {
+    expect(() => assertNotSelf(customerAdmin(), "u-spa-admin")).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("sửa người khác thì qua", () => {
+    expect(() => assertNotSelf(customerAdmin(), "u-nv")).not.toThrow();
+  });
+
+  it("toàn quyền tự sửa mình được", () => {
+    expect(() => assertNotSelf(opsAdmin(), "u-ops")).not.toThrow();
+  });
+});
+
+describe("D5 — sửa được thì phải sở hữu TRỌN", () => {
+  it("mọi membership nằm trong nhánh thì qua", () => {
+    expect(() =>
+      assertFullyOwned(customerAdmin(), target({ workspaceIds: ["spa-qc"] })),
+    ).not.toThrow();
+  });
+
+  it("người VẮT ra ngoài nhánh: đọc được, sửa KHÔNG được", () => {
+    try {
+      assertFullyOwned(
+        customerAdmin(),
+        target({ workspaceIds: ["spa-qc", "tanloc"] }),
+      );
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D5_NOT_FULLY_OWNED");
+    }
+  });
+
+  it("người chưa thuộc không gian nào thì không ai ngoài toàn quyền đụng được", () => {
+    expect(() =>
+      assertFullyOwned(customerAdmin(), target({ workspaceIds: [] })),
+    ).toThrow(DelegationError);
+    expect(() =>
+      assertFullyOwned(opsAdmin(), target({ workspaceIds: [] })),
+    ).not.toThrow();
+  });
+});
+
+describe("D6 — tài khoản được bảo vệ", () => {
+  it("chặn dù CÙNG workspace và D5 đã thoả", () => {
+    const protectedOps = target({
+      id: "u-ops-support",
+      workspaceIds: ["spa-qc"],
+      isProtected: true,
+    });
+    // D5 qua…
+    expect(() => assertFullyOwned(customerAdmin(), protectedOps)).not.toThrow();
+    // …nhưng D6 chặn. Đây chính là lỗ mà D5 một mình không bịt được.
+    expect(() => assertNotProtected(customerAdmin(), protectedOps)).toThrow(
+      DelegationError,
+    );
+  });
+
+  it("toàn quyền vẫn thao tác được", () => {
+    expect(() =>
+      assertNotProtected(opsAdmin(), target({ isProtected: true })),
+    ).not.toThrow();
+  });
+});
+
+describe("D2 + D4 — vai trò gán được", () => {
+  it("vai trò nằm trọn trong quyền của mình và rank thấp hơn thì qua", () => {
+    expect(() => assertRoleAssignable(customerAdmin(), role())).not.toThrow();
+  });
+
+  it("vai trò chứa quyền mình KHÔNG có thì chặn (trần quyền)", () => {
+    expect(() =>
+      assertRoleAssignable(
+        customerAdmin(),
+        role({ permissions: ["meal-order:view", "payment:approve"] }),
+      ),
+    ).toThrow(/payment:approve/);
+  });
+
+  it("vai trò chứa action nguy hiểm thì chặn KỂ CẢ khi trần quyền thoả", () => {
+    const actor = customerAdmin({
+      permissions: new Set(["role:update", "user:view"]),
+    });
+    try {
+      assertRoleAssignable(actor, role({ permissions: ["role:update"] }));
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D4_DANGEROUS_ROLE");
+    }
+  });
+
+  it("hậu tố view-all-* là nguy hiểm bất kể resource nào mang nó", () => {
+    expect(isDangerousPermission("user:view-all-workspaces")).toBe(true);
+    expect(isDangerousPermission("sales-order:view-all-branches")).toBe(true);
+    expect(isDangerousPermission("meal-order:view")).toBe(false);
+  });
+
+  it("vai trò hệ thống thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ isSystem: true })),
+    ).toThrow(/vai trò hệ thống/);
+  });
+
+  it("vai trò ngang hoặc cao hơn cấp mình thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ rank: 50 })),
+    ).toThrow(/ngang hoặc cao hơn/);
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ rank: 10 })),
+    ).toThrow(/ngang hoặc cao hơn/);
+  });
+
+  it("vai trò thuộc nhánh khác thì chặn", () => {
+    expect(() =>
+      assertRoleAssignable(customerAdmin(), role({ workspaceId: "tanloc" })),
+    ).toThrow(/ngoài phạm vi/);
+  });
+
+  it("assignableRoles lọc đúng cái picker được phép hiện", () => {
+    const roles = [
+      role({ id: "ok", code: "NV" }),
+      role({ id: "cao", code: "QL", rank: 10 }),
+      role({ id: "nguy", code: "ADMIN", permissions: ["role:update"] }),
+      role({ id: "vuot", code: "KT", permissions: ["payment:approve"] }),
+    ];
+    expect(assignableRoles(customerAdmin(), roles).map((r) => r.id)).toEqual([
+      "ok",
+    ]);
+    expect(assignableRoles(opsAdmin(), roles)).toHaveLength(4);
+  });
+});
+
+describe("D2 bản CHẠY — trần quyền là phép GIAO", () => {
+  it("không có trần thì giữ nguyên quyền vai trò", () => {
+    expect(applyPermissionCeiling(["a:x", "b:y"], null)).toEqual([
+      "a:x",
+      "b:y",
+    ]);
+    expect(applyPermissionCeiling(["a:x"], undefined)).toEqual(["a:x"]);
+  });
+
+  it("có trần thì cắt phần vượt", () => {
+    expect(applyPermissionCeiling(["a:x", "b:y"], ["a:x", "c:z"])).toEqual([
+      "a:x",
+    ]);
+  });
+
+  it("trần rỗng khác trần null: rỗng = không còn quyền nào", () => {
+    expect(applyPermissionCeiling(["a:x"], [])).toEqual([]);
+  });
+});
+
+describe("D7 — không tháo được rào", () => {
+  const base = target({
+    workspaceIds: ["spa-qc"],
+    permissionCeilingRoleId: "r-tran",
+    isProtected: false,
+  });
+
+  it("sửa trần quyền của người khác thì chặn", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, {
+        permissionCeilingRoleId: null,
+      }),
+    ).toThrow(/trần quyền/);
+  });
+
+  it("gửi lại đúng giá trị cũ thì không tính là sửa", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, {
+        permissionCeilingRoleId: "r-tran",
+      }),
+    ).not.toThrow();
+  });
+
+  it("tự bật cờ bảo vệ thì chặn", () => {
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), base, { isProtected: true }),
+    ).toThrow(/trạng thái bảo vệ/);
+  });
+
+  it("gỡ membership NGOÀI nhánh để đẩy nạn nhân ra rồi thao tác tiếp → chặn", () => {
+    const crossed = target({ workspaceIds: ["spa-qc", "tanloc"] });
+    try {
+      assertBoundaryIntact(customerAdmin(), crossed, {
+        workspaceIds: ["spa-qc"],
+      });
+      throw new Error("đáng lẽ phải ném");
+    } catch (error) {
+      expect((error as DelegationError).code).toBe("D7_BOUNDARY_TAMPER");
+    }
+  });
+
+  it("gỡ membership TRONG nhánh mình thì được", () => {
+    const both = target({ workspaceIds: ["spa-qc", "spa-kho"] });
+    expect(() =>
+      assertBoundaryIntact(customerAdmin(), both, { workspaceIds: ["spa-qc"] }),
+    ).not.toThrow();
+  });
+});
+
+describe("cổng tổng hợp", () => {
+  it("assertCanUpdateUser chạy đủ D3/D5/D6/D7/D1", () => {
+    const actor = customerAdmin();
+    expect(() =>
+      assertCanUpdateUser(actor, target(), { workspaceIds: ["spa-kho"] }),
+    ).not.toThrow();
+
+    // D3
+    expect(() =>
+      assertCanUpdateUser(actor, target({ id: actor.userId })),
+    ).toThrow(/chính mình/);
+    // D6 chạy TRƯỚC D5 — thông báo phải nói về tài khoản bảo vệ, không phải phạm vi
+    expect(() =>
+      assertCanUpdateUser(actor, target({ isProtected: true })),
+    ).toThrow(/được bảo vệ/);
+    // D1 trên danh sách mới
+    expect(() =>
+      assertCanUpdateUser(actor, target(), { workspaceIds: ["tanloc"] }),
+    ).toThrow(DelegationError);
+  });
+
+  it("assertCanCreateUser bắt buộc chọn ít nhất một không gian trong nhánh", () => {
+    const actor = customerAdmin();
+    expect(() =>
+      assertCanCreateUser(actor, ["spa-qc"], [role()]),
+    ).not.toThrow();
+    expect(() => assertCanCreateUser(actor, [])).toThrow(
+      /ít nhất một không gian/,
+    );
+    expect(() =>
+      assertCanCreateUser(actor, ["spa-qc"], [role({ rank: 10 })]),
+    ).toThrow(DelegationError);
+    // Toàn quyền được phép tạo user chưa gắn không gian nào.
+    expect(() => assertCanCreateUser(opsAdmin(), [])).not.toThrow();
+  });
+});