@uipath/data-fabric-tool 0.9.1 → 1.0.1

package/src/commands/entities.spec.ts

@@ -39,6 +39,7 @@ function mockSdk(overrides: Record<string, unknown> = {}) {
             getById: vi.fn().mockResolvedValue({}),
             create: vi.fn().mockResolvedValue("new-entity-id"),
             updateById: vi.fn().mockResolvedValue(undefined),
+            deleteById: vi.fn().mockResolvedValue(undefined),
             ...overrides,
         },
     };
@@ -52,7 +53,7 @@ describe("entities list", () => {
         process.exitCode = undefined;
     });
 
-    it("should register the entities command with list, get, create, and update subcommands", () => {
+    it("should register the entities command with list, get, create, update, and delete subcommands", () => {
         const program = buildProgram();
         const cmd = program.commands.find((c) => c.name() === "entities");
         expect(cmd).toBeDefined();
@@ -60,7 +61,17 @@ describe("entities list", () => {
         expect(cmd?.commands.map((c) => c.name())).toContain("get");
         expect(cmd?.commands.map((c) => c.name())).toContain("create");
         expect(cmd?.commands.map((c) => c.name())).toContain("update");
-        expect(cmd?.commands.map((c) => c.name())).not.toContain("delete");
+        expect(cmd?.commands.map((c) => c.name())).toContain("delete");
+    });
+
+    it("should expose the delete subcommand in --help (not hidden)", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "entities");
+        const deleteCmd = cmd?.commands.find((c) => c.name() === "delete");
+        expect(deleteCmd).toBeDefined();
+        expect(
+            (deleteCmd as unknown as { _hidden?: boolean })._hidden,
+        ).toBeFalsy();
     });
 
     it("should list entities successfully", async () => {
@@ -527,6 +538,31 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
+    it("should error when a field is missing fieldName", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"type":"STRING"}]}',
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Each field must include a 'fieldName' string",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should error when a field has an invalid type", async () => {
         vi.mocked(readJsonInput).mockResolvedValue({
             fields: [{ fieldName: "title", type: "text" }],
@@ -781,7 +817,7 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Each field in addFields must include a 'fieldName' string",
+                    "Each field in addFields must include a non-empty 'fieldName' string",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -832,15 +868,456 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Each field in updateFields must include an 'id' string",
+                    "Each field in updateFields must include a non-empty 'id' string",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject removeFields when not an array", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: "oldField",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":"oldField"}',
+            "--confirm",
+            "--reason",
+            "drop legacy",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "'removeFields' must be an array",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject removeFields entries missing fieldName", async () => {
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{}],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{}]}',
+            "--confirm",
+            "--reason",
+            "drop legacy",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message:
+                    "Each field in removeFields must include a non-empty 'fieldName' string",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject removeFields without --confirm", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{ fieldName: "oldField" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"oldField"}]}',
+            "--reason",
+            "drop legacy",
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Confirmation required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject removeFields without --reason", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [{ fieldName: "oldField" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"oldField"}]}',
+            "--confirm",
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should remove fields when --confirm and --reason are present", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [
+                { fieldName: "oldField" },
+                { fieldName: "anotherOld" },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[{"fieldName":"oldField"},{"fieldName":"anotherOld"}]}',
+            "--confirm",
+            "--reason",
+            "drop legacy fields",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                removeFields: [
+                    { fieldName: "oldField" },
+                    { fieldName: "anotherOld" },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+                Data: expect.objectContaining({
+                    ID: "entity-id",
+                    RemovedFields: ["oldField", "anotherOld"],
+                    Reason: "drop legacy fields",
+                }),
+            }),
+        );
+    });
+
+    it("should not include RemovedFields/Reason in payload when no removeFields", async () => {
+        mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "Just a Rename",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"Just a Rename"}',
+        ]);
+
+        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
+            Data: Record<string, unknown>;
+        };
+        expect(call.Data).toEqual({ ID: "entity-id" });
+    });
+
+    it("should accept addFields + removeFields + updateFields + metadata in one call", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "newField", type: "STRING" }],
+            removeFields: [{ fieldName: "oldField" }],
+            updateFields: [
+                {
+                    id: "field-uuid-1",
+                    displayName: "Renamed",
+                    isRequired: true,
+                },
+            ],
+            displayName: "Combined",
+            description: "all-in-one update",
+            isRbacEnabled: true,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"newField","type":"STRING"}],"removeFields":[{"fieldName":"oldField"}],"updateFields":[{"id":"field-uuid-1","displayName":"Renamed","isRequired":true}],"displayName":"Combined","description":"all-in-one update","isRbacEnabled":true}',
+            "--confirm",
+            "--reason",
+            "schema overhaul",
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: [{ fieldName: "newField", type: "STRING" }],
+                removeFields: [{ fieldName: "oldField" }],
+                updateFields: [
+                    {
+                        id: "field-uuid-1",
+                        displayName: "Renamed",
+                        isRequired: true,
+                    },
+                ],
+                displayName: "Combined",
+                description: "all-in-one update",
+                isRbacEnabled: true,
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityUpdated",
+                Data: expect.objectContaining({
+                    ID: "entity-id",
+                    RemovedFields: ["oldField"],
+                    Reason: "schema overhaul",
+                }),
+            }),
+        );
+    });
+
+    it("should reject when same fieldName appears in addFields and removeFields", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "shared", type: "STRING" }],
+            removeFields: [{ fieldName: "shared" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"shared","type":"STRING"}],"removeFields":[{"fieldName":"shared"}]}',
+            "--confirm",
+            "--reason",
+            "recreate",
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message:
+                    "Field 'shared' appears in both addFields and removeFields",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject duplicate fieldNames within addFields", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [
+                { fieldName: "dup", type: "STRING" },
+                { fieldName: "dup", type: "INTEGER" },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"dup","type":"STRING"},{"fieldName":"dup","type":"INTEGER"}]}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Duplicate fieldName 'dup' in addFields",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject addFields when not an array", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: "newField",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":"newField"}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "'addFields' must be an array",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject updateFields when not an array", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            updateFields: { id: "x", displayName: "y" },
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"updateFields":{"id":"x","displayName":"y"}}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "'updateFields' must be an array",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should drop unknown keys before forwarding to the SDK", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "Renamed",
+            unknownGarbage: "should be dropped",
+            displayname: "typo, lowercase d",
+            __proto__: { malicious: true },
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"Renamed","unknownGarbage":"x","displayname":"y"}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledTimes(1);
+        const [, payload] = vi.mocked(sdk.entities.updateById).mock
+            .calls[0] as [string, Record<string, unknown>];
+        expect(payload).toEqual({ displayName: "Renamed" });
+        expect(payload).not.toHaveProperty("unknownGarbage");
+        expect(payload).not.toHaveProperty("displayname");
+    });
+
+    it("should treat empty removeFields as no-op (no --confirm/--reason needed)", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            removeFields: [],
+            displayName: "Just rename",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"removeFields":[],"displayName":"Just rename"}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalled();
+        const call = vi.mocked(OutputFormatter.success).mock.calls[0][0] as {
+            Data: Record<string, unknown>;
+        };
+        expect(call.Data).toEqual({ ID: "entity-id" });
+    });
+
+    it("should reject empty fieldName in addFields", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ fieldName: "   ", type: "STRING" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"fieldName":"   ","type":"STRING"}]}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message:
+                    "Each field in addFields must include a non-empty 'fieldName' string",
             }),
         );
         expect(process.exitCode).toBe(1);
     });
 
