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

package/src/commands/records.spec.ts

@@ -423,6 +423,7 @@ describe("records get", () => {
         expect(sdk.entities.getRecordById).toHaveBeenCalledWith(
             "entity-id",
             "rec-1",
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -527,6 +528,7 @@ describe("records insert", () => {
         expect(sdk.entities.insertRecordById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({ amount: 100 }),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -578,6 +580,7 @@ describe("records insert", () => {
                 expect.objectContaining({ amount: 100 }),
                 expect.objectContaining({ amount: 200 }),
             ]),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -702,6 +705,7 @@ describe("records insert", () => {
                 assignee: "AEDE69C3-EFD1-4897-B216-019E1A7E9269",
                 rel1: "B065E2A8-F33B-4721-8228-019DE0C593AF",
             }),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({ Code: "RecordInserted" }),
@@ -740,6 +744,7 @@ describe("records insert", () => {
                     assignee: "2481A9F6-E0F7-4996-8446-019E1A7E926A",
                 }),
             ]),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({ Code: "RecordsBatchInserted" }),
@@ -806,6 +811,7 @@ describe("records update", () => {
             "entity-id",
             "rec-1",
             expect.objectContaining({ Id: "rec-1", amount: 200 }),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -862,6 +868,7 @@ describe("records update", () => {
                 expect.objectContaining({ Id: "rec-1" }),
                 expect.objectContaining({ Id: "rec-2" }),
             ]),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1075,6 +1082,7 @@ describe("records delete", () => {
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
             "entity-id",
             ["rec-1", "rec-2"],
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1187,6 +1195,7 @@ describe("records delete", () => {
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
             "entity-id",
             ["rec-1"],
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1292,6 +1301,7 @@ describe("records insert via --file", () => {
         expect(sdk.entities.insertRecordById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({ amount: 100 }),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1765,6 +1775,7 @@ describe("records import", () => {
         expect(sdk.entities.importRecordsById).toHaveBeenCalledWith(
             "entity-id",
             expect.any(File),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -2396,3 +2407,228 @@ describe("records — negative scenarios", () => {
         expect(process.exitCode).toBe(1);
     });
 });
+
+describe("records --folder-key forwarding", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should forward --folder-key to getAllRecords on list", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "list",
+            "entity-id",
+            "--folder-key",
+            "folder-guid-1",
+        ]);
+
+        expect(sdk.entities.getAllRecords).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ folderKey: "folder-guid-1" }),
+        );
+    });
+
+    it("should forward --folder-key to getRecordById on get", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "get",
+            "entity-id",
+            "rec-1",
+            "--folder-key",
+            "folder-guid-2",
+        ]);
+
+        expect(sdk.entities.getRecordById).toHaveBeenCalledWith(
+            "entity-id",
+            "rec-1",
+            { folderKey: "folder-guid-2" },
+        );
+    });
+
+    it("should forward --folder-key to insertRecordById on single insert", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "insert",
+            "entity-id",
+            "--body",
+            '{"amount":100}',
+            "--folder-key",
+            "folder-guid-3",
+        ]);
+
+        expect(sdk.entities.insertRecordById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ amount: 100 }),
+            { folderKey: "folder-guid-3" },
+        );
+    });
+
+    it("should forward --folder-key to insertRecordsById on batch insert", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "insert",
+            "entity-id",
+            "--body",
+            '[{"amount":100},{"amount":200}]',
+            "--folder-key",
+            "folder-guid-4",
+        ]);
+
+        expect(sdk.entities.insertRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.any(Array),
+            { folderKey: "folder-guid-4" },
+        );
+    });
+
+    it("should forward --folder-key to updateRecordById on single update", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "update",
+            "entity-id",
+            "--body",
+            '{"Id":"rec-1","amount":200}',
+            "--folder-key",
+            "folder-guid-5",
+        ]);
+
+        expect(sdk.entities.updateRecordById).toHaveBeenCalledWith(
+            "entity-id",
+            "rec-1",
+            expect.objectContaining({ Id: "rec-1" }),
+            { folderKey: "folder-guid-5" },
+        );
+    });
+
+    it("should forward --folder-key to updateRecordsById on batch update", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.updateRecordsById).mockResolvedValue({
+            successRecords: [{ Id: "rec-1" }, { Id: "rec-2" }],
+            failureRecords: [],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "update",
+            "entity-id",
+            "--body",
+            '[{"Id":"rec-1","amount":200},{"Id":"rec-2","amount":300}]',
+            "--folder-key",
+            "folder-guid-8",
+        ]);
+
+        expect(sdk.entities.updateRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.any(Array),
+            { folderKey: "folder-guid-8" },
+        );
+    });
+
+    it("should forward --folder-key to importRecordsById on import", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.importRecordsById).mockResolvedValue({
+            insertedRecords: 1,
+            totalRecords: 1,
+        });
+
+        const { getFileSystem } = await import("@uipath/filesystem");
+        const csvBytes = new TextEncoder().encode("title,amount\ntest,100");
+        vi.mocked(getFileSystem).mockReturnValue({
+            readFile: vi.fn().mockResolvedValue(csvBytes),
+            path: { basename: vi.fn().mockReturnValue("data.csv") },
+        } as never);
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "import",
+            "entity-id",
+            "--file",
+            "data.csv",
+            "--folder-key",
+            "folder-guid-9",
+        ]);
+
+        expect(sdk.entities.importRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.any(File),
+            { folderKey: "folder-guid-9" },
+        );
+    });
+
+    it("should forward --folder-key to deleteRecordsById on delete", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "delete",
+            "entity-id",
+            "rec-1",
+            "--yes",
+            "--reason",
+            "cleanup",
+            "--folder-key",
+            "folder-guid-6",
+        ]);
+
+        expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            ["rec-1"],
+            { folderKey: "folder-guid-6" },
+        );
+    });
+
+    it("should forward --folder-key to queryRecordsById on query", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "query",
+            "entity-id",
+            "--folder-key",
+            "folder-guid-7",
+        ]);
+
+        expect(sdk.entities.queryRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ folderKey: "folder-guid-7" }),
+        );
+    });
+});

