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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/data-fabric-tool",
   "license": "MIT",
-  "version": "1.199.0",
+  "version": "1.201.0-preview.115",
   "description": "Manage Data Fabric entities and records.",
   "type": "module",
   "main": "./dist/tool.js",
@@ -14,5 +14,5 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
   },
-  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
+  "gitHead": "f1086b73654d7728cb71f280588b3e0c77d535fc"
 }

package/src/commands/choice-sets.spec.ts

@@ -815,6 +815,50 @@ describe("choice-set-values", () => {
         expect(process.exitCode).toBe(1);
     });
 
+    it("should reject underscores in a choice-set value name", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "business_travel",
+        ]);
+        expect(sdk.entities.choicesets.insertValueById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Invalid choice-set value name 'business_travel'",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
+    it("should reject an overlong choice-set value display name", async () => {
+        const sdk = mockSdk();
+        const program = buildValuesProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "choice-set-values",
+            "create",
+            "cs-1",
+            "travel",
+            "--display-name",
+            "x".repeat(501),
+        ]);
+        expect(sdk.entities.choicesets.insertValueById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "Choice-set value display name exceeds 500 characters",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should update a value's display name", async () => {
         const sdk = mockSdk();
         const program = buildValuesProgram();

package/src/commands/choice-sets.ts

@@ -21,7 +21,12 @@ import type {
 import { type Command, Option } from "commander";
 import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
-import { validateChoiceValueName, validateName } from "../utils/validate";
+import {
+    validateChoiceValueDisplayName,
+    validateChoiceValueName,
+    validateName,
+    validateSchemaMetadata,
+} from "../utils/validate";
 
 const OUTPUT_CODES = {
     ChoiceSetList: "ChoiceSetList",
@@ -368,6 +373,15 @@ export const registerChoiceSetsCommand = (program: Command) => {
             async (name: string, options: CreateOptions) => {
                 const nameErr = validateName(name, "choice set");
                 if (nameErr) return fail(nameErr.message, nameErr.instructions);
+                const metadataErr = validateSchemaMetadata(
+                    {
+                        displayName: options.displayName,
+                        description: options.description,
+                    },
+                    "Choice set",
+                );
+                if (metadataErr)
+                    return fail(metadataErr.message, metadataErr.instructions);
 
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
@@ -441,6 +455,15 @@ export const registerChoiceSetsCommand = (program: Command) => {
                         "The server rejects a partial update with 'DisplayName is required.' or Internal Server Error. To change one field, run 'uip df choice-sets list' first to read the current value of the other, then re-send both with --display-name and --description.",
                     );
                 }
+                const metadataErr = validateSchemaMetadata(
+                    {
+                        displayName: options.displayName,
+                        description: options.description,
+                    },
+                    "Choice set",
+                );
+                if (metadataErr)
+                    return fail(metadataErr.message, metadataErr.instructions);
 
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
@@ -614,7 +637,7 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
         .argument("<choice-set-id>", "Choice set ID")
         .argument(
             "<name>",
-            "Value name (must start with a letter; letters, numbers, and underscores only)",
+            "Value name (must start with a letter; letters and numbers only)",
         )
         .addOption(
             createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>"),
@@ -634,6 +657,16 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
             ) => {
                 const nameErr = validateChoiceValueName(name);
                 if (nameErr) return fail(nameErr.message, nameErr.instructions);
+                if (options.displayName !== undefined) {
+                    const displayErr = validateChoiceValueDisplayName(
+                        options.displayName,
+                    );
+                    if (displayErr)
+                        return fail(
+                            displayErr.message,
+                            displayErr.instructions,
+                        );
+                }
 
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
@@ -696,6 +729,10 @@ export const registerChoiceSetValuesCommand = (program: Command) => {
                 displayName: string,
                 options: ValueUpdateOptions,
             ) => {
+                const displayErr = validateChoiceValueDisplayName(displayName);
+                if (displayErr)
+                    return fail(displayErr.message, displayErr.instructions);
+
                 const sdk = await connectOrFail(options.tenant);
                 if (!sdk) return;
 

package/src/commands/entities.spec.ts

@@ -561,7 +561,7 @@ describe("entities create", () => {
         vi.mocked(sdk.entities.create).mockResolvedValue("entity-xfolder-rel");
         const fields = [
             {
-                fieldName: "order",
+                fieldName: "purchaseOrder",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -587,7 +587,7 @@ describe("entities create", () => {
             "OrderLine",
             expect.arrayContaining([
                 expect.objectContaining({
-                    fieldName: "order",
+                    fieldName: "purchaseOrder",
                     type: "RELATIONSHIP",
                     referenceFolderKey: "f1000000-0000-0000-0000-000000000060",
                 }),
@@ -826,6 +826,33 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
+    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" }],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "Order",
+            "--body",
+            '{"fields":[{"fieldName":"title","type":"STRING"}]}',
+        ]);
+
+        expect(sdk.entities.create).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining("reserved SQL keyword"),
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should reject a fieldName that is a reserved system field", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
@@ -853,6 +880,41 @@ describe("entities create", () => {
         expect(process.exitCode).toBe(1);
     });
 
+    it("should reject reference metadata on a FILE field", async () => {
+        const sdk = mockSdk();
+        vi.mocked(readJsonInput).mockResolvedValue({
+            fields: [
+                {
+                    fieldName: "receipt",
+                    type: "FILE",
+                    referenceFolderKey: "folder-id",
+                },
+            ],
+        });
+
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "entities",
+            "create",
+            "MyEntity",
+            "--body",
+            '{"fields":[{"fieldName":"receipt","type":"FILE","referenceFolderKey":"folder-id"}]}',
+        ]);
+
+        expect(sdk.entities.create).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: expect.stringContaining(
+                    "FILE field 'receipt' must not pass reference fields",
+                ),
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
+
     it("should reject a UI-broken field type", async () => {
         const sdk = mockSdk();
         vi.mocked(readJsonInput).mockResolvedValue({
@@ -958,7 +1020,7 @@ describe("entities update", () => {
         const sdk = mockSdk();
         const addFields = [
             {
-                fieldName: "order",
+                fieldName: "purchaseOrder",
                 type: "RELATIONSHIP",
                 referenceEntityId: "a1b2c3d4-0000-0000-0000-000000000010",
                 referenceFieldId: "f1000000-0000-0000-0000-000000000100",
@@ -1655,8 +1717,8 @@ describe("entities update", () => {
     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" }],
+            addFields: [{ fieldName: "overlap", type: "STRING" }],
+            removeFields: [{ fieldName: "overlap" }],
         });
 
         const program = buildProgram();
@@ -1667,7 +1729,7 @@ describe("entities update", () => {
             "update",
             "entity-id",
             "--body",
-            '{"addFields":[{"fieldName":"shared","type":"STRING"}],"removeFields":[{"fieldName":"shared"}]}',
+            '{"addFields":[{"fieldName":"overlap","type":"STRING"}],"removeFields":[{"fieldName":"overlap"}]}',
             "--confirm",
             "--reason",
             "recreate",
@@ -1678,7 +1740,7 @@ describe("entities update", () => {
             expect.objectContaining({
                 Result: "Failure",
                 Message:
-                    "Field 'shared' appears in both addFields and removeFields",
+                    "Field 'overlap' appears in both addFields and removeFields",
             }),
         );
         expect(process.exitCode).toBe(1);
@@ -1708,7 +1770,7 @@ describe("entities update", () => {
         expect(OutputFormatter.error).toHaveBeenCalledWith(
             expect.objectContaining({
                 Result: "Failure",
-                Message: "Duplicate fieldName 'dup' in addFields",
+                Message: "Duplicate field name 'dup' (case-insensitive)",
             }),
         );
         expect(process.exitCode).toBe(1);

package/src/commands/entities.ts

@@ -24,12 +24,16 @@ import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
 import {
     findInvalidFieldConstraints,
+    findInvalidFieldMetadata,
     findInvalidFieldName,
     findIsUniqueInUpdateFields,
     findMissingComplexFieldExtras,
+    findReferenceFieldsOnFile,
     findReferenceFolderKeyOnChoiceSet,
+    findTooManyMultilineMaxFields,
     findUiBrokenFieldType,
     validateName,
+    validateSchemaMetadata,
 } from "../utils/validate";
 
 interface ListOptions {
@@ -173,10 +177,11 @@ const ENTITIES_CREATE_EXAMPLES: CommandExample[] = [
         Description:
             "Create a folder-scoped entity with cross-folder references. " +
             "Pass '--folder-key' to place the new entity in a folder. " +
-            "Per-field 'referenceFolderKey' points a RELATIONSHIP or CHOICE_SET_* field at a target that lives in a different folder (or at the tenant level when omitted). " +
+            "Per-field 'referenceFolderKey' points a RELATIONSHIP field at a target that lives in a different folder (or at the tenant level when omitted). " +
+            "CHOICE_SET_* fields resolve scope from 'choiceSetId' and must not pass 'referenceFolderKey'. " +
             "Get target entity/field IDs from 'df entities list --folder-key <key>' and 'df entities get <id> --folder-key <key>'; get choice-set IDs from 'df choice-sets list --folder-key <key>' (omit '--folder-key' for tenant-level choice sets).",
         Command:
-            'uip df entities create OrderLine --folder-key f1000000-0000-0000-0000-000000000050 --body \'{"displayName":"Order Line","fields":[{"fieldName":"order","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","referenceFolderKey":"f1000000-0000-0000-0000-000000000060","isRequired":true},{"fieldName":"userType","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000077"}]}\'',
+            'uip df entities create OrderLine --folder-key f1000000-0000-0000-0000-000000000050 --body \'{"displayName":"Order Line","fields":[{"fieldName":"purchaseOrder","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","referenceFolderKey":"f1000000-0000-0000-0000-000000000060","isRequired":true},{"fieldName":"userType","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000077"}]}\'',
         Output: {
             Code: "EntityCreated",
             Data: { ID: "a1b2c3d4-0000-0000-0000-000000000005" },
@@ -220,13 +225,20 @@ function pickKnownUpdateKeys(
 // name rules and UI-broken-type substitution. The SDK-enum type check
 // stays inline at the call site because it needs `hasInvalidFieldType`
 // (bound to the SDK enum, not portable to @uipath/common).
-function validateFieldsPayload(fields: unknown[]): ValidationError | null {
+function validateFieldsPayload(
+    fields: unknown[],
+    entityName?: string,
+    isNewEntity = false,
+): ValidationError | null {
     return runChecks([
         () => findInvalidFieldName(fields),
+        () => findInvalidFieldMetadata(fields, entityName),
         () => findUiBrokenFieldType(fields),
+        () => findReferenceFieldsOnFile(fields),
         () => findReferenceFolderKeyOnChoiceSet(fields),
         () => findMissingComplexFieldExtras(fields),
         () => findInvalidFieldConstraints(fields),
+        () => (isNewEntity ? findTooManyMultilineMaxFields(fields) : null),
     ]);
 }
 
@@ -436,7 +448,13 @@ export const registerEntitiesCommand = (program: Command) => {
 
                 const err = runChecks([
                     () => validateName(name, "entity"),
-                    () => validateFieldsPayload(definition.fields as unknown[]),
+                    () => validateSchemaMetadata(definition, "Entity"),
+                    () =>
+                        validateFieldsPayload(
+                            definition.fields as unknown[],
+                            name,
+                            true,
+                        ),
                 ]);
                 if (err) return fail(err.message, err.instructions);
 
@@ -544,6 +562,9 @@ export const registerEntitiesCommand = (program: Command) => {
                 }
 
                 const input = parsed as Record<string, unknown>;
+                const metadataErr = validateSchemaMetadata(input, "Entity");
+                if (metadataErr)
+                    return fail(metadataErr.message, metadataErr.instructions);
 
                 if (
                     input.addFields !== undefined &&
@@ -571,7 +592,7 @@ export const registerEntitiesCommand = (program: Command) => {
                 ) {
                     return fail(
                         "'removeFields' must be an array",
-                        'Example: {"removeFields":[{"fieldName":"old_field"}]}',
+                        'Example: {"removeFields":[{"fieldName":"oldField"}]}',
                     );
                 }
 
@@ -591,7 +612,7 @@ export const registerEntitiesCommand = (program: Command) => {
                     if (hasInvalidRemove) {
                         return fail(
                             "Each field in removeFields must include a non-empty 'fieldName' string",
-                            'Example: {"removeFields":[{"fieldName":"old_field"}]}',
+                            'Example: {"removeFields":[{"fieldName":"oldField"}]}',
                         );
                     }
 
@@ -640,19 +661,12 @@ export const registerEntitiesCommand = (program: Command) => {
                     const addNames = (
                         input.addFields as { fieldName: string }[]
                     ).map((f) => f.fieldName);
-                    const duplicateAdd = addNames.find(
-                        (name, i) => addNames.indexOf(name) !== i,
-                    );
-                    if (duplicateAdd !== undefined) {
-                        return fail(
-                            `Duplicate fieldName '${duplicateAdd}' in addFields`,
-                            "Each entry in addFields must have a unique fieldName.",
-                        );
-                    }
-
                     if (removedFieldNames.length > 0) {
+                        const removedNamesLower = new Set(
+                            removedFieldNames.map((name) => name.toLowerCase()),
+                        );
                         const conflict = addNames.find((name) =>
-                            removedFieldNames.includes(name),
+                            removedNamesLower.has(name.toLowerCase()),
                         );
                         if (conflict !== undefined) {
                             return fail(
@@ -683,6 +697,15 @@ export const registerEntitiesCommand = (program: Command) => {
                     );
                     if (updateErr)
                         return fail(updateErr.message, updateErr.instructions);
+
+                    const updateMetadataErr = findInvalidFieldMetadata(
+                        input.updateFields as unknown[],
+                    );
+                    if (updateMetadataErr)
+                        return fail(
+                            updateMetadataErr.message,
+                            updateMetadataErr.instructions,
+                        );
                 }
 
                 const sdk = await connectOrFail(options.tenant);

package/src/commands/records.spec.ts

@@ -2067,6 +2067,35 @@ describe("records query — filter validation", () => {
         );
         expect(process.exitCode).toBe(1);
     });
+
+    it("rejects more than five aggregates before connecting", async () => {
+        const sdk = mockSdk();
+        const program = buildProgram();
+        await program.parseAsync([
+            "node",
+            "test",
+            "records",
+            "query",
+            "entity-id",
+            "--body",
+            JSON.stringify({
+                aggregates: Array.from({ length: 6 }, (_, index) => ({
+                    function: "COUNT",
+                    field: "Id",
+                    alias: `count${index}`,
+                })),
+            }),
+        ]);
+
+        expect(sdk.entities.queryRecordsById).not.toHaveBeenCalled();
+        expect(OutputFormatter.error).toHaveBeenCalledWith(
+            expect.objectContaining({
+                Result: "Failure",
+                Message: "A query supports at most 5 aggregates",
+            }),
+        );
+        expect(process.exitCode).toBe(1);
+    });
 });
 
 describe("records query — pagination", () => {

package/src/commands/records.ts

@@ -13,7 +13,11 @@ import { type Command, Option } from "commander";
 import { readFileBinary, readJsonInput } from "../utils/input";
 import { fail, requireDestructiveConfirmation } from "../utils/output";
 import { connectOrFail } from "../utils/sdk-client";
-import { findFilePayloadKeys, validateQueryFilter } from "../utils/validate";
+import {
+    findFilePayloadKeys,
+    validateQueryAggregates,
+    validateQueryFilter,
+} from "../utils/validate";
 
 // Fetch the entity schema and return the set of FILE-typed field names.
 // One RTT — worth it: without this, `records insert/update` silently
@@ -766,6 +770,13 @@ export const registerRecordsCommand = (program: Command) => {
                     );
                     if (filterErr)
                         return fail(filterErr.message, filterErr.instructions);
+
+                    const aggregateErr = validateQueryAggregates(queryBody);
+                    if (aggregateErr)
+                        return fail(
+                            aggregateErr.message,
+                            aggregateErr.instructions,
+                        );
                 }
 
                 const sdk = await connectOrFail(options.tenant);