@uipath/data-fabric-tool 1.0.4 → 1.195.0

package/src/index.ts

@@ -1,17 +1,12 @@
 #!/usr/bin/env bun
 import { Command } from "commander";
-import pkg from "../package.json" with { type: "json" };
-import { registerEntitiesCommand } from "./commands/entities";
-import { registerFilesCommand } from "./commands/files";
-import { registerRecordsCommand } from "./commands/records";
+import { metadata, registerCommands } from "./tool.js";
 
 const program = new Command();
 program
-    .name("data-fabric-tool")
-    .description("UiPath Data Fabric Tool - Standalone CLI")
-    .version(pkg.version);
+    .name(metadata.name)
+    .description(metadata.description)
+    .version(metadata.version);
 
-registerEntitiesCommand(program);
-registerRecordsCommand(program);
-registerFilesCommand(program);
+await registerCommands(program);
 await program.parseAsync(process.argv);

package/src/tool.ts

@@ -1,5 +1,9 @@
 import type { Command } from "commander";
 import pkg from "../package.json" with { type: "json" };
+import {
+    registerChoiceSetsCommand,
+    registerChoiceSetValuesCommand,
+} from "./commands/choice-sets";
 import { registerEntitiesCommand } from "./commands/entities";
 import { registerFilesCommand } from "./commands/files";
 import { registerRecordsCommand } from "./commands/records";
@@ -16,4 +20,6 @@ export const registerCommands = async (program: Command): Promise<void> => {
     registerEntitiesCommand(program);
     registerRecordsCommand(program);
     registerFilesCommand(program);
+    registerChoiceSetsCommand(program);
+    registerChoiceSetValuesCommand(program);
 };

package/src/utils/output.spec.ts

@@ -0,0 +1,78 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+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 { fail, requireDestructiveConfirmation } from "./output";
+
+describe("fail", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("emits a failure result and sets a non-zero exit code", () => {
+        fail("Something broke", "Try again.");
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Something broke",
+                Instructions: "Try again.",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("requireDestructiveConfirmation", () => {
+    const reasonInstruction = "Pass --reason to explain.";
+
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("returns the trimmed reason when --confirm and --reason are present", () => {
+        const result = requireDestructiveConfirmation(
+            { confirm: true, reason: "  cleanup  " },
+            reasonInstruction,
+        );
+        expect(result).toBe("cleanup");
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+    });
+
+    it("fails and returns null when --confirm is missing", () => {
+        const result = requireDestructiveConfirmation(
+            { reason: "cleanup" },
+            reasonInstruction,
+        );
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "Confirmation required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("fails and returns null when --reason is missing or blank", () => {
+        const result = requireDestructiveConfirmation(
+            { confirm: true, reason: "   " },
+            reasonInstruction,
+        );
+        expect(result).toBeNull();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Message: "Reason required for destructive operation",
+                Instructions: reasonInstruction,
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});

package/src/utils/output.ts

@@ -0,0 +1,51 @@
+import { OutputFormatter, processContext, RESULTS } from "@uipath/common";
+
+/**
+ * Emit a standard failure result and set a non-zero exit code.
+ *
+ * Returns `void` so a handler can halt in one line: `return fail(msg, instr);`
+ * (`processContext.exit` only sets `process.exitCode`, so the caller must still
+ * return to stop execution).
+ */
+export function fail(message: string, instructions: string): void {
+    OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: message,
+        Instructions: instructions,
+    });
+    processContext.exit(1);
+}
+
+export interface DestructiveOptions {
+    confirm?: boolean;
+    reason?: string;
+}
+
+/**
+ * Validate the `--confirm`/`--reason` flags required for a destructive
+ * operation. On failure, emits the appropriate error, sets the exit code, and
+ * returns `null`. On success, returns the trimmed reason.
+ *
+ * @param reasonInstruction - Instruction text shown when `--reason` is missing,
+ *   e.g. `'Pass --reason "<text>" to record why the choice set is being deleted.'`
+ */
+export function requireDestructiveConfirmation(
+    options: DestructiveOptions,
+    reasonInstruction: string,
+): string | null {
+    if (options.confirm !== true) {
+        fail(
+            "Confirmation required for destructive operation",
+            "Pass --confirm to acknowledge this is irreversible.",
+        );
+        return null;
+    }
+
+    const reason = options.reason?.trim();
+    if (reason === undefined || reason === "") {
+        fail("Reason required for destructive operation", reasonInstruction);
+        return null;
+    }
+
+    return reason;
+}

package/src/utils/sdk-client.spec.ts

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("@uipath/auth", () => ({
+    getLoginStatusAsync: vi.fn(),
+}));
+
+vi.mock("@uipath/uipath-typescript", () => ({
+    UiPath: class {},
+}));
+
+vi.mock("@uipath/common", async (importOriginal) => {
+    const actual = await importOriginal<typeof import("@uipath/common")>();
+    return {
+        ...actual,
+        OutputFormatter: { success: vi.fn(), error: vi.fn() },
+    };
+});
+
+import { getLoginStatusAsync } from "@uipath/auth";
+import { OutputFormatter } from "@uipath/common";
+import { connectOrFail } from "./sdk-client";
+
+describe("connectOrFail", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("returns a client when logged in", async () => {
+        vi.mocked(getLoginStatusAsync).mockResolvedValue({
+            loginStatus: "Logged in",
+            accessToken: "token",
+            baseUrl: "https://cloud.uipath.com",
+            organizationName: "org",
+            tenantName: "tenant",
+        } as never);
+
+        const sdk = await connectOrFail();
+        expect(sdk).toBeDefined();
+        expect(OutputFormatter.error).not.toHaveBeenCalled();
+    });
+
+    it("emits a connection error and returns undefined when not logged in", async () => {
+        vi.mocked(getLoginStatusAsync).mockResolvedValue({
+            loginStatus: "LoggedOut",
+            hint: "Run 'uip login' first.",
+        } as never);
+
+        const sdk = await connectOrFail();
+        expect(sdk).toBeUndefined();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});

package/src/utils/sdk-client.ts

@@ -1,5 +1,7 @@
 import { getLoginStatusAsync } from "@uipath/auth";
+import { catchError, extractErrorMessage } from "@uipath/common";
 import { UiPath } from "@uipath/uipath-typescript";
+import { fail } from "./output";
 
 export const createDataFabricClient = async (
     tenantOverride?: string,
@@ -21,3 +23,24 @@ export const createDataFabricClient = async (
         tenantName: tenantOverride ?? status.tenantName,
     });
 };
+
+/**
+ * Create a Data Fabric client, or emit a standard connection error and return
+ * `undefined`. Lets a handler open with: `const sdk = await connectOrFail(t);
+ * if (!sdk) return;`
+ */
+export const connectOrFail = async (
+    tenantOverride?: string,
+): Promise<UiPath | undefined> => {
+    const [clientError, sdk] = await catchError(
+        createDataFabricClient(tenantOverride),
+    );
+    if (clientError) {
+        fail(
+            "Error connecting to Data Fabric",
+            await extractErrorMessage(clientError),
+        );
+        return undefined;
+    }
+    return sdk;
+};