@uipath/data-fabric-tool 1.201.0-preview.115 → 1.201.0-preview.121

package/src/commands/entities.spec.ts

@@ -301,7 +301,7 @@ describe("entities create", () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.create).mockResolvedValue("new-entity-id");
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -312,12 +312,12 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).toHaveBeenCalledWith(
             "MyEntity",
-            [{ fieldName: "title", type: "STRING" }],
+            [{ name: "title", type: "STRING" }],
             undefined,
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -329,13 +329,58 @@ describe("entities create", () => {
         );
     });
 
+    it("should normalize fields copied from entities get read shape on create", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("roundtrip-id");
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [
+                {
+                    ID: "f1000000-0000-0000-0000-000000000001",
+                    Name: "note",
+                    DisplayName: "Note",
+                    FieldDataType: { Name: "STRING", LengthLimit: 200 },
+                    IsRequired: true,
+                    System: false,
+                },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"ID":"f1000000-0000-0000-0000-000000000001","Name":"note","DisplayName":"Note","FieldDataType":{"Name":"STRING","LengthLimit":200},"IsRequired":true,"System":false}]}',
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "MyEntity",
+            [
+                {
+                    name: "note",
+                    displayName: "Note",
+                    type: "STRING",
+                    lengthLimit: 200,
+                    isRequired: true,
+                },
+            ],
+            undefined,
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
     it("should accept MULTILINE_MAX as a field type on create", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.create).mockResolvedValue("doc-entity-id");
         vi.mocked(readJsonInput).mockResolvedValue({
             fields: [
-                { fieldName: "title", type: "STRING" },
-                { fieldName: "body", type: "MULTILINE_MAX" },
+                { name: "title", type: "STRING" },
+                { name: "body", type: "MULTILINE_MAX" },
             ],
         });
 
@@ -347,14 +392,14 @@ describe("entities create", () => {
             "create",
             "Document",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"},{"fieldName":"body","type":"MULTILINE_MAX"}]}',
+            '{"fields":[{"name":"title","type":"STRING"},{"name":"body","type":"MULTILINE_MAX"}]}',
         ]);
 
         expect(sdk.entities.create).toHaveBeenCalledWith(
             "Document",
             [
-                { fieldName: "title", type: "STRING" },
-                { fieldName: "body", type: "MULTILINE_MAX" },
+                { name: "title", type: "STRING" },
+                { name: "body", type: "MULTILINE_MAX" },
             ],
             undefined,
         );
@@ -371,7 +416,7 @@ describe("entities create", () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-with-opts");
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "amount", type: "DECIMAL" }],
+            fields: [{ name: "amount", type: "DECIMAL" }],
             displayName: "My Entity",
             description: "A test entity",
             isRbacEnabled: true,
@@ -385,12 +430,12 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"amount","type":"DECIMAL"}],"displayName":"My Entity","description":"A test entity","isRbacEnabled":true}',
+            '{"fields":[{"name":"amount","type":"DECIMAL"}],"displayName":"My Entity","description":"A test entity","isRbacEnabled":true}',
         ]);
 
         expect(sdk.entities.create).toHaveBeenCalledWith(
             "MyEntity",
-            [{ fieldName: "amount", type: "DECIMAL" }],
+            [{ name: "amount", type: "DECIMAL" }],
             expect.objectContaining({
                 displayName: "My Entity",
                 description: "A test entity",
@@ -405,11 +450,40 @@ describe("entities create", () => {
         );
     });
 
+    it("should forward isAnalyticsEnabled to create", async () => {
+        const sdk = mockSdk();
+        vi.mocked(sdk.entities.create).mockResolvedValue("analytics-entity");
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [{ name: "amount", type: "DECIMAL" }],
+            isAnalyticsEnabled: true,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"name":"amount","type":"DECIMAL"}],"isAnalyticsEnabled":true}',
+        ]);
+
+        expect(sdk.entities.create).toHaveBeenCalledWith(
+            "MyEntity",
+            [{ name: "amount", type: "DECIMAL" }],
+            expect.objectContaining({ isAnalyticsEnabled: true }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityCreated" }),
+        );
+    });
+
     it("should create entity with only displayName (partial options)", async () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-partial");
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "name", type: "STRING" }],
+            fields: [{ name: "name", type: "STRING" }],
             displayName: "Partial Entity",
         });
 
