@uipath/data-fabric-tool 1.195.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({
@@ -1067,11 +1074,15 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalledWith(
             "entity-id",
             ["rec-1", "rec-2"],
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1093,6 +1104,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(sdk.entities.deleteRecordsById).toHaveBeenCalled();
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1119,6 +1133,9 @@ describe("records delete", () => {
             "delete",
             "entity-id",
             "rec-1",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -1142,6 +1159,9 @@ describe("records delete", () => {
             "entity-id",
             "rec-1",
             "rec-2",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -1155,6 +1175,79 @@ 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"],
+            undefined,
+        );
+        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", () => {
@@ -1208,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({
@@ -1681,6 +1775,7 @@ describe("records import", () => {
         expect(sdk.entities.importRecordsById).toHaveBeenCalledWith(
             "entity-id",
             expect.any(File),
+            undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
@@ -2242,6 +2337,9 @@ describe("records — negative scenarios", () => {
             "delete",
             "entity-id",
             "nonexistent-record-id",
+            "--yes",
+            "--reason",
+            "test cleanup",
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -2309,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" }),
+        );
+    });
+});