@goplusvn/core 0.1.78 → 0.1.79

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

@@ -590,3 +590,101 @@ describe("memberScopeWhere", () => {
     ).toEqual({});
   });
 });
+
+/**
+ * CÔ LẬP DỮ LIỆU THEO VAI TRÒ (`Role.dataScope` → `getScopeLevel`).
+ *
+ * Điểm mấu chốt của thiết kế: bốn nấc `none/workspace/subtree/all` được GẤP vào
+ * chính đối tượng phạm vi lúc dựng, nên mọi `scopedWhere` / `memberScopeWhere`
+ * / guard lớp 2 đang có tự tuân theo — không trang nào phải sửa. Test dưới đây
+ * canh đúng tính chất đó; hỏng nó là hỏng toàn bộ cách tiếp cận.
+ */
+describe("nấc cô lập dữ liệu gấp vào phạm vi", () => {
+  const TREE = [
+    { id: "spa", path: "/spa/" },
+    { id: "spa-qc", path: "/spa/spa-qc/" },
+    { id: "spa-kho", path: "/spa/spa-kho/" },
+  ];
+
+  function configure(level: string | null) {
+    resetWorkspaceConfig();
+    configureWorkspaces<{ id: string }>({
+      scopeField: "workspaceId",
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+      getScopeLevel: () => level as never,
+      getMemberships: () => [{ workspaceId: "spa", isAdmin: true }],
+      db: {
+        userWorkspace: { findMany: async () => [] },
+        workspace: {
+          findMany: async ({ where }: { where: any }) =>
+            where?.id?.in
+              ? TREE.filter((n) => where.id.in.includes(n.id))
+              : TREE.filter((n) =>
+                  (where?.OR ?? []).some((c: any) =>
+                    n.path.startsWith(c.path.startsWith),
+                  ),
+                ),
+        },
+      },
+    });
+  }
+
+  beforeEach(() => resetWorkspaceConfig());
+
+  it("mặc định (không khai nấc) = subtree — bung con cháu, y như trước", async () => {
+    configure(null);
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.allowedIds).toEqual(["spa", "spa-qc", "spa-kho"]);
+    expect(scopedWhere(scope)).toEqual({
+      OR: [
+        { workspaceId: { in: ["spa", "spa-qc", "spa-kho"] } },
+        { workspaceId: null },
+      ],
+    });
+  });
+
+  it("nấc `workspace` KHÔNG bung con cháu", async () => {
+    configure("workspace");
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.allowedIds).toEqual(["spa"]);
+    expect(scopedWhere(scope)).toEqual({
+      OR: [{ workspaceId: { in: ["spa"] } }, { workspaceId: null }],
+    });
+  });
+
+  it("nấc `all` bỏ cô lập — kể cả khi không có quyền view-all", async () => {
+    configure("all");
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.canViewAll).toBe(true);
+    expect(scopedWhere(scope)).toEqual({});
+    expect(memberScopeWhere(scope)).toEqual({});
+  });
+
+  it("nấc `none` đóng sạch — sentinel chứ không phải 'không lọc'", async () => {
+    configure("none");
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.canViewAll).toBe(false);
+    expect(scope.allowedIds).toEqual([NO_WORKSPACE_ACCESS]);
+  });
+
+  it("nấc `own` lọc theo cột chủ sở hữu, và THIẾU cột thì đóng chứ không nới", async () => {
+    configure("own");
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scopedWhere(scope, { ownerField: "createdBy" })).toEqual({
+      createdBy: "u1",
+    });
+    // Không khai ownerField ⇒ fail-closed.
+    expect(scopedWhere(scope)).toEqual({ id: NO_WORKSPACE_ACCESS });
+    // Trên chính bảng người dùng: chỉ thấy hồ sơ của mình.
+    expect(memberScopeWhere(scope)).toEqual({ id: "u1" });
+  });
+
+  it("nấc `own` qua quan hệ", async () => {
+    configure("own");
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(
+      scopedWhere(scope, { relation: "employee", ownerField: "user_id" }),
+    ).toEqual({ employee: { user_id: "u1" } });
+  });
+});

package/src/workspace/delegation.ts

@@ -278,6 +278,154 @@ export function assignableRoles<T extends DelegationRole>(
   });
 }
 
