@uipath/data-fabric-tool 1.1.0 → 1.196.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();
     });
 });
 
@@ -246,7 +237,31 @@ describe("files delete", () => {
     it("should delete and return FileDeleted on success", async () => {
         const sdk = mockSdk();
         const program = buildProgram();
-        await runCommand(program, "files delete entity-1 record-1 attachment");
+        await runCommand(
+            program,
+            "files delete entity-1 record-1 attachment --yes --reason cleanup",
+        );
+        expect(sdk.entities.deleteAttachment).toHaveBeenCalledWith(
+            "entity-1",
+            "record-1",
+            "attachment",
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "FileDeleted",
+                Data: expect.objectContaining({ Reason: "cleanup" }),
+            }),
+        );
+    });
+
+    it("should accept --confirm as a deprecated alias for --yes", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await runCommand(
+            program,
+            "files delete entity-1 record-1 attachment --confirm --reason cleanup",
+        );
         expect(sdk.entities.deleteAttachment).toHaveBeenCalledWith(
             "entity-1",
             "record-1",
@@ -257,11 +272,26 @@ describe("files delete", () => {
         );
     });
 
+    it("should require confirmation: without --yes, exit 1 and SDK not called", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await runCommand(
+            program,
+            "files delete entity-1 record-1 attachment --reason cleanup",
+        );
+        expect(sdk.entities.deleteAttachment).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should error when delete API fails", async () => {
         const sdk = mockSdk();
         sdk.entities.deleteAttachment.mockRejectedValue(new Error("Forbidden"));
         const program = buildProgram();
-        await runCommand(program, "files delete entity-1 record-1 attachment");
+        await runCommand(
+            program,
+            "files delete entity-1 record-1 attachment --yes --reason cleanup",
+        );
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
@@ -270,18 +300,16 @@ 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",
-            }),
+        await runCommand(
+            program,
+            "files delete entity-1 record-1 attachment --yes --reason cleanup",
         );
+        expect(sdk.entities.deleteAttachment).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 

package/src/commands/files.ts

@@ -8,9 +8,10 @@ import {
     RESULTS,
 } from "@uipath/common";
 import { getFileSystem } from "@uipath/filesystem";
-import type { Command } from "commander";
+import { type Command, Option } from "commander";
 import { readFileBinary } from "../utils/input";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { fail, requireDestructiveConfirmation } from "../utils/output";
+import { connectOrFail } from "../utils/sdk-client";
 
 interface UploadOptions {
     tenant?: string;
@@ -24,6 +25,9 @@ interface DownloadOptions {
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
+    confirm?: boolean;
+    reason?: string;
 }
 
 const FILES_UPLOAD_EXAMPLES: CommandExample[] = [
@@ -101,41 +105,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 +138,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 +179,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 +191,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 +205,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 +216,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({
@@ -283,6 +244,14 @@ export const registerFilesCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
+        .option("-y, --yes", "Acknowledge this is an irreversible operation")
+        .addOption(
+            new Option("--confirm", "Deprecated alias for --yes").hideHelp(),
+        )
+        .option(
+            "--reason <reason>",
+            "Reason for the deletion — echoed back in the response so the caller can log it",
+        )
         .examples(FILES_DELETE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -292,19 +261,15 @@ export const registerFilesCommand = (program: Command) => {
                 fieldName: string,
                 options: DeleteOptions,
             ) => {
-                const [clientError, sdk] = await catchError(
-                    createDataFabricClient(options.tenant),
+                const reason = requireDestructiveConfirmation(
+                    options,
+                    `delete the file in field '${fieldName}'`,
+                    'Pass --reason "<text>" to record why the file is being deleted.',
                 );
+                if (reason === null) return;
 
-                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 +280,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({
@@ -331,6 +293,7 @@ export const registerFilesCommand = (program: Command) => {
                         EntityId: entityId,
                         RecordId: recordId,
                         FieldName: fieldName,
+                        Reason: reason,
                     },
                 });
             },