@goplusvn/core 0.1.74 → 0.1.76

package/src/workspace/components/workspace-tree-view.tsx

@@ -0,0 +1,260 @@
+"use client";
+
+// Cây không gian làm việc — dạng DÒNG DÀY, không phải lưới thẻ (L11).
+//
+// Mỗi dòng mang: tên, mã, nhãn cấp, số thành viên, số quản trị viên. Cây tổ chức
+// là thứ người ta quét dọc để tìm một nhánh, nên dòng mảnh xếp sát nhau đọc
+// nhanh hơn hẳn thẻ to có icon.
+//
+// Nút hành động chỉ hiện khi hover / focus và CHỈ ở nhánh người dùng thực sự
+// quản trị được: hiện nút rồi để server trả 403 là cách chắc chắn làm người dùng
+// tưởng hệ thống hỏng.
+import * as React from "react";
+
+import { ChevronDown, ChevronRight, MoreHorizontal, Plus } from "lucide-react";
+
+import {
+  Badge,
+  Button,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "../../ui";
+import { cn } from "../../utils";
+
+export interface WorkspaceTreeNode {
+  id: string;
+  code: string;
+  name: string;
+  kind?: string;
+  kindLabel?: string;
+  isActive?: boolean;
+  memberCount?: number;
+  adminCount?: number;
+  children: WorkspaceTreeNode[];
+}
+
+export interface WorkspaceTreeViewProps {
+  nodes: WorkspaceTreeNode[];
+  /** Nhánh người dùng được uỷ quyền quản trị (đã bung con cháu). */
+  adminIds?: string[];
+  /** Xem-tất: mọi nút đều thao tác được. */
+  canManageAll?: boolean;
+  selectedId?: string | null;
+  onSelect?: (node: WorkspaceTreeNode) => void;
+  onAddChild?: (parent: WorkspaceTreeNode) => void;
+  onEdit?: (node: WorkspaceTreeNode) => void;
+  onMove?: (node: WorkspaceTreeNode) => void;
+  onDeactivate?: (node: WorkspaceTreeNode) => void;
+  /** Lọc theo tên/mã — nhánh cha của kết quả khớp vẫn hiện để giữ ngữ cảnh. */
+  search?: string;
+  emptyMessage?: string;
+}
+
+/** Giữ nhánh nào có ÍT NHẤT một hậu duệ khớp — cắt cha thì mất ngữ cảnh. */
+function filterTree(
+  nodes: WorkspaceTreeNode[],
+  term: string,
+): WorkspaceTreeNode[] {
+  const needle = term.trim().toLowerCase();
+  if (!needle) return nodes;
+  const walk = (node: WorkspaceTreeNode): WorkspaceTreeNode | null => {
+    const children = node.children
+      .map(walk)
+      .filter((n): n is WorkspaceTreeNode => n !== null);
+    const hit =
+      node.name.toLowerCase().includes(needle) ||
+      node.code.toLowerCase().includes(needle);
+    if (!hit && children.length === 0) return null;
+    return { ...node, children };
+  };
+  return nodes.map(walk).filter((n): n is WorkspaceTreeNode => n !== null);
+}
+
+function collectIds(nodes: WorkspaceTreeNode[], out: Set<string>): Set<string> {
+  for (const node of nodes) {
+    out.add(node.id);
+    collectIds(node.children, out);
+  }
+  return out;
+}
+
+export function WorkspaceTreeView({
+  nodes,
+  adminIds,
+  canManageAll = false,
+  selectedId,
+  onSelect,
+  onAddChild,
+  onEdit,
+  onMove,
+  onDeactivate,
+  search = "",
+  emptyMessage = "Chưa có không gian nào.",
+}: WorkspaceTreeViewProps) {
+  const visible = React.useMemo(
+    () => filterTree(nodes, search),
+    [nodes, search],
+  );
+
+  // Đang tìm kiếm thì bung hết — gõ xong mà vẫn phải tự mở từng nhánh là vô nghĩa.
+  const [collapsed, setCollapsed] = React.useState<Set<string>>(new Set());
+  const searching = search.trim().length > 0;
+
+  const adminSet = React.useMemo(() => new Set(adminIds ?? []), [adminIds]);
+  const canManage = React.useCallback(
+    (id: string) => canManageAll || adminSet.has(id),
+    [canManageAll, adminSet],
+  );
+
+  const toggle = (id: string) =>
+    setCollapsed((prev) => {
+      const next = new Set(prev);
+      if (next.has(id)) next.delete(id);
+      else next.add(id);
+      return next;
+    });
+
+  if (visible.length === 0) {
+    return (
+      <p className="px-4 py-10 text-center text-sm text-muted-foreground">
+        {searching ? "Không có không gian nào khớp." : emptyMessage}
+      </p>
+    );
+  }
+
+  const render = (node: WorkspaceTreeNode, depth: number): React.ReactNode => {
+    const hasChildren = node.children.length > 0;
+    const isOpen = searching || !collapsed.has(node.id);
+    const manageable = canManage(node.id);
+
+    return (
+      <React.Fragment key={node.id}>
+        <div
+          className={cn(
+            "group flex items-center gap-2 border-b border-border/60 px-2 py-1.5 text-sm transition-colors last:border-b-0",
+            selectedId === node.id ? "bg-muted" : "hover:bg-muted/50",
+            node.isActive === false && "opacity-55",
+          )}
+          style={{ paddingLeft: `${0.5 + depth * 1.25}rem` }}
+        >
+          {hasChildren ? (
+            <button
+              type="button"
+              onClick={() => toggle(node.id)}
+              className="shrink-0 text-muted-foreground hover:text-foreground"
+              title={isOpen ? "Thu gọn" : "Mở rộng"}
+              aria-label={isOpen ? "Thu gọn" : "Mở rộng"}
+            >
+              {isOpen ? (
+                <ChevronDown className="h-3.5 w-3.5" />
+              ) : (
+                <ChevronRight className="h-3.5 w-3.5" />
+              )}
+            </button>
+          ) : (
+            <span className="h-3.5 w-3.5 shrink-0" />
+          )}
+
+          <button
+            type="button"
+            onClick={() => onSelect?.(node)}
+            className="min-w-0 flex-1 truncate text-left font-medium"
+          >
+            {node.name}
+            {node.isActive === false ? (
+              <span className="ml-1.5 text-xs font-normal text-muted-foreground">
+                (ngừng)
+              </span>
+            ) : null}
+          </button>
+
+          <span className="hidden shrink-0 text-xs tabular-nums text-muted-foreground sm:inline">
+            {node.code}
+          </span>
+
+          {node.kindLabel ? (
+            <Badge variant="outline" className="hidden shrink-0 md:inline-flex">
+              {node.kindLabel}
+            </Badge>
+          ) : null}
+
+          {node.memberCount !== undefined ? (
+            <span
+              className="w-16 shrink-0 text-right text-xs tabular-nums text-muted-foreground"
+              title={
+                node.adminCount !== undefined
+                  ? `${node.memberCount} thành viên, ${node.adminCount} quản trị`
+                  : `${node.memberCount} thành viên`
+              }
+            >
+              {node.memberCount}
+              {node.adminCount ? ` · ${node.adminCount}` : ""}
+            </span>
+          ) : null}
+
+          {manageable ? (
+            <div className="flex shrink-0 items-center opacity-0 transition-opacity focus-within:opacity-100 group-hover:opacity-100">
+              {onAddChild ? (
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="h-7 w-7"
+                  onClick={() => onAddChild(node)}
+                  title="Thêm không gian con"
+                >
+                  <Plus className="h-3.5 w-3.5" />
+                </Button>
+              ) : null}
+              <DropdownMenu>
+                <DropdownMenuTrigger asChild>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="h-7 w-7"
+                    title="Thao tác khác"
+                  >
+                    <MoreHorizontal className="h-3.5 w-3.5" />
+                  </Button>
+                </DropdownMenuTrigger>
+                <DropdownMenuContent align="end">
+                  {onEdit ? (
+                    <DropdownMenuItem onClick={() => onEdit(node)}>
+                      Sửa thông tin
+                    </DropdownMenuItem>
+                  ) : null}
+                  {onMove ? (
+                    <DropdownMenuItem onClick={() => onMove(node)}>
+                      Chuyển nhánh
+                    </DropdownMenuItem>
+                  ) : null}
+                  {onDeactivate && node.isActive !== false ? (
+                    <>
+                      <DropdownMenuSeparator />
+                      <DropdownMenuItem
+                        className="text-destructive focus:text-destructive"
+                        onClick={() => onDeactivate(node)}
+                      >
+                        Ngừng hoạt động
+                      </DropdownMenuItem>
+                    </>
+                  ) : null}
+                </DropdownMenuContent>
+              </DropdownMenu>
+            </div>
+          ) : null}
+        </div>
+        {isOpen ? node.children.map((child) => render(child, depth + 1)) : null}
+      </React.Fragment>
+    );
+  };
+
+  return <div>{visible.map((node) => render(node, 0))}</div>;
+}
+
+/** Số nút trong cây — dùng cho bộ đếm ở toolbar. */
+export function countTreeNodes(nodes: WorkspaceTreeNode[]): number {
+  return collectIds(nodes, new Set()).size;
+}

package/src/workspace/context.ts

@@ -0,0 +1,78 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+import type { BranchScope } from "../branch-scope/types";
+
+import type { WorkspaceScope } from "./types";
+
+/**
+ * Context của lưới an toàn lớp 2 — **MỘT AsyncLocalStorage duy nhất cho cả
+ * `branch-scope` lẫn `workspace`**.
+ *
+ * Đây là điểm dễ hỏng nhất của việc tách module: hai store riêng thì
+ * `runWithoutScope()` chỉ thoát được store của nó, còn store kia vẫn lọc —
+ * nghĩa là `MAX(số phiếu)` lại bị cắt theo phạm vi và **sinh trùng số phiếu**
+ * (sự cố có thật RS-260727-0003). Vì vậy `branch-scope/context.ts` re-export
+ * thẳng file này chứ không tự tạo store.
+ *
+ * Phạm vi được resolve LƯỜI — lần đầu một model bị guard thực sự được đọc.
+ * Request không đụng model nào bị guard thì không tốn thêm truy vấn nào.
+ *
+ * File này cố ý không import phần scope: composition root của app tiêm hàm
+ * `resolve` vào lúc mở context, nhờ vậy context không kéo theo prisma và không
+ * tạo vòng import.
+ */
+
+export interface ScopeContext<TScope = BranchScope | WorkspaceScope> {
+  resolve: () => Promise<TScope>;
+  /** Cache trong phạm vi 1 request — extension gán ở lần resolve đầu. */
+  cached?: Promise<TScope>;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const store = new AsyncLocalStorage<ScopeContext<any>>();
+
+/**
+ * PrismaPromise là LƯỜI: truy vấn chỉ thật sự chạy ở lần `.then()` đầu tiên.
+ * `run(ctx, () => db.x.count())` trả promise chưa chạy ra ngoài, người gọi
+ * `await` bên ngoài → truy vấn chạy NGOÀI context → guard im lặng không lọc
+ * (và với `exit` thì ngược lại: truy vấn cần toàn cục lại bị lọc → trùng số
+ * phiếu). Gọi `.then` ngay tại đây, khi còn ở trong/ngoài context đúng như ý,
+ * để việc chạy được ghim vào đúng phạm vi — bất kể người gọi await ở đâu.
+ */
+function pinToCurrentContext<T>(result: T): T {
+  const thenable = result as { then?: unknown };
+  if (typeof thenable?.then !== "function") return result;
+  return (result as unknown as Promise<unknown>).then((value) => value) as T;
+}
+
+export function runWithScope<T, TScope = BranchScope | WorkspaceScope>(
+  context: ScopeContext<TScope>,
+  fn: () => T | Promise<T>,
+): T | Promise<T> {
+  return store.run(context, () => pinToCurrentContext(fn()));
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getScopeContext(): ScopeContext<any> | undefined {
+  return store.getStore();
+}
+
+/** Phạm vi của request hiện tại (resolve + cache); undefined khi ở ngoài context. */
+export function resolveAmbientScope<TScope = BranchScope | WorkspaceScope>():
+  | Promise<TScope>
+  | undefined {
+  const ctx = store.getStore();
+  if (!ctx) return undefined;
+  ctx.cached ??= ctx.resolve();
+  return ctx.cached as Promise<TScope>;
+}
+
+/**
+ * Chạy `fn` NGOÀI lưới guard — cho truy vấn hạ tầng mà kết quả phải toàn cục
+ * bất kể phạm vi user. Ca kinh điển: đánh số phiếu (`MAX(number)` bị lọc theo
+ * phạm vi là sinh trùng số → lỗi unique). Mọi `await` bên trong đều thoát
+ * guard, nên chỉ bọc đúng truy vấn cần toàn cục, đừng bọc cả handler.
+ */
+export function runWithoutScope<T>(fn: () => T): T {
+  return store.exit(() => pinToCurrentContext(fn()));
+}