@navikt/ds-react 8.5.2 → 8.7.0

package/src/data/token-filter/helpers/generate-autocomplete-options.test.ts

@@ -1,51 +1,53 @@
 import { describe, expect, test } from "vitest";
 import type { AutoCompleteOption } from "../AutoSuggest.types";
 import type {
-  ParsedOption,
-  ParsedProperty,
-  QueryFilteringOption,
-  QueryFilteringProperty,
+  ExternalOption,
+  ExternalPropertyDefinition,
+  InternalParsedTextState,
+  InternalPropertyDefinition,
+  InternalPropertyOption,
 } from "../TokenFilter.types";
 import { generateAutoCompleteOptions } from "./generate-autocomplete-options";
-import type { ParsedText } from "./parse-query-text";
 
-const properties: QueryFilteringProperty[] = [
+const properties: ExternalPropertyDefinition[] = [
   {
-    groupValuesLabel: "Status values",
+    groupLabel: "Status values",
     group: "Metadata",
     key: "status",
-    propertyLabel: "Status",
+    label: "Status",
   },
   {
-    groupValuesLabel: "Region values",
+    groupLabel: "Region values",
     group: "Location",
     key: "region",
-    propertyLabel: "Region",
+    label: "Region",
   },
   {
-    groupValuesLabel: "Type values",
+    groupLabel: "Type values",
     group: "",
     key: "type",
-    propertyLabel: "Type",
+    label: "Type",
   },
 ];
 
-const parsedProperties: ParsedProperty[] = properties.map((prop) => ({
-  propertyKey: prop.key,
-  propertyLabel: prop.propertyLabel,
-  groupValuesLabel: prop.groupValuesLabel ?? "",
-  propertyGroup: prop.group ?? "",
-  externalProperty: prop,
-  operators: prop.operators ?? [],
-}));
-
-const statusOptions: QueryFilteringOption[] = [
+const parsedProperties: InternalPropertyDefinition[] = properties.map(
+  (prop) => ({
+    key: prop.key,
+    label: prop.label,
+    groupLabel: prop.groupLabel ?? "",
+    group: prop.group ?? "",
+    externalProperty: prop,
+    operators: prop.operators ?? [],
+  }),
+);
+
+const statusOptions: ExternalOption[] = [
   { propertyKey: "status", value: "active", label: "Active" },
   { propertyKey: "status", value: "pending", label: "Pending" },
   { propertyKey: "status", value: "inactive", label: "Inactive" },
 ];
 
-const regionOptions: QueryFilteringOption[] = [
+const regionOptions: ExternalOption[] = [
   {
     propertyKey: "region",
     value: "us-east-1",
@@ -60,25 +62,22 @@ const regionOptions: QueryFilteringOption[] = [
   },
 ];
 
-const allOptions: QueryFilteringOption[] = [...statusOptions, ...regionOptions];
+const allOptions: ExternalOption[] = [...statusOptions, ...regionOptions];
 
-const parsedOptions: ParsedOption[] = allOptions.map((option) => {
-  const property = parsedProperties.find(
-    (p) => p.propertyKey === option.propertyKey,
-  );
+const parsedOptions: InternalPropertyOption[] = allOptions.map((option) => {
+  const property = parsedProperties.find((p) => p.key === option.propertyKey);
   return {
     property: property || null,
     value: option.value,
     label: option.label || String(option.value),
     tags: option.tags || [],
-    filteringTags: option.filteringTags || [],
   };
 });
 
 describe("generateAutoCompleteOptions v2", () => {
   describe("free-text step", () => {
     test("empty value: should return all properties", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "",
       };
@@ -103,7 +102,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-empty value: should return filtered properties and values", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "statu",
       };
@@ -125,7 +124,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-empty value with operator '!:': should skip property suggestions", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "test",
         operator: "!:",
@@ -145,7 +144,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-empty value: case-insensitive filtering", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "STATU",
       };
@@ -167,7 +166,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-empty value: should match tags", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "europe",
       };
@@ -184,12 +183,12 @@ describe("generateAutoCompleteOptions v2", () => {
       expect(valueGroup).toBeDefined();
       expect(valueGroup?.options).toHaveLength(1);
       expect((valueGroup?.options[0] as AutoCompleteOption).label).toBe(
-        "EU West",
+        "Region = eu-west-1",
       );
     });
 
     test("non-empty value: whitespace-aware matching", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "us east",
       };
@@ -206,7 +205,7 @@ describe("generateAutoCompleteOptions v2", () => {
       expect(valueGroup).toBeDefined();
       expect(valueGroup?.options).toHaveLength(1);
       expect((valueGroup?.options[0] as AutoCompleteOption).label).toBe(
-        "US East",
+        "Region = us-east-1",
       );
     });
   });
@@ -215,7 +214,7 @@ describe("generateAutoCompleteOptions v2", () => {
     const statusProperty = parsedProperties[0];
 
     test("empty value: should return all values for selected property", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: statusProperty,
         operator: "=",
@@ -235,7 +234,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-empty value: should return filtered values", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: statusProperty,
         operator: "=",
@@ -252,12 +251,12 @@ describe("generateAutoCompleteOptions v2", () => {
       expect(result.options).toHaveLength(1);
       expect(result.options[0].options).toHaveLength(2);
       const labels = result.options[0].options.map((o) => o.label);
-      expect(labels).toContain("Active");
-      expect(labels).toContain("Inactive");
+      expect(labels).toContain("Status = active");
+      expect(labels).toContain("Status = inactive");
     });
 
     test("should use specified operator in value suggestions", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: statusProperty,
         operator: "!=",
@@ -280,7 +279,7 @@ describe("generateAutoCompleteOptions v2", () => {
     const statusProperty = parsedProperties[0];
 
     test("empty prefix: should return all operators", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: statusProperty,
         operatorPrefix: "",
@@ -298,7 +297,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("operator prefix '!': should filter operators starting with '!'", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: statusProperty,
         operatorPrefix: "!",
@@ -320,7 +319,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("operator prefix '>=': should filter to single operator", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: statusProperty,
         operatorPrefix: ">=",
@@ -340,7 +339,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("invalid prefix: should return empty suggestions", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: statusProperty,
         operatorPrefix: "invalid",
@@ -359,7 +358,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("operator filtering by description", () => {
     test("should filter operators by description text", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: parsedProperties[0],
         operatorPrefix: "",
@@ -380,7 +379,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("empty groups filtering", () => {
     test("should not return empty option groups", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "nonexistent",
       };
@@ -399,7 +398,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("value suggestions use correct operator", () => {
     test("free-text step uses '=' operator for all values", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "active",
       };
@@ -420,7 +419,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("property step uses selected operator", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: parsedProperties[0],
         operator: "!:",
@@ -441,20 +440,20 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("custom operators configuration", () => {
     test("property with string-format operators should filter to only those operators", () => {
-      const propertyWithCustomOps: ParsedProperty = {
-        propertyKey: "custom",
-        propertyLabel: "Custom",
-        groupValuesLabel: "Custom values",
-        propertyGroup: "Custom",
+      const propertyWithCustomOps: InternalPropertyDefinition = {
+        key: "custom",
+        label: "Custom",
+        groupLabel: "Custom values",
+        group: "Custom",
         operators: ["=", "!="],
         externalProperty: {
           key: "custom",
-          propertyLabel: "Custom",
+          label: "Custom",
           operators: ["=", "!="],
         },
       };
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: propertyWithCustomOps,
         operatorPrefix: "",
@@ -474,26 +473,26 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("property with object-format operators should extract operator strings", () => {
-      const propertyWithObjectOps: ParsedProperty = {
-        propertyKey: "custom2",
-        propertyLabel: "Custom2",
-        groupValuesLabel: "Custom2 values",
-        propertyGroup: "Custom",
+      const propertyWithObjectOps: InternalPropertyDefinition = {
+        key: "custom2",
+        label: "Custom2",
+        groupLabel: "Custom2 values",
+        group: "Custom",
         operators: [
-          { operator: ":", tokenType: "single" },
-          { operator: "!:", tokenType: "single" },
+          { operator: ":", type: "single" },
+          { operator: "!:", type: "single" },
         ],
         externalProperty: {
           key: "custom2",
-          propertyLabel: "Custom2",
+          label: "Custom2",
           operators: [
-            { operator: ":", tokenType: "single" },
-            { operator: "!:", tokenType: "single" },
+            { operator: ":", type: "single" },
+            { operator: "!:", type: "single" },
           ],
         },
       };
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: propertyWithObjectOps,
         operatorPrefix: "",
@@ -513,28 +512,28 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("property with mixed operator formats should normalize and filter", () => {
-      const propertyWithMixedOps: ParsedProperty = {
-        propertyKey: "mixed",
-        propertyLabel: "Mixed",
-        groupValuesLabel: "Mixed values",
-        propertyGroup: "Custom",
+      const propertyWithMixedOps: InternalPropertyDefinition = {
+        key: "mixed",
+        label: "Mixed",
+        groupLabel: "Mixed values",
+        group: "Custom",
         operators: [
           "=",
-          { operator: "!=", tokenType: "single" },
+          { operator: "!=", type: "single" },
           "invalid-operator",
         ],
         externalProperty: {
           key: "mixed",
-          propertyLabel: "Mixed",
+          label: "Mixed",
           operators: [
             "=",
-            { operator: "!=", tokenType: "single" },
+            { operator: "!=", type: "single" },
             "invalid-operator",
           ],
         },
       };
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: propertyWithMixedOps,
         operatorPrefix: "",
@@ -556,7 +555,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("edge case: operator without value", () => {
     test("should return empty options when operator is present but value is empty", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "",
         operator: "!=",
@@ -573,7 +572,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("should return empty options when operator-start input has no value", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "",
         operator: ":",
@@ -594,7 +593,7 @@ describe("generateAutoCompleteOptions v2", () => {
     test("scoped to property should only show values from that property", () => {
       const statusProperty = parsedProperties[0];
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: statusProperty,
         operator: "=",
@@ -616,7 +615,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-scoped (free-text) with empty value should show all properties", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "",
       };
@@ -636,7 +635,7 @@ describe("generateAutoCompleteOptions v2", () => {
     test("scoped property search should not include property labels in search fields", () => {
       const statusProperty = parsedProperties[0];
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: statusProperty,
         operator: "=",
@@ -653,7 +652,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("non-scoped search should include property labels in search", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "region",
       };
@@ -671,88 +670,30 @@ describe("generateAutoCompleteOptions v2", () => {
     });
   });
 
-  describe("filtering tags and metadata", () => {
-    test("should match filteringTags in search", () => {
-      const optionsWithFilteringTags: ParsedOption[] = [
-        {
-          property: parsedProperties[1],
-          value: "special-region",
-          label: "Special Region",
-          tags: [],
-          filteringTags: ["premium", "exclusive"],
-        },
-      ];
-
-      const queryState: ParsedText = {
-        step: "free-text",
-        value: "premium",
-      };
-
-      const result = generateAutoCompleteOptions(
-        queryState,
-        parsedProperties,
-        optionsWithFilteringTags,
-      );
-
-      const regionGroup = result.options.find(
-        (g) => g.label === "Region values",
-      );
-      expect(regionGroup?.options).toHaveLength(1);
-      expect((regionGroup?.options[0] as AutoCompleteOption).label).toBe(
-        "Special Region",
-      );
-    });
-
-    test("should preserve tags and filteringTags in suggestions", () => {
-      const queryState: ParsedText = {
-        step: "free-text",
-        value: "region",
-      };
-
-      const result = generateAutoCompleteOptions(
-        queryState,
-        parsedProperties,
-        parsedOptions,
-      );
-
-      const regionGroup = result.options.find(
-        (g) => g.label === "Region values",
-      );
-      const usEastOption = regionGroup?.options.find(
-        (o) => (o as AutoCompleteOption).label === "US East",
-      ) as AutoCompleteOption;
-
-      expect(usEastOption).toBeDefined();
-      expect(usEastOption.tags).toContain("north america");
-      expect(usEastOption.tags).toContain("usa");
-    });
-  });
-
   describe("properties with no groupValuesLabel", () => {
     test("should default to 'Values' when groupValuesLabel is empty", () => {
-      const propertyWithoutGroupLabel: ParsedProperty = {
-        propertyKey: "nogroup",
-        propertyLabel: "NoGroup",
-        groupValuesLabel: "",
-        propertyGroup: "Custom",
+      const propertyWithoutGroupLabel: InternalPropertyDefinition = {
+        key: "nogroup",
+        label: "NoGroup",
+        groupLabel: "",
+        group: "Custom",
         operators: [],
         externalProperty: {
           key: "nogroup",
-          propertyLabel: "NoGroup",
+          label: "NoGroup",
         },
       };
 
-      const optionsForProperty: ParsedOption[] = [
+      const optionsForProperty: InternalPropertyOption[] = [
         {
           property: propertyWithoutGroupLabel,
           value: "val1",
           label: "Value 1",
           tags: [],
-          filteringTags: [],
         },
       ];
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: propertyWithoutGroupLabel,
         operator: "=",
@@ -771,18 +712,17 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("null or missing property references", () => {
     test("should skip options with null property reference", () => {
-      const optionsWithNull: ParsedOption[] = [
+      const optionsWithNull: InternalPropertyOption[] = [
         {
           property: null,
           value: "orphaned",
           label: "Orphaned Value",
           tags: [],
-          filteringTags: [],
         },
         ...parsedOptions,
       ];
 
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "orphaned",
       };
@@ -800,7 +740,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("should skip properties with no data", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "free-text",
         value: "",
       };
@@ -813,7 +753,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("operator prefix filtering", () => {
     test("prefix ':' should match ':' and '!:' operators", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: parsedProperties[0],
         operatorPrefix: ":",
@@ -833,7 +773,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("prefix '>' should match '>', '>=', '!>' operators", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: parsedProperties[0],
         operatorPrefix: ">",
@@ -856,7 +796,7 @@ describe("generateAutoCompleteOptions v2", () => {
 
   describe("buildQueryString integration", () => {
     test("query string should contain property, operator, and value", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "property",
         property: parsedProperties[0],
         operator: "=",
@@ -878,7 +818,7 @@ describe("generateAutoCompleteOptions v2", () => {
     });
 
     test("operator-step value should only contain property and operator", () => {
-      const queryState: ParsedText = {
+      const queryState: InternalParsedTextState = {
         step: "operator",
         property: parsedProperties[0],
         operatorPrefix: "=",