@uipath/data-fabric-tool 1.0.4 → 1.195.0

package/src/commands/records.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) => {
@@ -23,7 +24,7 @@ vi.mock("@uipath/filesystem", () => ({
 }));
 
 import { OutputFormatter } from "@uipath/common";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { connectOrFail } from "../utils/sdk-client";
 import { registerRecordsCommand } from "./records";
 
 function buildProgram(): Command {
@@ -66,7 +67,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             ...overrides,
         },
     };
-    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
     return sdk;
 }
 
@@ -83,13 +84,14 @@ describe("records list", () => {
         expect(cmd?.commands.map((c) => c.name())).toContain("list");
     });
 
-    it("should list records successfully", async () => {
+    it("should list records successfully (raw SDK shape)", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-1", name: "test" }],
             totalCount: 1,
             hasNextPage: false,
-        });
+        };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -107,22 +109,20 @@ describe("records list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordList",
-                Data: expect.objectContaining({
-                    TotalCount: 1,
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
 
-    it("should pass cursor to SDK and include NextCursor in output", async () => {
+    it("should pass cursor to SDK and return the raw paginated response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-2" }],
             totalCount: 100,
             hasNextPage: true,
-            nextCursor: "cursor-abc",
-        });
+            nextCursor: { value: "cursor-abc" },
+        };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -141,16 +141,15 @@ describe("records list", () => {
         });
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "cursor-abc",
-                }),
+                Data: rawResult,
             }),
         );
     });
 
