@abi-software/map-utilities 1.6.1-beta.1 → 1.6.1-beta.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abi-software/map-utilities",
-  "version": "1.6.1-beta.1",
+  "version": "1.6.1-beta.3",
   "files": [
     "dist/*",
     "src/*",

package/src/components/CompetencyQueries/CompetencyQueries.js

@@ -171,44 +171,39 @@ async function queryPathsByDestination(flatmapAPI, knowledgeSource, featureId) {
   return [];
 }
 
-// Neuron populations from origin node(s) to destination node(s), via node(s)
-// API Label: Neuron populations that have source, via, and destination nodes
-async function queryPathsByRoute({ flatmapAPI, knowledgeSource, origins, destinations, vias }) {
-  const originParam = {
-    column: 'source_node_id',
-    value: origins
-  };
-  const viaParam = {
-    column: 'via_node_id',
-    value: vias
-  };
-  const destinationParam = {
-    column: 'dest_node_id',
-    value: destinations
-  };
-  if (!origins.length) {
-    originParam['negate'] = true;
-  }
-  if (!vias.length) {
-    viaParam['negate'] = true;
-  }
-  if (!destinations.length) {
-    destinationParam['negate'] = true;
+function extractFeatureIds(inputArray) {
+  const result = [];
+
+  for (const itemString of inputArray) {
+    const item = JSON.parse(itemString);
+
+    if (Array.isArray(item) && item.length >= 2) {
+      if (Array.isArray(item[1]) && item[1].length === 0) {
+        result.push(item[0]);
+      }
+    }
   }
+  return result;
+}
+
+// Neuron populations as forward or backward connections of a neuron population
+async function queryForwardBackwardConnections(flatmapAPI, knowledgeSource, pathIds) {
   const data = await competencyQuery({
-    flatmapAPI: flatmapAPI,
-    knowledgeSource: knowledgeSource,
-    queryId: 24,
+    flatmapAPI,
+    knowledgeSource,
+    queryId: 26,
     parameters: [
-      originParam,
-      viaParam,
-      destinationParam,
+      {
+        column: 'path_id',
+        value: pathIds
+      },
     ]
   });
   if (data?.results?.values) {
     const paths = data.results.values.map((value) => {
-      // value => [ 'source_id', 'path_id', 'axon_terminal']
-      return value[1];
+      // value => ["source_id", "base_path_id", "dest_path_id", "distance"]
+      // return dest_path_id
+      return value[2];
     });
     // remove duplicates
     return [...new Set(paths)];
@@ -216,6 +211,96 @@ async function queryPathsByRoute({ flatmapAPI, knowledgeSource, origins, destina
   return [];
 }
 
+// Neuron populations from origin to destination, via
+// Query 24: Neuron populations that have source, via, and destination nodes
+// Query 25: Neuron populations that have source, via, and destination locations
+async function queryPathsByRoute({ flatmapAPI, knowledgeSource, origins, destinations, vias }) {
+  const originFeatureIds = extractFeatureIds(origins);
+  const destinationFeatureIds = extractFeatureIds(destinations);
+  const viaFeatureIds = extractFeatureIds(vias);
+
+  const paramsF = [
+    {
+      column: 'source_feature_id',
+      value: originFeatureIds,
+      ...(originFeatureIds.length === 0 && { negate: true })
+    },
+    {
+      column: 'via_feature_id',
+      value: viaFeatureIds,
+      ...(viaFeatureIds.length === 0 && { negate: true })
+    },
+    {
+      column: 'dest_feature_id',
+      value: destinationFeatureIds,
+      ...(destinationFeatureIds.length === 0 && { negate: true })
+    }
+  ];
+
+  const params = [
+    {
+      column: 'source_node_id',
+      value: origins,
+      ...(origins.length === 0 && { negate: true })
+    },
+    {
+      column: 'via_node_id',
+      value: vias,
+      ...(vias.length === 0 && { negate: true })
+    },
+    {
+      column: 'dest_node_id',
+      value: destinations,
+      ...(destinations.length === 0 && { negate: true })
+    }
+  ];
+
+  const shouldCallDataF = paramsF.some(param =>
+    Array.isArray(param.value) && param.value.length > 0);
+
+  const promises = [
+    competencyQuery({
+      flatmapAPI,
+      knowledgeSource,
+      queryId: 24,
+      parameters: params
+    })
+  ];
+
+  if (shouldCallDataF) {
+    promises.push(
+      competencyQuery({
+        flatmapAPI,
+        knowledgeSource,
+        queryId: 25,
+        parameters: paramsF
+      })
+    );
+  }
+
+  const results = await Promise.all(promises);
+
+  let pathsF = [];
+  let data;
+  if (shouldCallDataF) {
+    const dataF = results[0];
+    data = results[1];
+    // value => [ 'source_id', 'path_id', 'axon_terminal']
+    pathsF = dataF?.results?.values?.map(value => value[1]) || [];
+  } else {
+    data = results[0];
+  }
+  // value => [ 'source_id', 'path_id', 'axon_terminal']
+  const paths = data?.results?.values?.map(value => value[1]) || [];
+  const combined = [...new Set([...pathsF, ...paths])];
+
+  // Continue to forward and backward connections
+  const additionalPaths = await queryForwardBackwardConnections(flatmapAPI, knowledgeSource, combined);
+  const total = [...new Set([...combined, ...additionalPaths])];
+
+  return total;
+}
+
 export {
   competencyQuery,
   queryAllConnectedPaths,
@@ -223,4 +308,5 @@ export {
   queryPathsByViaLocation,
   queryPathsByDestination,
   queryPathsByRoute,
+  queryForwardBackwardConnections,
 };

package/src/components/CompetencyQueries/knowledgeQueries.js

@@ -106,14 +106,23 @@ function getPhenotypeItems(obj, prop) {
   return arr;
 }
 
-async function transformResults(flatmapAPI, results) {
+async function transformResults(flatmapAPI, knowledgeSource, results) {
   const baseResults = Array.from(
     new Map(results.map(item => [JSON.stringify(item), item])).values()
   );
   const terms = baseResults.flat(Infinity);
   const uniqueTerms = [...new Set(terms)];
   const fetchResults = await fetchLabels(flatmapAPI, uniqueTerms);
-  const objectResults = fetchResults.map((item) => JSON.parse(item[1]));
+  // const objectResults = fetchResults.map((item) => JSON.parse(item[1]));
+  const objectResults = fetchResults.reduce((arr, item) => {
+    const id = item[0];
+    const valObj = JSON.parse(item[1]);
+    if (valObj.source === knowledgeSource) {
+      arr.push({ id, label: valObj.label });
+    }
+    return arr;
+  }, []);
+  const nodes = [];
   const formattedResults = baseResults.map((item) => {
     const itemPair = item.flat();
     const labels = [];
@@ -121,6 +130,12 @@ async function transformResults(flatmapAPI, results) {
       const foundObj = objectResults.find((obj) => obj.id === itemPair[i])
       if (foundObj) {
         labels.push(foundObj.label);
+        if (i > 0) {
+          nodes.push({
+            key: [itemPair[i], []],
+            label: foundObj.label,
+          });
+        }
       }
     }
     return {
@@ -128,10 +143,15 @@ async function transformResults(flatmapAPI, results) {
       label: labels.join(', '),
     };
   });
-  return formattedResults;
+  // unique results by combining formattedResults and nodes
+  // but filter out duplicates based on the labels
+  const uniqueResults = [...formattedResults, ...nodes].filter((result, index, self) =>
+    index === self.findIndex((r) => r.label === result.label)
+  );
+  return uniqueResults;
 }
 
-async function extractOriginItems(flatmapAPI, knowledge) {
+async function extractOriginItems(flatmapAPI, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -141,10 +161,10 @@ async function extractOriginItems(flatmapAPI, knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return await transformResults(flatmapAPI, results);
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
-async function extractDestinationItems(flatmapAPI, knowledge) {
+async function extractDestinationItems(flatmapAPI, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -157,10 +177,10 @@ async function extractDestinationItems(flatmapAPI, knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return await transformResults(flatmapAPI, results);
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
-async function extractViaItems(flatmapAPI, knowledge) {
+async function extractViaItems(flatmapAPI, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -173,7 +193,7 @@ async function extractViaItems(flatmapAPI, knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return await transformResults(flatmapAPI, results);
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
 function findPathsByOriginItem(knowledge, originItems) {

package/src/components/index.js

@@ -15,6 +15,7 @@ import {
   queryPathsByViaLocation,
   queryPathsByDestination,
   queryPathsByRoute,
+  queryForwardBackwardConnections,
 } from "./CompetencyQueries/CompetencyQueries.js";
 import {
   filterOrigins,
@@ -47,6 +48,7 @@ export {
   queryPathsByViaLocation,
   queryPathsByDestination,
   queryPathsByRoute,
+  queryForwardBackwardConnections,
   filterOrigins,
   filterDestinations,
   filterViaLocations,