Adopts Retrievable Explanation (#250)

## What is the goal of this PR?
As of Grakn 1.6.0 and since the changes made in the explanation retrieval with Client Node.js, explaining the inferred concepts were not possible against Core 1.6.0. This PR adopts these changes and brings back the explanation feature of Workbase.

## What are the changes implemented in this PR?

### Attaching `queryPattern` to nodes
Within the `EXPLAIN_CONCEPT` action in order to know if the retrieved explanation is a joint explanation or one resolved from a rule, we check the variables of the explanation answers against the original `queryPattern`. For this reason, we need to have access to the node's `queryPattern` and so we attach it to the node when building the node object.

### Retrieving explanation
In the legacy implementation of explanation retrieval, we could safely assume that when `queryPattern` is an empty string, the explanation is of type Joint and so we need to retrieve explanations one level deeper. This is no longer the case, and therefore we rely on the `isJointExplanation` variable which checks the variables of the retrieved explanation answers against the original `queryPattern`.

Author: Soroush Saffari

VERSION

@@ -1 +1 @@
-1.2.6
+1.2.7

dependencies/graknlabs/dependencies.bzl

@@ -22,14 +22,14 @@ def graknlabs_build_tools():
     git_repository(
         name = "graknlabs_build_tools",
         remote = "https://github.com/graknlabs/build-tools",
-        commit = "d8e266644cc5c1d44dc17515069b1a6b70c98c44", # sync-marker: do not remove this comment, this is used for sync-dependencies by @graknlabs_build_tools
+        commit = "2917a6d9348d67b036d762f521e6a8680101ea51", # sync-marker: do not remove this comment, this is used for sync-dependencies by @graknlabs_build_tools
     )
 
 def graknlabs_grakn_core():
     git_repository(
         name = "graknlabs_grakn_core",
         remote = "https://github.com/graknlabs/grakn",
-        commit = "2939a8464096c73b42ec0702647a246f357f226b", # sync-marker: do not remove this comment, this is used for sync-dependencies by @graknlabs_grakn_core
+        commit = "86f8a19a9bdac3093f5d131e0fe07667b047ca82", # sync-marker: do not remove this comment, this is used for sync-dependencies by @graknlabs_grakn_core
     )
 
 def graknlabs_client_nodejs():

package.json

@@ -165,4 +165,4 @@
         "unit": "node ./node_modules/jest/bin/jest.js ./test/unit"
     },
     "version": "1.2.4"
-}
+}

src/renderer/components/Visualiser/store/actions.js

@@ -29,6 +29,8 @@ import CDB from '../../shared/CanvasDataBuilder';
 import { reopenTransaction } from '../../shared/SharedUtils';
 
 