package/src/commands/records.ts

@@ -19,22 +19,26 @@ interface ListOptions {
     limit: string;
     offset?: string;
     cursor?: string;
+    folderKey?: string;
 }
 
 interface GetOptions {
     tenant?: string;
+    folderKey?: string;
 }
 
 interface InsertOptions {
     tenant?: string;
     file?: string;
     body?: string;
+    folderKey?: string;
 }
 
 interface UpdateOptions {
     tenant?: string;
     file?: string;
     body?: string;
+    folderKey?: string;
 }
 
 interface DeleteOptions {
@@ -42,6 +46,7 @@ interface DeleteOptions {
     yes?: boolean;
     confirm?: boolean;
     reason?: string;
+    folderKey?: string;
 }
 
 interface QueryOptions {
@@ -51,11 +56,13 @@ interface QueryOptions {
     limit: string;
     offset?: string;
     cursor?: string;
+    folderKey?: string;
 }
 
 interface ImportOptions {
     tenant?: string;
     file?: string;
+    folderKey?: string;
 }
 
 interface BatchResult {
@@ -198,6 +205,10 @@ export const registerRecordsCommand = (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 entity (for folder-scoped entities)",
+        )
         .examples(RECORDS_LIST_EXAMPLES)
         .trackedAction(
             processContext,
@@ -235,13 +246,18 @@ export const registerRecordsCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
+                const listPaginationOptions =
+                    options.cursor !== undefined
+                        ? { pageSize, cursor: { value: options.cursor } }
+                        : jumpToPage !== undefined
+                          ? { pageSize, jumpToPage }
+                          : { pageSize };
                 const [listError, result] = await catchError(
                     sdk.entities.getAllRecords(entityId, {
-                        pageSize,
-                        ...(options.cursor !== undefined && {
-                            cursor: { value: options.cursor },
+                        ...listPaginationOptions,
+                        ...(options.folderKey !== undefined && {
+                            folderKey: options.folderKey,
                         }),
-                        ...(jumpToPage !== undefined && { jumpToPage }),
                     }),
                 );
 
@@ -268,6 +284,10 @@ export const registerRecordsCommand = (program: Command) => {
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)",
+        )
         .examples(RECORDS_GET_EXAMPLES)
         .trackedAction(
             processContext,
@@ -276,7 +296,13 @@ export const registerRecordsCommand = (program: Command) => {
                 if (!sdk) return;
 
                 const [getError, record] = await catchError(
-                    sdk.entities.getRecordById(entityId, recordId),
+                    sdk.entities.getRecordById(
+                        entityId,
+                        recordId,
+                        options.folderKey !== undefined
+                            ? { folderKey: options.folderKey }
+                            : undefined,
+                    ),
                 );
 
                 if (getError) {
@@ -316,6 +342,10 @@ export const registerRecordsCommand = (program: Command) => {
             "--body <json>",
             "Inline JSON record data (object or array of objects; use `-` to read from stdin)",
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)",
+        )
         .examples(RECORDS_INSERT_EXAMPLES)
         .trackedAction(
             processContext,
@@ -336,9 +366,18 @@ export const registerRecordsCommand = (program: Command) => {
                     | Record<string, unknown>[];
                 const recordsList = Array.isArray(data) ? data : [data];
 
+                const folderOptions =
+                    options.folderKey !== undefined
+                        ? { folderKey: options.folderKey }
+                        : undefined;
+
                 if (recordsList.length === 1) {
                     const [insertError, result] = await catchError(
-                        sdk.entities.insertRecordById(entityId, recordsList[0]),
+                        sdk.entities.insertRecordById(
+                            entityId,
+                            recordsList[0],
+                            folderOptions,
+                        ),
                     );
 
                     if (insertError) {
@@ -355,7 +394,11 @@ export const registerRecordsCommand = (program: Command) => {
                     });
                 } else {
                     const [insertError, result] = await catchError(
-                        sdk.entities.insertRecordsById(entityId, recordsList),
+                        sdk.entities.insertRecordsById(
+                            entityId,
+                            recordsList,
+                            folderOptions,
+                        ),
                     );
 
                     if (insertError) {
@@ -399,6 +442,10 @@ export const registerRecordsCommand = (program: Command) => {
             "--body <json>",
             "Inline JSON record data (must include Id field; use `-` to read from stdin)",
         )
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)",
+        )
         .examples(RECORDS_UPDATE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -419,6 +466,11 @@ export const registerRecordsCommand = (program: Command) => {
                     | Record<string, unknown>[];
                 const recordsList = Array.isArray(data) ? data : [data];
 
+                const folderOptions =
+                    options.folderKey !== undefined
+                        ? { folderKey: options.folderKey }
+                        : undefined;
+
                 if (recordsList.length === 1) {
                     const record = recordsList[0];
                     const recordId =
@@ -435,6 +487,7 @@ export const registerRecordsCommand = (program: Command) => {
                             entityId,
                             String(recordId),
                             record,
+                            folderOptions,
                         ),
                     );
 
@@ -465,6 +518,7 @@ export const registerRecordsCommand = (program: Command) => {
                         sdk.entities.updateRecordsById(
                             entityId,
                             recordsList as EntityRecord[],
+                            folderOptions,
                         ),
                     );
 
@@ -527,6 +581,10 @@ export const registerRecordsCommand = (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 entity (for folder-scoped entities)",
+        )
         .trackedAction(
             processContext,
             async (entityId: string, options: QueryOptions) => {
@@ -591,14 +649,19 @@ export const registerRecordsCommand = (program: Command) => {
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 
+                const queryPaginationOptions =
+                    options.cursor !== undefined
+                        ? { pageSize, cursor: { value: options.cursor } }
+                        : jumpToPage !== undefined
+                          ? { pageSize, jumpToPage }
+                          : { pageSize };
                 const [queryError, result] = await catchError(
                     sdk.entities.queryRecordsById(entityId, {
                         ...(queryBody !== null && queryBody),
-                        pageSize,
-                        ...(options.cursor !== undefined && {
-                            cursor: { value: options.cursor },
+                        ...queryPaginationOptions,
+                        ...(options.folderKey !== undefined && {
+                            folderKey: options.folderKey,
                         }),
-                        ...(jumpToPage !== undefined && { jumpToPage }),
                     }),
                 );
 
@@ -625,6 +688,10 @@ export const registerRecordsCommand = (program: Command) => {
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
         )
         .option("-f, --file <path>", "Path to the CSV file to import")
+        .option(
+            "--folder-key <key>",
+            "Folder key (GUID) of the folder containing the entity (for folder-scoped entities)",
+        )
         .trackedAction(
             processContext,
             async (entityId: string, options: ImportOptions) => {
@@ -654,7 +721,13 @@ export const registerRecordsCommand = (program: Command) => {
                     { type: "text/csv" },
                 );
                 const [importError, result] = await catchError(
-                    sdk.entities.importRecordsById(entityId, csvFile),
+                    sdk.entities.importRecordsById(
+                        entityId,
+                        csvFile,
+                        options.folderKey !== undefined
+                            ? { folderKey: options.folderKey }
+                            : undefined,
+                    ),
                 );
 
                 if (importError) {
@@ -700,6 +773,10 @@ export const registerRecordsCommand = (program: Command) => {
             "--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 entity (for folder-scoped entities)",
+        )
         .examples(RECORDS_DELETE_EXAMPLES)
         .trackedAction(
             processContext,
@@ -719,7 +796,13 @@ export const registerRecordsCommand = (program: Command) => {
                 if (!sdk) return;
 
                 const [deleteError, result] = await catchError(
-                    sdk.entities.deleteRecordsById(entityId, recordIds),
+                    sdk.entities.deleteRecordsById(
+                        entityId,
+                        recordIds,
+                        options.folderKey !== undefined
+                            ? { folderKey: options.folderKey }
+                            : undefined,
+                    ),
                 );
 
                 if (deleteError) {