@uipath/data-fabric-tool 1.195.0 → 1.197.0-preview.59

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/data-fabric-tool",
   "license": "MIT",
-  "version": "1.195.0",
+  "version": "1.197.0-preview.59",
   "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": "df0e2b8140cced13f463b487214927c82bc0f85b"
 }

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

@@ -547,7 +547,10 @@ describe("choice-sets delete", () => {
             "--reason",
             "cleanup",
         ]);
-        expect(sdk.entities.choicesets.deleteById).toHaveBeenCalledWith("cs-1");
+        expect(sdk.entities.choicesets.deleteById).toHaveBeenCalledWith(
+            "cs-1",
+            undefined,
+        );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Success",
@@ -557,7 +560,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 +573,33 @@ 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",
+            undefined,
+        );
+        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 () => {
@@ -708,6 +731,7 @@ describe("choice-set-values", () => {
             "cs-1",
             "v-1",
             "Business Travel",
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -763,6 +787,7 @@ describe("choice-set-values", () => {
         expect(sdk.entities.choicesets.deleteValuesById).toHaveBeenCalledWith(
             "cs-1",
             ["v-1", "v-2", "v-3"],
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -800,7 +825,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 +840,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();
@@ -847,3 +888,211 @@ describe("choice-set-values", () => {
         expect(process.exitCode).toBe(1);
     });
 });
+
+describe("choice-sets list --include-folders", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should call getAll with no options when neither flag is passed", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync(["node", "test", "choice-sets", "list"]);
+        expect(sdk.entities.choicesets.getAll).toHaveBeenCalledWith(undefined);
+    });
+
+    it("should forward --include-folders as includeFolderChoiceSets: true", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list",
+            "--include-folders",
+        ]);
+        expect(sdk.entities.choicesets.getAll).toHaveBeenCalledWith({
+            includeFolderChoiceSets: true,
+        });
+    });
+
+    it("should forward --folder-key as folderKey to getAll", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list",
+            "--folder-key",
+            "folder-1",
+        ]);
+        expect(sdk.entities.choicesets.getAll).toHaveBeenCalledWith({
+            folderKey: "folder-1",
+        });
+    });
+
+    it("should reject --folder-key combined with --include-folders", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list",
+            "--folder-key",
+            "folder-1",
+            "--include-folders",
+        ]);
+        expect(sdk.entities.choicesets.getAll).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+});
+
+describe("choice-sets --folder-key forwarding", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should forward --folder-key to getById", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "list-values",
+            "cs-1",
+            "--folder-key",
+            "folder-1",
+        ]);
+        expect(sdk.entities.choicesets.getById).toHaveBeenCalledWith("cs-1", {
+            pageSize: 50,
+            folderKey: "folder-1",
+        });
+    });
+
+    it("should forward --folder-key into update options", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "update",
+            "cs-1",
+            "--display-name",
+            "New",
+            "--folder-key",
+            "folder-2",
+        ]);
+        expect(sdk.entities.choicesets.updateById).toHaveBeenCalledWith(
+            "cs-1",
+            {
+                displayName: "New",
+                folderKey: "folder-2",
+            },
+        );
+    });
+
+    it("should forward --folder-key to deleteById", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-sets",
+            "delete",
+            "cs-1",
+            "--yes",
+            "--reason",
+            "cleanup",
+            "--folder-key",
+            "folder-3",
+        ]);
+        expect(sdk.entities.choicesets.deleteById).toHaveBeenCalledWith(
+            "cs-1",
+            { folderKey: "folder-3" },
+        );
+    });
+});
+
+describe("choice-set-values --folder-key forwarding", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should forward --folder-key into insertValueById options", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "travel",
+            "--display-name",
+            "Travel",
+            "--folder-key",
+            "folder-4",
+        ]);
+        expect(sdk.entities.choicesets.insertValueById).toHaveBeenCalledWith(
+            "cs-1",
+            "travel",
+            {
+                displayName: "Travel",
+                folderKey: "folder-4",
+            },
+        );
+    });
+
+    it("should forward --folder-key to updateValueById", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "update",
+            "cs-1",
+            "v-1",
+            "Business Travel",
+            "--folder-key",
+            "folder-5",
+        ]);
+        expect(sdk.entities.choicesets.updateValueById).toHaveBeenCalledWith(
+            "cs-1",
+            "v-1",
+            "Business Travel",
+            { folderKey: "folder-5" },
+        );
+    });
+
+    it("should forward --folder-key to deleteValuesById", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "delete",
+            "cs-1",
+            "--ids",
+            "v-1,v-2",
+            "--yes",
+            "--reason",
+            "cleanup",
+            "--folder-key",
+            "folder-6",
+        ]);
+        expect(sdk.entities.choicesets.deleteValuesById).toHaveBeenCalledWith(
+            "cs-1",
+            ["v-1", "v-2"],
+            { folderKey: "folder-6" },
+        );
+    });
+});

