@uipath/data-fabric-tool 1.1.0 → 1.195.0

package/src/commands/files.spec.ts

@@ -3,6 +3,7 @@ import { beforeEach, describe, expect, it, vi } from "vitest";
 
 vi.mock("../utils/sdk-client", () => ({
     createDataFabricClient: vi.fn(),
+    connectOrFail: vi.fn(),
 }));
 
 vi.mock("@uipath/common", async (importOriginal) => {
@@ -27,7 +28,7 @@ vi.mock("@uipath/filesystem", () => ({
 }));
 
 import { OutputFormatter } from "@uipath/common";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { connectOrFail } from "../utils/sdk-client";
 import { registerFilesCommand } from "./files";
 
 function mockSdk(overrides: Record<string, unknown> = {}) {
@@ -39,7 +40,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             ...overrides,
         },
     };
-    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
     return sdk;
 }
 
@@ -134,22 +135,17 @@ describe("files upload", () => {
         );
     });
 
-    it("should error when SDK connection fails on upload", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on upload", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         mockFs.readFile.mockResolvedValue(new Uint8Array([1, 2, 3]));
         const program = buildProgram();
         await runCommand(
             program,
             "files upload entity-1 record-1 attachment --file /tmp/report.pdf",
         );
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
+        expect(sdk.entities.uploadAttachment).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when upload API fails", async () => {
@@ -218,21 +214,16 @@ describe("files download", () => {
         );
     });
 
-    it("should error when SDK connection fails", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await runCommand(
             program,
             "files download entity-1 record-1 attachment",
         );
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
+        expect(sdk.entities.downloadAttachment).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -270,18 +261,13 @@ describe("files delete", () => {
         );
     });
 
-    it("should error when SDK connection fails on delete", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on delete", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await runCommand(program, "files delete entity-1 record-1 attachment");
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
+        expect(sdk.entities.deleteAttachment).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 

package/src/commands/files.ts

@@ -10,7 +10,8 @@ import {
 import { getFileSystem } from "@uipath/filesystem";
 import type { Command } from "commander";
 import { readFileBinary } from "../utils/input";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { fail } from "../utils/output";
+import { connectOrFail } from "../utils/sdk-client";
 
 interface UploadOptions {
     tenant?: string;
@@ -101,41 +102,21 @@ export const registerFilesCommand = (program: Command) => {
                 options: UploadOptions,
             ) => {
                 if (!options.file) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "A file path is required",
-                        Instructions: "Provide a file path via --file.",
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "A file path is required",
+                        "Provide a file path via --file.",
+                    );
                 }
 
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [readError, fileContent] = await catchError(
                     readFileBinary(options.file),
                 );
 
                 if (readError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error reading file",
-                        Instructions: readError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail("Error reading file", readError.message);
                 }
 
                 const fsInst = getFileSystem();
@@ -154,13 +135,10 @@ export const registerFilesCommand = (program: Command) => {
                 );
 
                 if (uploadError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error uploading file to field '${fieldName}'`,
-                        Instructions: await extractErrorMessage(uploadError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error uploading file to field '${fieldName}'`,
+                        await extractErrorMessage(uploadError),
+                    );
                 }
 
                 OutputFormatter.success({
@@ -198,19 +176,8 @@ export const registerFilesCommand = (program: Command) => {
                 fieldName: string,
                 options: DownloadOptions,
             ) => {
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [downloadError, blob] = await catchError(
                     sdk.entities.downloadAttachment(
@@ -221,13 +188,10 @@ export const registerFilesCommand = (program: Command) => {
                 );
 
                 if (downloadError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error downloading file from field '${fieldName}'`,
-                        Instructions: await extractErrorMessage(downloadError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error downloading file from field '${fieldName}'`,
+                        await extractErrorMessage(downloadError),
+                    );
                 }
 
                 const outputPath =
@@ -238,13 +202,10 @@ export const registerFilesCommand = (program: Command) => {
                 );
 
                 if (bufferError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error reading downloaded file content",
-                        Instructions: bufferError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error reading downloaded file content",
+                        bufferError.message,
+                    );
                 }
 
                 const [writeError] = await catchError(
@@ -252,13 +213,10 @@ export const registerFilesCommand = (program: Command) => {
                 );
 
                 if (writeError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error writing downloaded file",
-                        Instructions: writeError.message,
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        "Error writing downloaded file",
+                        writeError.message,
+                    );
                 }
 
                 OutputFormatter.success({
@@ -292,19 +250,8 @@ export const registerFilesCommand = (program: Command) => {
                 fieldName: string,
                 options: DeleteOptions,
             ) => {
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
-                );
-
-                if (clientError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: "Error connecting to Data Fabric",
-                        Instructions: await extractErrorMessage(clientError),
-                    });
-                    processContext.exit(1);
-                    return;
-                }
+                const sdk = await connectOrFail(options.tenant);
+                if (!sdk) return;
 
                 const [deleteError] = await catchError(
                     sdk.entities.deleteAttachment(
@@ -315,13 +262,10 @@ export const registerFilesCommand = (program: Command) => {
                 );
 
                 if (deleteError) {
-                    OutputFormatter.error({
-                        Result: RESULTS.Failure,
-                        Message: `Error deleting file from field '${fieldName}'`,
-                        Instructions: await extractErrorMessage(deleteError),
-                    });
-                    processContext.exit(1);
-                    return;
+                    return fail(
+                        `Error deleting file from field '${fieldName}'`,
+                        await extractErrorMessage(deleteError),
+                    );
                 }
 
                 OutputFormatter.success({