@abi-software/map-utilities 1.6.1-beta.0 → 1.6.1-beta.2

package/package.json

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

package/src/components/CompetencyQueries/CompetencyQueries.js

@@ -171,10 +171,112 @@ async function queryPathsByDestination(flatmapAPI, knowledgeSource, featureId) {
   return [];
 }
 
+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 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])];
+
+  return combined;
+}
+
 export {
   competencyQuery,
   queryAllConnectedPaths,
   queryPathsByOrigin,
   queryPathsByViaLocation,
   queryPathsByDestination,
+  queryPathsByRoute,
 };

package/src/components/CompetencyQueries/knowledgeQueries.js

@@ -2,6 +2,46 @@
 // destinations = ilxtr:hasAxonPresynapticElementIn, ilxtr:hasAxonSensorySubcellularElementIn
 // via = ilxtr:hasAxonLeadingToSensorySubcellularElementIn, ilxtr:hasAxonLocatedIn
 
+async function query(flatmapAPI, sql, params) {
+  const url = `${flatmapAPI}knowledge/query/`;
+  const query = { sql, params };
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        "Accept": "application/json; charset=utf-8",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(query)
+    });
+
+    if (!response.ok) {
+      throw new Error(`Cannot access ${url}`);
+    }
+
+    return await response.json();
+  } catch {
+    return {
+      values: []
+    };
+  }
+}
+
+async function fetchLabels(flatmapAPI, labelledTerms) {
+  if (!labelledTerms.length) return [];
+
+  const data = await query(
+    flatmapAPI,
+    `select entity, knowledge from knowledge
+      where entity in (?${', ?'.repeat(labelledTerms.length - 1)})
+      order by source desc`,
+    [...labelledTerms]
+  );
+
+  return await data.values;
+}
+
 function filterOrigins(item) {
   const soma = item["node-phenotypes"]?.["ilxtr:hasSomaLocatedIn"];
   return Array.isArray(item.connectivity) &&
@@ -66,7 +106,52 @@ function getPhenotypeItems(obj, prop) {
   return arr;
 }
 
-function extractOriginItems(knowledge) {
+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.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 = [];
+    for (let i = 0; i < itemPair.length; i++) {
+      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 {
+      key: item,
+      label: labels.join(', '),
+    };
+  });
+  // 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, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -76,12 +161,10 @@ function extractOriginItems(knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return Array.from(
-    new Map(results.map(item => [JSON.stringify(item), item])).values()
-  );
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
-function extractDestinationItems(knowledge) {
+async function extractDestinationItems(flatmapAPI, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -94,12 +177,10 @@ function extractDestinationItems(knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return Array.from(
-    new Map(results.map(item => [JSON.stringify(item), item])).values()
-  );
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
-function extractViaItems(knowledge) {
+async function extractViaItems(flatmapAPI, knowledgeSource, knowledge) {
   const results = [];
   knowledge.forEach(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
@@ -112,41 +193,55 @@ function extractViaItems(knowledge) {
       if (connectivityItems.has(stringifyItem)) results.push(item);
     });
   });
-  return Array.from(
-    new Map(results.map(item => [JSON.stringify(item), item])).values()
-  );
+  return await transformResults(flatmapAPI, knowledgeSource, results);
 }
 
-function findPathsByOriginItem(knowledge, originItem) {
+function findPathsByOriginItem(knowledge, originItems) {
   return knowledge.filter(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
     const origins = getPhenotypeItems(obj, "ilxtr:hasSomaLocatedIn");
-    return origins.some(item => JSON.stringify(item) === JSON.stringify(originItem));
+    return origins.some(item => originItems.map(i => JSON.stringify(i)).includes(JSON.stringify(item)));
   });
 }
 
-function findPathsByDestinationItem(knowledge, destinationItem) {
+function findPathsByDestinationItem(knowledge, destinationItems) {
   return knowledge.filter(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
     const destinations = [
       ...getPhenotypeItems(obj, "ilxtr:hasAxonPresynapticElementIn"),
       ...getPhenotypeItems(obj, "ilxtr:hasAxonSensorySubcellularElementIn")
     ];
-    return destinations.some(item => JSON.stringify(item) === JSON.stringify(destinationItem));
+    return destinations.some(item => destinationItems.map(i => JSON.stringify(i)).includes(JSON.stringify(item)));
   });
 }
 
-function findPathsByViaItem(knowledge, viaItem) {
+function findPathsByViaItem(knowledge, viaItems) {
   return knowledge.filter(obj => {
     if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return false;
     const vias = [
       ...getPhenotypeItems(obj, "ilxtr:hasAxonLeadingToSensorySubcellularElementIn"),
       ...getPhenotypeItems(obj, "ilxtr:hasAxonLocatedIn")
     ];
-    return vias.some(item => JSON.stringify(item) === JSON.stringify(viaItem));
+    return vias.some(item => viaItems.map(i => JSON.stringify(i)).includes(JSON.stringify(item)));
   });
 }
 
+async function queryPathsByRouteFromKnowledge({ knowledge, origins, destinations, vias }) {
+  let results = knowledge;
+
+  if (origins.length) {
+    results = findPathsByOriginItem(results, origins);
+  }
+  if (destinations.length) {
+    results = findPathsByDestinationItem(results, destinations);
+  }
+  if (vias.length) {
+    results = findPathsByViaItem(results, vias);
+  }
+
+  return results;
+}
+
 export {
   filterOrigins,
   filterDestinations,
@@ -157,4 +252,6 @@ export {
   findPathsByOriginItem,
   findPathsByDestinationItem,
   findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
 }

package/src/components/index.js

@@ -14,6 +14,7 @@ import {
   queryPathsByOrigin,
   queryPathsByViaLocation,
   queryPathsByDestination,
+  queryPathsByRoute,
 } from "./CompetencyQueries/CompetencyQueries.js";
 import {
   filterOrigins,
@@ -25,6 +26,8 @@ import {
   findPathsByOriginItem,
   findPathsByDestinationItem,
   findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
 } from "./CompetencyQueries/knowledgeQueries.js";
 
 export {
@@ -43,6 +46,7 @@ export {
   queryPathsByOrigin,
   queryPathsByViaLocation,
   queryPathsByDestination,
+  queryPathsByRoute,
   filterOrigins,
   filterDestinations,
   filterViaLocations,
@@ -52,4 +56,6 @@ export {
   findPathsByOriginItem,
   findPathsByDestinationItem,
   findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
 };