@goplusvn/core 0.1.78 → 0.1.79

package/src/rbac/role-service.ts

@@ -35,6 +35,32 @@ export type RoleServiceSchema = {
   roleTimestamps?: boolean;
 };
 
+/**
+ * PHẠM VI vai trò — chỉ dành cho app đã bật multi-tenant (cột `Role.workspaceId`).
+ *
+ * Không truyền thì hàm chạy y như trước: mọi vai trò, mọi người dùng nhúng bên
+ * trong. App một-đơn-vị (vinhhoa) cứ để trống.
+ *
+ * Vai trò `workspaceId = null` là vai trò DÙNG CHUNG do cấp vận hành dựng
+ * ("Nhân viên", "Bếp"): quản trị viên đơn vị vẫn THẤY để biết mình đang gán gì,
+ * nhưng `canManage` trả `false` nên nút sửa/xoá tắt.
+ */
+export type RoleQueryScope = {
+  /** Nhóm vận hành — thấy tất cả, sửa tất cả. */
+  canManageAll?: boolean;
+  /** Các workspace người này quản trị (`scope.adminIds`). */
+  adminWorkspaceIds?: readonly string[];
+  /** Có kèm vai trò dùng chung (`workspaceId = null`) không. Mặc định có. */
+  includeShared?: boolean;
+  /**
+   * Điều kiện kẹp danh sách NGƯỜI DÙNG nhúng trong mỗi vai trò — dạng where của
+   * bảng User (thường là `memberScopeWhere(scope)`). Thiếu nó thì trang vai trò
+   * là cửa hậu xem toàn bộ danh bạ: mỗi thẻ vai trò in kèm avatar + email của
+   * mọi người mang vai trò đó, kể cả đơn vị khác.
+   */
+  userWhere?: any;
+};
+
 export type RoleData = {
   id: string;
   name: string;
@@ -54,6 +80,12 @@ export type RoleData = {
   updatedAt: string;
   createdBy?: string;
   updatedBy?: string;
+  /** Chỉ có ở app multi-tenant. `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. `undefined` = không xét. */
+  canManage?: boolean;
 };
 
 // Interface for the DB client injected into the service
@@ -68,6 +100,12 @@ export interface RolePrismaClient {
       take: number;
       include: any;
     }) => Promise<any[]>;
+    /**
+     * Prisma sinh sẵn — dùng để dò cột tuỳ chọn (workspaceId/rank/isSystem).
+     * Kiểu `object` chứ không `Record<string, unknown>`: `RoleFieldRefs` của
+     * Prisma không có index signature nên app truyền thẳng `db` sẽ đỏ.
+     */
+    fields?: object;
   };
 }
 
@@ -75,6 +113,11 @@ export interface RolePrismaClient {
 // Service Logic
 // ============================================================================
 
+/** App chưa có cột thì bỏ qua điều kiện tương ứng — hỏi cột không tồn tại là Prisma ném. */
+const hasRoleField = (db: RolePrismaClient, field: string) =>
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  Boolean((db as any)?.role?.fields?.[field]);
+
 /**
  * Get roles data with pagination and filtering
  * Generic core implementation using injected DB client
@@ -86,6 +129,7 @@ export async function getRolesData(
   db: RolePrismaClient,
   params: RoleFilters = {},
   schema: RoleServiceSchema = {},
+  scope?: RoleQueryScope,
 ): Promise<{
   total: number;
   page: number;
@@ -117,6 +161,22 @@ export async function getRolesData(
     whereConditions.push({ status });
   }
 
+  // Kẹp phạm vi — chỉ khi app THẬT SỰ có cột `workspaceId` trên Role. Dò bằng
+  // `role.fields` (Prisma sinh sẵn) thay vì đoán theo tên app.
+  const hasWorkspaceField = hasRoleField(db, "workspaceId");
+  const adminIds = scope?.adminWorkspaceIds ?? [];
+  const scoped = Boolean(scope) && !scope?.canManageAll && hasWorkspaceField;
+
+  if (scoped) {
+    const branches: any[] = [];
+    if (adminIds.length > 0) branches.push({ workspaceId: { in: [...adminIds] } });
+    if (scope?.includeShared !== false) branches.push({ workspaceId: null });
+    // Không quản trị đơn vị nào và không lấy vai trò dùng chung ⇒ không thấy gì.
+    // Viết tường minh chứ không để `OR: []` — dựa vào cách Prisma diễn giải mảng
+    // rỗng là dựa vào chi tiết cài đặt.
+    whereConditions.push(branches.length > 0 ? { OR: branches } : { id: { in: [] } });
+  }
+
   const where: any = whereConditions.length > 0 ? { AND: whereConditions } : {};
 
   // Build the user select from the (possibly overridden) field names.
@@ -132,7 +192,10 @@ export async function getRolesData(
       skip: (page - 1) * pageSize,
       take: pageSize,
       include: {
-        userRoles: { include: { user: { select: userSelect } } },
+        userRoles: {
+          ...(scope?.userWhere ? { where: { user: scope.userWhere } } : {}),
+          include: { user: { select: userSelect } },
+        },
         rolePermissions: {
           include: {
             resource: { select: { code: true, name: true, icon: true } },
@@ -154,6 +217,8 @@ export async function getRolesData(
     permissions: role.rolePermissions.map(
       (rp: any) => `${rp.actionCode}:${rp.resourceCode}`,
     ),
+    // Đếm theo danh sách ĐÃ kẹp: người quản trị đơn vị thấy "3 người dùng" là 3
+    // người trong đơn vị mình, không phải tổng toàn hệ thống.
     usersCount: role.userRoles.length,
     users: role.userRoles.map((ur: any) => ({
       id: ur.user.id,
@@ -166,6 +231,22 @@ export async function getRolesData(
     updatedAt: hasTimestamps && role.updatedAt ? role.updatedAt.toISOString() : "",
     createdBy: role.createdBy || undefined,
     updatedBy: role.updatedBy || undefined,
+    ...(hasWorkspaceField
+      ? {
+          workspaceId: role.workspaceId ?? null,
+          isSystem: Boolean(role.isSystem),
+          rank: typeof role.rank === "number" ? role.rank : undefined,
+          // Vai trò dùng chung / vai trò hệ thống / vai trò của đơn vị khác:
+          // xem được, không sửa được. Cùng luật với `canManageRole` bên
+          // `@goerp/core/workspace` — đây chỉ là bản chiếu xuống UI.
+          canManage: scope
+            ? scope.canManageAll ||
+              (!role.isSystem &&
+                Boolean(role.workspaceId) &&
+                adminIds.includes(role.workspaceId))
+            : undefined,
+        }
+      : {}),
   }));
 
   return { total, page, pageSize, items: transformedItems };

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,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 },
@@ -171,7 +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);
@@ -192,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/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();
+  });
+});