@goplusvn/core 0.1.76 → 0.1.77

package/src/workspace/route-handlers.ts

@@ -13,7 +13,14 @@
 //     prisma, getSession, canManageAll: (s) => checkPermission(s, "workspace", "update"),
 //   })
 
-import { getWorkspaceScope, isWorkspaceAdmin } from "./scope";
+import { DelegationError, assertCanUpdateUser } from "./delegation";
+import type { DelegationActor } from "./delegation";
+import {
+  getWorkspaceConfig,
+  getWorkspaceScope,
+  isWorkspaceAdmin,
+  memberScopeWhere,
+} from "./scope";
 import {
   buildTree,
   createWorkspace,
@@ -35,6 +42,14 @@ export interface WorkspaceHandlerDeps {
   canManageAll?: (session: any) => MaybePromise<boolean>;
   /** Gate đọc; bỏ trống = ai đăng nhập cũng đọc được cây (trong phạm vi của mình). */
   canRead?: (session: any) => MaybePromise<boolean>;
+  /**
+   * Nhãn cấp của app, để GET trả kèm `kindLabel`.
+   *
+   * Bỏ trống thì cây tải lại sau mỗi lần thêm/sửa sẽ MẤT nhãn cấp — trang server
+   * render có nhãn, `reload()` thì không, và huy hiệu "Bộ phận" lặng lẽ biến mất
+   * cho tới khi người dùng F5.
+   */
+  kinds?: { key: string; label: string }[];
   onError?: (error: unknown, req: Request) => Response | Promise<Response>;
 }
 
@@ -128,15 +143,33 @@ export function createWorkspaceCollectionHandlers(deps: WorkspaceHandlerDeps) {
         ? rows.filter((r: any) => allowed.has(r.id))
         : rows;
 
+      // Số quản trị đếm riêng bằng groupBy: `_count` của Prisma không lọc được
+      // theo `isAdmin`, mà đây là con số phân biệt "có người cầm trịch nhánh
+      // này" với "một đống thành viên không ai quản" — không suy ra được từ
+      // tổng thành viên.
+      const adminRows = await deps.prisma.userWorkspace.groupBy({
+        by: ["workspaceId"],
+        where: { isAdmin: true },
+        _count: { _all: true },
+      });
+      const adminCounts = new Map<string, number>(
+        adminRows.map((r: any) => [r.workspaceId, r._count?._all ?? 0]),
+      );
+      const kindLabels = new Map<string, string>(
+        (deps.kinds ?? []).map((k) => [k.key, k.label]),
+      );
+
       const nodes = visible.map((r: any) => ({
         id: r.id,
         code: r.code,
         name: r.name,
         kind: r.kind,
+        kindLabel: kindLabels.get(r.kind) ?? undefined,
         parentId: r.parentId,
         path: r.path,
         isActive: r.isActive,
         memberCount: r._count?.members ?? 0,
+        adminCount: adminCounts.get(r.id) ?? 0,
       }));
       return json(toClient(buildTree(nodes)));
     } catch (error) {
@@ -158,7 +191,7 @@ export function createWorkspaceCollectionHandlers(deps: WorkspaceHandlerDeps) {
       if (!parentId) {
         if (!actor.manageAll) {
           return json(
-            { error: "Chỉ quản trị toàn hệ thống tạo được không gian gốc." },
+            { error: "Chỉ quản trị toàn hệ thống tạo được workspace gốc." },
             403,
           );
         }
@@ -234,6 +267,249 @@ export function createWorkspaceItemHandlers(deps: WorkspaceHandlerDeps) {
   return { PATCH, DELETE };
 }
 
+/**
+ * GET (thành viên + tìm ứng viên) / POST (gán, đổi cờ) / DELETE (gỡ) cho
+ * `/api/workspaces/[id]/members`.
+ *
+ * Đây là đường DUY NHẤT ghi bảng membership từ giao diện. Mọi thao tác đi qua
+ * `assertCanUpdateUser` — không tự gọi lẻ từng luật D1…D7, vì quên một cái là
+ * thủng một bất biến, mà thủng thì không có gì báo.
+ */
+export function createWorkspaceMemberHandlers(deps: WorkspaceHandlerDeps) {
+  type Ctx = { params: Promise<{ id: string }> | { id: string } };
+
+  const readId = async (ctx: Ctx) => (await ctx.params).id;
+
+  /**
+   * Actor cho tầng uỷ quyền.
+   *
+   * `permissions` rỗng + `rank` thấp nhất là CỐ Ý: endpoint này chỉ ghi
+   * membership, KHÔNG gán vai trò, nên D2 (trần quyền) và D4 (cấm vai trò nguy
+   * hiểm) không có gì để soi — hai luật đó đọc đúng hai trường này.
+   * **Đừng tái dùng actor này cho đường gán vai trò**: ở đó `permissions`/`rank`
+   * rỗng nghĩa là hai luật kia thành no-op, tức mở toang đường leo thang.
+   */
+  const toDelegationActor = (actor: Actor): DelegationActor => ({
+    // Lấy id qua `getUserId` của config, KHÔNG đọc `session.user.id`: hình dạng
+    // session là chuyện của app (NextAuth, Better Auth, session tự chế…). Đoán
+    // sai thì `userId` thành chuỗi rỗng, và D3 — luật cấm tự nâng chính mình —
+    // im lặng không khớp ai cả.
+    userId: String(getWorkspaceConfig()?.getUserId(actor.session) ?? ""),
+    scope: actor.scope,
+    canManageAll: actor.manageAll,
+    permissions: new Set<string>(),
+    rank: Number.MAX_SAFE_INTEGER,
+  });
+
+  /** Lỗi uỷ quyền là 403 kèm nguyên văn câu giải thích — người dùng cần biết VÌ SAO. */
+  const delegationFailure = (error: unknown) =>
+    error instanceof DelegationError
+      ? json({ error: error.message, code: error.code }, 403)
+      : null;
+
+  /** Membership ĐẦY ĐỦ của target, không phải phần giao với phạm vi actor (D5/D7 cần cả). */
+  async function loadTarget(userId: string) {
+    const user = await deps.prisma.user.findUnique({
+      where: { id: userId },
+      select: {
+        id: true,
+        isProtected: true,
+        permissionCeilingRoleId: true,
+        userWorkspaces: { select: { workspaceId: true } },
+      },
+    });
+    if (!user) return null;
+    return {
+      id: user.id,
+      isProtected: user.isProtected ?? false,
+      permissionCeilingRoleId: user.permissionCeilingRoleId ?? null,
+      workspaceIds: user.userWorkspaces.map(
+        (m: any) => m.workspaceId as string,
+      ) as string[],
+    };
+  }
+
+  async function GET(req: Request, ctx: Ctx) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+      const id = await readId(ctx);
+
+      // Đọc thì chỉ cần THẤY được nút; ghi mới cần quản trị được nút.
+      if (
+        !actor.scope.canViewAll &&
+        !(actor.scope.allowedIds ?? []).includes(id)
+      ) {
+        return json({ error: "Không gian này ngoài phạm vi của bạn." }, 403);
+      }
+
+      const url = new URL(req.url);
+      const query = (url.searchParams.get("q") ?? "").trim();
+
+      if (url.searchParams.get("candidates") === "1") {
+        const denied = assertWritable(actor, id);
+        if (denied) return denied;
+
+        // Ứng viên chỉ lấy trong nhánh mình QUẢN TRỊ (adminOnly), không phải
+        // nhánh mình xem được: xem được cả công ty mà thêm được ai cũng vào
+        // nhánh mình thì D1 chỉ còn là trang trí.
+        const rows = await deps.prisma.user.findMany({
+          where: {
+            AND: [
+              memberScopeWhere(actor.scope, { adminOnly: true }),
+              { userWorkspaces: { none: { workspaceId: id } } },
+              query
+                ? {
+                    OR: [
+                      { name: { contains: query, mode: "insensitive" } },
+                      { email: { contains: query, mode: "insensitive" } },
+                    ],
+                  }
+                : {},
+            ],
+          },
+          select: { id: true, name: true, email: true, isActive: true },
+          orderBy: { name: "asc" },
+          take: 20,
+        });
+        return json(rows);
+      }
+
+      const rows = await deps.prisma.userWorkspace.findMany({
+        where: { workspaceId: id },
+        select: {
+          isAdmin: true,
+          isDefault: true,
+          user: {
+            select: { id: true, name: true, email: true, isActive: true },
+          },
+        },
+        orderBy: [{ isAdmin: "desc" }, { user: { name: "asc" } }],
+      });
+      return json(
+        rows.map((r: any) => ({
+          userId: r.user.id,
+          name: r.user.name,
+          email: r.user.email,
+          isActive: r.user.isActive,
+          isAdmin: r.isAdmin,
+          isDefault: r.isDefault,
+        })),
+      );
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  /** Gán người vào không gian, hoặc đổi cờ quản trị / mặc định của người đã ở trong. */
+  async function POST(req: Request, ctx: Ctx) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+      const id = await readId(ctx);
+      const denied = assertWritable(actor, id);
+      if (denied) return denied;
+
+      const body = await req.json();
+      const userId = String(body?.userId ?? "").trim();
+      if (!userId) return json({ error: "Thiếu userId." }, 400);
+
+      const target = await loadTarget(userId);
+      if (!target) return json({ error: "Không tìm thấy người dùng." }, 404);
+
+      const already = target.workspaceIds.includes(id);
+      const next = already ? target.workspaceIds : [...target.workspaceIds, id];
+      try {
+        assertCanUpdateUser(toDelegationActor(actor), target, {
+          workspaceIds: next,
+        });
+      } catch (error) {
+        const denied403 = delegationFailure(error);
+        if (denied403) return denied403;
+        throw error;
+      }
+
+      const isAdmin = Boolean(body?.isAdmin);
+      const isDefault = Boolean(body?.isDefault);
+
+      await deps.prisma.$transaction(async (tx: any) => {
+        // "Mặc định" là DUY NHẤT trên mỗi người: không hạ cờ cũ xuống thì lúc
+        // đăng nhập biết mở không gian nào.
+        if (isDefault) {
+          await tx.userWorkspace.updateMany({
+            where: { userId, isDefault: true, NOT: { workspaceId: id } },
+            data: { isDefault: false },
+          });
+        }
+        await tx.userWorkspace.upsert({
+          where: { userId_workspaceId: { userId, workspaceId: id } },
+          create: { userId, workspaceId: id, isAdmin, isDefault },
+          update: { isAdmin, isDefault },
+        });
+      });
+
+      return json(
+        { userId, workspaceId: id, isAdmin, isDefault },
+        already ? 200 : 201,
+      );
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  async function DELETE(req: Request, ctx: Ctx) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+      const id = await readId(ctx);
+      const denied = assertWritable(actor, id);
+      if (denied) return denied;
+
+      const url = new URL(req.url);
+      const userId = String(url.searchParams.get("userId") ?? "").trim();
+      if (!userId) return json({ error: "Thiếu userId." }, 400);
+
+      const target = await loadTarget(userId);
+      if (!target) return json({ error: "Không tìm thấy người dùng." }, 404);
+      if (!target.workspaceIds.includes(id)) {
+        return json({ removed: 0 });
+      }
+
+      const next = target.workspaceIds.filter((w) => w !== id);
+      try {
+        assertCanUpdateUser(toDelegationActor(actor), target, {
+          workspaceIds: next,
+        });
+      } catch (error) {
+        const denied403 = delegationFailure(error);
+        if (denied403) return denied403;
+        throw error;
+      }
+
+      // Gỡ hết thì người này không còn phạm vi nào — với admin nhánh đó là ngõ
+      // cụt (D5 chặn mọi thao tác sau đó), nên chặn ngay và nói rõ.
+      if (!actor.manageAll && next.length === 0) {
+        return json(
+          {
+            error:
+              "Không thể gỡ workspace cuối cùng của người dùng — hãy chuyển họ sang workspace khác trước.",
+          },
+          400,
+        );
+      }
+
+      const result = await deps.prisma.userWorkspace.deleteMany({
+        where: { userId, workspaceId: id },
+      });
+      return json({ removed: result.count ?? 0 });
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  return { GET, POST, DELETE };
+}
+
 /** POST cho `/api/workspaces/[id]/move`. */
 export function createWorkspaceMoveHandler(deps: WorkspaceHandlerDeps) {
   type Ctx = { params: Promise<{ id: string }> | { id: string } };

package/src/workspace/service.ts

@@ -79,7 +79,7 @@ function assertKindAllowed(
   if (!parent) return;
   if (parent.canHaveChildren === false) {
     throw new WorkspaceTreeError(
-      `"${parent.label}" không được có không gian con.`,
+      `"${parent.label}" không được có workspace con.`,
     );
   }
   if (
@@ -140,7 +140,7 @@ export async function createWorkspace(
       select: { id: true, path: true, kind: true },
     });
     if (!parent) {
-      throw new WorkspaceTreeError("Không tìm thấy không gian cha.");
+      throw new WorkspaceTreeError("Không tìm thấy workspace cha.");
     }
     assertKindAllowed(parent.kind, input.kind);
     parentPath = parent.path;
@@ -184,14 +184,14 @@ export async function moveWorkspace(
 
   const moved = nodes.find((n) => n.id === input.id);
   if (!moved)
-    throw new WorkspaceTreeError("Không tìm thấy không gian cần chuyển.");
+    throw new WorkspaceTreeError("Không tìm thấy workspace cần chuyển.");
 
   assertNoCycle(input.id, input.newParentId, nodes);
 
   let newParentPath: string | null = null;
   if (input.newParentId) {
     const parent = nodes.find((n) => n.id === input.newParentId);
-    if (!parent) throw new WorkspaceTreeError("Không tìm thấy không gian cha.");
+    if (!parent) throw new WorkspaceTreeError("Không tìm thấy workspace cha.");
     assertKindAllowed(parent.kind, moved.kind);
     newParentPath = parent.path;
   }

package/src/workspace/tree.ts

@@ -170,7 +170,7 @@ export function assertNoCycle(
   if (!parent || !moved) return;
   if (isInSubtree(parent.path, subtreePrefix(moved.path))) {
     throw new WorkspaceTreeError(
-      "Không thể chuyển một không gian vào bên trong nhánh con của chính nó.",
+      "Không thể chuyển một workspace vào bên trong nhánh con của chính nó.",
     );
   }
 }

package/src/workspace/types.ts

@@ -106,7 +106,7 @@ export const SCOPE_LEVELS: readonly ScopeLevel[] = [
 export const SCOPE_LEVEL_LABELS: Record<ScopeLevel, string> = {
   none: "Không",
   own: "Của tôi",
-  workspace: "Không gian của tôi",
+  workspace: "Workspace của tôi",
   subtree: "Cả nhánh con",
   all: "Tất cả",
 };