Explorer subpath support (#1368)

* feat: add support for attribute expressions

* test: update tests

* feat: add support for filtering with attribute expressions

* fix: caught a couple bugs while updating tests

Author: aaron-steinfeld

projects/common/src/utilities/types/types.ts

@@ -7,6 +7,8 @@ export type DistributiveOmit<T, K extends UnionKeys<T>> = T extends any ? Omit<T
 
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type RequireBy<T, K extends keyof T> = T & Required<Pick<T, K>>;
+export type KeysWithType<T, V> = { [K in keyof T]-?: T[K] extends V ? K : never }[keyof T];
+
 export interface Dictionary<T> {
   [key: string]: T;
 }

projects/components/src/filtering/filter-bar/filter-bar.service.test.ts

@@ -35,8 +35,9 @@ describe('Filter Bar service', () => {
     ),
     new StringMapFilterBuilder().buildFilter(
       getTestFilterAttribute(FilterAttributeType.StringMap),
-      FilterOperator.ContainsKeyValue,
-      ['myKey', 'myValue']
+      FilterOperator.Equals,
+      'myValue',
+      'myKey'
     )
   ];
 
@@ -184,18 +185,33 @@ describe('Filter Bar service', () => {
     expect(testFilters).toEqual([stringFilter, inNumberFilter]);
 
     /*
-     * Add a StringMap CONTAINS_KEY_VALUE that should not replace any existing filters
+     * Add a StringMap EQUALS should not replace any existing filters
      */
 
-    const ckvStringMapFilter = new StringMapFilterBuilder().buildFilter(
+    const firstStringMapFilter = new StringMapFilterBuilder().buildFilter(
       getTestFilterAttribute(FilterAttributeType.StringMap),
-      FilterOperator.ContainsKeyValue,
-      ['myKey', 'myValue']
+      FilterOperator.Equals,
+      'myValue',
+      'myKey'
     );
 
-    testFilters = spectator.service.addFilter(testFilters, ckvStringMapFilter);
+    testFilters = spectator.service.addFilter(testFilters, firstStringMapFilter);
+
+    expect(testFilters).toEqual([stringFilter, inNumberFilter, firstStringMapFilter]);
+    /*
+     * Add a second StringMap EQUALS filters with a different key should not replace any existing filters
+     */
 
-    expect(testFilters).toEqual([stringFilter, inNumberFilter, ckvStringMapFilter]);
+    const secondStringMapFilter = new StringMapFilterBuilder().buildFilter(
+      getTestFilterAttribute(FilterAttributeType.StringMap),
+      FilterOperator.Equals,
+      'myValue',
+      'mySecondKey'
+    );
+
+    testFilters = spectator.service.addFilter(testFilters, secondStringMapFilter);
+
+    expect(testFilters).toEqual([stringFilter, inNumberFilter, firstStringMapFilter, secondStringMapFilter]);
 
     /*
      * Add a StringMap CONTAINS_KEY that should not replace any existing filters
@@ -209,7 +225,13 @@ describe('Filter Bar service', () => {
 
     testFilters = spectator.service.addFilter(testFilters, ckStringMapFilter);
 
-    expect(testFilters).toEqual([stringFilter, inNumberFilter, ckvStringMapFilter, ckStringMapFilter]);
+    expect(testFilters).toEqual([
+      stringFilter,
+      inNumberFilter,
+      firstStringMapFilter,
+      secondStringMapFilter,
+      ckStringMapFilter
+    ]);
   });
 
   test('correctly updates filters', () => {
@@ -221,8 +243,9 @@ describe('Filter Bar service', () => {
 
     const testStringMapFilter = new StringMapFilterBuilder().buildFilter(
       getTestFilterAttribute(FilterAttributeType.StringMap),
-      FilterOperator.ContainsKeyValue,
-      ['myTestKey', 'myTestValue']
+      FilterOperator.Equals,
+      'myTestValue',
+      'myTestKey'
     );
 
     const testNumberFilter = new NumberFilterBuilder().buildFilter(

projects/components/src/filtering/filter-bar/filter-bar.service.ts

@@ -1,5 +1,6 @@
 import { Injectable } from '@angular/core';
-import { areCompatibleFilters, areEqualFilters, Filter } from '../filter/filter';
+import { isEqual } from 'lodash-es';
+import { areCompatibleFilters, Filter } from '../filter/filter';
 
 @Injectable({
   providedIn: 'root'
@@ -14,18 +15,18 @@ export class FilterBarService {
   public updateFilter(filters: Filter[], oldFilter: Filter, newFilter: Filter): Filter[] {
     const clonedFilters = [...filters];
 
-    const index = filters.findIndex(f => areEqualFilters(f, oldFilter));
+    const index = filters.findIndex(f => isEqual(f, oldFilter));
 
     if (index < 0) {
       throw new Error(`Unable to update filter. Filter for '${oldFilter.field}' not found.`);
     }
 
     clonedFilters.splice(index, 1, newFilter);
 
-    return clonedFilters.filter(f => areEqualFilters(f, newFilter) || areCompatibleFilters(f, newFilter));
+    return clonedFilters.filter(f => isEqual(f, newFilter) || areCompatibleFilters(f, newFilter));
   }
 
   public deleteFilter(filters: Filter[], filter: Filter): Filter[] {
-    return filters.filter(f => !areEqualFilters(f, filter));
+    return filters.filter(f => !isEqual(f, filter));
   }
 }

projects/components/src/filtering/filter-bar/filter-chip/filter-chip.component.ts

@@ -120,8 +120,7 @@ export class FilterChipComponent implements OnInit, OnChanges {
   private mapToComboBoxOption(filter: IncompleteFilter): ComboBoxOption<IncompleteFilter> {
     return {
       text: filter.userString,
-      value: filter,
-      tooltip: `${filter.userString} (${filter.field})`
+      value: filter
     };
   }
 }

projects/components/src/filtering/filter-bar/filter-chip/filter-chip.service.test.ts

@@ -62,7 +62,6 @@ describe('Filter Chip service', () => {
             case FilterOperator.In:
               return new InFilterParser();
             case FilterOperator.ContainsKey:
-            case FilterOperator.ContainsKeyValue:
               return new ContainsFilterParser();
             default:
               assertUnreachable(operator);
@@ -246,21 +245,79 @@ describe('Filter Chip service', () => {
     ]);
   });
 
-  test('correctly autocompletes operator filters for string map attribute once space key is entered', () => {
+  test('correctly autocompletes operator filters for string map attribute', () => {
     const attribute = getTestFilterAttribute(FilterAttributeType.StringMap);
 
-    expect(spectator.service.autocompleteFilters(attributes, 'String Map Attribute.testKey ')).toEqual([
+    // Contains key or subpath operators if no subpath specified but could be
+    expect(spectator.service.autocompleteFilters(attributes, 'String Map Attribute')).toEqual([
       {
         metadata: attribute,
         field: attribute.name,
         operator: FilterOperator.ContainsKey,
-        userString: `${attribute.displayName} ${FilterOperator.ContainsKey} testKey`
+        userString: `${attribute.displayName} ${FilterOperator.ContainsKey}`
       },
       {
         metadata: attribute,
         field: attribute.name,
-        operator: FilterOperator.ContainsKeyValue,
-        userString: `${attribute.displayName}.testKey ${FilterOperator.ContainsKeyValue}`
+        operator: FilterOperator.Equals,
+        userString: `${attribute.displayName}.example ${FilterOperator.Equals}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        operator: FilterOperator.NotEquals,
+        userString: `${attribute.displayName}.example ${FilterOperator.NotEquals}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        operator: FilterOperator.In,
+        userString: `${attribute.displayName}.example ${FilterOperator.In}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        operator: FilterOperator.Like,
+        userString: `${attribute.displayName}.example ${FilterOperator.Like}`
+      }
+    ]);
+
+    // Regular operators only once subpath included
+    expect(spectator.service.autocompleteFilters(attributes, 'String Map Attribute.testKey')).toEqual([
+      expect.objectContaining({
+        metadata: attribute,
+        field: attribute.name,
+        operator: FilterOperator.ContainsKey,
+        // This operator isn't actually eligible but filtering operators is done by the chip/combobox, so just make sure the string doesn't match
+        userString: expect.not.stringMatching(`${attribute.displayName}.testKey`)
+      }),
+      {
+        metadata: attribute,
+        field: attribute.name,
+        subpath: 'testKey',
+        operator: FilterOperator.Equals,
+        userString: `${attribute.displayName}.testKey ${FilterOperator.Equals}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        subpath: 'testKey',
+        operator: FilterOperator.NotEquals,
+        userString: `${attribute.displayName}.testKey ${FilterOperator.NotEquals}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        subpath: 'testKey',
+        operator: FilterOperator.In,
+        userString: `${attribute.displayName}.testKey ${FilterOperator.In}`
+      },
+      {
+        metadata: attribute,
+        field: attribute.name,
+        subpath: 'testKey',
+        operator: FilterOperator.Like,
+        userString: `${attribute.displayName}.testKey ${FilterOperator.Like}`
       }
     ]);
   });