-    it("should return empty list when no records exist", async () => {
-        mockSdk();
+    it("should return empty list when no records exist (raw SDK shape)", async () => {
+        const sdk = mockSdk();
+        const rawResult = { items: [], totalCount: 0 };
+        vi.mocked(sdk.entities.getAllRecords).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -165,7 +164,7 @@ describe("records list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordList",
-                Data: expect.objectContaining({ TotalCount: 0, Records: [] }),
+                Data: rawResult,
             }),
         );
         expect(process.exitCode).not.toBe(1);
@@ -361,10 +360,9 @@ describe("records list client error", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on list", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on list", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -373,20 +371,14 @@ describe("records list client error", () => {
             "list",
             "entity-id",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getAllRecords).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
-    it("should handle list result without items/totalCount (uses defaults)", async () => {
+    it("should pass through the raw list result verbatim", async () => {
+        const rawResult = { items: [], hasNextPage: false };
         const sdk = mockSdk({
-            getAllRecords: vi
-                .fn()
-                .mockResolvedValue({ items: [], hasNextPage: false }),
+            getAllRecords: vi.fn().mockResolvedValue(rawResult),
         });
         const program = buildProgram();
         await program.parseAsync([
@@ -399,11 +391,7 @@ describe("records list client error", () => {
         expect(sdk.entities.getAllRecords).toHaveBeenCalled();
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    TotalCount: 0,
-                    Records: [],
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -496,10 +484,9 @@ describe("records get client error", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on get", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on get", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -509,13 +496,8 @@ describe("records get client error", () => {
             "entity-id",
             "rec-1",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -630,10 +612,9 @@ describe("records insert", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on insert", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on insert", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -644,13 +625,8 @@ describe("records insert", () => {
             "--body",
             '{"amount":100}',
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.insertRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should handle batch insert result without successRecords/failureRecords", async () => {
@@ -701,6 +677,75 @@ describe("records insert", () => {
         expect(process.exitCode).toBe(1);
     });
 
+    it("should pass choice-set NumberId integers and a relationship UUID through to the SDK on single insert", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.insertRecordById).mockResolvedValue({
+            Id: "new-rec",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "insert",
+            "entity-id",
+            "--body",
+            '{"title":"Flight to NYC","amount":420.5,"opType":0,"multiOpType":[0,1],"assignee":"AEDE69C3-EFD1-4897-B216-019E1A7E9269","rel1":"B065E2A8-F33B-4721-8228-019DE0C593AF"}',
+        ]);
+
+        expect(sdk.entities.insertRecordById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                opType: 0,
+                multiOpType: [0, 1],
+                assignee: "AEDE69C3-EFD1-4897-B216-019E1A7E9269",
+                rel1: "B065E2A8-F33B-4721-8228-019DE0C593AF",
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "RecordInserted" }),
+        );
+    });
+
+    it("should pass choice-set and relationship values through unchanged on batch insert", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.insertRecordsById).mockResolvedValue({
+            successRecords: [{ Id: "rec-a" }, { Id: "rec-b" }],
+            failureRecords: [],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "insert",
+            "entity-id",
+            "--body",
+            '[{"opType":0,"multiOpType":[0],"assignee":"AEDE69C3-EFD1-4897-B216-019E1A7E9269"},{"opType":1,"multiOpType":[0,1],"assignee":"2481A9F6-E0F7-4996-8446-019E1A7E926A"}]',
+        ]);
+
+        expect(sdk.entities.insertRecordsById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.arrayContaining([
+                expect.objectContaining({
+                    opType: 0,
+                    multiOpType: [0],
+                    assignee: "AEDE69C3-EFD1-4897-B216-019E1A7E9269",
+                }),
+                expect.objectContaining({
+                    opType: 1,
+                    multiOpType: [0, 1],
+                    assignee: "2481A9F6-E0F7-4996-8446-019E1A7E926A",
+                }),
+            ]),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "RecordsBatchInserted" }),
+        );
+    });
+
     it("should error on partial batch insert failure (FailureCount > 0)", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.insertRecordsById).mockResolvedValue({
@@ -908,10 +953,9 @@ describe("records update client/batch errors", () => {
         process.exitCode = undefined;
     });
 
-    it("should error when SDK connection fails on update", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on update", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -922,13 +966,8 @@ describe("records update client/batch errors", () => {
             "--body",
             '{"Id":"rec-1"}',
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.updateRecordById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should handle batch update result without successRecords/failureRecords", async () => {
@@ -1124,10 +1163,9 @@ describe("records delete client error", () => {
         process.exitCode = undefined;
     });
 
-    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 program.parseAsync([
             "node",
@@ -1137,13 +1175,8 @@ describe("records delete client error", () => {
             "entity-id",
             "rec-1",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.deleteRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -1236,13 +1269,14 @@ describe("records query", () => {
         process.exitCode = undefined;
     });
 
-    it("should query records without filters (no --body)", async () => {
+    it("should query records without filters (no --body) and return raw shape", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-1", title: "test" }],
             totalCount: 1,
             hasNextPage: false,
-        });
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1261,10 +1295,7 @@ describe("records query", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordQuery",
-                Data: expect.objectContaining({
-                    TotalCount: 1,
-                    HasNextPage: false,
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -1352,7 +1383,7 @@ describe("records query", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "RecordQuery",
-                Data: expect.objectContaining({ TotalCount: 2 }),
+                Data: expect.objectContaining({ totalCount: 2 }),
             }),
         );
     });
@@ -1401,8 +1432,8 @@ describe("records query", () => {
                 Result: "Success",
                 Code: "RecordQuery",
                 Data: expect.objectContaining({
-                    TotalCount: 2,
-                    Records: [
+                    totalCount: 2,
+                    items: [
                         { status: "Open", total: 12 },
                         { status: "Closed", total: 5 },
                     ],
@@ -1458,12 +1489,13 @@ describe("records query", () => {
 
     it("should pass custom --limit and --cursor to queryRecordsById", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "rec-3" }],
             totalCount: 100,
             hasNextPage: true,
-            nextCursor: "next-cursor-xyz",
-        });
+            nextCursor: { value: "next-cursor-xyz" },
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1487,10 +1519,7 @@ describe("records query", () => {
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
-                Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "next-cursor-xyz",
-                }),
+                Data: rawResult,
             }),
         );
     });
@@ -1558,10 +1587,9 @@ describe("records query", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on query", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on query", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
         const program = buildProgram();
         await program.parseAsync([
             "node",
@@ -1570,13 +1598,8 @@ describe("records query", () => {
             "query",
             "entity-id",
         ]);
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.queryRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when query API fails", async () => {
@@ -1808,10 +1831,9 @@ describe("records import", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on import", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails on import", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const { getFileSystem } = await import("@uipath/filesystem");
         vi.mocked(getFileSystem).mockReturnValue({
@@ -1831,13 +1853,8 @@ describe("records import", () => {
             "data.csv",
         ]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.importRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 });
 
@@ -1871,14 +1888,14 @@ describe("records query — pagination", () => {
         const call = vi.mocked(OutputFormatter.success).mock
             .calls[0][0] as unknown as {
             Data: {
-                TotalCount: number;
-                Records: unknown[];
-                HasNextPage: boolean;
+                totalCount: number;
+                items: unknown[];
+                hasNextPage: boolean;
             };
         };
-        expect(call.Data.TotalCount).toBe(3);
-        expect(call.Data.Records).toHaveLength(3);
-        expect(call.Data.HasNextPage).toBe(false);
+        expect(call.Data.totalCount).toBe(3);
+        expect(call.Data.items).toHaveLength(3);
+        expect(call.Data.hasNextPage).toBe(false);
     });
 
     it("should return first page with cursor when paginated", async () => {
@@ -1887,7 +1904,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r1" }, { Id: "r2" }],
             totalCount: 5,
             hasNextPage: true,
-            nextCursor: "cursor-page2",
+            nextCursor: { value: "cursor-page2" },
         });
 
         const program = buildProgram();
@@ -1908,16 +1925,16 @@ describe("records query — pagination", () => {
         const call = vi.mocked(OutputFormatter.success).mock
             .calls[0][0] as unknown as {
             Data: {
-                TotalCount: number;
-                Records: unknown[];
-                HasNextPage: boolean;
-                NextCursor: string;
+                totalCount: number;
+                items: unknown[];
+                hasNextPage: boolean;
+                nextCursor: { value: string };
             };
         };
-        expect(call.Data.TotalCount).toBe(5);
-        expect(call.Data.Records).toHaveLength(2);
-        expect(call.Data.HasNextPage).toBe(true);
-        expect(call.Data.NextCursor).toBe("cursor-page2");
+        expect(call.Data.totalCount).toBe(5);
+        expect(call.Data.items).toHaveLength(2);
+        expect(call.Data.hasNextPage).toBe(true);
+        expect(call.Data.nextCursor).toEqual({ value: "cursor-page2" });
     });
 
     it("should pass cursor to second page request", async () => {
@@ -1926,7 +1943,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r3" }, { Id: "r4" }],
             totalCount: 5,
             hasNextPage: true,
-            nextCursor: "cursor-page3",
+            nextCursor: { value: "cursor-page3" },
         });
 
         const program = buildProgram();
@@ -1952,8 +1969,8 @@ describe("records query — pagination", () => {
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Data: expect.objectContaining({
-                    HasNextPage: true,
-                    NextCursor: "cursor-page3",
+                    hasNextPage: true,
+                    nextCursor: { value: "cursor-page3" },
                 }),
             }),
         );
@@ -1965,7 +1982,7 @@ describe("records query — pagination", () => {
             items: [{ Id: "r1", status: "active" }],
             totalCount: 10,
             hasNextPage: true,
-            nextCursor: "cur-next",
+            nextCursor: { value: "cur-next" },
         });
 
         const body = JSON.stringify({
@@ -2005,67 +2022,14 @@ describe("records query — pagination", () => {
         expect(OutputFormatter.success).toHaveBeenCalledWith(
             expect.objectContaining({
                 Data: expect.objectContaining({
-                    TotalCount: 10,
-                    HasNextPage: true,
-                    NextCursor: "cur-next",
+                    totalCount: 10,
+                    hasNextPage: true,
+                    nextCursor: { value: "cur-next" },
                 }),
             }),
         );
     });
 
-    it("should omit NextCursor when hasNextPage is false", async () => {
-        const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
-            items: [{ Id: "r1" }],
-            totalCount: 1,
-            hasNextPage: false,
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "records",
-            "query",
-            "entity-id",
-        ]);
-
-        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: Record<string, unknown>;
-        };
-        expect(call.Data).not.toHaveProperty("NextCursor");
-    });
-
-    it("should normalise cursor object {value} returned by SDK to a plain string", async () => {
-        const sdk = mockSdk();
-        // SDK may return PaginationCursor = { value: string } instead of a raw string
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
-            items: [{ Id: "r1" }, { Id: "r2" }],
-            totalCount: 4,
-            hasNextPage: true,
-            nextCursor: { value: "cursor-as-object" } as unknown as string,
-        });
-
-        const program = buildProgram();
-        await program.parseAsync([
-            "node",
-            "test",
-            "records",
-            "query",
-            "entity-id",
-            "--limit",
-            "2",
-        ]);
-
-        const call = vi.mocked(OutputFormatter.success).mock
-            .calls[0][0] as unknown as {
-            Data: { NextCursor: unknown };
-        };
-        // Must be a plain string, not the object
-        expect(typeof call.Data.NextCursor).toBe("string");
-        expect(call.Data.NextCursor).toBe("cursor-as-object");
-    });
-
     it("should use default limit 50 when --cursor is given without --limit", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
@@ -2171,14 +2135,14 @@ describe("records query — pagination", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should handle last page correctly — no NextCursor even if SDK emits undefined", async () => {
+    it("should pass cursor through on the last page and return the raw result", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue({
+        const rawResult = {
             items: [{ Id: "r5" }],
             totalCount: 5,
             hasNextPage: false,
-            nextCursor: undefined,
-        });
+        };
+        vi.mocked(sdk.entities.queryRecordsById).mockResolvedValue(rawResult);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -2200,11 +2164,11 @@ describe("records query — pagination", () => {
                 cursor: { value: "cursor-page2" },
             }),
         );
-        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: Record<string, unknown>;
-        };
-        expect(call.Data.HasNextPage).toBe(false);
-        expect(call.Data).not.toHaveProperty("NextCursor");
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: rawResult,
+            }),
+        );
     });
 });