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

package/src/commands/roles.ts

@@ -7,6 +7,7 @@ import {
     processContext,
     RESULTS,
 } from "@uipath/common";
+import type { DataFabricRoleGetAllOptions } from "@uipath/uipath-typescript";
 import type { Command } from "commander";
 import { fail } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
@@ -63,13 +64,14 @@ export const registerRolesCommand = (program: Command) => {
             const sdk = await connectOrFail(options.tenant);
             if (!sdk) return;
 
-            const [listError, result] = await catchError(
-                sdk.entities.roles.getAll({
-                    stats: options.stats,
-                    ...(options.folderKey !== undefined && {
-                        folderKey: options.folderKey,
-                    }),
+            const getAllOptions: DataFabricRoleGetAllOptions = {
+                stats: options.stats,
+                ...(options.folderKey !== undefined && {
+                    folderKey: options.folderKey,
                 }),
+            };
+            const [listError, result] = await catchError(
+                sdk.entities.roles.getAll(getAllOptions),
             );
 
             if (listError) {

package/src/utils/output.spec.ts

@@ -9,7 +9,11 @@ vi.mock("@uipath/common", async (importOriginal) => {
 });
 
 import { OutputFormatter } from "@uipath/common";
-import { fail, requireDestructiveConfirmation } from "./output";
+import {
+    fail,
+    failInvalidArgument,
+    requireDestructiveConfirmation,
+} from "./output";
 
 describe("fail", () => {
     beforeEach(() => {
@@ -28,6 +32,20 @@ describe("fail", () => {
         );
         expect(process.exitCode).toBe(1);
     });
+
+    it("can mark client-side validation failures as invalid arguments", () => {
+        failInvalidArgument("Bad body", "Fix the JSON shape.");
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Bad body",
+                Instructions: "Fix the JSON shape.",
+                ErrorCode: "invalid_argument",
+                Retry: "RetryWillNotFix",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
 });
 
 describe("requireDestructiveConfirmation", () => {
@@ -84,6 +102,8 @@ describe("requireDestructiveConfirmation", () => {
             expect.objectContaining({
                 Message: "Reason required for destructive operation",
                 Instructions: reasonInstruction,
+                ErrorCode: "invalid_argument",
+                Retry: "RetryWillNotFix",
             }),
         );
         expect(process.exitCode).toBe(1);

package/src/utils/output.ts

@@ -22,6 +22,24 @@ export function fail(message: string, instructions: string): void {
     processContext.exit(1);
 }
 
+/**
+ * Keep Data Fabric's existing `Failure` + exit 1 envelope while setting the
+ * machine-readable validation classification explicitly.
+ */
+export function failInvalidArgument(
+    message: string,
+    instructions: string,
+): void {
+    OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: message,
+        Instructions: instructions,
+        ErrorCode: "invalid_argument",
+        Retry: "RetryWillNotFix",
+    });
+    processContext.exit(1);
+}
+
 export interface DestructiveOptions {
     yes?: boolean;
     // Legacy hidden alias for `yes`. The canonical flag is `--yes`; `--confirm`
@@ -61,7 +79,10 @@ export function requireDestructiveConfirmation(
 
     const reason = options.reason?.trim();
     if (reason === undefined || reason === "") {
-        fail("Reason required for destructive operation", reasonInstruction);
+        failInvalidArgument(
+            "Reason required for destructive operation",
+            reasonInstruction,
+        );
         return null;
     }
 

package/src/utils/validate.spec.ts

@@ -115,29 +115,29 @@ describe("validateName", () => {
 });
 
 describe("findInvalidFieldName", () => {
-    it("returns null when every fieldName is valid", () => {
+    it("returns null when every name is valid", () => {
         expect(
             findInvalidFieldName([
-                { fieldName: "title", type: "STRING" },
-                { fieldName: "amount", type: "DECIMAL" },
+                { name: "title", type: "STRING" },
+                { name: "amount", type: "DECIMAL" },
             ]),
         ).toBeNull();
     });
 
-    it("flags the first invalid fieldName", () => {
+    it("flags the first invalid name", () => {
         const err = findInvalidFieldName([
-            { fieldName: "title", type: "STRING" },
-            { fieldName: "Class", type: "STRING" },
-            { fieldName: "amount", type: "DECIMAL" },
+            { name: "title", type: "STRING" },
+            { name: "Class", type: "STRING" },
+            { name: "amount", type: "DECIMAL" },
         ]);
         expect(err?.message).toContain("'Class'");
     });
 
-    it("skips entries where fieldName is not a string", () => {
-        // A shape-level check catches non-string fieldName earlier in the
+    it("skips entries where name is not a string", () => {
+        // A shape-level check catches non-string name earlier in the
         // command handler. This helper simply ignores them.
         expect(
-            findInvalidFieldName([{ fieldName: 42 }, { fieldName: "good" }]),
+            findInvalidFieldName([{ name: 42 }, { name: "good" }]),
         ).toBeNull();
     });
 });
@@ -156,29 +156,26 @@ describe("schema metadata validation", () => {
 
     it("rejects case-insensitive field name and display-name collisions", () => {
         expect(
-            findInvalidFieldMetadata([
-                { fieldName: "Amount" },
-                { fieldName: "amount" },
-            ])?.message,
+            findInvalidFieldMetadata([{ name: "Amount" }, { name: "amount" }])
+                ?.message,
         ).toContain("Duplicate field name");
         expect(
             findInvalidFieldMetadata([
-                { fieldName: "Amount", displayName: "Total" },
-                { fieldName: "Price", displayName: "total" },
+                { name: "Amount", displayName: "Total" },
+                { name: "Price", displayName: "total" },
             ])?.message,
         ).toContain("Duplicate field display name");
     });
 
     it("rejects a field name matching its entity name", () => {
         expect(
-            findInvalidFieldMetadata([{ fieldName: "invoice" }], "Invoice")
-                ?.message,
+            findInvalidFieldMetadata([{ name: "invoice" }], "Invoice")?.message,
         ).toContain("cannot match entity name");
     });
 
     it("rejects more than ten MULTILINE_MAX fields", () => {
         const fields = Array.from({ length: 11 }, (_, i) => ({
-            fieldName: `Body${i}`,
+            name: `Body${i}`,
             type: "MULTILINE_MAX",
         }));
         expect(findTooManyMultilineMaxFields(fields)?.message).toContain(
@@ -191,17 +188,15 @@ describe("findUiBrokenFieldType", () => {
     it("returns null for UI-compatible types", () => {
         expect(
             findUiBrokenFieldType([
-                { fieldName: "title", type: "STRING" },
-                { fieldName: "amount", type: "DECIMAL" },
-                { fieldName: "receipt", type: "FILE" },
+                { name: "title", type: "STRING" },
+                { name: "amount", type: "DECIMAL" },
+                { name: "receipt", type: "FILE" },
             ]),
         ).toBeNull();
     });
 
     it("flags INTEGER with a DECIMAL substitution", () => {
-        const err = findUiBrokenFieldType([
-            { fieldName: "count", type: "INTEGER" },
-        ]);
+        const err = findUiBrokenFieldType([{ name: "count", type: "INTEGER" }]);
         expect(err?.message).toContain("'INTEGER'");
         expect(err?.instructions).toContain("DECIMAL");
     });
@@ -215,16 +210,16 @@ describe("findUiBrokenFieldType", () => {
             "UUID",
             "DATETIME",
         ]) {
-            const err = findUiBrokenFieldType([{ fieldName: "x", type }]);
+            const err = findUiBrokenFieldType([{ name: "x", type }]);
             expect(err, `${type} should be flagged`).not.toBeNull();
         }
     });
 
     it("flags the first offender when multiple are present", () => {
         const err = findUiBrokenFieldType([
-            { fieldName: "a", type: "STRING" },
-            { fieldName: "b", type: "FLOAT" },
-            { fieldName: "c", type: "DATETIME" },
+            { name: "a", type: "STRING" },
+            { name: "b", type: "FLOAT" },
+            { name: "c", type: "DATETIME" },
         ]);
         expect(err?.message).toContain("'b'");
     });
@@ -471,12 +466,12 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
         expect(
             findReferenceFolderKeyOnChoiceSet([
                 {
-                    fieldName: "status",
+                    name: "status",
                     type: "CHOICE_SET_SINGLE",
                     choiceSetId: "cs-1",
                 },
                 {
-                    fieldName: "tags",
+                    name: "tags",
                     type: "CHOICE_SET_MULTIPLE",
                     choiceSetId: "cs-2",
                 },
@@ -488,7 +483,7 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
         expect(
             findReferenceFolderKeyOnChoiceSet([
                 {
-                    fieldName: "customerId",
+                    name: "customerId",
                     type: "RELATIONSHIP",
                     referenceEntityId: "e-1",
                     referenceFieldId: "f-1",
@@ -501,7 +496,7 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
     it("flags referenceFolderKey on CHOICE_SET_SINGLE", () => {
         const err = findReferenceFolderKeyOnChoiceSet([
             {
-                fieldName: "status",
+                name: "status",
                 type: "CHOICE_SET_SINGLE",
                 choiceSetId: "cs-1",
                 referenceFolderKey: "folder-1",
@@ -514,7 +509,7 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
     it("flags referenceFolderKey on CHOICE_SET_MULTIPLE", () => {
         const err = findReferenceFolderKeyOnChoiceSet([
             {
-                fieldName: "tags",
+                name: "tags",
                 type: "CHOICE_SET_MULTIPLE",
                 choiceSetId: "cs-2",
                 referenceFolderKey: "folder-1",
@@ -527,7 +522,7 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
 describe("findReferenceFieldsOnFile", () => {
     it("accepts a FILE field without reference metadata", () => {
         expect(
-            findReferenceFieldsOnFile([{ fieldName: "receipt", type: "FILE" }]),
+            findReferenceFieldsOnFile([{ name: "receipt", type: "FILE" }]),
         ).toBeNull();
     });
 
@@ -540,7 +535,7 @@ describe("findReferenceFieldsOnFile", () => {
         ]) {
             const err = findReferenceFieldsOnFile([
                 {
-                    fieldName: "receipt",
+                    name: "receipt",
                     type: "FILE",
                     [key]: "value",
                 },
@@ -555,7 +550,7 @@ describe("findReferenceFieldsOnFile", () => {
         expect(
             findReferenceFieldsOnFile([
                 {
-                    fieldName: "customer",
+                    name: "customer",
                     type: "RELATIONSHIP",
                     referenceEntityId: "entity-id",
                     referenceFieldId: "field-id",
@@ -571,30 +566,30 @@ describe("findMissingComplexFieldExtras", () => {
         expect(
             findMissingComplexFieldExtras([
                 {
-                    fieldName: "status",
+                    name: "status",
                     type: "CHOICE_SET_SINGLE",
                     choiceSetId: "cs-1",
                 },
                 {
-                    fieldName: "tags",
+                    name: "tags",
                     type: "CHOICE_SET_MULTIPLE",
                     choiceSetId: "cs-2",
                 },
                 {
-                    fieldName: "customerId",
+                    name: "customerId",
                     type: "RELATIONSHIP",
                     referenceEntityId: "e-1",
                     referenceFieldId: "f-1",
                 },
-                { fieldName: "receipt", type: "FILE" },
-                { fieldName: "title", type: "STRING" },
+                { name: "receipt", type: "FILE" },
+                { name: "title", type: "STRING" },
             ]),
         ).toBeNull();
     });
 
     it("flags CHOICE_SET_SINGLE without choiceSetId", () => {
         const err = findMissingComplexFieldExtras([
-            { fieldName: "status", type: "CHOICE_SET_SINGLE" },
+            { name: "status", type: "CHOICE_SET_SINGLE" },
         ]);
         expect(err?.message).toContain("'status'");
         expect(err?.message).toContain("requires 'choiceSetId'");
@@ -602,7 +597,7 @@ describe("findMissingComplexFieldExtras", () => {
 
     it("flags CHOICE_SET_MULTIPLE with empty-string choiceSetId", () => {
         const err = findMissingComplexFieldExtras([
-            { fieldName: "tags", type: "CHOICE_SET_MULTIPLE", choiceSetId: "" },
+            { name: "tags", type: "CHOICE_SET_MULTIPLE", choiceSetId: "" },
         ]);
         expect(err).not.toBeNull();
     });
@@ -610,7 +605,7 @@ describe("findMissingComplexFieldExtras", () => {
     it("flags RELATIONSHIP without referenceEntityId", () => {
         const err = findMissingComplexFieldExtras([
             {
-                fieldName: "customerId",
+                name: "customerId",
                 type: "RELATIONSHIP",
                 referenceFieldId: "f-1",
             },
@@ -621,7 +616,7 @@ describe("findMissingComplexFieldExtras", () => {
     it("flags RELATIONSHIP without referenceFieldId", () => {
         const err = findMissingComplexFieldExtras([
             {
-                fieldName: "customerId",
+                name: "customerId",
                 type: "RELATIONSHIP",
                 referenceEntityId: "e-1",
             },
@@ -631,8 +626,8 @@ describe("findMissingComplexFieldExtras", () => {
 
     it("stops at the first offender", () => {
         const err = findMissingComplexFieldExtras([
-            { fieldName: "ok", type: "CHOICE_SET_SINGLE", choiceSetId: "cs-1" },
-            { fieldName: "bad", type: "RELATIONSHIP" },
+            { name: "ok", type: "CHOICE_SET_SINGLE", choiceSetId: "cs-1" },
+            { name: "bad", type: "RELATIONSHIP" },
         ]);
         expect(err?.message).toContain("'bad'");
     });
@@ -642,19 +637,19 @@ describe("findInvalidFieldConstraints", () => {
     it("returns null when constraints match their type + ranges", () => {
         expect(
             findInvalidFieldConstraints([
-                { fieldName: "title", type: "STRING", lengthLimit: 500 },
+                { name: "title", type: "STRING", lengthLimit: 500 },
                 {
-                    fieldName: "body",
+                    name: "body",
                     type: "MULTILINE_TEXT",
                     lengthLimit: 8000,
                 },
                 {
-                    fieldName: "note",
+                    name: "note",
                     type: "MULTILINE_MAX",
                     lengthLimit: 100000,
                 },
                 {
-                    fieldName: "price",
+                    name: "price",
                     type: "DECIMAL",
                     decimalPrecision: 2,
                     minValue: 0,
@@ -666,7 +661,7 @@ describe("findInvalidFieldConstraints", () => {
 
     it("rejects lengthLimit on a non-text type", () => {
         const err = findInvalidFieldConstraints([
-            { fieldName: "score", type: "DECIMAL", lengthLimit: 100 },
+            { name: "score", type: "DECIMAL", lengthLimit: 100 },
         ]);
         expect(err?.message).toContain(
             "'DECIMAL' does not accept 'lengthLimit'",
@@ -675,7 +670,7 @@ describe("findInvalidFieldConstraints", () => {
 
     it("rejects lengthLimit outside the STRING range", () => {
         const err = findInvalidFieldConstraints([
-            { fieldName: "title", type: "STRING", lengthLimit: 5000 },
+            { name: "title", type: "STRING", lengthLimit: 5000 },
         ]);
         expect(err?.message).toContain("outside the allowed range");
         expect(err?.instructions).toContain("1 and 4000");
@@ -683,7 +678,7 @@ describe("findInvalidFieldConstraints", () => {
 
     it("rejects lengthLimit outside the MULTILINE_MAX byte budget", () => {
         const err = findInvalidFieldConstraints([
-            { fieldName: "body", type: "MULTILINE_MAX", lengthLimit: 200000 },
+            { name: "body", type: "MULTILINE_MAX", lengthLimit: 200000 },
         ]);
         expect(err?.message).toContain("MULTILINE_MAX");
         expect(err?.instructions).toContain("131072");
@@ -691,7 +686,7 @@ describe("findInvalidFieldConstraints", () => {
 
     it("rejects maxValue on non-DECIMAL", () => {
         const err = findInvalidFieldConstraints([
-            { fieldName: "title", type: "STRING", maxValue: 100 },
+            { name: "title", type: "STRING", maxValue: 100 },
         ]);
         expect(err?.message).toContain("does not accept 'maxValue'");
     });
@@ -700,7 +695,7 @@ describe("findInvalidFieldConstraints", () => {
         expect(
             findInvalidFieldConstraints([
                 {
-                    fieldName: "fixed",
+                    name: "fixed",
                     type: "DECIMAL",
                     minValue: 100,
                     maxValue: 100,
@@ -709,7 +704,7 @@ describe("findInvalidFieldConstraints", () => {
         ).toBeNull();
         const err = findInvalidFieldConstraints([
             {
-                fieldName: "price",
+                name: "price",
                 type: "DECIMAL",
                 minValue: 101,
                 maxValue: 100,
@@ -721,13 +716,13 @@ describe("findInvalidFieldConstraints", () => {
     it("rejects fractional length limits and out-of-range numeric bounds", () => {
         expect(
             findInvalidFieldConstraints([
-                { fieldName: "title", type: "STRING", lengthLimit: 1.5 },
+                { name: "title", type: "STRING", lengthLimit: 1.5 },
             ])?.message,
         ).toContain("integer");
         expect(
             findInvalidFieldConstraints([
                 {
-                    fieldName: "amount",
+                    name: "amount",
                     type: "DECIMAL",
                     maxValue: 9_007_199_254_740_992,
                 },
@@ -737,7 +732,7 @@ describe("findInvalidFieldConstraints", () => {
 
     it("rejects decimalPrecision outside 0-10", () => {
         const err = findInvalidFieldConstraints([
-            { fieldName: "price", type: "DECIMAL", decimalPrecision: 15 },
+            { name: "price", type: "DECIMAL", decimalPrecision: 15 },
         ]);
         expect(err?.message).toContain("decimalPrecision");
         expect(err?.instructions).toContain("0 and 10");
@@ -746,7 +741,7 @@ describe("findInvalidFieldConstraints", () => {
     it("rejects decimalPrecision on non-DECIMAL", () => {
         const err = findInvalidFieldConstraints([
             {
-                fieldName: "title",
+                name: "title",
                 type: "STRING",
                 decimalPrecision: 2,
             },

package/src/utils/validate.ts

@@ -326,7 +326,7 @@ export function findInvalidFieldName(
 ): ValidationError | null {
     for (const f of fields) {
         if (typeof f !== "object" || f === null) continue;
-        const fieldName = (f as Record<string, unknown>).fieldName;
+        const fieldName = (f as Record<string, unknown>).name;
         if (typeof fieldName !== "string") continue;
         const err = validateName(fieldName, "field");
         if (err) return err;
@@ -390,19 +390,18 @@ export function findInvalidFieldMetadata(
     for (const f of fields) {
         if (typeof f !== "object" || f === null) continue;
         const rec = f as Record<string, unknown>;
-        const fieldName =
-            typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+        const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
         const metadataErr = validateMetadataLengths(
             rec,
             `Field '${fieldName}'`,
         );
         if (metadataErr) return metadataErr;
 
-        if (typeof rec.fieldName !== "string") continue;
-        const normalizedName = rec.fieldName.toLowerCase();
+        if (typeof rec.name !== "string") continue;
+        const normalizedName = rec.name.toLowerCase();
         if (names.has(normalizedName)) {
             return {
-                message: `Duplicate field name '${rec.fieldName}' (case-insensitive)`,
+                message: `Duplicate field name '${rec.name}' (case-insensitive)`,
                 instructions:
                     "Every field in one create/addFields batch must have a unique name, ignoring case.",
             };
@@ -414,7 +413,7 @@ export function findInvalidFieldMetadata(
             normalizedName === entityName.toLowerCase()
         ) {
             return {
-                message: `Field name '${rec.fieldName}' cannot match entity name '${entityName}'`,
+                message: `Field name '${rec.name}' cannot match entity name '${entityName}'`,
                 instructions:
                     "Entity and field names are compared case-insensitively. Pick a different field name.",
             };
@@ -423,7 +422,7 @@ export function findInvalidFieldMetadata(
         const effectiveDisplayName =
             typeof rec.displayName === "string" && rec.displayName.length > 0
                 ? rec.displayName
-                : rec.fieldName;
+                : rec.name;
         const normalizedDisplayName = effectiveDisplayName.toLowerCase();
         if (displayNames.has(normalizedDisplayName)) {
             return {
@@ -471,7 +470,7 @@ export function findUiBrokenFieldType(
         if (typeof type !== "string") continue;
         if (UI_BROKEN_FIELD_TYPES.has(type)) {
             const fieldName =
-                typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+                typeof rec.name === "string" ? rec.name : "<field>";
             const substitute = UI_BROKEN_SUBSTITUTIONS[type];
             return {
                 message: `Field '${fieldName}' uses type '${type}' which the Data Fabric UI cannot render`,
@@ -499,7 +498,7 @@ export function findReferenceFolderKeyOnChoiceSet(
             rec.referenceFolderKey !== undefined
         ) {
             const fieldName =
-                typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+                typeof rec.name === "string" ? rec.name : "<field>";
             return {
                 message: `CHOICE_SET_* field '${fieldName}' must not pass 'referenceFolderKey'`,
                 instructions:
@@ -534,8 +533,7 @@ export function findReferenceFieldsOnFile(
         );
         if (invalidKeys.length === 0) continue;
 
-        const fieldName =
-            typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+        const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
         return {
             message: `FILE field '${fieldName}' must not pass reference fields`,
             instructions: `FILE fields are auto-wired by the platform. Drop ${invalidKeys.map((key) => `'${key}'`).join(", ")} from the field definition.`,
@@ -556,8 +554,7 @@ export function findMissingComplexFieldExtras(
         const rec = f as Record<string, unknown>;
         const type = rec.type;
         if (typeof type !== "string") continue;
-        const fieldName =
-            typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+        const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
 
         if (type === "CHOICE_SET_SINGLE" || type === "CHOICE_SET_MULTIPLE") {
             if (
@@ -618,8 +615,7 @@ export function findInvalidFieldConstraints(
         const rec = f as Record<string, unknown>;
         const type = rec.type;
         if (typeof type !== "string") continue;
-        const fieldName =
-            typeof rec.fieldName === "string" ? rec.fieldName : "<field>";
+        const fieldName = typeof rec.name === "string" ? rec.name : "<field>";
 
         if (rec.lengthLimit !== undefined) {
             if (