@uipath/data-fabric-tool 1.0.4 → 1.195.0

package/src/commands/entities.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) => {
@@ -22,7 +23,7 @@ vi.mock("../utils/input", () => ({
 
 import { OutputFormatter } from "@uipath/common";
 import { readJsonInput } from "../utils/input";
-import { createDataFabricClient } from "../utils/sdk-client";
+import { connectOrFail } from "../utils/sdk-client";
 import { registerEntitiesCommand } from "./entities";
 
 function buildProgram(): Command {
@@ -43,7 +44,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             ...overrides,
         },
     };
-    vi.mocked(createDataFabricClient).mockResolvedValue(sdk as never);
+    vi.mocked(connectOrFail).mockResolvedValue(sdk as never);
     return sdk;
 }
 
@@ -74,9 +75,9 @@ describe("entities list", () => {
         ).toBeFalsy();
     });
 
-    it("should list entities successfully", async () => {
+    it("should list entities successfully (raw SDK shape)", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAll).mockResolvedValue([
+        const rawEntities = [
             {
                 id: "uuid-1",
                 name: "invoice",
@@ -86,7 +87,8 @@ describe("entities list", () => {
                 fields: [{ name: "amount" }, { name: "date" }],
                 externalFields: [],
             },
-        ]);
+        ];
+        vi.mocked(sdk.entities.getAll).mockResolvedValue(rawEntities);
 
         const program = buildProgram();
         await program.parseAsync(["node", "test", "entities", "list"]);
@@ -95,53 +97,12 @@ describe("entities list", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "EntityList",
-                Data: expect.arrayContaining([
-                    expect.objectContaining({
-                        Name: "invoice",
-                        ID: "uuid-1",
-                        FieldCount: 2,
-                        Source: "Native",
-                    }),
-                ]),
+                Data: rawEntities,
             }),
         );
     });
 
-    it("should label federated entity with connector name", async () => {
-        const sdk = mockSdk();
-        vi.mocked(sdk.entities.getAll).mockResolvedValue([
-            {
-                id: "uuid-2",
-                name: "contacts",
-                displayName: "Contacts",
-                entityType: "Federated",
-                description: "",
-                fields: [],
-                externalFields: [
-                    {
-                        externalConnectionDetail: {
-                            connectorName: "Salesforce",
-                        },
-                    },
-                ],
-            },
-        ]);
-
-        const program = buildProgram();
-        await program.parseAsync(["node", "test", "entities", "list"]);
-
-        expect(OutputFormatter.success).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Data: expect.arrayContaining([
-                    expect.objectContaining({
-                        Source: "Federated (Salesforce)",
-                    }),
-                ]),
-            }),
-        );
-    });
-
-    it("should filter out federated entities with --native-only", async () => {
+    it("should filter out federated entities with --native-only (raw shape)", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.getAll).mockResolvedValue([
             {
@@ -168,10 +129,10 @@ describe("entities list", () => {
         ]);
 
         const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
-            Data: { ID: string }[];
+            Data: { id: string }[];
         };
         expect(call.Data).toHaveLength(1);
-        expect(call.Data[0].ID).toBe("uuid-1");
+        expect(call.Data[0].id).toBe("uuid-1");
     });
 
     it("should return empty list when no entities exist", async () => {
@@ -189,21 +150,15 @@ describe("entities list", () => {
         );
     });
 
-    it("should error when SDK connection fails", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const program = buildProgram();
         await program.parseAsync(["node", "test", "entities", "list"]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getAll).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when list API fails", async () => {
@@ -231,23 +186,33 @@ describe("entities get", () => {
         process.exitCode = undefined;
     });
 
-    it("should return entity schema with fields", async () => {
+    it("should return entity schema as the raw SDK response", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getById).mockResolvedValue({
+        const rawEntity = {
             id: "uuid-1",
             name: "invoice",
             displayName: "Invoice",
             entityType: "Local",
             description: "Invoice entity",
+            isRbacEnabled: false,
             fields: [
                 {
                     id: "field-uuid-1",
                     name: "amount",
                     displayName: "Amount",
                     fieldDataType: { name: "DECIMAL" },
+                    sqlType: {
+                        name: "DECIMAL",
+                        decimalPrecision: 2,
+                    },
                     isRequired: true,
                     isPrimaryKey: false,
                     isSystemField: false,
+                    // SDK-internal fields are no longer projected away
+                    isForeignKey: false,
+                    referenceName: "fk_Amount_ab00841b",
+                    createdTime: "2026-01-01T00:00:00Z",
+                    createdBy: "u1",
                 },
                 {
                     id: "field-uuid-2",
@@ -259,7 +224,8 @@ describe("entities get", () => {
                     isSystemField: false,
                 },
             ],
-        });
+        };
+        vi.mocked(sdk.entities.getById).mockResolvedValue(rawEntity);
 
         const program = buildProgram();
         await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
@@ -268,55 +234,20 @@ describe("entities get", () => {
             expect.objectContaining({
                 Result: "Success",
                 Code: "EntitySchema",
-                Data: expect.objectContaining({
-                    ID: "uuid-1",
-                    Name: "invoice",
-                    Fields: expect.arrayContaining([
-                        expect.objectContaining({
-                            ID: "field-uuid-1",
-                            Name: "amount",
-                            Type: "DECIMAL",
-                            Required: true,
-                        }),
-                    ]),
-                }),
+                Data: rawEntity,
             }),
         );
     });
 
-    it("should use name as DisplayName when displayName is missing", async () => {
+    it("should bail when SDK connection fails", async () => {
         const sdk = mockSdk();
-        vi.mocked(sdk.entities.getById).mockResolvedValue({
-            id: "uuid-1",
-            name: "invoice",
-            fields: [],
-        });
-
-        const program = buildProgram();
-        await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
-
-        expect(OutputFormatter.success).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Data: expect.objectContaining({ DisplayName: "invoice" }),
-            }),
-        );
-    });
-
-    it("should error when SDK connection fails", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const program = buildProgram();
         await program.parseAsync(["node", "test", "entities", "get", "uuid-1"]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.getById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when entity is not found (SDK throws)", async () => {
@@ -465,6 +396,128 @@ describe("entities create", () => {
         );
     });
 
+    it("should create entity with a CHOICE_SET_SINGLE field carrying choiceSetId", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue(
+            "entity-choice-single",
+        );
+        const fields = [
+            {
+                fieldName: "opType",
+                type: "CHOICE_SET_SINGLE",
+                choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
+                isRequired: true,
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ fields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "CliTestExpense",
+            "--body",
+            JSON.stringify({ fields }),
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "CliTestExpense",
+            expect.arrayContaining([
+                expect.objectContaining({
+                    fieldName: "opType",
+                    type: "CHOICE_SET_SINGLE",
+                    choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
+                }),
+            ]),
+            undefined,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
+    it("should create entity with a CHOICE_SET_MULTIPLE field carrying choiceSetId", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("entity-choice-multi");
+        const fields = [
+            {
+                fieldName: "multiOpType",
+                type: "CHOICE_SET_MULTIPLE",
+                choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ fields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "CliTestExpense",
+            "--body",
+            JSON.stringify({ fields }),
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "CliTestExpense",
+            expect.arrayContaining([
+                expect.objectContaining({
+                    fieldName: "multiOpType",
+                    type: "CHOICE_SET_MULTIPLE",
+                    choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
+                }),
+            ]),
+            undefined,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
+    it("should create entity with a RELATIONSHIP field carrying referenceEntityId and referenceFieldId", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("entity-rel");
+        const fields = [
+            {
+                fieldName: "rel1",
+                type: "RELATIONSHIP",
+                referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                referenceFieldId: "f1000000-0000-0000-0000-000000000100",
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ fields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "CliTestExpense",
+            "--body",
+            JSON.stringify({ fields }),
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "CliTestExpense",
+            expect.arrayContaining([
+                expect.objectContaining({
+                    fieldName: "rel1",
+                    type: "RELATIONSHIP",
+                    referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                    referenceFieldId: "f1000000-0000-0000-0000-000000000100",
+                }),
+            ]),
+            undefined,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
     it("should error when no --body or --file provided", async () => {
         vi.mocked(readJsonInput).mockRejectedValue(
             new Error("Provide entity definition via --file or --body."),
@@ -588,13 +641,12 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on create", async () => {
+    it("should bail when SDK connection fails on create", async () => {
+        const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
             fields: [{ fieldName: "title", type: "STRING" }],
         });
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -607,13 +659,8 @@ describe("entities create", () => {
             '{"fields":[{"fieldName":"title","type":"STRING"}]}',
         ]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.create).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when create API fails", async () => {
@@ -684,6 +731,69 @@ describe("entities update", () => {
         );
     });
 
+    it("should update entity by adding a RELATIONSHIP field with referenceEntityId and referenceFieldId", async () => {
+        const sdk = mockSdk();
+        const addFields = [
+            {
+                fieldName: "rel1",
+                type: "RELATIONSHIP",
+                referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                referenceFieldId: "f1000000-0000-0000-0000-000000000100",
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ addFields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ addFields }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ addFields }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should update entity by adding a CHOICE_SET_MULTIPLE field with choiceSetId", async () => {
+        const sdk = mockSdk();
+        const addFields = [
+            {
+                fieldName: "multiOpType",
+                type: "CHOICE_SET_MULTIPLE",
+                choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ addFields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ addFields }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ addFields }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
     it("should update entity by modifying existing fields (updateFields)", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
@@ -727,6 +837,182 @@ describe("entities update", () => {
         );
     });
 
+    it("should update displayName on a CHOICE_SET_SINGLE field via updateFields", async () => {
+        const sdk = mockSdk();
+        const updateFields = [
+            {
+                id: "f9ccd648-ac52-f111-8ef3-6045bd07956d",
+                displayName: "Operator Type",
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ updateFields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ updateFields }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ updateFields }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should update displayName and isRequired on a CHOICE_SET_MULTIPLE field via updateFields", async () => {
+        const sdk = mockSdk();
+        const updateFields = [
+            {
+                id: "8750af08-b252-f111-8ef3-6045bd07956d",
+                displayName: "Multi Operator Types",
+                isRequired: true,
+            },
+        ];
+        vi.mocked(readJsonInput).mockResolvedValue({ updateFields });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ updateFields }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ updateFields }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should remove a CHOICE_SET_SINGLE field via removeFields with --confirm and --reason", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{ fieldName: "opType" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"opType"}]}',
+            "--confirm",
+            "--reason",
+            "dropping single-select choice-set field",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                removeFields: [{ fieldName: "opType" }],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+                Data: expect.objectContaining({
+                    RemovedFields: ["opType"],
+                    Reason: "dropping single-select choice-set field",
+                }),
+            }),
+        );
+    });
+
+    it("should remove a CHOICE_SET_MULTIPLE field via removeFields with --confirm and --reason", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{ fieldName: "multiOpType" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"multiOpType"}]}',
+            "--confirm",
+            "--reason",
+            "dropping multi-select choice-set field",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                removeFields: [{ fieldName: "multiOpType" }],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.objectContaining({
+                    RemovedFields: ["multiOpType"],
+                    Reason: "dropping multi-select choice-set field",
+                }),
+            }),
+        );
+    });
+
+    it("should remove both choice-set fields in a single removeFields call", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [
+                { fieldName: "opType" },
+                { fieldName: "multiOpType" },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"opType"},{"fieldName":"multiOpType"}]}',
+            "--confirm",
+            "--reason",
+            "dropping all choice-set fields",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                removeFields: [
+                    { fieldName: "opType" },
+                    { fieldName: "multiOpType" },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Data: expect.objectContaining({
+                    RemovedFields: ["opType", "multiOpType"],
+                }),
+            }),
+        );
+    });
+
     it("should update entity metadata only (displayName and description)", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
@@ -1390,13 +1676,12 @@ describe("entities update", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails on update", async () => {
+    it("should bail when SDK connection fails on update", async () => {
+        const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
             displayName: "New Name",
         });
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1409,13 +1694,8 @@ describe("entities update", () => {
             '{"displayName":"New Name"}',
         ]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when updateById API fails", async () => {
@@ -1556,10 +1836,9 @@ describe("entities delete", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when SDK connection fails", async () => {
-        vi.mocked(createDataFabricClient).mockRejectedValue(
-            new Error("Not logged in"),
-        );
+    it("should bail when SDK connection fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         const program = buildProgram();
         await program.parseAsync([
@@ -1573,13 +1852,8 @@ describe("entities delete", () => {
             "cleanup",
         ]);
 
-        expect(OutputFormatter.error).toHaveBeenCalledWith(
-            expect.objectContaining({
-                Result: "Failure",
-                Message: "Error connecting to Data Fabric",
-            }),
-        );
-        expect(process.exitCode).toBe(1);
+        expect(sdk.entities.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.success).not.toHaveBeenCalled();
     });
 
     it("should error when delete API fails", async () => {