package/src/commands/choice-sets.ts

@@ -9,11 +9,16 @@ import {
 } from "@uipath/common";
 import type {
     ChoiceSetCreateOptions,
+    ChoiceSetDeleteByIdOptions,
+    ChoiceSetGetAllOptions,
+    ChoiceSetGetByIdOptions,
     ChoiceSetServiceModel,
     ChoiceSetUpdateOptions,
+    ChoiceSetValueDeleteOptions,
     ChoiceSetValueInsertOptions,
+    ChoiceSetValueUpdateOptions,
 } 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";
 
@@ -30,6 +35,8 @@ const OUTPUT_CODES = {
 
 interface ListOptions {
     tenant?: string;
+    folderKey?: string;
+    includeFolders?: boolean;
 }
 
 interface GetOptions {
@@ -37,6 +44,7 @@ interface GetOptions {
     limit?: string;
     offset?: string;
     cursor?: string;
+    folderKey?: string;
 }
 
 interface CreateOptions {
@@ -50,34 +58,42 @@ interface UpdateOptions {
     tenant?: string;
     displayName?: string;
     description?: string;
+    folderKey?: string;
 }
 
 interface DeleteOptions {
     tenant?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
+    folderKey?: string;
 }
 
 interface ValueCreateOptions {
     tenant?: string;
     displayName?: string;
+    folderKey?: string;
 }
 
 interface ValueUpdateOptions {
     tenant?: string;
+    folderKey?: string;
 }
 
 interface ValueDeleteOptions {
     tenant?: string;
     ids?: string;
+    yes?: boolean;
     confirm?: boolean;
     reason?: string;
+    folderKey?: string;
 }
 
 const CHOICE_SETS_LIST_EXAMPLES: CommandExample[] = [
     {
         Description:
-            "List all Data Fabric choice sets. The returned 'id' is the value to pass as 'choiceSetId' on a CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity field, or to 'df choice-sets list-values <id>'.",
+            "List all Data Fabric choice sets. The returned 'id' is the value to pass as 'choiceSetId' on a CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE entity field, or to 'df choice-sets list-values <id>'. " +
+            "Scope modes: omit both flags to see only tenant-level choice sets (the default); pass '--folder-key <uuid>' to see only that folder's choice sets; pass '--include-folders' to see tenant + folder choice sets together. '--folder-key' and '--include-folders' are mutually exclusive.",
         Command: "uip df choice-sets list",
         Output: {
             Code: OUTPUT_CODES.ChoiceSetList,
@@ -184,13 +200,42 @@ export const registerChoiceSetsCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) to scope the listing to a specific folder",
+        )
+        .option(
+            "--include-folders",
+            "List tenant-level choice sets together with choice sets from every folder you can see. Mutually exclusive with --folder-key.",
+        )
         .examples(CHOICE_SETS_LIST_EXAMPLES)
         .trackedAction(processContext, async (options: ListOptions) => {
+            if (
+                options.folderKey !== undefined &&
+                options.includeFolders === true
+            ) {
+                return fail(
+                    "--folder-key and --include-folders are mutually exclusive",
+                    "Use --folder-key to list a single folder, or --include-folders to list tenant + folder choice sets together.",
+                );
+            }
+
             const sdk = await connectOrFail(options.tenant);
             if (!sdk) return;
 
+            const listOpts: ChoiceSetGetAllOptions = {
+                ...(options.folderKey !== undefined && {
+                    folderKey: options.folderKey,
+                }),
+                ...(options.includeFolders === true && {
+                    includeFolderChoiceSets: true,
+                }),
+            };
+
             const [listError, result] = await catchError(
-                sdk.entities.choicesets.getAll(),
+                sdk.entities.choicesets.getAll(
+                    Object.keys(listOpts).length > 0 ? listOpts : undefined,
+                ),
             );
 
             if (listError) {
@@ -227,6 +272,10 @@ export const registerChoiceSetsCommand = (program: Command) => {
             "--cursor <cursor>",
             "Pagination cursor from a previous response to fetch the next page",
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SETS_GET_EXAMPLES)
         .trackedAction(
             processContext,
@@ -264,12 +313,15 @@ export const registerChoiceSetsCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
-                const paginationOptions =
+                const paginationOptions: ChoiceSetGetByIdOptions =
                     options.cursor !== undefined
                         ? { pageSize, cursor: { value: options.cursor } }
                         : jumpToPage !== undefined
                           ? { pageSize, jumpToPage }
                           : { pageSize };
+                if (options.folderKey !== undefined) {
+                    paginationOptions.folderKey = options.folderKey;
+                }
 
                 const [getError, result] = await catchError(
                     sdk.entities.choicesets.getById(
@@ -363,6 +415,10 @@ export const registerChoiceSetsCommand = (program: Command) => {
         )
         .option("--display-name <name>", "New display name")
         .option("--description <text>", "New description")
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SETS_UPDATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -387,6 +443,9 @@ export const registerChoiceSetsCommand = (program: Command) => {
                     ...(options.description !== undefined && {
                         description: options.description,
                     }),
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
                 };
 
                 const choiceSetService: ChoiceSetServiceModel =
@@ -417,17 +476,25 @@ 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",
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SETS_DELETE_EXAMPLES)
         .trackedAction(
             processContext,
             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;
@@ -435,10 +502,21 @@ export const registerChoiceSetsCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
+                const deleteOpts: ChoiceSetDeleteByIdOptions = {
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
+                };
+
                 const choiceSetService: ChoiceSetServiceModel =
                     sdk.entities.choicesets;
                 const [deleteError] = await catchError(
-                    choiceSetService.deleteById(choiceSetId),
+                    choiceSetService.deleteById(
+                        choiceSetId,
+                        Object.keys(deleteOpts).length > 0
+                            ? deleteOpts
+                            : undefined,
+                    ),
                 );
 
                 if (deleteError) {
@@ -533,6 +611,10 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
         .option("--display-name <name>", "Human-readable display name")
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (required for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SET_VALUES_CREATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -548,6 +630,9 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
                     ...(options.displayName !== undefined && {
                         displayName: options.displayName,
                     }),
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
                 };
 
                 const choiceSetService: ChoiceSetServiceModel =
@@ -586,6 +671,10 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (required for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SET_VALUES_UPDATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -598,6 +687,12 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
+                const updateOpts: ChoiceSetValueUpdateOptions = {
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
+                };
+
                 const choiceSetService: ChoiceSetServiceModel =
                     sdk.entities.choicesets;
                 const [updateError, result] = await catchError(
@@ -605,6 +700,9 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
                         choiceSetId,
                         valueId,
                         displayName,
+                        Object.keys(updateOpts).length > 0
+                            ? updateOpts
+                            : undefined,
                     ),
                 );
 
@@ -633,11 +731,18 @@ 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",
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the choice set (required for folder-scoped choice sets)",
+        )
         .examples(CHOICE_SET_VALUES_DELETE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -656,6 +761,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;
@@ -663,10 +769,22 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
+                const deleteOpts: ChoiceSetValueDeleteOptions = {
+                    ...(options.folderKey !== undefined && {
+                        folderKey: options.folderKey,
+                    }),
+                };
+
                 const choiceSetService: ChoiceSetServiceModel =
                     sdk.entities.choicesets;
                 const [deleteError] = await catchError(
-                    choiceSetService.deleteValuesById(choiceSetId, valueIds),
+                    choiceSetService.deleteValuesById(
+                        choiceSetId,
+                        valueIds,
+                        Object.keys(deleteOpts).length > 0
+                            ? deleteOpts
+                            : undefined,
+                    ),
                 );
 
                 if (deleteError) {