@uipath/data-fabric-tool 1.1.0 → 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",
-                    }),
-                ]),
-            }),
-        );
-    });
-
-    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)",
-                    }),
-                ]),
+                Data: rawEntities,
             }),
         );
     });
 
-    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: [],
-        });
+        vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
         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"),
-        );
-
-        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 () => {
@@ -546,15 +477,15 @@ describe("entities create", () => {
         );
     });
 
-    it("should create entity with a RELATIONSHIP field carrying referenceEntityName and referenceFieldName", async () => {
+    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",
-                referenceEntityName: "CodeEvalTestEntity",
-                referenceFieldName: "Email",
+                referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                referenceFieldId: "f1000000-0000-0000-0000-000000000100",
             },
         ];
         vi.mocked(readJsonInput).mockResolvedValue({ fields });
@@ -576,8 +507,8 @@ describe("entities create", () => {
                 expect.objectContaining({
                     fieldName: "rel1",
                     type: "RELATIONSHIP",
-                    referenceEntityName: "CodeEvalTestEntity",
-                    referenceFieldName: "Email",
+                    referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                    referenceFieldId: "f1000000-0000-0000-0000-000000000100",
                 }),
             ]),
             undefined,
@@ -710,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([
@@ -729,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 () => {
@@ -806,14 +731,14 @@ describe("entities update", () => {
         );
     });
 
-    it("should update entity by adding a RELATIONSHIP field with referenceFieldName=Email", async () => {
+    it("should update entity by adding a RELATIONSHIP field with referenceEntityId and referenceFieldId", async () => {
         const sdk = mockSdk();
         const addFields = [
             {
                 fieldName: "rel1",
                 type: "RELATIONSHIP",
-                referenceEntityName: "CodeEvalTestEntity",
-                referenceFieldName: "Email",
+                referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
+                referenceFieldId: "f1000000-0000-0000-0000-000000000100",
             },
         ];
         vi.mocked(readJsonInput).mockResolvedValue({ addFields });
@@ -1751,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([
@@ -1770,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 () => {
@@ -1917,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([
@@ -1934,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 () => {