-    it("should reject removeFields with explicit error", async () => {
+    it("should reject empty id in updateFields", async () => {
+        const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            removeFields: ["oldField"],
+            updateFields: [{ id: "", displayName: "x" }],
         });
 
         const program = buildProgram();
@@ -851,13 +1328,15 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":["oldField"]}',
+            '{"updateFields":[{"id":"","displayName":"x"}]}',
         ]);
 
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "removeFields is not supported",
+                Message:
+                    "Each field in updateFields must include a non-empty 'id' string",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -968,3 +1447,165 @@ describe("entities update", () => {
         expect(process.exitCode).toBe(1);
     });
 });
+
+describe("entities delete", () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+        process.exitCode = undefined;
+    });
+
+    it("should delete an entity successfully with --confirm and --reason", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "entity-to-delete",
+            "--confirm",
+            "--reason",
+            "cleanup after eval",
+        ]);
+
+        expect(sdk.entities.deleteById).toHaveBeenCalledWith(
+            "entity-to-delete",
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Success",
+                Code: "EntityDeleted",
+                Data: expect.objectContaining({
+                    ID: "entity-to-delete",
+                    Reason: "cleanup after eval",
+                }),
+            }),
+        );
+    });
+
+    it("should error when --confirm is missing", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "entity-id",
+            "--reason",
+            "cleanup",
+        ]);
+
+        expect(sdk.entities.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Confirmation required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --reason is missing", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "entity-id",
+            "--confirm",
+        ]);
+
+        expect(sdk.entities.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when --reason is empty/whitespace", async () => {
+        const sdk = mockSdk();
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "entity-id",
+            "--confirm",
+            "--reason",
+            "   ",
+        ]);
+
+        expect(sdk.entities.deleteById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Reason required for destructive operation",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    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",
+            "delete",
+            "entity-id",
+            "--confirm",
+            "--reason",
+            "cleanup",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error connecting to Data Fabric",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should error when delete API fails", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.deleteById).mockRejectedValue(
+            new Error("Entity not found"),
+        );
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "delete",
+            "bad-entity-id",
+            "--confirm",
+            "--reason",
+            "cleanup",
+        ]);
+
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Error deleting entity 'bad-entity-id'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+});