@truedat/lm 5.13.1 → 5.13.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/lm",
-  "version": "5.13.1",
+  "version": "5.13.3",
   "description": "Truedat Link Manager",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -86,7 +86,7 @@
     ]
   },
   "dependencies": {
-    "@truedat/core": "5.13.1",
+    "@truedat/core": "5.13.3",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.8.1",
     "react-graph-vis": "1.0.6",
@@ -107,5 +107,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 2.0.3 < 2.2"
   },
-  "gitHead": "59eb6f428c3489a2ae689381d2f239378284be8c"
+  "gitHead": "93c1576f82fedd1d9b607cd0c9053279763877bc"
 }

package/src/components/RelationGraphDepth.js

@@ -8,7 +8,7 @@ import { FormattedMessage } from "react-intl";
 
 export const RelationGraphDepth = ({ onChange, depth, maxDepth }) => {
   return _.isUndefined(maxDepth) ? null : (
-    <Segment className="graph-depth">
+    <Segment className={`graph-depth ${maxDepth == 0 ? "disabled" : ""}`}>
       <FormattedMessage id="relationGraph.depth" />
       <div>{depth}</div>
       <Slider
@@ -16,7 +16,7 @@ export const RelationGraphDepth = ({ onChange, depth, maxDepth }) => {
         orientation="vertical"
         reverse
         onChange={onChange}
-        min={1}
+        min={0}
         max={maxDepth}
         tooltip={false}
       />

package/src/components/__tests__/ImplementationRelationForm.spec.js

@@ -80,9 +80,12 @@ describe("<ImplementationRelationForm />", () => {
       renderOpts
     );
 
-    await waitFor(() => {
-      expect(getByText(/relates_to/)).toBeInTheDocument();
-    });
+    await waitFor(
+      () => {
+        expect(getByText(/relates_to/)).toBeInTheDocument();
+      },
+      { timeout: 60000 }
+    );
     expect(container).toMatchSnapshot();
   });
 

package/src/components/__tests__/StructureRelationForm.spec.js

@@ -85,9 +85,12 @@ describe("<StructureRelationForm />", () => {
       renderOpts
     );
 
-    await waitFor(() => {
-      expect(getByText(/relates_to/)).toBeInTheDocument();
-    });
+    await waitFor(
+      () => {
+        expect(getByText(/relates_to/)).toBeInTheDocument();
+      },
+      { timeout: 60000 }
+    );
 
     expect(container).toMatchSnapshot();
   });

package/src/selectors/index.js

@@ -1,3 +1,3 @@
 export * from "./getStructureLinks";
 export * from "./getImplementationToConceptLinks";
-export * from "./relationGraphTraversal";
+export * from "../services/relationGraphTraversal";

package/src/services/__tests__/relationGraphTraversal.spec.js

@@ -0,0 +1,388 @@
+import _ from "lodash/fp";
+import { findMaxDepth, EMPTY, pruneGraph } from "../relationGraphTraversal";
+
+const nodes = [
+  {
+    id: "character:taiga",
+    name: "Taiga",
+  },
+  {
+    id: "character:ryuuji",
+    name: "Ryuuji",
+  },
+  {
+    id: "character:minori",
+    name: "Minori",
+  },
+  {
+    id: "character:ami",
+    name: "Ami",
+  },
+  {
+    id: "character:yuusaku",
+    name: "Yuusaku",
+  },
+  {
+    id: "character:yasuko",
+    name: "Yasuko",
+  },
+  {
+    id: "character:sumire",
+    name: "Sumire",
+  },
+  {
+    id: "character:maya",
+    name: "Maya",
+  },
+  {
+    id: "character:non_connected",
+    name: "unrelated",
+  },
+];
+
+const tag_suki = {
+  id: "suki",
+  value: {
+    target_type: "character",
+    type: "loves",
+  },
+};
+
+const tag_shinyuu = {
+  id: "shinyuu",
+  value: {
+    target_type: "character",
+    type: "close_friend",
+  },
+};
+
+const tag_seitokai = {
+  id: "seitokai",
+  value: {
+    target_type: "character",
+    type: "student_council",
+  },
+};
+
+const tag_sonkei = {
+  id: "sonkei",
+  value: {
+    target_type: "character",
+    type: "respect",
+  },
+};
+
+const tag_haha = {
+  id: "haha",
+  value: {
+    target_type: "character",
+    type: "mother",
+  },
+};
+
+const tag_musuko = {
+  id: "musuko",
+  value: {
+    target_type: "character",
+    type: "son",
+  },
+};
+
+const tag_osananajimi = {
+  id: "osananajimi",
+  value: {
+    target_type: "character",
+    type: "childhood_friend",
+  },
+};
+
+const edges = [
+  {
+    id: "taiga_to_yuusaku",
+    source_id: "character:taiga",
+    target_id: "character:yuusaku",
+    tags: [tag_suki],
+  },
+  {
+    id: "yuusaku_to_taiga",
+    source_id: "character:yuusaku",
+    target_id: "character:taiga",
+    tags: [],
+  },
+  {
+    id: "taiga_to_minori",
+    source_id: "character:taiga",
+    target_id: "character:minori",
+    tags: [tag_shinyuu],
+  },
+  {
+    id: "minori_to_taiga",
+    source_id: "character:minori",
+    target_id: "character:taiga",
+    tags: [tag_shinyuu],
+  },
+  {
+    id: "taiga_to_ryuuji",
+    source_id: "character:taiga",
+    target_id: "character:ryuuji",
+    tags: [],
+  },
+  {
+    id: "ryuuji_to_taiga",
+    source_id: "character:ryuuji",
+    target_id: "character:taiga",
+    tags: [],
+  },
+  {
+    id: "taiga_to_ami",
+    source_id: "character:taiga",
+    target_id: "character:ami",
+    tags: [],
+  },
+  {
+    id: "ami_to_taiga",
+    source_id: "character:ami",
+    target_id: "character:taiga",
+    tags: [],
+  },
+  {
+    id: "ryuuji_to_minori",
+    source_id: "character:ryuuji",
+    target_id: "character:minori",
+    tags: [tag_suki],
+  },
+  {
+    id: "minori_to_ryuuji",
+    source_id: "character:minori",
+    target_id: "character:ryuuji",
+    tags: [],
+  },
+  {
+    id: "ryuuji_to_yuusaku",
+    source_id: "character:ryuuji",
+    target_id: "character:yuusaku",
+    tags: [tag_shinyuu],
+  },
+  {
+    id: "yuusaku_to_ryuuji",
+    source_id: "character:yuusaku",
+    target_id: "character:ryuuji",
+    tags: [tag_shinyuu],
+  },
+  {
+    id: "ryuuji_to_yasuko",
+    source_id: "character:ryuuji",
+    target_id: "character:yasuko",
+    tags: [tag_haha],
+  },
+  {
+    id: "yasuko_to_ryuuji",
+    source_id: "character:yasuko",
+    target_id: "character:ryuuji",
+    tags: [tag_musuko],
+  },
+  {
+    id: "yuusaku_to_sumire",
+    source_id: "character:yuusaku",
+    target_id: "character:sumire",
+    tags: [tag_seitokai, tag_sonkei],
+  },
+  {
+    id: "sumire_to_yuusaku",
+    source_id: "character:sumire",
+    target_id: "character:yuusaku",
+    tags: [tag_seitokai],
+  },
+  {
+    id: "yuusaku_to_maya",
+    source_id: "character:yuusaku",
+    target_id: "character:maya",
+    tags: [],
+  },
+  {
+    id: "maya_to_yuusaku",
+    source_id: "character:maya",
+    target_id: "character:yuusaku",
+    tags: [tag_suki],
+  },
+  {
+    id: "yuusaku_to_ami",
+    source_id: "character:yuusaku",
+    target_id: "character:ami",
+    tags: [tag_osananajimi],
+  },
+  {
+    id: "ami_to_yuusaku",
+    source_id: "character:ami",
+    target_id: "character:yuusaku",
+    tags: [tag_osananajimi],
+  },
+];
+
+const relationsGraph = {
+  nodes,
+  edges,
+};
+
+describe("relationGraphTraversal", () => {
+  const traversalTags = [];
+
+  it("get graph max depth, starting from taiga, no limitations (all tags)", () => {
+    const currentId = "character:taiga";
+    expect(findMaxDepth(relationsGraph, currentId, traversalTags)).toBe(2);
+  });
+
+  it("get graph max depth, starting from ami, no limitations (all tags)", () => {
+    const currentId = "character:ami";
+    expect(findMaxDepth(relationsGraph, currentId, traversalTags)).toBe(3);
+  });
+
+  it("empty input graph", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph({}, currentId, 3, traversalTags);
+    expect(limitedGraph).toStrictEqual({});
+  });
+
+  it("get graph, no limitations (max depth, all tags)", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph(
+      relationsGraph,
+      currentId,
+      2,
+      traversalTags
+    );
+    const { nodes: outputNodes, edges: outputEdges } = limitedGraph;
+
+    const inputNodeIds = _.map((node) => node.id, nodes);
+    const outputNodeIds = _.map((node) => node.id, outputNodes);
+
+    // excludes non connected nodes
+    expect(_.difference(inputNodeIds, outputNodeIds)).toStrictEqual([
+      "character:non_connected",
+    ]);
+
+    const inputEdgeIds = _.map((edge) => edge.id, edges);
+    const outputEdgeIds = _.map((edge) => edge.id, outputEdges);
+
+    expect(_.difference(inputEdgeIds, outputEdgeIds)).toStrictEqual([]);
+  });
+
+  it("get graph, limit depth to 1, all tags", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph(
+      relationsGraph,
+      currentId,
+      1,
+      traversalTags
+    );
+    const { nodes: outputNodes, edges: outputEdges } = limitedGraph;
+    const outputNodeIds = new Set(_.map((node) => node.id, outputNodes));
+    const expectedNodeIds = new Set([
+      "character:taiga",
+      "character:ryuuji",
+      "character:minori",
+      "character:ami",
+      "character:yuusaku",
+    ]);
+
+    expect(_.isEqual(outputNodeIds, expectedNodeIds)).toBeTruthy();
+
+    const outputEdgeIds = new Set(_.map((edge) => edge.id, outputEdges));
+    const expectedEdgeIds = new Set([
+      // Directly reachable edges
+      "taiga_to_yuusaku",
+      "yuusaku_to_taiga",
+      "taiga_to_minori",
+      "minori_to_taiga",
+      "taiga_to_ryuuji",
+      "ryuuji_to_taiga",
+      "taiga_to_ami",
+      "ami_to_taiga",
+      /* Indirectly reachable edges
+       * (are shown even though depth first search has not actually traversed
+       * through them, to avoid possible user confusion thinking they
+       * do not exist).
+       */
+      "ryuuji_to_minori",
+      "minori_to_ryuuji",
+      "ami_to_yuusaku",
+      "yuusaku_to_ami",
+      "ryuuji_to_yuusaku",
+      "yuusaku_to_ryuuji",
+    ]);
+
+    expect(_.isEqual(outputEdgeIds, expectedEdgeIds)).toBeTruthy();
+  });
+
+  it("get graph, limit depth to 2, with traversal tags", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph(relationsGraph, currentId, 2, [
+      "suki",
+      "sonkei",
+    ]);
+    const { nodes: outputNodes, edges: outputEdges } = limitedGraph;
+    const outputNodeIds = new Set(_.map((node) => node.id, outputNodes));
+    const expectedNodeIds = new Set([
+      "character:taiga",
+      "character:yuusaku",
+      "character:sumire",
+      "character:maya",
+    ]);
+
+    expect(_.isEqual(outputNodeIds, expectedNodeIds)).toBeTruthy();
+
+    const outputEdgeIds = new Set(_.map((edge) => edge.id, outputEdges));
+    const expectedEdgeIds = new Set([
+      "taiga_to_yuusaku",
+      "yuusaku_to_sumire",
+      "maya_to_yuusaku",
+    ]);
+
+    expect(_.isEqual(outputEdgeIds, expectedEdgeIds)).toBeTruthy();
+  });
+
+  it("EMPTY tag", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph(relationsGraph, currentId, 2, [EMPTY]);
+    const { nodes: outputNodes, edges: outputEdges } = limitedGraph;
+    const outputNodeIds = new Set(_.map((node) => node.id, outputNodes));
+    const expectedNodeIds = new Set([
+      "character:taiga",
+      "character:ryuuji",
+      "character:ami",
+      "character:maya",
+      "character:minori",
+      "character:yuusaku",
+    ]);
+
+    expect(_.isEqual(outputNodeIds, expectedNodeIds)).toBeTruthy();
+
+    const outputEdgeIds = new Set(_.map((edge) => edge.id, outputEdges));
+    const expectedEdgeIds = new Set([
+      "taiga_to_ryuuji",
+      "ryuuji_to_taiga",
+      "taiga_to_ami",
+      "ami_to_taiga",
+      "yuusaku_to_taiga",
+      "minori_to_ryuuji",
+      "yuusaku_to_maya",
+    ]);
+
+    expect(_.isEqual(outputEdgeIds, expectedEdgeIds)).toBeTruthy();
+  });
+
+  it("unreachable tag", () => {
+    const currentId = "character:taiga";
+    const limitedGraph = pruneGraph(relationsGraph, currentId, 2, ["sonkei"]);
+    const { nodes: outputNodes, edges: outputEdges } = limitedGraph;
+    const outputNodeIds = new Set(_.map((node) => node.id, outputNodes));
+    const expectedNodeIds = new Set(["character:taiga"]);
+
+    expect(_.isEqual(outputNodeIds, expectedNodeIds)).toBeTruthy();
+
+    const outputEdgeIds = new Set(_.map((edge) => edge.id, outputEdges));
+    const expectedEdgeIds = new Set([]);
+
+    expect(_.isEqual(outputEdgeIds, expectedEdgeIds)).toBeTruthy();
+  });
+});

