@uipath/data-fabric-tool 1.198.0 → 1.199.0-preview.104

package/src/utils/validate.spec.ts

@@ -0,0 +1,555 @@
+import { describe, expect, it } from "vitest";
+import {
+    findFilePayloadKeys,
+    findInvalidFieldConstraints,
+    findInvalidFieldName,
+    findIsUniqueInUpdateFields,
+    findMissingComplexFieldExtras,
+    findReferenceFolderKeyOnChoiceSet,
+    findUiBrokenFieldType,
+    validateChoiceValueName,
+    validateName,
+    validateQueryFilter,
+} from "./validate";
+
+describe("validateName", () => {
+    it("accepts a plain field name", () => {
+        expect(validateName("total", "field")).toBeNull();
+    });
+
+    it("accepts letters, digits, and underscores", () => {
+        expect(validateName("Order_2024_v1", "entity")).toBeNull();
+    });
+
+    it("rejects a name starting with a digit", () => {
+        const err = validateName("1Order", "entity");
+        expect(err).not.toBeNull();
+        expect(err?.message).toContain("Invalid entity name");
+    });
+
+    it("rejects a name with a hyphen", () => {
+        expect(validateName("my-field", "field")).not.toBeNull();
+    });
+
+    it("rejects a two-character name", () => {
+        expect(validateName("ab", "field")).not.toBeNull();
+    });
+
+    it("rejects the system-generated field name 'Id'", () => {
+        const err = validateName("Id", "field");
+        expect(err).not.toBeNull();
+        expect(err?.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.
+        expect(validateName("CreateTime", "entity")).toBeNull();
+    });
+
+    it("rejects a reserved C#/VB keyword case-insensitively", () => {
+        for (const name of ["Class", "class", "CLASS", "New", "Case"]) {
+            const err = validateName(name, "field");
+            expect(err).not.toBeNull();
+            expect(err?.message).toContain("reserved C# or VB keyword");
+        }
+    });
+
+    it("labels the message with the kind", () => {
+        expect(validateName("Class", "entity")?.message).toContain("Entity");
+        expect(validateName("Class", "field")?.message).toContain("Field");
+        expect(validateName("Class", "choice set")?.message).toContain(
+            "Choice set",
+        );
+    });
+});
+
+describe("findInvalidFieldName", () => {
+    it("returns null when every fieldName is valid", () => {
+        expect(
+            findInvalidFieldName([
+                { fieldName: "title", type: "STRING" },
+                { fieldName: "amount", type: "DECIMAL" },
+            ]),
+        ).toBeNull();
+    });
+
+    it("flags the first invalid fieldName", () => {
+        const err = findInvalidFieldName([
+            { fieldName: "title", type: "STRING" },
+            { fieldName: "Class", type: "STRING" },
+            { fieldName: "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
+        // command handler. This helper simply ignores them.
+        expect(
+            findInvalidFieldName([{ fieldName: 42 }, { fieldName: "good" }]),
+        ).toBeNull();
+    });
+});
+
+describe("findUiBrokenFieldType", () => {
+    it("returns null for UI-compatible types", () => {
+        expect(
+            findUiBrokenFieldType([
+                { fieldName: "title", type: "STRING" },
+                { fieldName: "amount", type: "DECIMAL" },
+                { fieldName: "receipt", type: "FILE" },
+            ]),
+        ).toBeNull();
+    });
+
+    it("flags INTEGER with a DECIMAL substitution", () => {
+        const err = findUiBrokenFieldType([
+            { fieldName: "count", type: "INTEGER" },
+        ]);
+        expect(err?.message).toContain("'INTEGER'");
+        expect(err?.instructions).toContain("DECIMAL");
+    });
+
+    it("flags each UI-broken type", () => {
+        for (const type of [
+            "INTEGER",
+            "BIG_INTEGER",
+            "FLOAT",
+            "DOUBLE",
+            "UUID",
+            "DATETIME",
+        ]) {
+            const err = findUiBrokenFieldType([{ fieldName: "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" },
+        ]);
+        expect(err?.message).toContain("'b'");
+    });
+});
+
+describe("validateChoiceValueName", () => {
+    it("accepts a plain snake_case name", () => {
+        expect(validateChoiceValueName("internal_audit")).toBeNull();
+    });
+
+    it("accepts a capitalized keyword — the validator is case-sensitive", () => {
+        // `Class` is rejected as an entity/field name but passes as a
+        // choice-set value name because the server-side validator here is
+        // case-sensitive.
+        expect(validateChoiceValueName("Class")).toBeNull();
+    });
+
+    it("rejects a lowercase reserved keyword", () => {
+        for (const name of ["internal", "class", "case", "new", "object"]) {
+            const err = validateChoiceValueName(name);
+            expect(err, `${name} should be flagged`).not.toBeNull();
+            expect(err?.message).toContain("reserved C# keyword");
+        }
+    });
+
+    it("rejects a name that fails format validation", () => {
+        expect(validateChoiceValueName("1bad")?.message).toContain("Invalid");
+        expect(validateChoiceValueName("has-hyphen")?.message).toContain(
+            "Invalid",
+        );
+    });
+
+    it("suggests --display-name in the fix instructions", () => {
+        const err = validateChoiceValueName("internal");
+        expect(err?.instructions).toContain("--display-name");
+    });
+});
+
+describe("validateQueryFilter", () => {
+    it("returns null when filterGroup is undefined", () => {
+        expect(validateQueryFilter(undefined)).toBeNull();
+    });
+
+    it("accepts a well-formed filter group", () => {
+        expect(
+            validateQueryFilter({
+                logicalOperator: 0,
+                queryFilters: [
+                    { fieldName: "Status", operator: "=", value: "Active" },
+                ],
+            }),
+        ).toBeNull();
+    });
+
+    it("accepts the string form of logicalOperator, case-insensitive", () => {
+        for (const op of ["AND", "and", "OR", "or"]) {
+            expect(
+                validateQueryFilter({
+                    logicalOperator: op,
+                    queryFilters: [
+                        { fieldName: "x", operator: "=", value: "y" },
+                    ],
+                }),
+            ).toBeNull();
+        }
+    });
+
+    it("rejects an unsupported operator", () => {
+        for (const op of ["==", "equals", "Equals", "like", "BETWEEN"]) {
+            const err = validateQueryFilter({
+                queryFilters: [{ fieldName: "x", operator: op, value: "y" }],
+            });
+            expect(err, `${op} should be flagged`).not.toBeNull();
+            expect(err?.message).toContain("unsupported operator");
+        }
+    });
+
+    it("requires valueList on 'in' / 'not in'", () => {
+        const err = validateQueryFilter({
+            queryFilters: [
+                { fieldName: "Status", operator: "in", value: "Active" },
+            ],
+        });
+        expect(err?.message).toContain("requires 'valueList'");
+    });
+
+    it("requires value on operators other than in / not in", () => {
+        const err = validateQueryFilter({
+            queryFilters: [{ fieldName: "Status", operator: "=" }],
+        });
+        expect(err?.message).toContain("requires 'value'");
+    });
+
+    it("accepts null value (is-empty / is-not-empty)", () => {
+        expect(
+            validateQueryFilter({
+                queryFilters: [
+                    { fieldName: "Status", operator: "=", value: null },
+                ],
+            }),
+        ).toBeNull();
+    });
+
+    it("recurses into nested filterGroups", () => {
+        const err = validateQueryFilter({
+            queryFilters: [{ fieldName: "x", operator: "=", value: "y" }],
+            filterGroups: [
+                {
+                    queryFilters: [
+                        { fieldName: "y", operator: "like", value: "z" },
+                    ],
+                },
+            ],
+        });
+        expect(err?.message).toContain("unsupported operator 'like'");
+    });
+
+    it("rejects a bad logicalOperator", () => {
+        const err = validateQueryFilter({
+            logicalOperator: 2,
+            queryFilters: [{ fieldName: "x", operator: "=", value: "y" }],
+        });
+        expect(err?.message).toContain("logicalOperator");
+    });
+
+    it("rejects a queryFilters entry with missing fieldName", () => {
+        const err = validateQueryFilter({
+            queryFilters: [{ operator: "=", value: "y" }],
+        });
+        expect(err?.message).toContain("fieldName");
+    });
+});
+
+describe("findReferenceFolderKeyOnChoiceSet", () => {
+    it("returns null when CHOICE_SET_* fields omit referenceFolderKey", () => {
+        expect(
+            findReferenceFolderKeyOnChoiceSet([
+                {
+                    fieldName: "status",
+                    type: "CHOICE_SET_SINGLE",
+                    choiceSetId: "cs-1",
+                },
+                {
+                    fieldName: "tags",
+                    type: "CHOICE_SET_MULTIPLE",
+                    choiceSetId: "cs-2",
+                },
+            ]),
+        ).toBeNull();
+    });
+
+    it("ignores referenceFolderKey on RELATIONSHIP / FILE (allowed there)", () => {
+        expect(
+            findReferenceFolderKeyOnChoiceSet([
+                {
+                    fieldName: "customerId",
+                    type: "RELATIONSHIP",
+                    referenceEntityId: "e-1",
+                    referenceFieldId: "f-1",
+                    referenceFolderKey: "folder-1",
+                },
+                {
+                    fieldName: "receipt",
+                    type: "FILE",
+                    referenceFolderKey: "folder-1",
+                },
+            ]),
+        ).toBeNull();
+    });
+
+    it("flags referenceFolderKey on CHOICE_SET_SINGLE", () => {
+        const err = findReferenceFolderKeyOnChoiceSet([
+            {
+                fieldName: "status",
+                type: "CHOICE_SET_SINGLE",
+                choiceSetId: "cs-1",
+                referenceFolderKey: "folder-1",
+            },
+        ]);
+        expect(err?.message).toContain("CHOICE_SET_* field 'status'");
+        expect(err?.instructions).toContain("choiceSetId");
+    });
+
+    it("flags referenceFolderKey on CHOICE_SET_MULTIPLE", () => {
+        const err = findReferenceFolderKeyOnChoiceSet([
+            {
+                fieldName: "tags",
+                type: "CHOICE_SET_MULTIPLE",
+                choiceSetId: "cs-2",
+                referenceFolderKey: "folder-1",
+            },
+        ]);
+        expect(err).not.toBeNull();
+    });
+});
+
+describe("findMissingComplexFieldExtras", () => {
+    it("returns null when complex fields carry their extras", () => {
+        expect(
+            findMissingComplexFieldExtras([
+                {
+                    fieldName: "status",
+                    type: "CHOICE_SET_SINGLE",
+                    choiceSetId: "cs-1",
+                },
+                {
+                    fieldName: "tags",
+                    type: "CHOICE_SET_MULTIPLE",
+                    choiceSetId: "cs-2",
+                },
+                {
+                    fieldName: "customerId",
+                    type: "RELATIONSHIP",
+                    referenceEntityId: "e-1",
+                    referenceFieldId: "f-1",
+                },
+                { fieldName: "receipt", type: "FILE" },
+                { fieldName: "title", type: "STRING" },
+            ]),
+        ).toBeNull();
+    });
+
+    it("flags CHOICE_SET_SINGLE without choiceSetId", () => {
+        const err = findMissingComplexFieldExtras([
+            { fieldName: "status", type: "CHOICE_SET_SINGLE" },
+        ]);
+        expect(err?.message).toContain("'status'");
+        expect(err?.message).toContain("requires 'choiceSetId'");
+    });
+
+    it("flags CHOICE_SET_MULTIPLE with empty-string choiceSetId", () => {
+        const err = findMissingComplexFieldExtras([
+            { fieldName: "tags", type: "CHOICE_SET_MULTIPLE", choiceSetId: "" },
+        ]);
+        expect(err).not.toBeNull();
+    });
+
+    it("flags RELATIONSHIP without referenceEntityId", () => {
+        const err = findMissingComplexFieldExtras([
+            {
+                fieldName: "customerId",
+                type: "RELATIONSHIP",
+                referenceFieldId: "f-1",
+            },
+        ]);
+        expect(err?.message).toContain("requires 'referenceEntityId'");
+    });
+
+    it("flags RELATIONSHIP without referenceFieldId", () => {
+        const err = findMissingComplexFieldExtras([
+            {
+                fieldName: "customerId",
+                type: "RELATIONSHIP",
+                referenceEntityId: "e-1",
+            },
+        ]);
+        expect(err?.message).toContain("requires 'referenceFieldId'");
+    });
+
+    it("stops at the first offender", () => {
+        const err = findMissingComplexFieldExtras([
+            { fieldName: "ok", type: "CHOICE_SET_SINGLE", choiceSetId: "cs-1" },
+            { fieldName: "bad", type: "RELATIONSHIP" },
+        ]);
+        expect(err?.message).toContain("'bad'");
+    });
+});
+
+describe("findInvalidFieldConstraints", () => {
+    it("returns null when constraints match their type + ranges", () => {
+        expect(
+            findInvalidFieldConstraints([
+                { fieldName: "title", type: "STRING", lengthLimit: 500 },
+                {
+                    fieldName: "body",
+                    type: "MULTILINE_TEXT",
+                    lengthLimit: 8000,
+                },
+                {
+                    fieldName: "note",
+                    type: "MULTILINE_MAX",
+                    lengthLimit: 100000,
+                },
+                {
+                    fieldName: "price",
+                    type: "DECIMAL",
+                    decimalPrecision: 2,
+                    minValue: 0,
+                    maxValue: 999999,
+                },
+            ]),
+        ).toBeNull();
+    });
+
+    it("rejects lengthLimit on a non-text type", () => {
+        const err = findInvalidFieldConstraints([
+            { fieldName: "score", type: "DECIMAL", lengthLimit: 100 },
+        ]);
+        expect(err?.message).toContain(
+            "'DECIMAL' does not accept 'lengthLimit'",
+        );
+    });
+
+    it("rejects lengthLimit outside the STRING range", () => {
+        const err = findInvalidFieldConstraints([
+            { fieldName: "title", type: "STRING", lengthLimit: 5000 },
+        ]);
+        expect(err?.message).toContain("outside the allowed range");
+        expect(err?.instructions).toContain("1 and 4000");
+    });
+
+    it("rejects lengthLimit outside the MULTILINE_MAX byte budget", () => {
+        const err = findInvalidFieldConstraints([
+            { fieldName: "body", type: "MULTILINE_MAX", lengthLimit: 200000 },
+        ]);
+        expect(err?.message).toContain("MULTILINE_MAX");
+        expect(err?.instructions).toContain("131072");
+    });
+
+    it("rejects maxValue on non-DECIMAL", () => {
+        const err = findInvalidFieldConstraints([
+            { fieldName: "title", type: "STRING", maxValue: 100 },
+        ]);
+        expect(err?.message).toContain("does not accept 'maxValue'");
+    });
+
+    it("rejects minValue >= maxValue on DECIMAL", () => {
+        const err = findInvalidFieldConstraints([
+            {
+                fieldName: "price",
+                type: "DECIMAL",
+                minValue: 100,
+                maxValue: 100,
+            },
+        ]);
+        expect(err?.message).toContain("must be strictly less than");
+    });
+
+    it("rejects decimalPrecision outside 0-10", () => {
+        const err = findInvalidFieldConstraints([
+            { fieldName: "price", type: "DECIMAL", decimalPrecision: 15 },
+        ]);
+        expect(err?.message).toContain("decimalPrecision");
+        expect(err?.instructions).toContain("0 and 10");
+    });
+
+    it("rejects decimalPrecision on non-DECIMAL", () => {
+        const err = findInvalidFieldConstraints([
+            {
+                fieldName: "title",
+                type: "STRING",
+                decimalPrecision: 2,
+            },
+        ]);
+        expect(err?.message).toContain("does not accept 'decimalPrecision'");
+    });
+});
+
+describe("findFilePayloadKeys", () => {
+    it("returns null when there are no FILE fields", () => {
+        expect(
+            findFilePayloadKeys(
+                [{ title: "x", receipt: "/tmp/r.pdf" }],
+                new Set(),
+            ),
+        ).toBeNull();
+    });
+
+    it("returns null when no record key matches a FILE field", () => {
+        expect(
+            findFilePayloadKeys(
+                [{ title: "x", score: 5 }],
+                new Set(["receipt"]),
+            ),
+        ).toBeNull();
+    });
+
+    it("flags a matching FILE key and names the field + record index", () => {
+        const err = findFilePayloadKeys(
+            [{ title: "ok" }, { title: "bad", receipt: "/tmp/r.pdf" }],
+            new Set(["receipt"]),
+        );
+        expect(err?.message).toContain("Record #1");
+        expect(err?.message).toContain("'receipt'");
+        expect(err?.instructions).toContain("files upload");
+    });
+
+    it("stops at the first offender", () => {
+        const err = findFilePayloadKeys(
+            [
+                { title: "x", receipt: "/tmp/a.pdf" },
+                { title: "y", cover: "/tmp/b.pdf" },
+            ],
+            new Set(["receipt", "cover"]),
+        );
+        expect(err?.message).toContain("Record #0");
+    });
+});
+
+describe("findIsUniqueInUpdateFields", () => {
+    it("returns null when isUnique is absent", () => {
+        expect(
+            findIsUniqueInUpdateFields([
+                { id: "f1", displayName: "New Name" },
+                { id: "f2", isRequired: true },
+            ]),
+        ).toBeNull();
+    });
+
+    it("flags isUnique: true", () => {
+        const err = findIsUniqueInUpdateFields([{ id: "f1", isUnique: true }]);
+        expect(err?.message).toContain("'f1'");
+        expect(err?.instructions).toContain("fixed at field creation");
+    });
+
+    it("flags isUnique: false too", () => {
+        // The server silently ignores the value regardless of what's passed.
+        // Both true and false are unsafe — the caller can't rely on the toggle.
+        expect(
+            findIsUniqueInUpdateFields([{ id: "f1", isUnique: false }]),
+        ).not.toBeNull();
+    });
+});