@uipath/data-fabric-tool 1.0.4 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/data-fabric-tool",
-    "version": "1.0.4",
+    "version": "1.1.0",
     "description": "Manage Data Fabric entities and records.",
     "type": "module",
     "main": "./dist/tool.js",
@@ -10,19 +10,11 @@
     "bin": {
         "data-fabric-tool": "./dist/index.js"
     },
-    "scripts": {
-        "build": "bun ../../tools/build-tool.ts",
-        "package": "bun run build && bun pm pack",
-        "test": "vitest run",
-        "test:coverage": "vitest run --coverage",
-        "lint": "biome check .",
-        "lint:fix": "biome check --write ."
-    },
     "devDependencies": {
         "commander": "^14.0.3",
-        "@uipath/common": "1.0.4",
-        "@uipath/auth": "1.0.4",
-        "@uipath/filesystem": "1.0.4",
+        "@uipath/common": "1.1.0",
+        "@uipath/auth": "1.1.0",
+        "@uipath/filesystem": "1.1.0",
         "@uipath/uipath-typescript": "^1.3.7",
         "@types/node": "^25.5.2",
         "typescript": "^6.0.2"
@@ -30,5 +22,5 @@
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "e496ee5b65951c8047259ab50d7d6a284eea58a9"
+    "gitHead": "06e8c8f566df4b87da4a008635483c62f64f33f0"
 }

package/src/commands/choice-sets.spec.ts

@@ -0,0 +1,394 @@
+import { Command } from "commander";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("../utils/sdk-client", () => ({
+    createDataFabricClient: vi.fn(),
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: {
+            success: vi.fn(),
+            error: vi.fn(),
+        },
+    };
+});
+
+import { OutputFormatter } from "@uipath/common";
+import { createDataFabricClient } from "../utils/sdk-client";
+import { registerChoiceSetsCommand } from "./choice-sets";
+
+function buildProgram(): Command {
+    const program = new Command();
+    program.name("test").exitOverride();
+    registerChoiceSetsCommand(program);
+    return program;
+}
+
+function mockSdk(overrides: Record<string, unknown> = {}) {
+    const sdk = {
+        entities: {
+            choicesets: {
+                getAll: vi.fn().mockResolvedValue([]),
+                getById: vi.fn().mockResolvedValue({
+                    items: [],
+                    totalCount: 0,
+                }),
+                ...overrides,
+            },
+        },
+    };
+    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    return sdk;
+}
+
+describe("choice-sets list", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should register the choice-sets command with list and get subcommands", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "choice-sets");
+        expect(cmd).toBeDefined();
+        const subNames = cmd?.commands.map((c) => c.name()) ?? [];
+        expect(subNames).toContain("list");
+        expect(subNames).toContain("get");
+    });
+
+    it("should list choice sets successfully and expose the runtime ID", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getAll).mockResolvedValue([
+            {
+                id: "cs-uuid-1",
+                name: "ExpenseTypes",
+                displayName: "Expense Types",
+                description: "Categories of expenses",
+                folderId: "f-1",
+                createdBy: "u-1",
+                updatedBy: "u-2",
+                createdTime: "2026-01-01T00:00:00Z",
+                updatedTime: "2026-01-02T00:00:00Z",
+            } as never,
+        ]);
+
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetList",
+                Data: expect.arrayContaining([
+                    expect.objectContaining({
+                        ID: "cs-uuid-1",
+                        Name: "ExpenseTypes",
+                        DisplayName: "Expense Types",
+                    }),
+                ]),
+            }),
+        );
+    });
+
+    it("should return empty list when no choice sets exist", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetList",
+                Data: [],
+            }),
+        );
+    });
+
+    it("should output error when list fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getAll).mockRejectedValue(
+            new Error("forbidden"),
+        );
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error listing choice sets",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when SDK connection fails on list", async () => {
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("choice-sets get", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should get values for a choice set", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+            items: [
+                {
+                    id: "v-1",
+                    name: "travel",
+                    displayName: "Travel",
+                    numberId: 1,
+                    createdTime: "2026-01-01T00:00:00Z",
+                    updatedTime: "2026-01-02T00:00:00Z",
+                },
+            ],
+            totalCount: 1,
+            hasNextPage: false,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+        ]);
+
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 50,
+        });
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "ChoiceSetValues",
+                Data: expect.objectContaining({
+                    TotalCount: 1,
+                    Values: expect.arrayContaining([
+                        expect.objectContaining({
+                            Id: "v-1",
+                            Name: "travel",
+                            DisplayName: "Travel",
+                            NumberId: 1,
+                        }),
+                    ]),
+                    HasNextPage: false,
+                }),
+            }),
+        );
+    });
+
+    it("should pass cursor to choicesets.getById and include NextCursor", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+            items: [
+                {
+                    id: "v-1",
+                    name: "n",
+                    displayName: "N",
+                    numberId: 1,
+                },
+            ],
+            totalCount: 100,
+            hasNextPage: true,
+            nextCursor: "next-cur",
+        });
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--cursor",
+            "prev",
+            "--limit",
+            "10",
+        ]);
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 10,
+            cursor: { value: "prev" },
+        });
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.objectContaining({
+                    HasNextPage: true,
+                    NextCursor: "next-cur",
+                }),
+            }),
+        );
+    });
+
+    it("should pass jumpToPage to choicesets.getById when --offset is given", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+            items: [],
+            totalCount: 100,
+            hasNextPage: false,
+        });
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--offset",
+            "20",
+            "--limit",
+            "10",
+        ]);
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 10,
+            jumpToPage: 3,
+        });
+    });
+
+    it("should error when --offset and --cursor are both given", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--offset",
+            "10",
+            "--cursor",
+            "x",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "--offset and --cursor are mutually exclusive",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --limit is invalid", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--limit",
+            "0",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --limit value",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --offset is negative", async () => {
+        mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--offset",
+            "-1",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid --offset value",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should output error when get fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockRejectedValue(
+            new Error("404"),
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "missing",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error getting choice set 'missing'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when SDK connection fails on get", async () => {
+        vi.mocked(createDataFabricClient).mockRejectedValue(
+            new Error("Not logged in"),
+        );
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+        ]);
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should normalise cursor object {value} to a plain string in NextCursor", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.choicesets.getById).mockResolvedValue({
+            items: [{ id: "v-1", name: "n", displayName: "N", numberId: 1 }],
+            totalCount: 5,
+            hasNextPage: true,
+            nextCursor: { value: "cursor-as-object" } as unknown as string,
+        });
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "get",
+            "cs-1",
+            "--limit",
+            "2",
+        ]);
+        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
+            Data: { NextCursor: unknown };
+        };
+        expect(typeof call.Data.NextCursor).toBe("string");
+        expect(call.Data.NextCursor).toBe("cursor-as-object");
+    });
+});