package/src/services/relationGraphTraversal.js

@@ -1,31 +1,117 @@
+/* eslint-disable fp/no-mutation */
+/* eslint-disable fp/no-let */
 import _ from "lodash/fp";
+import { defaultMemoize } from "reselect";
 
-const getNeighbours = (relationsGraph, start) => {
-  return _.concat(
-    // Up
-    _.flow(
-      _.filter((edge) => edge.target_id === start.id),
-      _.flatMap((edge) => _.find({ id: edge.source_id }, relationsGraph.nodes))
-    )(relationsGraph.edges),
-    // Down
-    _.flow(
-      _.filter((edge) => edge.source_id === start.id),
-      _.flatMap((edge) => _.find({ id: edge.target_id }, relationsGraph.nodes))
-    )(relationsGraph.edges)
+export const EMPTY = "_EMPTY";
+
+const currentIdToNode = (graph, currentId) =>
+  _.flow(_.getOr([], "nodes"), _.find({ id: currentId }))(graph) || {};
+
+const equalityCheck = (previousVal, currentVal) =>
+  _.isArray(previousVal) && _.isArray(currentVal) // traversalTags uses arrays
+    ? _.isEqual(previousVal.sort(), currentVal.sort())
+    : previousVal === currentVal;
+
+export const findMaxDepth = defaultMemoize(
+  (graph, currentId, traversalTags) => {
+    const start = currentIdToNode(graph, currentId);
+    return bfsMaxDepth(graph, start, traversalTags);
+  },
+  { maxSize: 10, equalityCheck }
+);
+
+export const pruneGraph = defaultMemoize(
+  (graph, currentId, depth, traversalTags) => {
+    const start = currentIdToNode(graph, currentId);
+    const maxDepth = findMaxDepth(graph, currentId, traversalTags);
+
+    if (!_.isEmpty(graph) && !_.isEmpty(start)) {
+      const nodes = dfs(
+        graph,
+        start,
+        {},
+        depth < maxDepth ? depth : maxDepth,
+        traversalTags
+      );
+      return {
+        nodes,
+        /* This will show both directly and indirectly reachable edges
+         * Indirectly reachable edges are shown even though depth first search
+         * has not actually traversed through them. Could avoid by accumulating
+         * edges while traversing. However, I prefer to display them to avoid
+         * possible user confusion thinking they do not exist.
+         * See test for more details
+         */
+        edges: filterEdges(graph, nodes, traversalTags),
+      };
+    } else {
+      return graph;
+    }
+  },
+  { maxSize: 10, equalityCheck }
+);
+
+export const anyTraversalTags = (traversalTagIds, tags) => {
+  const tagIds = _.map((tag) => tag.id, tags);
+  return (
+    _.isEmpty(traversalTagIds) || // If no tags specified, any tag is accepted
+    (traversalTagIds.includes(EMPTY) && _.isEmpty(tagIds)) ||
+    !_.isEmpty(_.intersection(traversalTagIds, tagIds))
+  );
+};
+
+const findNeighbours = (relationsGraph, start, traversalTags) => {
+  const inNeighbours = _.flow(
+    _.filter(
+      (edge) =>
+        edge.target_id === start.id &&
+        anyTraversalTags(traversalTags, edge.tags)
+    ),
+    _.flatMap((edge) => _.find({ id: edge.source_id }, relationsGraph.nodes))
+  );
+  const outNeighbours = _.flow(
+    _.filter(
+      (edge) =>
+        edge.source_id === start.id &&
+        anyTraversalTags(traversalTags, edge.tags)
+    ),
+    _.flatMap((edge) => _.find({ id: edge.target_id }, relationsGraph.nodes))
   );
+
+  return _.flow(
+    (edges) => [...inNeighbours(edges), ...outNeighbours(edges)],
+    _.uniq
+  )(relationsGraph.edges);
 };
 
-export const getEdges = (relationsGraph, nodes) => {
+export const filterEdges = (relationsGraph, nodes, traversalTags) => {
   const nodeIds = Object.keys(nodes);
-  return _.filter(
+  const edges = _.filter(
     (edge) =>
-      nodeIds.includes(edge.source_id) && nodeIds.includes(edge.target_id),
+      nodeIds.includes(edge.source_id) &&
+      nodeIds.includes(edge.target_id) &&
+      anyTraversalTags(traversalTags, edge.tags),
     relationsGraph.edges
   );
+  return edges;
 };
 
-export const dfs = (relationsGraph, start, visited, maxDepth) => {
-  if (Object.keys(visited).includes(start.id) || maxDepth === 0) return {};
+export const graphDistinctTags = ({ edges }) =>
+  _.flow(
+    _.flatMap((edge) => edge?.tags),
+    _.uniqBy((tag) => tag?.id)
+  )(edges);
+
+export const dfs = (
+  relationsGraph,
+  start,
+  visited,
+  maxDepth,
+  traversalTags
+) => {
+  // Depth range: [0, maxDepth]
+  if (Object.keys(visited).includes(start.id) || maxDepth === -1) return {};
 
   return _.reduce(
     (acc, neighbour) => ({
@@ -34,27 +120,41 @@ export const dfs = (relationsGraph, start, visited, maxDepth) => {
         relationsGraph,
         neighbour,
         { ...visited, [start.id]: start },
-        maxDepth - 1
+        maxDepth - 1,
+        traversalTags
       ),
     }),
     { [start.id]: start }
-  )(getNeighbours(relationsGraph, start));
+  )(findNeighbours(relationsGraph, start, traversalTags));
 };
 
-export const dfsMaxDepth = (relationsGraph, start, visited, currDepth) => {
-  if (Object.keys(visited).includes(start.id)) return currDepth;
+/*
+ * Shortest Path (Unweighted Graph)
+ * If the graph is unweighed, then finding the shortest path is easy: we can
+ * use the breadth-first search algorithm. For a weighted graph, we can use Dijkstra's algorithm.
+ * https://aquarchitect.github.io/swift-algorithm-club/Shortest%20Path%20%28Unweighted%29/
+ */
+const bfsMaxDepth = (relationsGraph, start, traversalTags) => {
+  let queue = [];
+  let nodesDistance = {};
 
-  return _.reduce(
-    (currMax, neighbour) =>
-      Math.max(
-        currMax,
-        dfsMaxDepth(
-          relationsGraph,
-          neighbour,
-          { ...visited, [start.id]: start },
-          currDepth + 1
-        )
-      ),
-    0
-  )(getNeighbours(relationsGraph, start));
+  queue.push(start);
+  nodesDistance[start.id] = 0; // Depth range: [0, maxDepth]
+
+  let current = start;
+  while (!_.isEmpty(current)) {
+    current = queue.shift() || {};
+    for (let neighbour of findNeighbours(
+      relationsGraph,
+      current,
+      traversalTags
+    )) {
+      if (!(neighbour.id in nodesDistance)) {
+        queue.push(neighbour);
+        nodesDistance[neighbour.id] = nodesDistance[current.id] + 1;
+      }
+    }
+  }
+
+  return Math.max(...Object.values(nodesDistance));
 };

package/src/styles/relationGraph.less

@@ -2,20 +2,30 @@
   position: absolute !important;
   z-index: 1;
   margin-right: 0px;
+  right: 14px;
 
   div {
     text-align: center;
     font-weight: bold;
   }
-}
 
-.graph-depth .rangeslider-vertical {
-  .rangeslider__fill {
-    background-color: #ed5c17;
-    border: 1px solid gray;
+  &.disabled {
+    pointer-events: none;
+    opacity: 0.7;
+
+    .rangeslider-vertical .rangeslider__fill {
+      background-color: gray;
+    }
   }
 
-  .rangeslider__handle {
-    border-radius: 4px;
+  .rangeslider-vertical {
+    .rangeslider__fill {
+      background-color: #ed5c17;
+      border: 1px solid gray;
+    }
+  
+    .rangeslider__handle {
+      border-radius: 4px;
+    }
   }
 }

package/src/selectors/__tests__/relationGraphTraversal.spec.js

@@ -1,188 +0,0 @@
-import _ from "lodash/fp";
-import { selectLimitedGraph } from "..";
-import { selectMaxDepth } from "../relationGraphTraversal";
-
-const nodes = [
-  {
-    id: "business_concept:92",
-    name: "My Awesome Concept",
-  },
-  {
-    id: "business_concept:5",
-    name: "New Concept 4",
-  },
-  {
-    id: "business_concept:18",
-    name: "Float Concept",
-  },
-];
-
-const edges = [
-  {
-    id: 1,
-    source_id: "business_concept:92",
-    target_id: "business_concept:5",
-    tags: [
-      {
-        id: 3,
-        value: {
-          target_type: "business_concept",
-          type: "bc_padre",
-        },
-      },
-    ],
-  },
-  {
-    id: 2,
-    source_id: "business_concept:5",
-    target_id: "business_concept:18",
-    tags: [
-      {
-        id: 3,
-        value: {
-          target_type: "business_concept",
-          type: "bc_padre",
-        },
-      },
-    ],
-  },
-  {
-    id: 3,
-    source_id: "business_concept:18",
-    target_id: "business_concept:5",
-    tags: [
-      {
-        id: 3,
-        value: {
-          target_type: "business_concept",
-          type: "bc_padre",
-        },
-      },
-    ],
-  },
-];
-
-const relationsGraph = {
-  nodes,
-  edges,
-};
-
-describe("selectors: relationGraphTraversal", () => {
-  const currentId = "business_concept:92";
-
-  it("gets Graph on non-empty relationsGraph", () => {
-    const limitedGraph = selectLimitedGraph({ relationsGraph }, currentId, 3);
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[0].id, name: nodes[0].name }, limitedGraph.nodes)
-      ) &&
-        _.isUndefined(
-          _.find({ id: nodes[1].id, name: nodes[1].name }, limitedGraph.nodes)
-        ) &&
-        _.isUndefined(
-          _.find({ id: nodes[2].id, name: nodes[2].name }, limitedGraph.nodes)
-        )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            source_id: edges[0].source_id,
-            target_id: edges[0].target_id,
-          },
-          limitedGraph.edges
-        )
-      ) &&
-        _.isUndefined(
-          _.find(
-            {
-              source_id: edges[1].source_id,
-              target_id: edges[1].target_id,
-            },
-            limitedGraph.edges
-          )
-        ) &&
-        _.isUndefined(
-          _.find(
-            {
-              source_id: edges[2].source_id,
-              target_id: edges[2].target_id,
-            },
-            limitedGraph.edges
-          )
-        )
-    ).toBeFalsy();
-  });
-
-  it("gets Graph on empty relationsGraph", () => {
-    const limitedGraph = selectLimitedGraph(
-      { relationsGraph: {} },
-      currentId,
-      3
-    );
-    expect(limitedGraph).toStrictEqual({});
-  });
-
-  it("gets depth limited graph", () => {
-    const limitedGraph = selectLimitedGraph({ relationsGraph }, currentId, 2);
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[0].id, name: nodes[0].name }, limitedGraph.nodes)
-      ) &&
-        _.isUndefined(
-          _.find({ id: nodes[1].id, name: nodes[1].name }, limitedGraph.nodes)
-        )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[2].id, name: nodes[2].name }, limitedGraph.nodes)
-      )
-    ).toBeTruthy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            source_id: edges[0].source_id,
-            target_id: edges[0].target_id,
-          },
-          limitedGraph.edges
-        )
-      )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            source_id: edges[1].source_id,
-            target_id: edges[1].target_id,
-          },
-          limitedGraph.edges
-        )
-      ) &&
-        _.isUndefined(
-          _.find(
-            {
-              source_id: edges[2].source_id,
-              target_id: edges[2].target_id,
-            },
-            limitedGraph.edges
-          )
-        )
-    ).toBeTruthy();
-  });
-
-  it("get graph max depth", () => {
-    const start = {
-      id: "business_concept:92",
-      name: "My Awesome Concept",
-    };
-
-    expect(selectMaxDepth({ relationsGraph }, currentId, start)).toBe(3);
-  });
-});