+/**
+ * Vai trò đang được TẠO hoặc SỬA — đầu vào của đường quản trị vai trò.
+ *
+ * Khác `DelegationRole` (thứ đã có trong DB, dùng để hỏi "gán đi được không"):
+ * đây là bản nháp người dùng vừa bấm lưu, chưa qua cổng nào.
+ */
+export interface RoleDraft {
+  code: string;
+  /** Bỏ trống = để engine đóng dấu theo nhánh của người tạo. */
+  workspaceId?: string | null;
+  rank?: number | null;
+  isSystem?: boolean;
+  permissions: readonly string[];
+}
+
+/**
+ * Vai trò DÙNG CHUNG (`workspaceId === null`) là của cấp vận hành: admin nhánh
+ * NHÌN thấy để biết mình đang gán gì, nhưng không sửa được — một nhánh sửa thì
+ * mọi đơn vị khác lãnh đủ.
+ */
+export function canManageRole(
+  actor: DelegationActor,
+  role: Pick<DelegationRole, "workspaceId" | "isSystem">,
+): boolean {
+  if (actor.canManageAll) return true;
+  if (role.isSystem) return false;
+  if (!role.workspaceId) return false;
+  return isWorkspaceAdmin(actor.scope, role.workspaceId);
+}
+
+/**
+ * Nhánh mà vai trò mới sẽ mang dấu. Người quản trị nhiều nhánh thì lấy nhánh
+ * mặc định nếu nó nằm trong quyền quản trị, không thì nhánh đầu tiên.
+ */
+export function defaultRoleWorkspaceIdFor(
+  actor: DelegationActor,
+): string | null {
+  if (actor.canManageAll) return null;
+  const { defaultId, adminIds } = actor.scope;
+  if (defaultId && adminIds.includes(defaultId)) return defaultId;
+  return adminIds[0] ?? null;
+}
+
+/**
+ * Cổng đầy đủ cho đường TẠO / SỬA một vai trò (D1 + D2 + D4).
+ *
+ * Đây là lỗ hổng đối xứng với `assertCanCreateUser`: chặn *gán* vai trò mạnh mà
+ * để ngỏ đường *tạo* vai trò mạnh thì admin nhánh chỉ cần đi vòng một bước —
+ * tạo vai trò "Trợ lý" có `role:update` rồi tự gán cho tài khoản mình vừa lập.
+ *
+ * `existing` là vai trò trong DB (null khi tạo mới). Trả về `workspaceId` +
+ * `rank` đã chuẩn hoá để route ghi thẳng, khỏi tự suy lại rồi suy sai.
+ */
+export function assertCanManageRole(
+  actor: DelegationActor,
+  existing: DelegationRole | null,
+  draft: RoleDraft,
+): { workspaceId: string | null; rank: number } {
+  const requestedRank = draft.rank ?? existing?.rank ?? 100;
+
+  if (actor.canManageAll) {
+    return {
+      workspaceId:
+        draft.workspaceId !== undefined
+          ? draft.workspaceId
+          : (existing?.workspaceId ?? null),
+      rank: requestedRank,
+    };
+  }
+
+  if (actor.scope.adminIds.length === 0) {
+    throw new DelegationError(
+      "NO_DELEGATION",
+      "Bạn không được uỷ quyền quản trị workspace nào.",
+    );
+  }
+
+  if (existing && !canManageRole(actor, existing)) {
+    throw new DelegationError(
+      existing.isSystem ? "D4_DANGEROUS_ROLE" : "D1_OUT_OF_SCOPE",
+      existing.isSystem
+        ? `Vai trò "${existing.code}" là vai trò hệ thống — chỉ quản trị toàn hệ thống sửa được.`
+        : `Vai trò "${existing.code}" ${existing.workspaceId ? "thuộc đơn vị ngoài phạm vi của bạn" : "là vai trò dùng chung của cấp trên"} — bạn xem được nhưng không sửa được.`,
+    );
+  }
+
+  if (draft.isSystem) {
+    throw new DelegationError(
+      "D4_DANGEROUS_ROLE",
+      "Không thể đánh dấu vai trò là vai trò hệ thống.",
+    );
+  }
+
+  // Đóng dấu nhánh: vai trò không mang dấu là vai trò DÙNG CHUNG, tức là admin
+  // nhánh vừa tạo ra thứ mà mọi đơn vị khác cũng gán được.
+  const workspaceId =
+    draft.workspaceId ??
+    existing?.workspaceId ??
+    defaultRoleWorkspaceIdFor(actor);
+  if (!workspaceId || !isWorkspaceAdmin(actor.scope, workspaceId)) {
+    throw new DelegationError(
+      "D1_OUT_OF_SCOPE",
+      "Vai trò phải thuộc một đơn vị trong phạm vi quản trị của bạn.",
+    );
+  }
+
+  // D2 lúc TẠO: vai trò yếu hơn chính người tạo. Không có luật này thì họ tạo
+  // vai trò rank 0 rồi nhờ người khác gán ngược lại cho mình.
+  if (requestedRank <= actor.rank) {
+    throw new DelegationError(
+      "D2_EXCEEDS_CEILING",
+      `Vai trò phải có cấp thấp hơn bạn (rank > ${actor.rank}).`,
+    );
+  }
+
+  const dangerous = draft.permissions.filter(isDangerousPermission);
+  if (dangerous.length > 0) {
+    throw new DelegationError(
+      "D4_DANGEROUS_ROLE",
+      `Không thể đưa quyền quản trị hệ thống vào vai trò: ${dangerous.join(", ")}.`,
+    );
+  }
+
+  const exceeded = draft.permissions.filter((p) => !actor.permissions.has(p));
+  if (exceeded.length > 0) {
+    throw new DelegationError(
+      "D2_EXCEEDS_CEILING",
+      `Vai trò chứa quyền bạn không có: ${exceeded.slice(0, 5).join(", ")}${exceeded.length > 5 ? "…" : ""}.`,
+    );
+  }
+
+  return { workspaceId, rank: requestedRank };
+}
+
+/** Cổng cho đường XOÁ vai trò — cùng luật với sửa, không có phần bộ quyền. */
+export function assertCanDeleteRole(
+  actor: DelegationActor,
+  role: DelegationRole,
+): void {
+  if (actor.canManageAll) return;
+  if (!canManageRole(actor, role)) {
+    throw new DelegationError(
+      role.isSystem ? "D4_DANGEROUS_ROLE" : "D1_OUT_OF_SCOPE",
+      `Vai trò "${role.code}" nằm ngoài phạm vi quản trị của bạn — không xoá được.`,
+    );
+  }
+}
+
 /**
  * D2 bản CHẠY — quyền hiệu lực = GIAO của quyền vai trò và trần quyền.
  *

package/src/workspace/index.ts

@@ -97,6 +97,10 @@ export {
   assertNotProtected,
   assertRoleAssignable,
   assignableRoles,
+  canManageRole,
+  defaultRoleWorkspaceIdFor,
+  assertCanManageRole,
+  assertCanDeleteRole,
   applyPermissionCeiling,
   assertBoundaryIntact,
   assertCanUpdateUser,
@@ -107,6 +111,7 @@ export {
   type DelegationTarget,
   type DelegationRole,
   type DelegationChanges,
+  type RoleDraft,
 } from "./delegation";
 
 export {

package/src/workspace/scope.ts

@@ -66,6 +66,8 @@ export function createWorkspaceScope(input: {
   allowedIds?: string[];
   adminIds?: string[];
   defaultId?: string;
+  level?: ScopeLevel;
+  userId?: string;
 }): WorkspaceScope {
   if (input.canViewAll) {
     return {
@@ -73,6 +75,8 @@ export function createWorkspaceScope(input: {
       rootIds: input.rootIds ?? [],
       adminIds: input.adminIds ?? [],
       defaultId: input.defaultId,
+      level: input.level,
+      userId: input.userId,
     };
   }
   const allowed =
@@ -86,6 +90,8 @@ export function createWorkspaceScope(input: {
     allowedBranchIds: allowed,
     adminIds: input.adminIds ?? [],
     defaultId: input.defaultId,
+    level: input.level,
+    userId: input.userId,
   };
 }
 
@@ -97,8 +103,18 @@ export async function getWorkspaceScope<TSession>(
   session: TSession,
 ): Promise<WorkspaceScope> {
   const config = requireConfigured();
+  const userId = config.getUserId(session) ?? undefined;
+  // Nấc cô lập của vai trò. `all` mở toàn bộ, `none` đóng sạch — hai nấc này
+  // quyết định xong là không cần đọc membership nữa.
+  const level = (await config.getScopeLevel?.(session)) ?? undefined;
+  if (level === "all") {
+    return createWorkspaceScope({ canViewAll: true, level, userId });
+  }
+  if (level === "none") {
+    return createWorkspaceScope({ canViewAll: false, allowedIds: [], level, userId });
+  }
   if (config.canViewAll(session)) {
-    return createWorkspaceScope({ canViewAll: true });
+    return createWorkspaceScope({ canViewAll: true, level, userId });
   }
 
   const memberships = await readMemberships(config, session);
@@ -109,7 +125,10 @@ export async function getWorkspaceScope<TSession>(
   const defaultId =
     memberships.find((m) => m.isDefault)?.workspaceId ?? rootIds[0];
 
-  const allowedIds = await expand(config, rootIds);
+  // `workspace` = đúng nút được gán, KHÔNG bung con cháu. Gấp ngay vào
+  // `allowedIds` ở đây thay vì bắt từng trang nhớ gọi `scopeLevelWhere`.
+  const allowedIds =
+    level === "workspace" ? rootIds : await expand(config, rootIds);
   // Quản trị viên của nhánh nào thì quản trị được cả con cháu nhánh đó — cùng
   // luật cộng dồn với phạm vi đọc, nếu không thì admin nút cha lại không đụng
   // được phòng ban con của chính mình.
@@ -122,6 +141,8 @@ export async function getWorkspaceScope<TSession>(
     allowedIds,
     adminIds,
     defaultId,
+    level,
+    userId,
   });
 }
 
@@ -252,6 +273,8 @@ export function memberScopeWhere(
   scope: WorkspaceScope,
   options?: { relation?: string; field?: string; adminOnly?: boolean },
 ): Record<string, unknown> {
+  // Nấc `own` trên chính bảng NGƯỜI DÙNG = chỉ thấy hồ sơ của mình.
+  if (scope.level === "own") return { id: scope.userId ?? NO_WORKSPACE_ACCESS };
   if (scope.canViewAll) return {};
   const config = configured;
   const relation =
@@ -274,8 +297,23 @@ export function memberScopeWhere(
  */
 export function scopedWhere(
   scope: WorkspaceScope,
-  options?: { field?: string; relation?: string },
+  options?: { field?: string; relation?: string; ownerField?: string },
 ): Record<string, unknown> {
+  // Nấc `own` là nấc DUY NHẤT không gấp được vào `allowedIds` — nó lọc theo
+  // người chứ không theo không gian. Không khai `ownerField` (ở đây hoặc trong
+  // `configureWorkspaces`) thì đóng lại: fail-closed, đừng lặng lẽ nới thành
+  // `subtree`.
+  if (scope.level === "own") {
+    const ownerField = options?.ownerField ?? configured?.ownerField;
+    if (options?.relation) {
+      return ownerField
+        ? { [options.relation]: { [ownerField]: scope.userId ?? NO_WORKSPACE_ACCESS } }
+        : { [options.relation]: { id: NO_WORKSPACE_ACCESS } };
+    }
+    return ownerField
+      ? { [ownerField]: scope.userId ?? NO_WORKSPACE_ACCESS }
+      : { id: NO_WORKSPACE_ACCESS };
+  }
   if (scope.canViewAll) return {};
   const field = options?.field ?? workspaceScopeField();
   const ids = scope.allowedIds ?? [NO_WORKSPACE_ACCESS];

package/src/workspace/types.ts

@@ -84,6 +84,18 @@ export interface WorkspaceScope extends BranchScope {
   adminIds: string[];
   /** Không gian mở sẵn khi đăng nhập / gán cho bản ghi mới tạo. */
   defaultId?: string;
+  /**
+   * Nấc cô lập dữ liệu ĐÃ ÁP dụng khi dựng phạm vi này (Δ1). Bỏ trống = `subtree`,
+   * đúng hành vi cũ.
+   *
+   * Bốn nấc `none/workspace/subtree/all` được **gấp thẳng vào** `canViewAll` +
+   * `allowedIds` lúc dựng, nên mọi `scopedWhere` / `memberScopeWhere` / guard
+   * lớp 2 đang có tự tuân theo mà không phải sửa một call-site nào. Riêng `own`
+   * cần biết cột chủ sở hữu nên phải khai ở call-site (`ownerField`).
+   */
+  level?: ScopeLevel;
+  /** Chủ phiên — chỉ dùng cho nấc `own`. */
+  userId?: string;
 }
 
 /**
@@ -175,6 +187,19 @@ export interface WorkspaceScopeConfig<TSession = unknown> {
   getUserId: (session: TSession) => string | null | undefined;
   /** "Xem mọi không gian" — app tự quyết (vai trò quản trị / quyền `view-all-workspaces`). */
   canViewAll: (session: TSession) => boolean;
+  /**
+   * NẤC CÔ LẬP DỮ LIỆU của phiên (Δ1) — thường là nấc RỘNG NHẤT trong các vai
+   * trò của người này (`Role.dataScope`). Bỏ trống ⇒ `subtree`, y hệt hôm nay.
+   *
+   * Trả `all` là bỏ cô lập (thấy hết), `workspace` là **không** bung con cháu,
+   * `none` là không thấy gì. Nấc này được gấp vào phạm vi lúc dựng nên không
+   * trang nào phải sửa — đó là lý do nó nằm ở đây chứ không rải ra call-site.
+   */
+  getScopeLevel?: (
+    session: TSession,
+  ) => ScopeLevel | null | undefined | Promise<ScopeLevel | null | undefined>;
+  /** Cột chủ sở hữu mặc định cho nấc `own` (VD `createdBy`). */
+  ownerField?: string;
   /** Trần độ sâu cây. Mặc định 4 (Δ9). */
   maxDepth?: number;
   /** Ngưỡng cảnh báo số con trực tiếp. Mặc định 200. */