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

package/package.json

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

package/src/components/CompetencyQueries/CompetencyQueries.js

@@ -0,0 +1,226 @@
+/**
+ * Competency Queries
+ *
+ * competencyQuery: base function
+ * query[functionName]: specific queries
+ *
+ * Note: use named-export for better tree-shaking.
+ */
+
+async function postRequest(API_URL, payload) {
+  try {
+    const response = await fetch(API_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      throw new Error(`API Error: ${response.status} ${response.statusText}`);
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error("Request failed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Competency Query
+ *
+ * @param {Object} options - Query options.
+ * @param {string} options.flatmapAPI - Base URL of the flatmap server.
+ * @param {string} options.knowledgeSource - SCKAN source ID.
+ * @param {string} options.queryId - Competency query ID.
+ * @param {Array} options.parameters - Parameters specific to the query.
+ * @param {string} [options.orderId] - Optional order ID for sorting.
+ * @returns {Promise<any>} - JSON response.
+ */
+async function competencyQuery(options) {
+  const { flatmapAPI, knowledgeSource, queryId, parameters, orderId } = options;
+  const API_URL = `${flatmapAPI}competency/query`;
+
+  const params = Array.isArray(parameters) ? [...parameters] : [];
+
+  params.push({
+    "column": "source_id",
+    "value": knowledgeSource,
+  });
+
+  let queryIdStr;
+  if (typeof queryId === 'number') {
+    queryIdStr = queryId.toString();
+  } else if (typeof queryId === 'string') {
+    queryIdStr = queryId;
+  } else {
+    throw new TypeError('queryId must be a string or a number convertible to string.');
+  }
+
+  const payload = {
+    "query_id": queryIdStr,
+    "parameters": params,
+  };
+
+  // Currently only query 12 has an order parameter
+  if (orderId) {
+    payload.order = [orderId];
+  }
+
+  return postRequest(API_URL, payload);
+}
+
+// Neuron populations associated with a location [query id => 1] (or)
+// Neuron populations that share at least one edge with another neuron population [query id => 23]
+async function queryAllConnectedPaths(flatmapAPI, knowledgeSource, featureId) {
+  const featureIds = Array.isArray(featureId) ? featureId : [featureId];
+  const queryId = featureIds[0].startsWith('ilxtr:') ? 23 : 1;
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: queryId,
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureIds
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations beginning at a location
+async function queryPathsByOrigin(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 1, // TODO: to update to a specific query ID for origins
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations via a location
+async function queryPathsByViaLocation(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 1, // TODO: to update to a specific query ID for via
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+// Neuron populations terminating at a location
+async function queryPathsByDestination(flatmapAPI, knowledgeSource, featureId) {
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 2,
+    parameters: [
+      {
+        column: 'feature_id',
+        value: featureId
+      },
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  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;
+  }
+  const data = await competencyQuery({
+    flatmapAPI: flatmapAPI,
+    knowledgeSource: knowledgeSource,
+    queryId: 24,
+    parameters: [
+      originParam,
+      viaParam,
+      destinationParam,
+    ]
+  });
+  if (data?.results?.values) {
+    const paths = data.results.values.map((value) => {
+      // value => [ 'source_id', 'path_id', 'axon_terminal']
+      return value[1];
+    });
+    // remove duplicates
+    return [...new Set(paths)];
+  }
+  return [];
+}
+
+export {
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+  queryPathsByRoute,
+};

package/src/components/CompetencyQueries/knowledgeQueries.js

@@ -0,0 +1,237 @@
+// origins = ilxtr:hasSomaLocatedIn
+// 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) &&
+    item.connectivity.length > 0 &&
+    Array.isArray(soma) &&
+    soma.length > 0;
+}
+
+function filterDestinations(item) {
+  const axonPresyn = item["node-phenotypes"]?.["ilxtr:hasAxonPresynapticElementIn"];
+  const axonSensory = item["node-phenotypes"]?.["ilxtr:hasAxonSensorySubcellularElementIn"];
+  const hasDest =
+    (Array.isArray(axonPresyn) && axonPresyn.length > 0) ||
+    (Array.isArray(axonSensory) && axonSensory.length > 0);
+  return Array.isArray(item.connectivity) &&
+    item.connectivity.length > 0 &&
+    hasDest;
+}
+
+function filterViaLocations(item) {
+  if (!Array.isArray(item.connectivity) || item.connectivity.length === 0) return false;
+
+  const origins = new Set(
+    (item["node-phenotypes"]?.["ilxtr:hasSomaLocatedIn"] || []).map(arr => arr[0])
+  );
+  const destinations = new Set([
+    ...((item["node-phenotypes"]?.["ilxtr:hasAxonPresynapticElementIn"] || []).map(arr => arr[0])),
+    ...((item["node-phenotypes"]?.["ilxtr:hasAxonSensorySubcellularElementIn"] || []).map(arr => arr[0]))
+  ]);
+
+  return item.connectivity.some(pair => {
+    const [from, to] = pair;
+    const fromId = from[0];
+    const toId = to[0];
+    return (
+      !origins.has(fromId) &&
+      !destinations.has(toId)
+    );
+  });
+}
+
+function getConnectivityItems(obj) {
+  if (!Array.isArray(obj.connectivity)) return [];
+  const items = new Set();
+
+  obj.connectivity.forEach((pair) => {
+    if (Array.isArray(pair) && pair.length) {
+      pair.forEach((endpoint) => {
+        if (Array.isArray(endpoint) && typeof endpoint[0] === 'string') {
+          const stringifyEndpoint = JSON.stringify(endpoint);
+          items.add(stringifyEndpoint);
+        }
+      });
+    }
+  });
+  return Array.from(items);
+}
+
+function getPhenotypeItems(obj, prop) {
+  const arr = obj["node-phenotypes"]?.[prop];
+  if (!Array.isArray(arr)) return [];
+  return arr;
+}
+
+async function transformResults(flatmapAPI, 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 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);
+      }
+    }
+    return {
+      key: item,
+      label: labels.join(', '),
+    };
+  });
+  return formattedResults;
+}
+
+async function extractOriginItems(flatmapAPI, knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    getPhenotypeItems(obj, "ilxtr:hasSomaLocatedIn").forEach((item) => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return await transformResults(flatmapAPI, results);
+}
+
+async function extractDestinationItems(flatmapAPI, knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonPresynapticElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonSensorySubcellularElementIn")
+    ].forEach(item => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return await transformResults(flatmapAPI, results);
+}
+
+async function extractViaItems(flatmapAPI, knowledge) {
+  const results = [];
+  knowledge.forEach(obj => {
+    if (!Array.isArray(obj.connectivity) || obj.connectivity.length === 0) return;
+    const connectivityItems = new Set(getConnectivityItems(obj));
+    [
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLeadingToSensorySubcellularElementIn"),
+      ...getPhenotypeItems(obj, "ilxtr:hasAxonLocatedIn")
+    ].forEach(item => {
+      const stringifyItem = JSON.stringify(item);
+      if (connectivityItems.has(stringifyItem)) results.push(item);
+    });
+  });
+  return await transformResults(flatmapAPI, results);
+}
+
+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 => originItems.map(i => JSON.stringify(i)).includes(JSON.stringify(item)));
+  });
+}
+
+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 => destinationItems.map(i => JSON.stringify(i)).includes(JSON.stringify(item)));
+  });
+}
+
+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 => 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,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
+}

