@goplusvn/core 0.1.75 → 0.1.77

package/src/workspace/route-handlers.ts

@@ -0,0 +1,550 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Route-handler cho `/api/workspaces` — nơi phạm vi được cưỡng chế THẬT.
+//
+// Trang cây ở `pages/workspace-list-page.tsx` đã ẩn nút ở nhánh không quản trị
+// được, nhưng ẩn nút không phải là hàng rào: ai cũng gọi thẳng API được. Entra
+// từng thừa nhận đúng lỗi này (UI lọc, API thì không) — nên mọi kiểm tra ở đây
+// lặp lại độc lập với UI, không tin gì từ client.
+//
+// Cách dùng (phía app):
+//   // src/app/api/workspaces/route.ts
+//   import { createWorkspaceCollectionHandlers } from "@goerp/core/workspace/route-handlers"
+//   export const { GET, POST } = createWorkspaceCollectionHandlers({
+//     prisma, getSession, canManageAll: (s) => checkPermission(s, "workspace", "update"),
+//   })
+
+import { DelegationError, assertCanUpdateUser } from "./delegation";
+import type { DelegationActor } from "./delegation";
+import {
+  getWorkspaceConfig,
+  getWorkspaceScope,
+  isWorkspaceAdmin,
+  memberScopeWhere,
+} from "./scope";
+import {
+  buildTree,
+  createWorkspace,
+  deactivateSubtree,
+  moveWorkspace,
+} from "./service";
+import { WorkspaceTreeError } from "./tree";
+import type { WorkspaceScope } from "./types";
+
+type MaybePromise<T> = T | Promise<T>;
+
+export interface WorkspaceHandlerDeps {
+  prisma: any;
+  getSession: () => MaybePromise<any | null>;
+  /**
+   * Quyền quản trị toàn hệ thống. Bỏ trống ⇒ suy từ `scope.canViewAll`, tức là
+   * "xem được tất" cũng "sửa được tất" — chỉ đúng với app một tổ chức.
+   */
+  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>;
+}
+
+const json = (data: unknown, status = 200) =>
+  new Response(JSON.stringify(data), {
+    status,
+    headers: { "content-type": "application/json" },
+  });
+
+/** Lỗi cây là lỗi NGHIỆP VỤ (chu trình, quá sâu, sai cấp) → 400 kèm câu nguyên văn. */
+function failure(error: unknown, req: Request, deps: WorkspaceHandlerDeps) {
+  if (error instanceof WorkspaceTreeError) {
+    return json({ error: error.message }, 400);
+  }
+  return deps.onError
+    ? deps.onError(error, req)
+    : json({ error: "Internal error" }, 500);
+}
+
+interface Actor {
+  session: any;
+  scope: WorkspaceScope;
+  manageAll: boolean;
+}
+
+async function resolveActor(
+  deps: WorkspaceHandlerDeps,
+): Promise<Actor | Response> {
+  const session = await deps.getSession();
+  if (!session) return json({ error: "Unauthorized" }, 401);
+  if (deps.canRead && !(await deps.canRead(session))) {
+    return json({ error: "Forbidden" }, 403);
+  }
+  const scope = await getWorkspaceScope(session);
+  const manageAll = deps.canManageAll
+    ? await deps.canManageAll(session)
+    : scope.canViewAll;
+  return { session, scope, manageAll };
+}
+
+/** Ghi được nút này không? Toàn quyền, hoặc là quản trị viên của đúng nhánh đó. */
+function assertWritable(actor: Actor, workspaceId: string): Response | null {
+  if (actor.manageAll) return null;
+  if (isWorkspaceAdmin(actor.scope, workspaceId)) return null;
+  return json({ error: "Không gian này ngoài phạm vi quản trị của bạn." }, 403);
+}
+
+/**
+ * Cắt `path` / `parentId` trước khi trả về client.
+ *
+ * Cây đã dựng xong ở server nên UI không cần hai trường này, mà `path` là chuỗi
+ * `/{tổ-tiên}/…/{chính-nó}/` — gửi nguyên đi là lộ id của những nút cha mà người
+ * này không được thấy. Ít thông tin, nhưng vẫn là thông tin về cấu trúc tổ chức
+ * của tenant khác, và trường thừa thì không có lý do gì để rò.
+ */
+function toClient(nodes: any[]): any[] {
+  return nodes.map(({ path: _path, parentId: _parentId, ...node }) => ({
+    ...node,
+    children: toClient(node.children ?? []),
+  }));
+}
+
+/** GET (cây) + POST (tạo nút) cho `/api/workspaces`. */
+export function createWorkspaceCollectionHandlers(deps: WorkspaceHandlerDeps) {
+  async function GET(req: Request) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+
+      const rows = await deps.prisma.workspace.findMany({
+        orderBy: { path: "asc" },
+        select: {
+          id: true,
+          code: true,
+          name: true,
+          kind: true,
+          parentId: true,
+          path: true,
+          depth: true,
+          isActive: true,
+          _count: { select: { members: true } },
+        },
+      });
+
+      // Lọc ở SERVER, không ở trang. Người dùng chỉ nhận về nhánh mình thấy được
+      // — nếu không thì cây của mọi khách hàng khác nằm sẵn trong payload HTML.
+      const allowed = actor.scope.canViewAll
+        ? null
+        : new Set(actor.scope.allowedIds ?? []);
+      const visible = allowed
+        ? 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) {
+      return failure(error, req, deps);
+    }
+  }
+
+  async function POST(req: Request) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+
+      const body = await req.json();
+      const parentId: string | null = body?.parentId ?? null;
+
+      // Tạo nút GỐC là việc của toàn quyền: nút gốc nằm ngoài mọi nhánh nên
+      // không ai "quản trị" nó, và cho phép thì admin khách hàng tự dựng được
+      // một tổ chức song song bên cạnh tổ chức của mình.
+      if (!parentId) {
+        if (!actor.manageAll) {
+          return json(
+            { error: "Chỉ quản trị toàn hệ thống tạo được workspace gốc." },
+            403,
+          );
+        }
+      } else {
+        const denied = assertWritable(actor, parentId);
+        if (denied) return denied;
+      }
+
+      const created = await createWorkspace(deps.prisma, {
+        code: String(body?.code ?? "").trim(),
+        name: String(body?.name ?? "").trim(),
+        kind: body?.kind,
+        parentId,
+      });
+      return json(created, 201);
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  return { GET, POST };
+}
+
+/** PATCH (sửa) + DELETE (ngừng hoạt động cả nhánh) cho `/api/workspaces/[id]`. */
+export function createWorkspaceItemHandlers(deps: WorkspaceHandlerDeps) {
+  type Ctx = { params: Promise<{ id: string }> | { id: string } };
+
+  const readId = async (ctx: Ctx) => (await ctx.params).id;
+
+  async function PATCH(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 data: Record<string, unknown> = {};
+      if (body?.code !== undefined) data.code = String(body.code).trim();
+      if (body?.name !== undefined) data.name = String(body.name).trim();
+      if (body?.kind !== undefined) data.kind = body.kind;
+      if (body?.settings !== undefined) data.settings = body.settings;
+      // `path` / `depth` / `parentId` cố ý KHÔNG nhận từ body: sửa tay là cách
+      // làm hỏng cây mà UI vẫn trông đúng. Đổi cha đi qua `/move`.
+
+      const updated = await deps.prisma.workspace.update({
+        where: { id },
+        data,
+      });
+      return json(updated);
+    } 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;
+
+      // Soft-delete: xoá cứng thì phạm vi của chứng từ cũ thành mồ côi.
+      const count = await deactivateSubtree(deps.prisma, id);
+      return json({ deactivated: count });
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  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 } };
+
+  async function POST(req: Request, ctx: Ctx) {
+    try {
+      const actor = await resolveActor(deps);
+      if (actor instanceof Response) return actor;
+      const { id } = await ctx.params;
+
+      const denied = assertWritable(actor, id);
+      if (denied) return denied;
+
+      const body = await req.json();
+      const newParentId: string | null = body?.newParentId ?? null;
+
+      // Phải quản trị được CẢ hai đầu. Chỉ kiểm nút bị chuyển thì admin nhánh
+      // đẩy được nhánh của mình sang dưới tổ chức khác — hoặc lên gốc, thành
+      // một tổ chức độc lập ngang hàng với tổ chức mẹ.
+      if (newParentId) {
+        const deniedTarget = assertWritable(actor, newParentId);
+        if (deniedTarget) return deniedTarget;
+      } else if (!actor.manageAll) {
+        return json(
+          { error: "Chỉ quản trị toàn hệ thống chuyển được lên cấp cao nhất." },
+          403,
+        );
+      }
+
+      const moved = await moveWorkspace(deps.prisma, { id, newParentId });
+      return json({ updated: moved });
+    } catch (error) {
+      return failure(error, req, deps);
+    }
+  }
+
+  return { POST };
+}