Chore/SOF-6991

src/utils/filter.ts

@@ -1,14 +1,14 @@
 import uniqBy from "lodash/uniqBy";
 
-// Entity or object with path property
-interface PathObject {
-    path: string;
-}
+import { PathSchema } from "../types";
+
+type PathObject = Required<PathSchema>;
 
 // Filter conditions
 export interface FilterObject {
     path?: string;
     regex?: RegExp;
+    isDefault?: boolean;
 }
 
 /**
@@ -42,6 +42,24 @@ function isMultiPathSupported(
     return expandedPaths.every((expandedPath) => isPathSupported(expandedPath, filterObjects));
 }
 
+function setDefaultAsFirst(
+    pathObjects: PathObject[],
+    filterObjects: FilterObject[],
+): PathObject[] {
+    const defaultFilter = filterObjects.find((f) => f.isDefault);
+    if (!defaultFilter) return pathObjects;
+
+    const defaultIndex = pathObjects.findIndex((pathObj) => {
+        return isPathSupported(pathObj, [defaultFilter]);
+    });
+    if (defaultIndex < 0 || pathObjects.length < 2) return pathObjects;
+
+    const tmp = pathObjects[1];
+    pathObjects[0] = pathObjects[defaultIndex];
+    pathObjects[1] = tmp;
+    return pathObjects;
+}
+
 interface FilterEntityListProps {
     entitiesOrPaths: PathObject[]; // Array of objects defining entity path
     filterObjects?: FilterObject[]; // Array of path or regular expression objects
@@ -50,13 +68,13 @@ interface FilterEntityListProps {
 
 /**
  * Filter list of entity paths or entities by paths and regular expressions.
- * @return {Object[]} - filtered entity path objects or entities
+ * @return - filtered entity path objects or entities
  */
 export function filterEntityList({
     entitiesOrPaths,
     filterObjects = [],
     multiPathSeparator = "",
-}: FilterEntityListProps) {
+}: FilterEntityListProps): PathObject[] {
     if (!filterObjects || !filterObjects.length) return [];
     const filterObjects_ = filterObjects.map((o) => (o.regex ? { regex: new RegExp(o.regex) } : o));
 
@@ -69,5 +87,7 @@ export function filterEntityList({
         filtered = entitiesOrPaths.filter((e) => isPathSupported(e, filterObjects_));
     }
 
+    filtered = setDefaultAsFirst(filtered, filterObjects_);
+
     return uniqBy(filtered, "path");
 }

tests/utils/filter.tests.ts

@@ -40,6 +40,13 @@ describe("entity filter", () => {
         expect(filtered).to.have.deep.members(expected);
     });
 
+    it("should place the default entity as first element in list", () => {
+        const filterObjects = [{ path: "/root/entity/b" }, { path: "/root/entity/c", isDefault: true }];
+        const filtered = filterEntityList({ filterObjects, entitiesOrPaths: entities });
+        const expectedPath ="/root/entity/c";
+        expect(filtered[0].path).to.be.equal(expectedPath);
+    });
+
     it("should filter an entity list containing concatenated paths", () => {
         const filterObjects = [{ path: "/root/entity/b" }, { path: "/root/entity/c" }];
         const multiPathEntities = [