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

package/src/utils/validate.spec.ts

@@ -2,14 +2,20 @@ import { describe, expect, it } from "vitest";
 import {
     findFilePayloadKeys,
     findInvalidFieldConstraints,
+    findInvalidFieldMetadata,
     findInvalidFieldName,
     findIsUniqueInUpdateFields,
     findMissingComplexFieldExtras,
+    findReferenceFieldsOnFile,
     findReferenceFolderKeyOnChoiceSet,
+    findTooManyMultilineMaxFields,
     findUiBrokenFieldType,
+    validateChoiceValueDisplayName,
     validateChoiceValueName,
     validateName,
+    validateQueryAggregates,
     validateQueryFilter,
+    validateSchemaMetadata,
 } from "./validate";
 
 describe("validateName", () => {
@@ -17,10 +23,16 @@ describe("validateName", () => {
         expect(validateName("total", "field")).toBeNull();
     });
 
-    it("accepts letters, digits, and underscores", () => {
+    it("accepts underscores in entity names", () => {
         expect(validateName("Order_2024_v1", "entity")).toBeNull();
     });
 
+    it("rejects underscores in field names", () => {
+        const err = validateName("order_total", "field");
+        expect(err?.message).toContain("Invalid field name");
+        expect(err?.instructions).toContain("no underscores");
+    });
+
     it("rejects a name starting with a digit", () => {
         const err = validateName("1Order", "entity");
         expect(err).not.toBeNull();
@@ -41,6 +53,19 @@ describe("validateName", () => {
         expect(err?.message).toContain("reserved");
     });
 
+    it("rejects every system field name case-insensitively", () => {
+        for (const name of [
+            "id",
+            "CREATEDBY",
+            "createTime",
+            "UpdatedBy",
+            "updatetime",
+            "RecordOwner",
+        ]) {
+            expect(validateName(name, "field")?.message).toContain("reserved");
+        }
+    });
+
     it("does not treat 'CreateTime' as reserved for an entity name", () => {
         // The reserved-field-name list is field-specific; entity names go
         // through the keyword check only.
@@ -55,6 +80,31 @@ describe("validateName", () => {
         }
     });
 
+    it("rejects confirmed SQL keywords for entity names only", () => {
+        for (const name of ["Order", "order", "Group", "GROUP"]) {
+            expect(validateName(name, "entity")?.message).toContain(
+                "reserved SQL keyword",
+            );
+        }
+    });
+
+    it("accepts SQL keywords as field names — server only blocks them on entity create", () => {
+        for (const name of ["Order", "order", "Group", "GROUP"]) {
+            expect(validateName(name, "field")).toBeNull();
+        }
+    });
+
+    it("accepts SQL-like names the platform allows", () => {
+        for (const name of ["Status", "Key", "Type", "OrderStatus"]) {
+            expect(validateName(name, "field")).toBeNull();
+        }
+    });
+
+    it("does not apply entity and field SQL rules to choice-set names", () => {
+        expect(validateName("Order", "choice set")).toBeNull();
+        expect(validateName("Group", "choice set")).toBeNull();
+    });
+
     it("labels the message with the kind", () => {
         expect(validateName("Class", "entity")?.message).toContain("Entity");
         expect(validateName("Class", "field")?.message).toContain("Field");
@@ -92,6 +142,51 @@ describe("findInvalidFieldName", () => {
     });
 });
 
+describe("schema metadata validation", () => {
+    it("enforces fixed entity metadata limits", () => {
+        expect(
+            validateSchemaMetadata({ displayName: "x".repeat(129) }, "Entity")
+                ?.message,
+        ).toContain("128");
+        expect(
+            validateSchemaMetadata({ description: "x".repeat(513) }, "Entity")
+                ?.message,
+        ).toContain("512");
+    });
+
+    it("rejects case-insensitive field name and display-name collisions", () => {
+        expect(
+            findInvalidFieldMetadata([
+                { fieldName: "Amount" },
+                { fieldName: "amount" },
+            ])?.message,
+        ).toContain("Duplicate field name");
+        expect(
+            findInvalidFieldMetadata([
+                { fieldName: "Amount", displayName: "Total" },
+                { fieldName: "Price", displayName: "total" },
+            ])?.message,
+        ).toContain("Duplicate field display name");
+    });
+
+    it("rejects a field name matching its entity name", () => {
+        expect(
+            findInvalidFieldMetadata([{ fieldName: "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}`,
+            type: "MULTILINE_MAX",
+        }));
+        expect(findTooManyMultilineMaxFields(fields)?.message).toContain(
+            "maximum is 10",
+        );
+    });
+});
+
 describe("findUiBrokenFieldType", () => {
     it("returns null for UI-compatible types", () => {
         expect(
@@ -136,8 +231,15 @@ describe("findUiBrokenFieldType", () => {
 });
 
 describe("validateChoiceValueName", () => {
-    it("accepts a plain snake_case name", () => {
-        expect(validateChoiceValueName("internal_audit")).toBeNull();
+    it("accepts one-character and alphanumeric names", () => {
+        expect(validateChoiceValueName("A")).toBeNull();
+        expect(validateChoiceValueName("internalAudit2")).toBeNull();
+    });
+
+    it("rejects underscores", () => {
+        expect(validateChoiceValueName("internal_audit")?.message).toContain(
+            "Invalid",
+        );
     });
 
     it("accepts a capitalized keyword — the validator is case-sensitive", () => {
@@ -166,6 +268,12 @@ describe("validateChoiceValueName", () => {
         const err = validateChoiceValueName("internal");
         expect(err?.instructions).toContain("--display-name");
     });
+
+    it("enforces the 500-character display-name limit", () => {
+        expect(
+            validateChoiceValueDisplayName("x".repeat(501))?.message,
+        ).toContain("500");
+    });
 });
 
 describe("validateQueryFilter", () => {
@@ -216,6 +324,15 @@ describe("validateQueryFilter", () => {
         expect(err?.message).toContain("requires 'valueList'");
     });
 
+    it("rejects an empty valueList", () => {
+        const err = validateQueryFilter({
+            queryFilters: [
+                { fieldName: "Status", operator: "in", valueList: [] },
+            ],
+        });
+        expect(err?.message).toContain("non-empty");
+    });
+
     it("requires value on operators other than in / not in", () => {
         const err = validateQueryFilter({
             queryFilters: [{ fieldName: "Status", operator: "=" }],
@@ -233,6 +350,22 @@ describe("validateQueryFilter", () => {
         ).toBeNull();
     });
 
+    it("rejects null with operators other than = and !=", () => {
+        const err = validateQueryFilter({
+            queryFilters: [{ fieldName: "Score", operator: ">", value: null }],
+        });
+        expect(err?.message).toContain("cannot use a null value");
+    });
+
+    it("rejects invalid filter field paths", () => {
+        const err = validateQueryFilter({
+            queryFilters: [
+                { fieldName: "bad-field", operator: "=", value: "x" },
+            ],
+        });
+        expect(err?.message).toContain("fieldName");
+    });
+
     it("recurses into nested filterGroups", () => {
         const err = validateQueryFilter({
             queryFilters: [{ fieldName: "x", operator: "=", value: "y" }],
@@ -263,6 +396,76 @@ describe("validateQueryFilter", () => {
     });
 });
 
+describe("validateQueryAggregates", () => {
+    it("accepts a valid grouped aggregate", () => {
+        expect(
+            validateQueryAggregates({
+                selectedFields: ["Status"],
+                groupBy: ["Status"],
+                aggregates: [
+                    { function: "COUNT", field: "Id", alias: "total" },
+                ],
+            }),
+        ).toBeNull();
+    });
+
+    it("enforces aggregate and groupBy count limits", () => {
+        expect(
+            validateQueryAggregates({
+                aggregates: Array.from({ length: 6 }, (_, i) => ({
+                    function: "COUNT",
+                    field: `Field${i}`,
+                })),
+            })?.message,
+        ).toContain("at most 5");
+        expect(
+            validateQueryAggregates({
+                aggregates: [{ function: "COUNT", field: "Id" }],
+                groupBy: ["A", "B", "C", "D", "E", "F"],
+            })?.message,
+        ).toContain("groupBy");
+    });
+
+    it("rejects invalid functions, aliases, and duplicate aliases", () => {
+        expect(
+            validateQueryAggregates({
+                aggregates: [{ function: "MEDIAN", field: "Score" }],
+            })?.message,
+        ).toContain("invalid function");
+        expect(
+            validateQueryAggregates({
+                aggregates: [
+                    { function: "COUNT", field: "Id", alias: "bad]alias" },
+                ],
+            })?.message,
+        ).toContain("Invalid aggregate alias");
+        expect(
+            validateQueryAggregates({
+                aggregates: [
+                    { function: "COUNT", field: "Id", alias: "total" },
+                    { function: "SUM", field: "Score", alias: "TOTAL" },
+                ],
+            })?.message,
+        ).toContain("Duplicate aggregate alias");
+    });
+
+    it("requires selected fields to be grouped", () => {
+        expect(
+            validateQueryAggregates({
+                selectedFields: ["Status"],
+                aggregates: [{ function: "COUNT", field: "Id" }],
+            })?.message,
+        ).toContain("'groupBy' is required");
+        expect(
+            validateQueryAggregates({
+                selectedFields: ["Status", "Region"],
+                groupBy: ["Status"],
+                aggregates: [{ function: "COUNT", field: "Id" }],
+            })?.message,
+        ).toContain("Region");
+    });
+});
+
 describe("findReferenceFolderKeyOnChoiceSet", () => {
     it("returns null when CHOICE_SET_* fields omit referenceFolderKey", () => {
         expect(
@@ -281,7 +484,7 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
         ).toBeNull();
     });
 
-    it("ignores referenceFolderKey on RELATIONSHIP / FILE (allowed there)", () => {
+    it("ignores referenceFolderKey on RELATIONSHIP", () => {
         expect(
             findReferenceFolderKeyOnChoiceSet([
                 {
@@ -291,11 +494,6 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
                     referenceFieldId: "f-1",
                     referenceFolderKey: "folder-1",
                 },
-                {
-                    fieldName: "receipt",
-                    type: "FILE",
-                    referenceFolderKey: "folder-1",
-                },
             ]),
         ).toBeNull();
     });
@@ -326,6 +524,48 @@ describe("findReferenceFolderKeyOnChoiceSet", () => {
     });
 });
 
+describe("findReferenceFieldsOnFile", () => {
+    it("accepts a FILE field without reference metadata", () => {
+        expect(
+            findReferenceFieldsOnFile([{ fieldName: "receipt", type: "FILE" }]),
+        ).toBeNull();
+    });
+
+    it("rejects reference metadata on FILE fields", () => {
+        for (const key of [
+            "referenceFolderKey",
+            "referenceEntityId",
+            "referenceFieldId",
+            "choiceSetId",
+        ]) {
+            const err = findReferenceFieldsOnFile([
+                {
+                    fieldName: "receipt",
+                    type: "FILE",
+                    [key]: "value",
+                },
+            ]);
+            expect(err, `${key} should be rejected`).not.toBeNull();
+            expect(err?.message).toContain("FILE field 'receipt'");
+            expect(err?.instructions).toContain(`'${key}'`);
+        }
+    });
+
+    it("ignores reference metadata on non-FILE fields", () => {
+        expect(
+            findReferenceFieldsOnFile([
+                {
+                    fieldName: "customer",
+                    type: "RELATIONSHIP",
+                    referenceEntityId: "entity-id",
+                    referenceFieldId: "field-id",
+                    referenceFolderKey: "folder-id",
+                },
+            ]),
+        ).toBeNull();
+    });
+});
+
 describe("findMissingComplexFieldExtras", () => {
     it("returns null when complex fields carry their extras", () => {
         expect(
@@ -456,16 +696,43 @@ describe("findInvalidFieldConstraints", () => {
         expect(err?.message).toContain("does not accept 'maxValue'");
     });
 
-    it("rejects minValue >= maxValue on DECIMAL", () => {
+    it("allows equal numeric bounds and rejects minValue > maxValue", () => {
+        expect(
+            findInvalidFieldConstraints([
+                {
+                    fieldName: "fixed",
+                    type: "DECIMAL",
+                    minValue: 100,
+                    maxValue: 100,
+                },
+            ]),
+        ).toBeNull();
         const err = findInvalidFieldConstraints([
             {
                 fieldName: "price",
                 type: "DECIMAL",
-                minValue: 100,
+                minValue: 101,
                 maxValue: 100,
             },
         ]);
-        expect(err?.message).toContain("must be strictly less than");
+        expect(err?.message).toContain("must not exceed");
+    });
+
+    it("rejects fractional length limits and out-of-range numeric bounds", () => {
+        expect(
+            findInvalidFieldConstraints([
+                { fieldName: "title", type: "STRING", lengthLimit: 1.5 },
+            ])?.message,
+        ).toContain("integer");
+        expect(
+            findInvalidFieldConstraints([
+                {
+                    fieldName: "amount",
+                    type: "DECIMAL",
+                    maxValue: 9_007_199_254_740_992,
+                },
+            ])?.message,
+        ).toContain("supported numeric range");
     });
 
     it("rejects decimalPrecision outside 0-10", () => {