@goplusvn/core 0.1.75 → 0.1.77

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

@@ -0,0 +1,339 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { configureWorkspaces, resetWorkspaceConfig } from "../scope";
+import {
+  buildTree,
+  createWorkspace,
+  deactivateSubtree,
+  listSubtree,
+  moveWorkspace,
+} from "../service";
+import { WorkspaceTreeError } from "../tree";
+import type { WorkspaceServiceDb } from "../service";
+import type { WorkspaceNode } from "../types";
+
+interface Row {
+  id: string;
+  code: string;
+  name: string;
+  kind: string;
+  parentId: string | null;
+  path: string;
+  depth: number;
+  isActive: boolean;
+  settings?: unknown;
+}
+
+/**
+ * DB giả trong bộ nhớ. Chỉ hiểu đúng những dạng `where` mà service thật sự phát
+ * ra (`id`, `parentId`, `path.startsWith`) — where lạ thì NÉM, để test không âm
+ * thầm đúng khi service đổi cách truy vấn.
+ */
+function fakeDb(seed: Row[] = []) {
+  const rows = new Map<string, Row>(seed.map((r) => [r.id, r]));
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const match = (row: Row, where: any): boolean => {
+    if (!where) return true;
+    for (const [key, cond] of Object.entries(where)) {
+      if (key === "path" && cond && typeof cond === "object") {
+        const startsWith = (cond as { startsWith?: string }).startsWith;
+        if (startsWith === undefined) throw new Error("where.path lạ");
+        if (!row.path.startsWith(startsWith)) return false;
+        continue;
+      }
+      if (key !== "id" && key !== "parentId") {
+        throw new Error(`fakeDb chưa hiểu where.${key}`);
+      }
+      if ((row as unknown as Record<string, unknown>)[key] !== cond)
+        return false;
+    }
+    return true;
+  };
+
+  const db: WorkspaceServiceDb & { rows: Map<string, Row> } = {
+    rows,
+    workspace: {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      findMany: async (args?: any) => {
+        const out = [...rows.values()].filter((r) => match(r, args?.where));
+        if (args?.orderBy?.path === "asc")
+          out.sort((a, b) => a.path.localeCompare(b.path));
+        return out;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      findUnique: async (args: any) => rows.get(args.where.id) ?? null,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      create: async (args: any) => {
+        const row = { isActive: true, ...args.data } as Row;
+        rows.set(row.id, row);
+        return row;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      update: async (args: any) => {
+        const row = rows.get(args.where.id);
+        if (!row) throw new Error("không có dòng để update");
+        Object.assign(row, args.data);
+        return row;
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      count: async (args?: any) =>
+        [...rows.values()].filter((r) => match(r, args?.where)).length,
+    },
+  };
+  return db;
+}
+
+/** Cây mẫu giống bộ test phạm vi: 2 đơn vị, Spartronics có 2 phòng ban. */
+function seedTree(): Row[] {
+  return [
+    row("tanloc", null, "/tanloc/", 1, "unit"),
+    row("spa", null, "/spa/", 1, "unit"),
+    row("spa-qc", "spa", "/spa/spa-qc/", 2, "department"),
+    row("spa-kho", "spa", "/spa/spa-kho/", 2, "department"),
+  ];
+}
+
+function row(
+  id: string,
+  parentId: string | null,
+  path: string,
+  depth: number,
+  kind: string,
+): Row {
+  return {
+    id,
+    code: id.toUpperCase(),
+    name: id,
+    kind,
+    parentId,
+    path,
+    depth,
+    isActive: true,
+  };
+}
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+  configureWorkspaces({
+    getUserId: () => undefined,
+    canViewAll: () => false,
+  });
+});
+
+describe("createWorkspace", () => {
+  it("nút gốc: path là /{id}/ và depth 1", async () => {
+    const db = fakeDb();
+    const created = await createWorkspace(db, { code: "TL", name: "Tấn Lộc" });
+    expect(created.path).toBe(`/${created.id}/`);
+    expect(created.depth).toBe(1);
+    expect(created.parentId).toBeNull();
+  });
+
+  it("nút con nối path của cha và id nằm TRONG path", async () => {
+    const db = fakeDb(seedTree());
+    const created = await createWorkspace(db, {
+      code: "SPA-IT",
+      name: "IT",
+      kind: "department",
+      parentId: "spa",
+    });
+    expect(created.path).toBe(`/spa/${created.id}/`);
+    expect(created.depth).toBe(2);
+  });
+
+  it("id truyền vào được giữ nguyên — đường backfill workspace.id = branch.id", async () => {
+    const db = fakeDb();
+    const created = await createWorkspace(db, {
+      id: "cn-hcm",
+      code: "HCM",
+      name: "Hồ Chí Minh",
+      kind: "branch",
+    });
+    expect(created.id).toBe("cn-hcm");
+    expect(created.path).toBe("/cn-hcm/");
+  });
+
+  it("cha không tồn tại thì ném, không tạo nút mồ côi", async () => {
+    const db = fakeDb(seedTree());
+    await expect(
+      createWorkspace(db, { code: "X", name: "X", parentId: "khong-co" }),
+    ).rejects.toThrow(WorkspaceTreeError);
+    expect(db.rows.size).toBe(4);
+  });
+
+  it("vượt trần độ sâu thì ném TRƯỚC khi ghi", async () => {
+    resetWorkspaceConfig();
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      maxDepth: 2,
+    });
+    const db = fakeDb(seedTree());
+    await expect(
+      createWorkspace(db, {
+        code: "X",
+        name: "X",
+        kind: "department",
+        parentId: "spa-qc",
+      }),
+    ).rejects.toThrow(WorkspaceTreeError);
+    expect(db.rows.size).toBe(4);
+  });
+
+  it("kind khai canHaveChildren: false thì chặn tạo con", async () => {
+    resetWorkspaceConfig();
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      kinds: [
+        { key: "unit", label: "Đơn vị", childKinds: ["department"] },
+        { key: "department", label: "Bộ phận", canHaveChildren: false },
+      ],
+    });
+    const db = fakeDb(seedTree());
+    await expect(
+      createWorkspace(db, {
+        code: "X",
+        name: "X",
+        kind: "department",
+        parentId: "spa-qc",
+      }),
+    ).rejects.toThrow(/không được có workspace con/);
+  });
+
+  it("kind ngoài childKinds của cha thì chặn", async () => {
+    resetWorkspaceConfig();
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      kinds: [
+        { key: "unit", label: "Đơn vị", childKinds: ["department"] },
+        { key: "department", label: "Bộ phận" },
+      ],
+    });
+    const db = fakeDb(seedTree());
+    await expect(
+      createWorkspace(db, {
+        code: "X",
+        name: "X",
+        kind: "unit",
+        parentId: "spa",
+      }),
+    ).rejects.toThrow(/chỉ đặt được/);
+  });
+
+  it("quá nhiều con thì CẢNH BÁO chứ không chặn", async () => {
+    resetWorkspaceConfig();
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      maxChildren: 2,
+    });
+    const db = fakeDb(seedTree());
+    const onWarn = vi.fn();
+    const created = await createWorkspace(
+      db,
+      { code: "X", name: "X", kind: "department", parentId: "spa" },
+      { onWarn },
+    );
+    expect(created.id).toBeTruthy();
+    expect(onWarn).toHaveBeenCalledOnce();
+    expect(onWarn.mock.calls[0][0]).toMatch(/2 nút con/);
+  });
+});
+
+describe("moveWorkspace", () => {
+  it("chuyển nhánh thì repath CẢ con cháu", async () => {
+    const db = fakeDb(seedTree());
+    const count = await moveWorkspace(db, { id: "spa", newParentId: "tanloc" });
+    expect(count).toBe(3);
+    expect(db.rows.get("spa")!.path).toBe("/tanloc/spa/");
+    expect(db.rows.get("spa-qc")!.path).toBe("/tanloc/spa/spa-qc/");
+    expect(db.rows.get("spa-kho")!.depth).toBe(3);
+  });
+
+  it("chỉ nút được chuyển đổi parentId; con cháu giữ nguyên cha của chúng", async () => {
+    const db = fakeDb(seedTree());
+    await moveWorkspace(db, { id: "spa", newParentId: "tanloc" });
+    expect(db.rows.get("spa")!.parentId).toBe("tanloc");
+    expect(db.rows.get("spa-qc")!.parentId).toBe("spa");
+  });
+
+  it("chuyển lên gốc", async () => {
+    const db = fakeDb(seedTree());
+    await moveWorkspace(db, { id: "spa-qc", newParentId: null });
+    expect(db.rows.get("spa-qc")!.path).toBe("/spa-qc/");
+    expect(db.rows.get("spa-qc")!.parentId).toBeNull();
+    expect(db.rows.get("spa-qc")!.depth).toBe(1);
+  });
+
+  it("chuyển vào chính con cháu mình = chu trình → ném, không ghi gì", async () => {
+    const db = fakeDb(seedTree());
+    await expect(
+      moveWorkspace(db, { id: "spa", newParentId: "spa-qc" }),
+    ).rejects.toThrow(WorkspaceTreeError);
+    expect(db.rows.get("spa")!.path).toBe("/spa/");
+    expect(db.rows.get("spa-qc")!.path).toBe("/spa/spa-qc/");
+  });
+
+  it("nhánh sâu chuyển xuống làm vượt trần → ném TRƯỚC khi ghi dòng nào", async () => {
+    resetWorkspaceConfig();
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      maxDepth: 2,
+    });
+    const db = fakeDb(seedTree());
+    // /spa/ (1) + con (2) chuyển xuống /tanloc/ ⇒ con thành depth 3 > trần 2.
+    await expect(
+      moveWorkspace(db, { id: "spa", newParentId: "tanloc" }),
+    ).rejects.toThrow(WorkspaceTreeError);
+    expect(db.rows.get("spa")!.path).toBe("/spa/");
+    expect(db.rows.get("spa-qc")!.path).toBe("/spa/spa-qc/");
+  });
+});
+
+describe("listSubtree / deactivateSubtree", () => {
+  it("listSubtree gồm cả chính nó, sắp theo path", async () => {
+    const db = fakeDb(seedTree());
+    const rows = await listSubtree(db, "spa");
+    expect(rows.map((r) => r.id)).toEqual(["spa", "spa-kho", "spa-qc"]);
+  });
+
+  it("nút không tồn tại → mảng rỗng", async () => {
+    const db = fakeDb(seedTree());
+    expect(await listSubtree(db, "khong-co")).toEqual([]);
+  });
+
+  it("deactivateSubtree tắt cả nhánh, KHÔNG xoá dòng nào", async () => {
+    const db = fakeDb(seedTree());
+    const count = await deactivateSubtree(db, "spa");
+    expect(count).toBe(3);
+    expect(db.rows.size).toBe(4);
+    expect(db.rows.get("spa-qc")!.isActive).toBe(false);
+    expect(db.rows.get("tanloc")!.isActive).toBe(true);
+  });
+});
+
+describe("buildTree", () => {
+  it("dựng cây lồng nhau từ danh sách phẳng", () => {
+    const nodes: WorkspaceNode[] = seedTree().map((r) => ({
+      id: r.id,
+      parentId: r.parentId,
+      path: r.path,
+      kind: r.kind,
+    }));
+    const roots = buildTree(nodes);
+    expect(roots.map((r) => r.id)).toEqual(["tanloc", "spa"]);
+    expect(roots[1].children.map((c) => c.id)).toEqual(["spa-qc", "spa-kho"]);
+    expect(roots[0].children).toEqual([]);
+  });
+
+  it("nút có cha KHÔNG nằm trong danh sách vẫn hiện ra như gốc, không biến mất", () => {
+    const roots = buildTree([
+      { id: "spa-qc", parentId: "spa", path: "/spa/spa-qc/", kind: "dept" },
+    ]);
+    expect(roots.map((r) => r.id)).toEqual(["spa-qc"]);
+  });
+});