+const collect = (array, current) => array.concat(current);
+
 export default {
   [INITIALISE_VISUALISER]({ state, commit, dispatch }, { container, visFacade }) {
     addResetGraphListener(dispatch, CANVAS_RESET);
@@ -129,7 +131,7 @@ export default {
         PATH: 'compute path',
       };
 
-        // eslint-disable-next-line no-prototype-builtins
+      // eslint-disable-next-line no-prototype-builtins
       const queryType = (result[0].hasOwnProperty('map') ? queryTypes.GET : queryTypes.PATH);
 
       let nodes = [];
@@ -217,41 +219,49 @@ export default {
     }
   },
   async [EXPLAIN_CONCEPT]({ state, getters, commit, rootState }) {
-    const explanation = getters.selectedNode.explanation;
-    const graknTx = global.graknTx[rootState.activeTab];
+    try {
+      const graknTx = global.graknTx[rootState.activeTab];
 
-    let queries;
+      const node = getters.selectedNode;
+      const queryPattern = node.queryPattern;
+      const queryPatternVariales = Array.from(new Set(queryPattern.match(/\$[^\s|)|;|,]*/g))).map(x => x.substring(1));
 
-    // If the explanation is formed from a conjuction inside a rule, go one step deeper to access the actual explanation
-    if (!explanation.queryPattern().length) {
-      queries = explanation.answers().map(answer => answer.explanation().answers().map(answer => mapAnswerToExplanationQuery(answer))).flatMap(x => x);
-    } else {
-      queries = explanation.answers().map(answer => mapAnswerToExplanationQuery(answer));
-    }
+      const explanationAnswers = (await node.explanation()).getAnswers();
 
-    try {
-      /* eslint-disable no-await-in-loop */
-      for (const query of queries) { // eslint-disable-line
-        commit('loadingQuery', true);
-        const result = await (await graknTx.query(query)).collect();
-        if (result.length > 0) {
-          const data = await CDB.buildInstances(result);
-
-          const rpData = await CDB.buildRPInstances(result, data, false, graknTx);
-          data.nodes.push(...rpData.nodes);
-          data.edges.push(...rpData.edges);
-
-          state.visFacade.addToCanvas(data);
-          commit('updateCanvasData');
-          const nodesWithAttributes = await computeAttributes(data.nodes, graknTx);
-
-          state.visFacade.updateNode(nodesWithAttributes);
-          const styledEdges = data.edges.map(edge => ({ ...edge, label: edge.hiddenLabel, ...state.visStyle.computeExplanationEdgeStyle() }));
-          state.visFacade.updateEdge(styledEdges);
-          commit('loadingQuery', false);
-        } else {
-          commit('setGlobalErrorMsg', 'The transaction has been refreshed since the loading of this node and, as a result, the explaination is incomplete.');
+      const explanationPromises = [];
+      const explanationResult = [];
+
+      explanationAnswers.forEach((answer) => {
+        const answerVariabes = Array.from(answer.map().keys());
+
+        const isJointExplanation = answerVariabes.every(variable => queryPatternVariales.includes(variable));
+        if (answer.hasExplanation() && isJointExplanation) {
+          explanationPromises.push(answer.explanation());
+        } else if (!isJointExplanation) {
+          explanationResult.push(answer);
         }
+      });
+
+      (await Promise.all(explanationPromises)).map(expl => expl.getAnswers()).reduce(collect, []).forEach((expl) => {
+        explanationResult.push(expl);
+      });
+
+      if (explanationResult.length > 0) {
+        const data = await CDB.buildInstances(explanationResult);
+        const rpData = await CDB.buildRPInstances(explanationResult, data, false, graknTx);
+        data.nodes.push(...rpData.nodes);
+        data.edges.push(...rpData.edges);
+
+        state.visFacade.addToCanvas(data);
+        commit('updateCanvasData');
+        const nodesWithAttributes = await computeAttributes(data.nodes, graknTx);
+
+        state.visFacade.updateNode(nodesWithAttributes);
+        const styledEdges = data.edges.map(edge => ({ ...edge, label: edge.hiddenLabel, ...state.visStyle.computeExplanationEdgeStyle() }));
+        state.visFacade.updateEdge(styledEdges);
+        commit('loadingQuery', false);
+      } else {
+        commit('setGlobalErrorMsg', 'The transaction has been refreshed since the loading of this node and, as a result, the explaination is incomplete.');
       }
     } catch (e) {
       await reopenTransaction(rootState, commit);

src/renderer/components/shared/CanvasDataBuilder.js

@@ -99,16 +99,19 @@ const getEdge = (from, to, edgeType, label) => {
  * @param {String} graqlVar
  * @param {ConceptMap[]} explanation
  */
-const buildCommonInstanceNode = async (instance, graqlVar, explanation) => {
+const buildCommonInstanceNode = async (instance, graqlVar, explanation, queryPattern) => {
   const node = {};
   node.id = instance.id;
   node.baseType = instance.baseType;
   node.var = graqlVar;
-  node.explanation = explanation();
   node.attrOffset = 0;
   node.type = await getConceptLabel(instance);
   node.isInferred = await instance.isInferred();
   node.attributes = instance.attributes;
+  if (node.isInferred) {
+    node.explanation = explanation;
+    node.queryPattern = queryPattern();
+  }
 
   return node;
 };
@@ -119,8 +122,8 @@ const buildCommonInstanceNode = async (instance, graqlVar, explanation) => {
  * @param {String} graqlVar
  * @param {ConceptMap[]} explanation
  */
-const getInstanceNode = async (instance, graqlVar, explanation) => {
-  const node = await buildCommonInstanceNode(instance, graqlVar, explanation);
+const getInstanceNode = async (instance, graqlVar, explanation, queryPattern) => {
+  const node = await buildCommonInstanceNode(instance, graqlVar, explanation, queryPattern);
   switch (instance.baseType) {
     case ENTITY_INSTANCE: {
       node.label = `${node.type}: ${node.id}`;
@@ -213,13 +216,15 @@ const getInstanceEdges = async (instance, existingNodeIds) => {
  */
 const buildInstances = async (answers) => {
   let data = answers.map((answerGroup) => {
-    const explanation = answerGroup.explanation;
+    const { explanation, queryPattern } = answerGroup;
     return Array.from(answerGroup.map().entries()).map(([graqlVar, concept]) => ({
       graqlVar,
       concept,
       explanation,
+      queryPattern,
     }));
   }).reduce(collect, []);
+
   const shouldVisualiseVals = await Promise.all(data.map(item => item.concept.isThing() && shouldVisualiseInstance(item.concept)));
   data = data.map((item, index) => {
     item.shouldVisualise = shouldVisualiseVals[index];
@@ -228,7 +233,7 @@ const buildInstances = async (answers) => {
 
   data = deduplicateConcepts(data);
 
-  const nodes = await Promise.all(data.filter(item => item.shouldVisualise).map(item => getInstanceNode(item.concept, item.graqlVar, item.explanation)));
+  const nodes = await Promise.all(data.filter(item => item.shouldVisualise).map(item => getInstanceNode(item.concept, item.graqlVar, item.explanation, item.queryPattern)));
   const nodeIds = nodes.map(node => node.id);
   const edges = (await Promise.all(data.filter(item => item.shouldVisualise).map(item => getInstanceEdges(item.concept, nodeIds)))).reduce(collect, []);
 
@@ -408,12 +413,12 @@ const buildTypes = async (answers) => {
  * @param {*} graqlVar
  * @param {*} explanation
  */
-const getNeighbourNode = async (concept, graqlVar, explanation) => {
+const getNeighbourNode = async (concept, graqlVar, explanation, queryPattern) => {
   let node;
   if (concept.isType()) {
     node = getTypeNode(concept, graqlVar);
   } else if (concept.isThing()) {
-    node = getInstanceNode(concept, graqlVar, explanation);
+    node = getInstanceNode(concept, graqlVar, explanation, queryPattern);
   }
   return node;
 };
@@ -468,11 +473,12 @@ const getNeighbourEdges = async (neighbourConcept, targetNode, graknTx) => {
  */
 const buildNeighbours = async (targetNode, answers, graknTx) => {
   let data = answers.map((answerGroup) => {
-    const explanation = answerGroup.explanation;
+    const { explanation, queryPattern } = answerGroup;
     return Array.from(answerGroup.map().entries()).map(([graqlVar, concept]) => ({
       graqlVar,
       concept,
       explanation,
+      queryPattern,
     }));
   }).reduce(collect, []);
 
@@ -485,11 +491,8 @@ const buildNeighbours = async (targetNode, answers, graknTx) => {
 
   data = deduplicateConcepts(data);
 
-  const nodesPromises = Promise.all(data.filter(item => item.shouldVisualise).map(item => getNeighbourNode(item.concept, item.graqlVar, item.explanation)));
-  const edgesPromises = Promise.all(data.filter(item => item.shouldVisualise).map(item => getNeighbourEdges(item.concept, targetNode, graknTx)));
-
-  const nodes = await nodesPromises;
-  const edges = (await edgesPromises).reduce(collect, []);
+  const nodes = await Promise.all(data.filter(item => item.shouldVisualise).map(item => getNeighbourNode(item.concept, item.graqlVar, item.explanation, item.queryPattern)));
+  const edges = (await Promise.all(data.filter(item => item.shouldVisualise).map(item => getNeighbourEdges(item.concept, targetNode, graknTx)))).reduce(collect, []);
 
   return { nodes, edges };
 };
@@ -535,7 +538,7 @@ const buildRPInstances = async (answers, currentData, shouldLimit, graknTx) => {
             const rp = roleplayers[l];
             if (rp.isThing() && await shouldVisualiseInstance(rp)) {
               edges.push(getEdge(instance, rp, edgeTypes.instance.RELATES, edgeLabel));
-              nodes.push(await getInstanceNode(rp, graqlVar, answer.explanation));
+              nodes.push(await getInstanceNode(rp, graqlVar, answer.explanation, answer.queryPattern));
             }
           }
         }

test/helpers/mockedConcepts.js

@@ -6,7 +6,7 @@ const getMockedGraknTx = (answers, extraProps = {}) => ({
   ...extraProps,
 });
 
-const getMockedExplanation = answers => ({ answers: () => answers });
+const getMockedExplanation = answers => Promise.resolve({ getAnswers: () => answers });
 
 const getMockedAnswer = (concepts, explanation) => {
   const answer = {};
@@ -15,6 +15,7 @@ const getMockedAnswer = (concepts, explanation) => {
   concepts.forEach((concept, index) => { map.set(index, concept); });
   answer.map = () => map;
   answer.explanation = () => explanation;
+  answer.queryPattern = () => '';
 
   return answer;
 };

test/unit/components/shared/CanvasDataBuilder.test.js

@@ -24,10 +24,13 @@ const expectCommonPropsOnInstanceNode = (node) => {
   expect(node).toHaveProperty('id');
   expect(node).toHaveProperty('baseType');
   expect(node).toHaveProperty('var');
-  expect(node).toHaveProperty('explanation');
   expect(node).toHaveProperty('attrOffset');
   expect(node).toHaveProperty('type');
   expect(node).toHaveProperty('isInferred');
+  if (node.isInferred) {
+    expect(node).toHaveProperty('explanation');
+    expect(node).toHaveProperty('queryPattern');
+  }
   expect(node).toHaveProperty('attributes');
 };
 
@@ -99,13 +102,15 @@ describe('building instances', () => {
   });
 
   test('when graql answer contains an explanation', async () => {
-    const explConcept = mockedAttributeInstance;
+    const entityInstance = { ...mockedEntityInstance };
+    entityInstance.isInferred = () => Promise.resolve(true);
+    const explConcept = { ...mockedAttributeInstance };
     const explAnswer = getMockedAnswer([explConcept], null);
     const explanation = getMockedExplanation([explAnswer]);
-    const answers = [getMockedAnswer([mockedEntityInstance], explanation)];
+    const answers = [getMockedAnswer([entityInstance], explanation)];
     const { nodes } = await CDB.buildInstances(answers);
-
-    expect(nodes[0].explanation.answers()[0].map().get(0)).toEqual(explConcept);
+    const explAnswers = (await nodes[0].explanation()).getAnswers();
+    expect(explAnswers[0].map().get(0)).toEqual(explConcept);
   });
 
   test('when graql answer contains an implicit instance', async () => {