@uipath/data-fabric-tool 1.195.0 → 1.196.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/data-fabric-tool",
   "license": "MIT",
-  "version": "1.195.0",
+  "version": "1.196.0",
   "description": "Manage Data Fabric entities and records.",
   "type": "module",
   "main": "./dist/tool.js",
@@ -14,5 +14,5 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "65fabb84552758b2710d8ca68470e70a9b1d19bc"
+  "gitHead": "94d71f9c52214980a1f0ae62b3f5372095788553"
 }

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

@@ -557,7 +557,7 @@ describe("choice-sets delete", () => {
         );
     });
 
-    it("should require --confirm", async () => {
+    it("should require confirmation (no --yes/--confirm): exit 1, SDK not called", async () => {
         const sdk = mockSdk();
         const program = buildProgram();
         await program.parseAsync([
@@ -570,13 +570,30 @@ describe("choice-sets delete", () => {
             "cleanup",
         ]);
         expect(sdk.entities.choicesets.deleteById).not.toHaveBeenCalled();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should accept --yes (canonical confirmation flag)", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "delete",
+            "cs-1",
+            "--yes",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteById).toHaveBeenCalledWith("cs-1");
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Result: "Failure",
-                Message: "Confirmation required for destructive operation",
+                Result: "Success",
+                Code: "ChoiceSetDeleted",
             }),
         );
-        expect(process.exitCode).toBe(1);
     });
 
     it("should require --reason", async () => {
@@ -800,7 +817,7 @@ describe("choice-set-values", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should require --confirm for value delete", async () => {
+    it("should require confirmation for value delete: exit 1, SDK not called", async () => {
         const sdk = mockSdk();
         const program = buildValuesProgram();
         await program.parseAsync([
@@ -815,15 +832,31 @@ describe("choice-set-values", () => {
             "cleanup",
         ]);
         expect(sdk.entities.choicesets.deleteValuesById).not.toHaveBeenCalled();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Confirmation required for destructive operation",
-            }),
-        );
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
         expect(process.exitCode).toBe(1);
     });
 
+    it("should accept --yes for value delete (canonical flag)", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--ids",
+            "v-1",
+            "--yes",
+            "--reason",
+            "cleanup",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).toHaveBeenCalled();
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Result: "Success" }),
+        );
+    });
+
     it("should require --reason for value delete", async () => {
         const sdk = mockSdk();
         const program = buildValuesProgram();

package/src/commands/choice-sets.ts

@@ -13,7 +13,7 @@ import type {
     ChoiceSetUpdateOptions,
     ChoiceSetValueInsertOptions,
 } from "@uipath/uipath-typescript";
-import type { Command } from "commander";
+import { type Command, Option } from "commander";
 import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
 
@@ -54,6 +54,7 @@ interface UpdateOptions {
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
@@ -70,6 +71,7 @@ interface ValueUpdateOptions {
 interface ValueDeleteOptions {
     tenant?: string;
     ids?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
@@ -417,7 +419,10 @@ export const registerChoiceSetsCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
-        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .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",
@@ -428,6 +433,7 @@ export const registerChoiceSetsCommand = (program: Command) => {
             async (choiceSetId: string, options: DeleteOptions) => {
                 const reason = requireDestructiveConfirmation(
                     options,
+                    `delete choice set '${choiceSetId}'`,
                     'Pass --reason "<text>" to record why the choice set is being deleted.',
                 );
                 if (reason === null) return;
@@ -633,7 +639,10 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
         .option("--ids <ids>", "Comma-separated list of value IDs to delete")
-        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .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",
@@ -656,6 +665,7 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
 
                 const reason = requireDestructiveConfirmation(
                     options,
+                    `delete ${valueIds.length} value(s) from choice set '${choiceSetId}'`,
                     'Pass --reason "<text>" to record why the values are being deleted.',
                 );
                 if (reason === null) return;

package/src/commands/entities.spec.ts

@@ -1217,7 +1217,7 @@ describe("entities update", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should reject removeFields without --confirm", async () => {
+    it("should reject removeFields without confirmation: exit 1, SDK not called", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
             removeFields: [{ fieldName: "oldField" }],
@@ -1237,15 +1237,36 @@ describe("entities update", () => {
         ]);
 
         expect(sdk.entities.updateById).not.toHaveBeenCalled();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Confirmation required for destructive operation",
-            }),
-        );
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
         expect(process.exitCode).toBe(1);
     });
 
+    it("should accept removeFields with --yes (canonical flag)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{ fieldName: "oldField" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"oldField"}]}',
+            "--yes",
+            "--reason",
+            "drop legacy",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalled();
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Result: "Success" }),
+        );
+    });
+
     it("should reject removeFields without --reason", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
@@ -1764,7 +1785,7 @@ describe("entities delete", () => {
         );
     });
 
-    it("should error when --confirm is missing", async () => {
+    it("should error when confirmation is missing: exit 1, SDK not called", async () => {
         const sdk = mockSdk();
 
         const program = buildProgram();
@@ -1779,15 +1800,31 @@ describe("entities delete", () => {
         ]);
 
         expect(sdk.entities.deleteById).not.toHaveBeenCalled();
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Confirmation required for destructive operation",
-            }),
-        );
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
         expect(process.exitCode).toBe(1);
     });
 