@@ -421,7 +495,7 @@ describe("entities create", () => {
             "create",
             "PartialEntity",
             "--body",
-            '{"fields":[{"fieldName":"name","type":"STRING"}],"displayName":"Partial Entity"}',
+            '{"fields":[{"name":"name","type":"STRING"}],"displayName":"Partial Entity"}',
         ]);
 
         expect(sdk.entities.create).toHaveBeenCalledWith(
@@ -441,7 +515,7 @@ describe("entities create", () => {
         );
         const fields = [
             {
-                fieldName: "opType",
+                name: "opType",
                 type: "CHOICE_SET_SINGLE",
                 choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
                 isRequired: true,
@@ -464,7 +538,7 @@ describe("entities create", () => {
             "CliTestExpense",
             expect.arrayContaining([
                 expect.objectContaining({
-                    fieldName: "opType",
+                    name: "opType",
                     type: "CHOICE_SET_SINGLE",
                     choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
                 }),
@@ -481,7 +555,7 @@ describe("entities create", () => {
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-choice-multi");
         const fields = [
             {
-                fieldName: "multiOpType",
+                name: "multiOpType",
                 type: "CHOICE_SET_MULTIPLE",
                 choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
             },
@@ -503,7 +577,7 @@ describe("entities create", () => {
             "CliTestExpense",
             expect.arrayContaining([
                 expect.objectContaining({
-                    fieldName: "multiOpType",
+                    name: "multiOpType",
                     type: "CHOICE_SET_MULTIPLE",
                     choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
                 }),
@@ -520,7 +594,7 @@ describe("entities create", () => {
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-rel");
         const fields = [
             {
-                fieldName: "rel1",
+                name: "rel1",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -543,7 +617,7 @@ describe("entities create", () => {
             "CliTestExpense",
             expect.arrayContaining([
                 expect.objectContaining({
-                    fieldName: "rel1",
+                    name: "rel1",
                     type: "RELATIONSHIP",
                     referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                     referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -561,7 +635,7 @@ describe("entities create", () => {
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-xfolder-rel");
         const fields = [
             {
-                fieldName: "purchaseOrder",
+                name: "purchaseOrder",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -587,7 +661,7 @@ describe("entities create", () => {
             "OrderLine",
             expect.arrayContaining([
                 expect.objectContaining({
-                    fieldName: "purchaseOrder",
+                    name: "purchaseOrder",
                     type: "RELATIONSHIP",
                     referenceFolderKey: "f1000000-0000-0000-0000-000000000060",
                 }),
@@ -671,7 +745,7 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should error when a field is missing fieldName", async () => {
+    it("should error when a field is missing name", async () => {
         vi.mocked(readJsonInput).mockResolvedValue({
             fields: [{ type: "STRING" }],
         });
@@ -690,7 +764,7 @@ describe("entities create", () => {
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "Each field must include a 'fieldName' string",
+                Message: "Each field must include a 'name' string",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -698,7 +772,7 @@ describe("entities create", () => {
 
     it("should error when a field has an invalid type", async () => {
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "text" }],
+            fields: [{ name: "title", type: "text" }],
         });
 
         const program = buildProgram();
@@ -709,7 +783,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"text"}]}',
+            '{"fields":[{"name":"title","type":"text"}]}',
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -724,7 +798,7 @@ describe("entities create", () => {
     it("should bail when SDK connection fails on create", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
         vi.mocked(connectOrFail).mockResolvedValue(undefined);
 
@@ -736,7 +810,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -749,7 +823,7 @@ describe("entities create", () => {
             new Error("Entity already exists"),
         );
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -760,7 +834,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -775,7 +849,7 @@ describe("entities create", () => {
     it("should reject an entity name that starts with a digit", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -786,7 +860,7 @@ describe("entities create", () => {
             "create",
             "1Bad",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -802,7 +876,7 @@ describe("entities create", () => {
     it("should reject an entity name that is a reserved keyword", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -813,7 +887,7 @@ describe("entities create", () => {
             "create",
             "Class",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -829,7 +903,7 @@ describe("entities create", () => {
     it("should reject an entity name that is a confirmed SQL keyword", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -840,7 +914,7 @@ describe("entities create", () => {
             "create",
             "Order",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -853,10 +927,10 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should reject a fieldName that is a reserved system field", async () => {
+    it("should reject a name that is a reserved system field", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "Id", type: "STRING" }],
+            fields: [{ name: "Id", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -867,7 +941,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"Id","type":"STRING"}]}',
+            '{"fields":[{"name":"Id","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -885,7 +959,7 @@ describe("entities create", () => {
         vi.mocked(readJsonInput).mockResolvedValue({
             fields: [
                 {
-                    fieldName: "receipt",
+                    name: "receipt",
                     type: "FILE",
                     referenceFolderKey: "folder-id",
                 },
@@ -900,7 +974,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"receipt","type":"FILE","referenceFolderKey":"folder-id"}]}',
+            '{"fields":[{"name":"receipt","type":"FILE","referenceFolderKey":"folder-id"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -918,7 +992,7 @@ describe("entities create", () => {
     it("should reject a UI-broken field type", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "count", type: "INTEGER" }],
+            fields: [{ name: "count", type: "INTEGER" }],
         });
 
         const program = buildProgram();
@@ -929,7 +1003,7 @@ describe("entities create", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"count","type":"INTEGER"}]}',
+            '{"fields":[{"name":"count","type":"INTEGER"}]}',
         ]);
 
         expect(sdk.entities.create).not.toHaveBeenCalled();
@@ -952,10 +1026,25 @@ describe("entities update", () => {
         process.exitCode = undefined;
     });
 
+    it("should document update field shapes in --help", () => {
+        const program = buildProgram();
+        const cmd = program.commands.find((c) => c.name() === "entities");
+        const updateCmd = cmd?.commands.find((c) => c.name() === "update");
+        expect(updateCmd).toBeDefined();
+
+        const help = updateCmd?.helpInformation() ?? "";
+        expect(help).toContain("addFields [{name,type,...}]");
+        expect(help).toContain("updateFields [{id,...}]");
+        expect(help).toContain("removeFields [{name}]");
+        expect(help.replace(/\s+/g, " ")).toContain(
+            "Do not paste a full copied field object into updateFields",
+        );
+    });
+
     it("should update entity by adding new fields (addFields)", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "newField", type: "STRING" }],
+            addFields: [{ name: "newField", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -966,13 +1055,13 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"newField","type":"STRING"}]}',
+            '{"addFields":[{"name":"newField","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                addFields: [{ fieldName: "newField", type: "STRING" }],
+                addFields: [{ name: "newField", type: "STRING" }],
             }),
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -984,11 +1073,167 @@ describe("entities update", () => {
         );
     });
 
+    it("should normalize addFields copied from entities get read shape", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [
+                {
+                    Name: "note",
+                    DisplayName: "Note",
+                    FieldDataType: {
+                        Name: "STRING",
+                        LengthLimit: 200,
+                    },
+                    IsRequired: true,
+                },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"Name":"note","DisplayName":"Note","FieldDataType":{"Name":"STRING","LengthLimit":200},"IsRequired":true}]}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: [
+                    {
+                        name: "note",
+                        displayName: "Note",
+                        type: "STRING",
+                        lengthLimit: 200,
+                        isRequired: true,
+                    },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should normalize a copied RELATIONSHIP field into referenceEntityId and referenceFieldId", async () => {
+        const sdk = mockSdk();
+        // Shape a user copies out of `df entities get`: the SDK returns
+        // referenceEntity/referenceField objects and the formatter PascalCases
+        // every key on the way out.
+        const copiedField = {
+            Id: "f1000000-0000-0000-0000-000000000200",
+            Name: "submitter",
+            DisplayName: "Submitter",
+            FieldDataType: { Name: "RELATIONSHIP" },
+            IsRequired: true,
+            ReferenceType: "ManyToOne",
+            ReferenceEntity: {
+                Id: "a1b2c3d4-0000-0000-0000-000000000010",
+                Name: "Person",
+                DisplayName: "Person",
+            },
+            ReferenceField: {
+                Id: "f1000000-0000-0000-0000-000000000100",
+                Definition: {
+                    Id: "f1000000-0000-0000-0000-000000000100",
+                    Name: "email",
+                },
+            },
+        };
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [copiedField],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ addFields: [copiedField] }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: [
+                    {
+                        name: "submitter",
+                        type: "RELATIONSHIP",
+                        displayName: "Submitter",
+                        isRequired: true,
+                        referenceEntityId:
+                            "a1b2c3d4-0000-0000-0000-000000000010",
+                        referenceFieldId:
+                            "f1000000-0000-0000-0000-000000000100",
+                    },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should normalize a copied CHOICE_SET_SINGLE field into choiceSetId", async () => {
+        const sdk = mockSdk();
+        const copiedField = {
+            Id: "f1000000-0000-0000-0000-000000000201",
+            Name: "category",
+            DisplayName: "Category",
+            FieldDataType: { Name: "CHOICE_SET_SINGLE" },
+            IsRequired: true,
+            ReferenceChoiceSet: {
+                Id: "c1d2e3f4-0000-0000-0000-000000000001",
+                Name: "ExpenseCategory",
+                DisplayName: "Expense Category",
+            },
+        };
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [copiedField],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            JSON.stringify({ addFields: [copiedField] }),
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                addFields: [
+                    {
+                        name: "category",
+                        type: "CHOICE_SET_SINGLE",
+                        displayName: "Category",
+                        isRequired: true,
+                        choiceSetId: "c1d2e3f4-0000-0000-0000-000000000001",
+                    },
+                ],
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
     it("should update entity by adding a RELATIONSHIP field with referenceEntityId and referenceFieldId", async () => {
         const sdk = mockSdk();
         const addFields = [
             {
-                fieldName: "rel1",
+                name: "rel1",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -1020,7 +1265,7 @@ describe("entities update", () => {
         const sdk = mockSdk();
         const addFields = [
             {
-                fieldName: "purchaseOrder",
+                name: "purchaseOrder",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -1057,7 +1302,7 @@ describe("entities update", () => {
         const sdk = mockSdk();
         const addFields = [
             {
-                fieldName: "multiOpType",
+                name: "multiOpType",
                 type: "CHOICE_SET_MULTIPLE",
                 choiceSetId: "9db00b66-9952-f111-8ef3-6045bd07956d",
             },
@@ -1191,7 +1436,7 @@ describe("entities update", () => {
     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" }],
+            removeFields: [{ name: "opType" }],
         });
 
         const program = buildProgram();
@@ -1202,7 +1447,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"opType"}]}',
+            '{"removeFields":[{"name":"opType"}]}',
             "--confirm",
             "--reason",
             "dropping single-select choice-set field",
@@ -1211,7 +1456,7 @@ describe("entities update", () => {
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                removeFields: [{ fieldName: "opType" }],
+                removeFields: [{ name: "opType" }],
             }),
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1229,7 +1474,7 @@ describe("entities update", () => {
     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" }],
+            removeFields: [{ name: "multiOpType" }],
         });
 
         const program = buildProgram();
@@ -1240,7 +1485,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"multiOpType"}]}',
+            '{"removeFields":[{"name":"multiOpType"}]}',
             "--confirm",
             "--reason",
             "dropping multi-select choice-set field",
@@ -1249,7 +1494,7 @@ describe("entities update", () => {
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                removeFields: [{ fieldName: "multiOpType" }],
+                removeFields: [{ name: "multiOpType" }],
             }),
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1265,10 +1510,7 @@ describe("entities update", () => {
     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" },
-            ],
+            removeFields: [{ name: "opType" }, { name: "multiOpType" }],
         });
 
         const program = buildProgram();
@@ -1279,7 +1521,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"opType"},{"fieldName":"multiOpType"}]}',
+            '{"removeFields":[{"name":"opType"},{"name":"multiOpType"}]}',
             "--confirm",
             "--reason",
             "dropping all choice-set fields",
@@ -1288,10 +1530,7 @@ describe("entities update", () => {
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                removeFields: [
-                    { fieldName: "opType" },
-                    { fieldName: "multiOpType" },
-                ],
+                removeFields: [{ name: "opType" }, { name: "multiOpType" }],
             }),
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1336,10 +1575,37 @@ describe("entities update", () => {
         );
     });
 
+    it("should forward isAnalyticsEnabled to updateById", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "My Entity",
+            isAnalyticsEnabled: true,
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"My Entity","isAnalyticsEnabled":true}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({ isAnalyticsEnabled: true }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
     it("should update entity with combined addFields, updateFields, and metadata", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "newField", type: "STRING" }],
+            addFields: [{ name: "newField", type: "STRING" }],
             updateFields: [{ id: "field-uuid-1", isRequired: false }],
             displayName: "Combined Update",
             isRbacEnabled: true,
@@ -1353,7 +1619,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"newField","type":"STRING"}],"updateFields":[{"id":"field-uuid-1","isRequired":false}],"displayName":"Combined Update","isRbacEnabled":true}',
+            '{"addFields":[{"name":"newField","type":"STRING"}],"updateFields":[{"id":"field-uuid-1","isRequired":false}],"displayName":"Combined Update","isRbacEnabled":true}',
         ]);
 
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
@@ -1373,7 +1639,8 @@ describe("entities update", () => {
         );
     });
 
-    it("should reject addFields items missing fieldName", async () => {
+    it("should reject addFields items missing name", async () => {
+        const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
             addFields: [{ type: "STRING" }],
         });
@@ -1393,15 +1660,152 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Each field in addFields must include a non-empty 'fieldName' string",
+                    "Each field in addFields must include a non-empty 'name' string",
+            }),
+        );
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject a name in the update body since the entity name is immutable", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            name: "RenamedEntity",
+            displayName: "Renamed Entity",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"name":"RenamedEntity","displayName":"Renamed Entity"}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining(
+                    "Entity name cannot be changed after creation",
+                ),
+                Instructions: expect.stringContaining(
+                    "Remove 'name' from the update body",
+                ),
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should require displayName when updating description without it", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            description: "New description",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"description":"New description"}',
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining(
+                    "'displayName' is required when updating entity metadata",
+                ),
             }),
         );
         expect(process.exitCode).toBe(1);
     });
 
+    it("should allow a metadata update that includes displayName", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            displayName: "Current Name",
+            description: "New description",
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"displayName":"Current Name","description":"New description"}',
+        ]);
+
+        expect(sdk.entities.updateById).toHaveBeenCalledWith(
+            "entity-id",
+            expect.objectContaining({
+                displayName: "Current Name",
+                description: "New description",
+            }),
+        );
+        expect(OutputFormatter.success).toHaveBeenCalledWith(
+            expect.objectContaining({ Code: "EntityUpdated" }),
+        );
+    });
+
+    it("should report malformed addFields and removeFields together", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            addFields: [{ type: "STRING" }],
+            removeFields: ["oldField"],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "update",
+            "entity-id",
+            "--body",
+            '{"addFields":[{"type":"STRING"}],"removeFields":["oldField"]}',
+            "--yes",
+            "--reason",
+            "temporary validation",
+        ]);
+
+        expect(sdk.entities.updateById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining(
+                    "Each field in addFields must include a non-empty 'name' string",
+                ),
+                Instructions: expect.stringContaining(
+                    'Example: {"removeFields":[{"name":"oldField"}]}',
+                ),
+                ErrorCode: "invalid_argument",
+                Retry: "RetryWillNotFix",
+            }),
+        );
+        const error = vi.mocked(OutputFormatter.error).mock.calls[0][0] as {
+            Message: string;
+        };
+        expect(error.Message).toContain(
+            "Each field in removeFields must include a non-empty 'name' string",
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should error when addFields has an invalid type", async () => {
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "price", type: "text" }],
+            addFields: [{ name: "price", type: "text" }],
         });
 
         const program = buildProgram();
@@ -1412,7 +1816,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"price","type":"text"}]}',
+            '{"addFields":[{"name":"price","type":"text"}]}',
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -1478,7 +1882,7 @@ describe("entities update", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should reject removeFields entries missing fieldName", async () => {
+    it("should reject removeFields entries missing name", async () => {
         vi.mocked(readJsonInput).mockResolvedValue({
             removeFields: [{}],
         });
@@ -1501,7 +1905,7 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Each field in removeFields must include a non-empty 'fieldName' string",
+                    "Each field in removeFields must include a non-empty 'name' string",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -1510,7 +1914,7 @@ describe("entities update", () => {
     it("should reject removeFields without confirmation: exit 1, SDK not called", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            removeFields: [{ fieldName: "oldField" }],
+            removeFields: [{ name: "oldField" }],
         });
 
         const program = buildProgram();
@@ -1521,7 +1925,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"oldField"}]}',
+            '{"removeFields":[{"name":"oldField"}]}',
             "--reason",
             "drop legacy",
         ]);
@@ -1534,7 +1938,7 @@ describe("entities update", () => {
     it("should accept removeFields with --yes (canonical flag)", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            removeFields: [{ fieldName: "oldField" }],
+            removeFields: [{ name: "oldField" }],
         });
 
         const program = buildProgram();
@@ -1545,7 +1949,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"oldField"}]}',
+            '{"removeFields":[{"name":"oldField"}]}',
             "--yes",
             "--reason",
             "drop legacy",
@@ -1560,7 +1964,7 @@ describe("entities update", () => {
     it("should reject removeFields without --reason", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            removeFields: [{ fieldName: "oldField" }],
+            removeFields: [{ name: "oldField" }],
         });
 
         const program = buildProgram();
@@ -1571,7 +1975,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"oldField"}]}',
+            '{"removeFields":[{"name":"oldField"}]}',
             "--confirm",
         ]);
 
@@ -1580,6 +1984,7 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message: "Reason required for destructive operation",
+                ErrorCode: "invalid_argument",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -1588,10 +1993,7 @@ describe("entities update", () => {
     it("should remove fields when --confirm and --reason are present", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            removeFields: [
-                { fieldName: "oldField" },
-                { fieldName: "anotherOld" },
-            ],
+            removeFields: [{ name: "oldField" }, { name: "anotherOld" }],
         });
 
         const program = buildProgram();
@@ -1602,7 +2004,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"removeFields":[{"fieldName":"oldField"},{"fieldName":"anotherOld"}]}',
+            '{"removeFields":[{"name":"oldField"},{"name":"anotherOld"}]}',
             "--confirm",
             "--reason",
             "drop legacy fields",
@@ -1611,10 +2013,7 @@ describe("entities update", () => {
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                removeFields: [
-                    { fieldName: "oldField" },
-                    { fieldName: "anotherOld" },
-                ],
+                removeFields: [{ name: "oldField" }, { name: "anotherOld" }],
             }),
         );
         expect(OutputFormatter.success).toHaveBeenCalledWith(
@@ -1656,8 +2055,8 @@ describe("entities update", () => {
     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" }],
+            addFields: [{ name: "newField", type: "STRING" }],
+            removeFields: [{ name: "oldField" }],
             updateFields: [
                 {
                     id: "field-uuid-1",
@@ -1678,7 +2077,7 @@ describe("entities update", () => {
             "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}',
+            '{"addFields":[{"name":"newField","type":"STRING"}],"removeFields":[{"name":"oldField"}],"updateFields":[{"id":"field-uuid-1","displayName":"Renamed","isRequired":true}],"displayName":"Combined","description":"all-in-one update","isRbacEnabled":true}',
             "--confirm",
             "--reason",
             "schema overhaul",
@@ -1687,8 +2086,8 @@ describe("entities update", () => {
         expect(sdk.entities.updateById).toHaveBeenCalledWith(
             "entity-id",
             expect.objectContaining({
-                addFields: [{ fieldName: "newField", type: "STRING" }],
-                removeFields: [{ fieldName: "oldField" }],
+                addFields: [{ name: "newField", type: "STRING" }],
+                removeFields: [{ name: "oldField" }],
                 updateFields: [
                     {
                         id: "field-uuid-1",
@@ -1714,11 +2113,11 @@ describe("entities update", () => {
         );
     });
 
-    it("should reject when same fieldName appears in addFields and removeFields", async () => {
+    it("should reject when same name appears in addFields and removeFields", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "overlap", type: "STRING" }],
-            removeFields: [{ fieldName: "overlap" }],
+            addFields: [{ name: "overlap", type: "STRING" }],
+            removeFields: [{ name: "overlap" }],
         });
 
         const program = buildProgram();
@@ -1729,7 +2128,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"overlap","type":"STRING"}],"removeFields":[{"fieldName":"overlap"}]}',
+            '{"addFields":[{"name":"overlap","type":"STRING"}],"removeFields":[{"name":"overlap"}]}',
             "--confirm",
             "--reason",
             "recreate",
@@ -1746,12 +2145,12 @@ describe("entities update", () => {
         expect(process.exitCode).toBe(1);
     });
 
-    it("should reject duplicate fieldNames within addFields", async () => {
+    it("should reject duplicate names within addFields", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
             addFields: [
-                { fieldName: "dup", type: "STRING" },
-                { fieldName: "dup", type: "DECIMAL" },
+                { name: "dup", type: "STRING" },
+                { name: "dup", type: "DECIMAL" },
             ],
         });
 
@@ -1763,7 +2162,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"dup","type":"STRING"},{"fieldName":"dup","type":"DECIMAL"}]}',
+            '{"addFields":[{"name":"dup","type":"STRING"},{"name":"dup","type":"DECIMAL"}]}',
         ]);
 
         expect(sdk.entities.updateById).not.toHaveBeenCalled();
@@ -1883,10 +2282,10 @@ describe("entities update", () => {
         expect(call.Data).toEqual({ ID: "entity-id" });
     });
 
-    it("should reject empty fieldName in addFields", async () => {
+    it("should reject empty name in addFields", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "   ", type: "STRING" }],
+            addFields: [{ name: "   ", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -1897,7 +2296,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"   ","type":"STRING"}]}',
+            '{"addFields":[{"name":"   ","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.updateById).not.toHaveBeenCalled();
@@ -1905,7 +2304,7 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Each field in addFields must include a non-empty 'fieldName' string",
+                    "Each field in addFields must include a non-empty 'name' string",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -2015,7 +2414,7 @@ describe("entities update", () => {
             new Error("Update failed"),
         );
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "newField", type: "STRING" }],
+            addFields: [{ name: "newField", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -2026,7 +2425,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"newField","type":"STRING"}]}',
+            '{"addFields":[{"name":"newField","type":"STRING"}]}',
         ]);
 
         expect(OutputFormatter.error).toHaveBeenCalledWith(
@@ -2041,7 +2440,7 @@ describe("entities update", () => {
     it("should reject a UI-broken type in addFields", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "count", type: "FLOAT" }],
+            addFields: [{ name: "count", type: "FLOAT" }],
         });
 
         const program = buildProgram();
@@ -2052,7 +2451,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"count","type":"FLOAT"}]}',
+            '{"addFields":[{"name":"count","type":"FLOAT"}]}',
         ]);
 
         expect(sdk.entities.updateById).not.toHaveBeenCalled();
@@ -2070,7 +2469,7 @@ describe("entities update", () => {
     it("should reject a reserved keyword in addFields", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
-            addFields: [{ fieldName: "New", type: "STRING" }],
+            addFields: [{ name: "New", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -2081,7 +2480,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"New","type":"STRING"}]}',
+            '{"addFields":[{"name":"New","type":"STRING"}]}',
         ]);
 
         expect(sdk.entities.updateById).not.toHaveBeenCalled();
@@ -2225,6 +2624,7 @@ describe("entities delete", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message: "Reason required for destructive operation",
+                ErrorCode: "invalid_argument",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -2250,6 +2650,7 @@ describe("entities delete", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message: "Reason required for destructive operation",
+                ErrorCode: "invalid_argument",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -2336,7 +2737,7 @@ describe("entities --folder-key forwarding", () => {
         const sdk = mockSdk();
         vi.mocked(sdk.entities.create).mockResolvedValue("new-entity-id");
         vi.mocked(readJsonInput).mockResolvedValue({
-            fields: [{ fieldName: "title", type: "STRING" }],
+            fields: [{ name: "title", type: "STRING" }],
         });
 
         const program = buildProgram();
@@ -2347,14 +2748,14 @@ describe("entities --folder-key forwarding", () => {
             "create",
             "MyEntity",
             "--body",
-            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+            '{"fields":[{"name":"title","type":"STRING"}]}',
             "--folder-key",
             "folder-guid-2",
         ]);
 
         expect(sdk.entities.create).toHaveBeenCalledWith(
             "MyEntity",
-            [{ fieldName: "title", type: "STRING" }],
+            [{ name: "title", type: "STRING" }],
             expect.objectContaining({ folderKey: "folder-guid-2" }),
         );
     });