package/src/components/index.js

@@ -8,6 +8,27 @@ import HelpModeDialog from "./HelpModeDialog/HelpModeDialog.vue";
 import Tooltip from "./Tooltip/Tooltip.vue";
 import TreeControls from "./TreeControls/TreeControls.vue";
 import ExternalResourceCard from "./Tooltip/ExternalResourceCard.vue";
+import {
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+  queryPathsByRoute,
+} from "./CompetencyQueries/CompetencyQueries.js";
+import {
+  filterOrigins,
+  filterDestinations,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
+} from "./CompetencyQueries/knowledgeQueries.js";
 
 export {
   AnnotationPopup,
@@ -20,4 +41,21 @@ export {
   Tooltip,
   TreeControls,
   ExternalResourceCard,
+  competencyQuery,
+  queryAllConnectedPaths,
+  queryPathsByOrigin,
+  queryPathsByViaLocation,
+  queryPathsByDestination,
+  queryPathsByRoute,
+  filterOrigins,
+  filterDestinations,
+  filterViaLocations,
+  extractOriginItems,
+  extractDestinationItems,
+  extractViaItems,
+  findPathsByOriginItem,
+  findPathsByDestinationItem,
+  findPathsByViaItem,
+  queryPathsByRouteFromKnowledge,
+  fetchLabels,
 };