package/src/selectors/relationGraphTraversal.js

@@ -1,113 +0,0 @@
-/* eslint-disable fp/no-mutation */
-/* eslint-disable fp/no-let */
-import _ from "lodash/fp";
-import { createSelector } from "reselect";
-
-const selectStart = createSelector(
-  (state) => state.relationsGraph,
-  (state, currentId) => currentId,
-  (relationsGraph, currentId) => {
-    return (
-      _.flow(_.getOr([], "nodes"), _.find({ id: currentId }))(relationsGraph) ||
-      {}
-    );
-  }
-);
-
-export const selectMaxDepth = createSelector(
-  (state) => state.relationsGraph,
-  (state, currentId) => selectStart(state, currentId),
-  (relationsGraph, start) => bfsMaxDepth(relationsGraph, start)
-);
-
-export const selectLimitedGraph = createSelector(
-  (state) => state.relationsGraph,
-  (state, currentId) => selectStart(state, currentId),
-  (state, currentId) => selectMaxDepth(state, currentId),
-  (state, currentId, depth) => depth,
-  (relationsGraph, start, maxDepth, depth) =>
-    getLimitedGraph(relationsGraph, start, maxDepth, depth)
-);
-
-const getLimitedGraph = (relationsGraph, start, maxDepth, depth) => {
-  if (!_.isEmpty(relationsGraph) && !_.isEmpty(start) && depth !== Infinity) {
-    const nodes = dfs(relationsGraph, start, {}, depth);
-    return depth < maxDepth
-      ? {
-          nodes,
-          edges: getEdges(relationsGraph, nodes),
-        }
-      : relationsGraph;
-  } else {
-    return relationsGraph;
-  }
-};
-
-const getNeighbours = (relationsGraph, start) => {
-  const neighbours = _.concat(
-    // Up
-    _.flow(
-      _.filter((edge) => edge.target_id === start.id),
-      _.flatMap((edge) => _.find({ id: edge.source_id }, relationsGraph.nodes))
-    )(relationsGraph.edges),
-    // Down
-    _.flow(
-      _.filter((edge) => edge.source_id === start.id),
-      _.flatMap((edge) => _.find({ id: edge.target_id }, relationsGraph.nodes))
-    )(relationsGraph.edges)
-  );
-  return neighbours;
-};
-
-export const getEdges = (relationsGraph, nodes) => {
-  const nodeIds = Object.keys(nodes);
-  return _.filter(
-    (edge) =>
-      nodeIds.includes(edge.source_id) && nodeIds.includes(edge.target_id),
-    relationsGraph.edges
-  );
-};
-
-export const dfs = (relationsGraph, start, visited, maxDepth) => {
-  if (Object.keys(visited).includes(start.id) || maxDepth === 0) return {};
-
-  return _.reduce(
-    (acc, neighbour) => ({
-      ...acc,
-      ...dfs(
-        relationsGraph,
-        neighbour,
-        { ...visited, [start.id]: start },
-        maxDepth - 1
-      ),
-    }),
-    { [start.id]: start }
-  )(getNeighbours(relationsGraph, start));
-};
-
-/*
- * Shortest Path (Unweighted Graph)
- * If the graph is unweighed, then finding the shortest path is easy: we can
- * use the breadth-first search algorithm. For a weighted graph, we can use Dijkstra's algorithm.
- * https://aquarchitect.github.io/swift-algorithm-club/Shortest%20Path%20%28Unweighted%29/
- */
-const bfsMaxDepth = (relationsGraph, start) => {
-  let queue = [];
-  let nodesDistance = {};
-
-  queue.push(start);
-  nodesDistance[start.id] = 1;
-
-  let current = start;
-  while (!_.isEmpty(current)) {
-    current = queue.shift() || {};
-    for (let neighbour of getNeighbours(relationsGraph, current)) {
-      if (!nodesDistance[neighbour.id]) {
-        queue.push(neighbour);
-        nodesDistance[neighbour.id] = nodesDistance[current.id] + 1;
-      }
-    }
-  }
-
-  return Math.max(...Object.values(nodesDistance));
-};