package/src/workspace/components/scope-level-select.tsx

@@ -0,0 +1,91 @@
+"use client";
+
+// Thang phạm vi 5 nấc (Δ1 — theo Dynamics 365). Dùng ở trang Vai trò: mỗi quyền
+// không chỉ có/không, mà còn "rộng tới đâu".
+//
+// Lý do là một component riêng chứ không phải `<Select>` gõ tay tại chỗ: chữ
+// hiển thị của mỗi nấc phụ thuộc NHÃN của app ("Chi nhánh của tôi" ở vinhhoa,
+// "Đơn vị của tôi" ở spartronics). Rải ra call-site thì mỗi trang một chữ.
+import * as React from "react";
+
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "../../ui";
+import { SCOPE_LEVELS, SCOPE_LEVEL_LABELS } from "../types";
+import type { ScopeLevel } from "../types";
+
+/** Mô tả ngắn dưới mỗi nấc — người tick quyền cần biết "rộng tới đâu". */
+const HINTS: Record<ScopeLevel, string> = {
+  none: "Không thấy gì",
+  own: "Chỉ bản ghi do chính mình tạo",
+  workspace: "Đúng workspace được gán",
+  subtree: "Workspace được gán và cấp dưới",
+  all: "Toàn hệ thống",
+};
+
+export interface ScopeLevelSelectProps {
+  value: ScopeLevel;
+  onChange: (level: ScopeLevel) => void;
+  /**
+   * Nấc CAO NHẤT được chọn. Admin nhánh không được cấp đi nấc `all` — cắt ngay ở
+   * dropdown thay vì để họ chọn rồi server mới từ chối.
+   */
+  maxLevel?: ScopeLevel;
+  /** Nhãn thay cho "Workspace" theo app: "Chi nhánh", "Đơn vị", "Phòng ban". */
+  kindLabel?: string;
+  disabled?: boolean;
+  className?: string;
+  id?: string;
+}
+
+/** Nhãn nấc, đã thay chữ "Workspace" bằng nhãn của app. */
+export function scopeLevelLabel(level: ScopeLevel, kindLabel?: string): string {
+  const base = SCOPE_LEVEL_LABELS[level];
+  if (!kindLabel) return base;
+  if (level === "workspace") return `${kindLabel} của tôi`;
+  if (level === "subtree") return `${kindLabel} và cấp dưới`;
+  return base;
+}
+
+export function ScopeLevelSelect({
+  value,
+  onChange,
+  maxLevel = "all",
+  kindLabel,
+  disabled,
+  className,
+  id,
+}: ScopeLevelSelectProps) {
+  const options = React.useMemo(() => {
+    const cap = SCOPE_LEVELS.indexOf(maxLevel);
+    return SCOPE_LEVELS.slice(0, cap >= 0 ? cap + 1 : SCOPE_LEVELS.length);
+  }, [maxLevel]);
+
+  return (
+    <Select
+      value={value}
+      onValueChange={(v) => onChange(v as ScopeLevel)}
+      disabled={disabled}
+    >
+      <SelectTrigger id={id} className={className}>
+        <SelectValue placeholder="Chọn phạm vi" />
+      </SelectTrigger>
+      <SelectContent>
+        {options.map((level) => (
+          <SelectItem key={level} value={level}>
+            <span className="flex flex-col items-start">
+              <span>{scopeLevelLabel(level, kindLabel)}</span>
+              <span className="text-xs text-muted-foreground">
+                {HINTS[level]}
+              </span>
+            </span>
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}