@goplusvn/core 0.1.74 → 0.1.76

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

@@ -0,0 +1,592 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  getBranchScopeContext,
+  resolveAmbientBranchScope,
+  runWithBranchScope,
+  runWithoutBranchScope,
+} from "../../branch-scope/context";
+import { canAccessBranch, scopedBranchWhere } from "../../branch-scope/scope";
+import {
+  getScopeContext,
+  resolveAmbientScope,
+  runWithScope,
+  runWithoutScope,
+} from "../context";
+import { createScopeGuardExtension } from "../guard";
+import {
+  canAccessWorkspace,
+  clampScopeFilter,
+  clampToAdminScope,
+  configureWorkspaces,
+  createWorkspaceScope,
+  getWorkspaceScope,
+  hasAdminScope,
+  isWorkspaceAdmin,
+  memberScopeWhere,
+  resetWorkspaceConfig,
+  scopeLevelAtLeast,
+  scopeLevelWhere,
+  scopedWhere,
+} from "../scope";
+import {
+  assertDepthLimit,
+  assertNoCycle,
+  buildPath,
+  isInSubtree,
+  pathDepth,
+  repathSubtree,
+  selfAndDescendants,
+  WorkspaceTreeError,
+} from "../tree";
+import { NO_WORKSPACE_ACCESS } from "../types";
+import type { WorkspaceNode } from "../types";
+
+/**
+ * Cây dùng chung: Tấn Lộc (vận hành) và Spartronics (khách hàng) là hai đơn vị
+ * ngang hàng; Spartronics có hai phòng ban con.
+ */
+const NODES: WorkspaceNode[] = [
+  { id: "tanloc", parentId: null, path: "/tanloc/", kind: "unit" },
+  { id: "spa", parentId: null, path: "/spa/", kind: "unit" },
+  { id: "spa-qc", parentId: "spa", path: "/spa/spa-qc/", kind: "department" },
+  { id: "spa-kho", parentId: "spa", path: "/spa/spa-kho/", kind: "department" },
+];
+
+interface FakeSession {
+  id?: string;
+  admin?: boolean;
+}
+
+beforeEach(() => {
+  resetWorkspaceConfig();
+});
+
+describe("cây — hàm thuần", () => {
+  it("buildPath luôn có / hai đầu (tránh bắt nhầm id trùng tiền tố)", () => {
+    expect(buildPath(null, "a")).toBe("/a/");
+    expect(buildPath("/a/", "b")).toBe("/a/b/");
+    expect(pathDepth("/a/b/c/")).toBe(3);
+  });
+
+  it("isInSubtree tính cả chính nó — 'được gán nhánh X' luôn gồm X", () => {
+    expect(isInSubtree("/spa/", "/spa/")).toBe(true);
+    expect(isInSubtree("/spa/", "/spa/", { includeSelf: false })).toBe(false);
+    expect(isInSubtree("/spa/spa-qc/", "/spa/")).toBe(true);
+    expect(isInSubtree("/tanloc/", "/spa/")).toBe(false);
+  });
+
+  it("bung con cháu: gán nút cha ⇒ thấy nút con", () => {
+    expect(selfAndDescendants(["spa"], NODES).sort()).toEqual(
+      ["spa", "spa-kho", "spa-qc"].sort(),
+    );
+  });
+
+  it("gán nút con KHÔNG kéo theo nút cha (quyền chảy xuống, không chảy lên)", () => {
+    expect(selfAndDescendants(["spa-qc"], NODES)).toEqual(["spa-qc"]);
+  });
+
+  it("id không có trong cây vẫn được giữ — app mức 0 truyền cây rỗng", () => {
+    expect(selfAndDescendants(["b1", "b2"], [])).toEqual(["b1", "b2"]);
+  });
+
+  it("đổi cha ⇒ ghi lại path cho CẢ nhánh con", () => {
+    const updates = repathSubtree("spa", "/tanloc/", NODES);
+    expect(updates).toEqual(
+      expect.arrayContaining([
+        { id: "spa", path: "/tanloc/spa/", depth: 2 },
+        { id: "spa-qc", path: "/tanloc/spa/spa-qc/", depth: 3 },
+        { id: "spa-kho", path: "/tanloc/spa/spa-kho/", depth: 3 },
+      ]),
+    );
+    expect(updates).toHaveLength(3);
+  });
+
+  it("chống chu trình: không nhận chính mình hay con cháu làm cha", () => {
+    expect(() => assertNoCycle("spa", "spa", NODES)).toThrow(
+      WorkspaceTreeError,
+    );
+    expect(() => assertNoCycle("spa", "spa-qc", NODES)).toThrow(
+      WorkspaceTreeError,
+    );
+    expect(() => assertNoCycle("spa", "tanloc", NODES)).not.toThrow();
+  });
+
+  it("trần độ sâu 4 tầng", () => {
+    expect(() => assertDepthLimit("/a/b/c/d/")).not.toThrow();
+    expect(() => assertDepthLimit("/a/b/c/d/e/")).toThrow(WorkspaceTreeError);
+  });
+});
+
+describe("getWorkspaceScope", () => {
+  it("xem-tất không tốn truy vấn membership", async () => {
+    const getMemberships = vi.fn(async () => []);
+    configureWorkspaces<FakeSession>({
+      getMemberships,
+      getUserId: (s) => s.id,
+      canViewAll: (s) => Boolean(s.admin),
+    });
+    const scope = await getWorkspaceScope({ id: "u1", admin: true });
+    expect(scope.canViewAll).toBe(true);
+    expect(scope.allowedIds).toBeUndefined();
+    expect(getMemberships).not.toHaveBeenCalled();
+  });
+
+  it("chưa gán không gian nào → sentinel = thấy 0 dòng, KHÔNG phải thấy tất", async () => {
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => [],
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.allowedIds).toEqual([NO_WORKSPACE_ACCESS]);
+    expect(scope.adminIds).toEqual([]);
+  });
+
+  it("MỨC 0 — không có db, không có expander ⇒ cây phẳng, hành vi như branch-scope", async () => {
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => ["b1", "b2"],
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.rootIds).toEqual(["b1", "b2"]);
+    expect(scope.allowedIds).toEqual(["b1", "b2"]);
+  });
+
+  it("bung con cháu qua expander; isAdmin cũng được bung", async () => {
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => [{ workspaceId: "spa", isAdmin: true }],
+      expandDescendants: (roots) => selfAndDescendants(roots, NODES),
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.rootIds).toEqual(["spa"]);
+    expect(scope.allowedIds?.sort()).toEqual(["spa", "spa-kho", "spa-qc"]);
+    // Admin nút cha PHẢI quản trị được phòng ban con của chính mình.
+    expect(scope.adminIds.sort()).toEqual(["spa", "spa-kho", "spa-qc"]);
+  });
+
+  it("thành viên thường KHÔNG có adminIds — xem được ≠ cấp tài khoản được", async () => {
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => [{ workspaceId: "spa" }],
+      expandDescendants: (roots) => selfAndDescendants(roots, NODES),
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.adminIds).toEqual([]);
+    expect(hasAdminScope(scope)).toBe(false);
+  });
+
+  it("defaultId lấy từ isDefault, không có thì lấy nút đầu", async () => {
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => [
+        { workspaceId: "a" },
+        { workspaceId: "b", isDefault: true },
+      ],
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    expect((await getWorkspaceScope({ id: "u1" })).defaultId).toBe("b");
+  });
+
+  it("session không có userId → sentinel, không tra DB bằng undefined", async () => {
+    const findMany = vi.fn(async () => [{ workspaceId: "spa" }]);
+    configureWorkspaces<FakeSession>({
+      db: {
+        userWorkspace: { findMany },
+        workspace: { findMany: vi.fn(async () => []) },
+      },
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({});
+    expect(scope.allowedIds).toEqual([NO_WORKSPACE_ACCESS]);
+    expect(findMany).not.toHaveBeenCalled();
+  });
+
+  it("bản mặc định đi DB: 2 truy vấn, dùng startsWith chứ không contains", async () => {
+    const workspaceFindMany = vi
+      .fn()
+      .mockResolvedValueOnce([{ id: "spa", path: "/spa/" }])
+      .mockResolvedValueOnce([
+        { id: "spa", path: "/spa/" },
+        { id: "spa-qc", path: "/spa/spa-qc/" },
+      ]);
+    configureWorkspaces<FakeSession>({
+      db: {
+        userWorkspace: {
+          findMany: vi.fn(async () => [{ workspaceId: "spa" }]),
+        },
+        workspace: { findMany: workspaceFindMany },
+      },
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+    const scope = await getWorkspaceScope({ id: "u1" });
+    expect(scope.allowedIds?.sort()).toEqual(["spa", "spa-qc"]);
+    expect(workspaceFindMany.mock.calls[1][0].where).toEqual({
+      OR: [{ path: { startsWith: "/spa/" } }],
+    });
+  });
+
+  it("chưa configureWorkspaces thì NÉM, không im lặng trả về rỗng", async () => {
+    await expect(getWorkspaceScope({})).rejects.toThrow(/configureWorkspaces/);
+  });
+});
+
+describe("scopedWhere / canAccessWorkspace", () => {
+  const scope = createWorkspaceScope({
+    canViewAll: false,
+    rootIds: ["spa"],
+    allowedIds: ["spa", "spa-qc"],
+  });
+
+  it("xem tất → không thêm điều kiện", () => {
+    expect(scopedWhere(createWorkspaceScope({ canViewAll: true }))).toEqual({});
+  });
+
+  it("cột phạm vi mặc định là branchId (tương thích ngược)", () => {
+    expect(scopedWhere(scope)).toEqual({
+      OR: [{ branchId: { in: ["spa", "spa-qc"] } }, { branchId: null }],
+    });
+  });
+
+  it("đổi cột + đi qua quan hệ", () => {
+    expect(scopedWhere(scope, { field: "workspaceId" })).toEqual({
+      OR: [{ workspaceId: { in: ["spa", "spa-qc"] } }, { workspaceId: null }],
+    });
+    expect(scopedWhere(scope, { relation: "warehouse" })).toEqual({
+      OR: [
+        { warehouse: { branchId: { in: ["spa", "spa-qc"] } } },
+        { warehouse: { branchId: null } },
+      ],
+    });
+  });
+
+  it("bản ghi không gắn không gian = dùng chung", () => {
+    expect(canAccessWorkspace(scope, null)).toBe(true);
+    expect(canAccessWorkspace(scope, "spa-qc")).toBe(true);
+    expect(canAccessWorkspace(scope, "tanloc")).toBe(false);
+  });
+});
+
+describe("thang 5 nấc (Δ1)", () => {
+  const scope = createWorkspaceScope({
+    canViewAll: false,
+    rootIds: ["spa"],
+    allowedIds: ["spa", "spa-qc", "spa-kho"],
+  });
+
+  it("all → không điều kiện; none → 0 dòng", () => {
+    expect(scopeLevelWhere("all", scope)).toEqual({});
+    expect(scopeLevelWhere("none", scope)).toEqual({
+      branchId: { in: [NO_WORKSPACE_ACCESS] },
+    });
+  });
+
+  it("own → chỉ bản ghi của user", () => {
+    expect(
+      scopeLevelWhere("own", scope, { ownerField: "createdBy", userId: "u1" }),
+    ).toEqual({ createdBy: "u1" });
+  });
+
+  it("own KHÔNG biết user là ai → đóng lại, không mở ra", () => {
+    expect(scopeLevelWhere("own", scope, { userId: null })).toEqual({
+      createdBy: NO_WORKSPACE_ACCESS,
+    });
+  });
+
+  it("workspace = đúng nút được gán, KHÔNG bung con cháu", () => {
+    expect(scopeLevelWhere("workspace", scope)).toEqual({
+      OR: [{ branchId: { in: ["spa"] } }, { branchId: null }],
+    });
+  });
+
+  it("subtree = nút được gán + con cháu", () => {
+    expect(scopeLevelWhere("subtree", scope)).toEqual({
+      OR: [
+        { branchId: { in: ["spa", "spa-qc", "spa-kho"] } },
+        { branchId: null },
+      ],
+    });
+  });
+
+  it("thứ tự nấc: all > subtree > workspace > own > none", () => {
+    expect(scopeLevelAtLeast("all", "subtree")).toBe(true);
+    expect(scopeLevelAtLeast("workspace", "subtree")).toBe(false);
+    expect(scopeLevelAtLeast("own", "own")).toBe(true);
+  });
+});
+
+describe("kẹp bộ lọc", () => {
+  const scope = createWorkspaceScope({
+    canViewAll: false,
+    rootIds: ["spa"],
+    allowedIds: ["spa", "spa-qc"],
+    adminIds: ["spa", "spa-qc"],
+  });
+
+  it("clampScopeFilter: toàn bộ ngoài phạm vi → sentinel, không rơi về không-lọc", () => {
+    expect(clampScopeFilter(["spa", "tanloc"], scope)).toEqual(["spa"]);
+    expect(clampScopeFilter(["tanloc"], scope)).toEqual([NO_WORKSPACE_ACCESS]);
+    expect(clampScopeFilter(undefined, scope)).toBeUndefined();
+  });
+
+  it("D1 — clampToAdminScope TỪ CHỐI khi có id ngoài nhánh, không lặng lẽ bỏ bớt", () => {
+    expect(clampToAdminScope(["spa", "spa-qc"], scope)).toEqual([
+      "spa",
+      "spa-qc",
+    ]);
+    expect(clampToAdminScope(["spa", "tanloc"], scope)).toBeNull();
+  });
+
+  it("D1 — người không được uỷ quyền thì không gán được gì", () => {
+    const plain = createWorkspaceScope({
+      canViewAll: false,
+      allowedIds: ["spa"],
+    });
+    expect(isWorkspaceAdmin(plain, "spa")).toBe(false);
+    expect(clampToAdminScope(["spa"], plain)).toBeNull();
+  });
+});
+
+describe("tương thích ngược với branch-scope", () => {
+  it("WorkspaceScope cắm thẳng vào hàm branch-scope cũ", () => {
+    const scope = createWorkspaceScope({
+      canViewAll: false,
+      allowedIds: ["b1", "b2"],
+    });
+    // Cùng một mảng, không phải bản sao — lệch nhau là bug im lặng.
+    expect(scope.allowedBranchIds).toBe(scope.allowedIds);
+    expect(scopedBranchWhere(scope)).toEqual({
+      OR: [{ branchId: { in: ["b1", "b2"] } }, { branchId: null }],
+    });
+    expect(canAccessBranch(scope, "b1")).toBe(true);
+    expect(canAccessBranch(scope, "x")).toBe(false);
+  });
+
+  /**
+   * BẪY SỐ MỘT của việc tách module: hai AsyncLocalStorage riêng thì
+   * `runWithoutBranchScope` chỉ thoát được một store, store kia vẫn lọc ⇒
+   * `MAX(số phiếu)` bị cắt theo phạm vi ⇒ TRÙNG SỐ PHIẾU (RS-260727-0003).
+   */
+  it("branch-scope và workspace dùng CHUNG một store", async () => {
+    const scope = createWorkspaceScope({ canViewAll: true });
+    await runWithScope({ resolve: async () => scope }, async () => {
+      expect(getBranchScopeContext()).toBeDefined();
+      expect(await resolveAmbientBranchScope()).toBe(scope);
+    });
+    await runWithBranchScope({ resolve: async () => scope }, async () => {
+      expect(getScopeContext()).toBeDefined();
+      expect(await resolveAmbientScope()).toBe(scope);
+    });
+  });
+
+  it("runWithoutScope thoát được context mở bằng runWithBranchScope (và ngược lại)", async () => {
+    const scope = createWorkspaceScope({ canViewAll: true });
+    await runWithBranchScope({ resolve: async () => scope }, async () => {
+      runWithoutScope(() => {
+        expect(getBranchScopeContext()).toBeUndefined();
+        expect(getScopeContext()).toBeUndefined();
+      });
+      expect(getScopeContext()).toBeDefined();
+    });
+    await runWithScope({ resolve: async () => scope }, async () => {
+      runWithoutBranchScope(() => {
+        expect(getScopeContext()).toBeUndefined();
+      });
+      expect(getBranchScopeContext()).toBeDefined();
+    });
+  });
+});
+
+/** Chữ ký thô của `$allOperations` — Prisma không xuất type này ra ngoài. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type GuardRun = (a: any) => Promise<any>;
+
+describe("createScopeGuardExtension", () => {
+  const scope = createWorkspaceScope({
+    canViewAll: false,
+    allowedIds: ["spa"],
+  });
+  const ext = createScopeGuardExtension({
+    models: {
+      Receipt: {},
+      GoodsReceipt: { relation: "warehouse" },
+      SalesOrder: { crossScopeRead: true },
+    },
+  });
+  const run = ext.query.$allModels.$allOperations as GuardRun;
+
+  let seen: unknown;
+  const query = vi.fn(async (args: unknown) => {
+    seen = args;
+    return "ok";
+  });
+
+  beforeEach(() => {
+    seen = undefined;
+    query.mockClear();
+    configureWorkspaces<FakeSession>({
+      getMemberships: async () => [],
+      getUserId: (s) => s.id,
+      canViewAll: () => false,
+    });
+  });
+
+  const call = (model: string, operation: string, args: unknown) =>
+    run({ model, operation, args, query });
+
+  it("model ngoài danh sách → đi thẳng", async () => {
+    await runWithScope({ resolve: async () => scope }, () =>
+      call("Customer", "findMany", { where: { name: "a" } }),
+    );
+    expect(seen).toEqual({ where: { name: "a" } });
+  });
+
+  it("ngoài context (cron/script) → không cắt dữ liệu", async () => {
+    await call("Receipt", "findMany", { where: { a: 1 } });
+    expect(seen).toEqual({ where: { a: 1 } });
+  });
+
+  it("AND thêm điều kiện, GIỮ nguyên where cũ", async () => {
+    await runWithScope({ resolve: async () => scope }, () =>
+      call("Receipt", "findMany", { where: { status: "paid" } }),
+    );
+    expect(seen).toEqual({
+      where: {
+        AND: [
+          { status: "paid" },
+          { OR: [{ branchId: { in: ["spa"] } }, { branchId: null }] },
+        ],
+      },
+    });
+  });
+
+  it("findUnique và ghi một dòng → không đụng vào (where chỉ nhận unique field)", async () => {
+    await runWithScope({ resolve: async () => scope }, async () => {
+      await call("Receipt", "findUnique", { where: { id: "r1" } });
+      expect(seen).toEqual({ where: { id: "r1" } });
+      await call("Receipt", "update", { where: { id: "r1" }, data: {} });
+      expect(seen).toEqual({ where: { id: "r1" }, data: {} });
+    });
+  });
+
+  /** Δ2 — NetSuite `Allow Cross-Subsidiary Record Viewing`: xem được, sửa không được. */
+  it("crossScopeRead: ĐỌC đi thẳng…", async () => {
+    await runWithScope({ resolve: async () => scope }, () =>
+      call("SalesOrder", "findMany", { where: { status: "new" } }),
+    );
+    expect(seen).toEqual({ where: { status: "new" } });
+  });
+
+  it("…nhưng GHI hàng loạt vẫn bị kẹp", async () => {
+    await runWithScope({ resolve: async () => scope }, () =>
+      call("SalesOrder", "updateMany", { where: { status: "new" }, data: {} }),
+    );
+    expect(seen).toEqual({
+      where: {
+        AND: [
+          { status: "new" },
+          { OR: [{ branchId: { in: ["spa"] } }, { branchId: null }] },
+        ],
+      },
+      data: {},
+    });
+  });
+
+  it("model thường: deleteMany cũng bị kẹp", async () => {
+    await runWithScope({ resolve: async () => scope }, () =>
+      call("Receipt", "deleteMany", {}),
+    );
+    expect(seen).toEqual({
+      where: { OR: [{ branchId: { in: ["spa"] } }, { branchId: null }] },
+    });
+  });
+
+  it("khai bằng mảng tên model vẫn chạy (dạng gọn)", async () => {
+    const simple = createScopeGuardExtension({ models: ["Receipt"] });
+
+    const runSimple = simple.query.$allModels.$allOperations as GuardRun;
+    await runWithScope({ resolve: async () => scope }, () =>
+      runSimple({ model: "Receipt", operation: "count", args: {}, query }),
+    );
+    expect(seen).toEqual({
+      where: { OR: [{ branchId: { in: ["spa"] } }, { branchId: null }] },
+    });
+  });
+});
+
+describe("memberScopeWhere", () => {
+  const scope = createWorkspaceScope({
+    canViewAll: false,
+    rootIds: ["spa"],
+    allowedIds: ["spa", "spa-qc", "spa-kho"],
+    adminIds: ["spa-qc"],
+  });
+
+  it("lọc qua bảng nối, KHÔNG có nhánh null", () => {
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+    });
+    expect(memberScopeWhere(scope)).toEqual({
+      userWorkspaces: {
+        some: { workspaceId: { in: ["spa", "spa-qc", "spa-kho"] } },
+      },
+    });
+  });
+
+  it("mức 0 khai lại tên quan hệ / cột", () => {
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+      membershipRelation: "userBranches",
+      membershipField: "branchId",
+    });
+    expect(memberScopeWhere(scope)).toEqual({
+      userBranches: {
+        some: { branchId: { in: ["spa", "spa-qc", "spa-kho"] } },
+      },
+    });
+  });
+
+  it("adminOnly thu về đúng nhánh được uỷ quyền", () => {
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+    });
+    expect(memberScopeWhere(scope, { adminOnly: true })).toEqual({
+      userWorkspaces: { some: { workspaceId: { in: ["spa-qc"] } } },
+    });
+  });
+
+  it("không được uỷ quyền nhánh nào + adminOnly ⇒ sentinel, 0 dòng", () => {
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+    });
+    const nobody = createWorkspaceScope({
+      canViewAll: false,
+      rootIds: ["spa"],
+      allowedIds: ["spa"],
+      adminIds: [],
+    });
+    expect(memberScopeWhere(nobody, { adminOnly: true })).toEqual({
+      userWorkspaces: { some: { workspaceId: { in: [NO_WORKSPACE_ACCESS] } } },
+    });
+  });
+
+  it("xem được tất ⇒ không thêm điều kiện", () => {
+    configureWorkspaces({
+      getUserId: () => undefined,
+      canViewAll: () => false,
+    });
+    expect(
+      memberScopeWhere(createWorkspaceScope({ canViewAll: true })),
+    ).toEqual({});
+  });
+});