@goplusvn/core 0.1.77 → 0.1.79

package/src/rbac/route-handlers.ts

@@ -13,11 +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>;
 
@@ -28,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 } });
@@ -46,9 +126,38 @@ async function writePermissions(tx: any, roleCode: string, permissions: string[]
   if (rows.length) await tx.rolePermission.createMany({ data: rows, skipDuplicates: true });
 }
 
+// ── Trang mở đầu theo vai trò (`Role.landingPath`) ─────────────────────────
+// Cột BỔ SUNG: app nào chưa migrate thì handler phải im lặng bỏ qua, không ném
+// — hai app đang chạy thật vẫn dùng core này. Dò bằng `prisma.role.fields`
+// (Prisma sinh sẵn), rẻ và đúng với schema THẬT của app chứ không đoán.
+const hasLandingPath = (prisma: any) => Boolean(prisma?.role?.fields?.landingPath);
+
+/** Mảnh `data` để ghép vào create/update — rỗng khi app chưa có cột. */
+function landingPathData(prisma: any, body: any) {
+  if (!hasLandingPath(prisma) || !("landingPath" in (body ?? {}))) return {};
+  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) {
@@ -58,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,
         {
@@ -67,6 +177,7 @@ export function createRolesCollectionHandlers(deps: RbacHandlerDeps) {
           status: sp.get("status")?.trim() || undefined,
         },
         schema,
+        roleScopeOf(actor),
       );
       return json(result);
     } catch (e) {
@@ -85,9 +196,40 @@ 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: { code, name, description: body.description ?? null, status: body.status ?? "active" },
+          data: {
+            code,
+            name,
+            description: body.description ?? null,
+            status: body.status ?? "active",
+            ...stamp,
+            ...landingPathData(prisma, body),
+            ...dataScopeData(prisma, body, actor),
+          },
         });
         await writePermissions(tx, created.code, permissions);
         return created;
@@ -104,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 }> };
 
@@ -115,17 +257,28 @@ 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,
         name: role.name,
         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) {
@@ -141,9 +294,32 @@ 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,
+            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;
+        } 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 },
@@ -151,6 +327,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);
@@ -171,6 +350,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,15 @@ 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;
+  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/schemas/role.schema.ts

@@ -6,6 +6,12 @@ export const roleSchema = z.object({
   description: z.string().optional(),
   status: z.enum(["active", "inactive"]).default("active"),
   permissions: z.array(z.string()).optional(),
+  /**
+   * Trang mở đầu của vai trò (`Role.landingPath`). Rỗng = "tự suy ra".
+   * Route phải lọc lại bằng `normalizeLandingPath` (@goerp/core/rbac/landing-path)
+   * trước khi ghi — schema chỉ nhận kiểu, không phán đường dẫn có an toàn không.
+   */
+  landingPath: z.string().optional().nullable(),
 });
 
 export type RoleFormData = z.infer<typeof roleSchema>;

package/src/ui/auth/sign-in-form.tsx

@@ -47,6 +47,18 @@ export interface SignInFormProps {
   /** Ghi đè nhãn ô định danh (vd "Email hoặc mã nhân viên"). */
   identifierLabel?: string;
   identifierPlaceholder?: string;
+  /**
+   * Endpoint trả `{ path }` — TRANG MỞ ĐẦU của chính người vừa đăng nhập.
+   *
+   * Chỉ hỏi được SAU khi đăng nhập xong (trước đó server chưa biết là ai), nên
+   * không thể gói vào `?redirectTo=`. Không khai prop này thì mọi thứ y như cũ:
+   * về `?redirectTo=` / NEXT_PUBLIC_HOME_PATHNAME / "/".
+   *
+   * Hỏng mạng hay trả bậy đều bỏ qua, vẫn về đường mặc định — chặn đăng nhập
+   * thành công rồi kẹt ở màn hình trắng là cái giá quá đắt cho một gợi ý điều
+   * hướng.
+   */
+  landingEndpoint?: string;
 }
 
 const IDENTIFIER_PRESETS = {
@@ -80,6 +92,7 @@ export function SignInForm({
   identifier = "email",
   identifierLabel,
   identifierPlaceholder,
+  landingEndpoint,
 }: SignInFormProps = {}) {
   const preset = IDENTIFIER_PRESETS[identifier];
   const schema = React.useMemo(
@@ -98,10 +111,9 @@ export function SignInForm({
   const { clearAllCache } = useTabContentCache();
   const { clearTabs } = useTabNavigation();
 
+  const explicitRedirect = searchParams.get("redirectTo");
   const redirectPathname =
-    searchParams.get("redirectTo") ||
-    process.env.NEXT_PUBLIC_HOME_PATHNAME ||
-    "/";
+    explicitRedirect || process.env.NEXT_PUBLIC_HOME_PATHNAME || "/";
 
   const form = useForm<SignInFormType>({
     resolver: zodResolver(schema),
@@ -145,7 +157,27 @@ export function SignInForm({
         // Best-effort only
       }
 
-      router.push(redirectPathname);
+      // `?redirectTo=` là chỗ người dùng đang muốn tới trước khi bị đòi đăng
+      // nhập — luôn thắng trang mở đầu của vai trò.
+      let target = redirectPathname;
+      if (landingEndpoint && !explicitRedirect) {
+        try {
+          const res = await fetch(landingEndpoint);
+          const data = await res.json();
+          // Chỉ nhận đường dẫn nội bộ ("//host" là URL giao thức tương đối).
+          if (
+            typeof data?.path === "string" &&
+            data.path.startsWith("/") &&
+            !data.path.startsWith("//")
+          ) {
+            target = data.path;
+          }
+        } catch {
+          // Giữ đường mặc định — đăng nhập đã thành công rồi.
+        }
+      }
+
+      router.push(target);
     } catch (error) {
       const rawMessage =
         error instanceof Error ? error.message : "Đăng nhập thất bại";

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();
+  });
+});