+    it("should delete with --yes (canonical confirmation flag)", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "entity-id",
+            "--yes",
+            "--reason",
+            "cleanup",
+        ]);
+
+        expect(sdk.entities.deleteById).toHaveBeenCalledWith("entity-id");
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Result: "Success" }),
+        );
+    });
+
     it("should error when --reason is missing", async () => {
         const sdk = mockSdk();
 

package/src/commands/entities.ts

@@ -15,7 +15,7 @@ import type {
     RawEntityGetResponse,
 } from "@uipath/uipath-typescript";
 import { EntityFieldDataType } from "@uipath/uipath-typescript";
-import type { Command } from "commander";
+import { type Command, Option } from "commander";
 import { readJsonInput } from "../utils/input";
 import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
@@ -39,12 +39,14 @@ interface UpdateEntityOptions {
     tenant?: string;
     file?: string;
     body?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
 }
@@ -278,7 +280,10 @@ export const registerEntitiesCommand = (program: Command) => {
             "-f, --file <path>",
             "Path to JSON file with entity definition (fields array required; displayName, description, isRbacEnabled optional)",
         )
-        .option("--body <json>", "Inline JSON entity definition")
+        .option(
+            "--body <json>",
+            "Inline JSON entity definition (use `-` to read from stdin)",
+        )
         .examples(ENTITIES_CREATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -390,11 +395,17 @@ export const registerEntitiesCommand = (program: Command) => {
             "-f, --file <path>",
             "Path to JSON file with update options (addFields, updateFields, removeFields, displayName, description, isRbacEnabled)",
         )
-        .option("--body <json>", "Inline JSON update options")
         .option(
-            "--confirm",
+            "--body <json>",
+            "Inline JSON update options (use `-` to read from stdin)",
+        )
+        .option(
+            "-y, --yes",
             "Required when 'removeFields' is non-empty — acknowledges the field deletion is irreversible",
         )
+        .addOption(
+            new Option("--confirm", "Deprecated alias for --yes").hideHelp(),
+        )
         .option(
             "--reason <reason>",
             "Required when 'removeFields' is non-empty — echoed back in the response so the caller can log it",
@@ -482,6 +493,7 @@ export const registerEntitiesCommand = (program: Command) => {
 
                     const reason = requireDestructiveConfirmation(
                         options,
+                        `remove fields from entity '${id}'`,
                         'Pass --reason "<text>" to record why fields are being removed.',
                     );
                     if (reason === null) return;
@@ -593,7 +605,10 @@ export const registerEntitiesCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
-        .option("--confirm", "Acknowledge this is an irreversible operation")
+        .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",
@@ -604,6 +619,7 @@ export const registerEntitiesCommand = (program: Command) => {
             async (id: string, options: DeleteOptions) => {
                 const reason = requireDestructiveConfirmation(
                     options,
+                    `delete entity '${id}'`,
                     'Pass --reason "<text>" to record why the entity is being deleted.',
                 );
                 if (reason === null) return;

package/src/commands/files.spec.ts

@@ -237,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",
@@ -248,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",
@@ -265,7 +304,10 @@ describe("files delete", () => {
         const sdk = mockSdk();
         vi.mocked(connectOrFail).mockResolvedValue(undefined);
         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).not.toHaveBeenCalled();
         expect(OutputFormatter.success).not.toHaveBeenCalled();
     });

package/src/commands/files.ts

@@ -8,9 +8,9 @@ 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 { fail } from "../utils/output";
+import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
 
 interface UploadOptions {
@@ -25,6 +25,9 @@ interface DownloadOptions {
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
+    confirm?: boolean;
+    reason?: string;
 }
 
 const FILES_UPLOAD_EXAMPLES: CommandExample[] = [
@@ -241,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,
@@ -250,6 +261,13 @@ export const registerFilesCommand = (program: Command) => {
                 fieldName: string,
                 options: DeleteOptions,
             ) => {
+                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;
+
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
@@ -275,6 +293,7 @@ export const registerFilesCommand = (program: Command) => {
                         EntityId: entityId,
                         RecordId: recordId,
                         FieldName: fieldName,
+                        Reason: reason,
                     },
                 });
             },

package/src/commands/records.spec.ts

@@ -1067,6 +1067,9 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
@@ -1093,6 +1096,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalled();
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1119,6 +1125,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -1142,6 +1151,9 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1155,6 +1167,78 @@ describe("records delete", () => {
         );
         expect(process.exitCode).toBe(1);
     });
+
+    it("should accept --confirm as a deprecated alias for --yes", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--confirm",
+            "--reason",
+            "test cleanup",
+        ]);
+
+        expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            ["rec-1"],
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "RecordsDeleted",
+            }),
+        );
+    });
+
+    it("should require confirmation: without --yes, exit 1 and SDK not called", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--reason",
+            "test cleanup",
+        ]);
+
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require --reason when confirmation is present", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--yes",
+        ]);
+
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
 });
 
 describe("records delete client error", () => {
@@ -2242,6 +2326,9 @@ describe("records — negative scenarios", () => {
             "delete",
             "entity-id",
             "nonexistent-record-id",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(