@toxplanet/pegasus-sdk 1.2.8 → 1.2.11

package/lib/chemicals.js

@@ -1,5 +1,6 @@
 const { logError, logInfo } = require('@toxplanet/tphelper/logging');
 const { SQSClient, SendMessageCommand } = require('@aws-sdk/client-sqs');
+const { getCasNumberVariations } = require('./search');
 
 const SEARCH_BOOST_EXACT_PRIMARY = 100;
 const SEARCH_BOOST_PREFIX_PRIMARY = 50;
@@ -8,11 +9,22 @@ const SEARCH_BOOST_PREFIX_SECONDARY = 10;
 
 const ALLOWED_IDENTIFIER_TYPES = new Set(['CAS', 'SMILES', 'InChI', 'InChIKey', 'PubChem', 'CID', 'DTXSID', 'EINECS', 'EC']);
 
+// Equivalence groups for CDI identifier_key normalization. When any member of
+// a group is present on a row, the others are backfilled with the same values
+// so consumers can look up by their preferred spelling.
+const IDENTIFIER_ALIAS_GROUPS = [
+  { keys: ['cid', 'pubchem_cid', 'pubchem'], names: { cid: 'CID', pubchem_cid: 'PubChem CID', pubchem: 'PubChem' } },
+  { keys: ['inchikey', 'inchi_key'],         names: { inchikey: 'InChIKey', inchi_key: 'InChIKey' } },
+  { keys: ['ec', 'ec_number'],               names: { ec: 'EC', ec_number: 'EC Number' } },
+  { keys: ['cas', 'cas_number', 'cas_rn'],   names: { cas: 'CAS', cas_number: 'CAS Number', cas_rn: 'CAS RN' } }
+];
+
 function escapeLikePattern(value) {
   return value.replace(/[%_\\]/g, '\\$&');
 }
 
 function parsePostgresArray(str) {
+  if (Array.isArray(str)) return str.map((v) => String(v));
   if (!str || str === '{}') return [];
   const trimmed = str.slice(1, -1);
   if (!trimmed) return [];
@@ -159,6 +171,85 @@ class ChemicalsService {
     });
   }
 
+  _expandIdentifierAliases(identifiers) {
+    const byKey = new Map(identifiers.map((i) => [i.identifier_key, i]));
+    const additions = [];
+    for (const group of IDENTIFIER_ALIAS_GROUPS) {
+      const present = group.keys.find((k) => byKey.has(k));
+      if (!present) continue;
+      const source = byKey.get(present);
+      for (const aliasKey of group.keys) {
+        if (byKey.has(aliasKey)) continue;
+        const alias = {
+          identifier_key: aliasKey,
+          identifier_name: group.names[aliasKey] || aliasKey,
+          identifier_value: [...source.identifier_value]
+        };
+        additions.push(alias);
+        byKey.set(aliasKey, alias);
+      }
+    }
+    return identifiers.concat(additions);
+  }
+
+  _chemicalRowToCDISource(chemical) {
+    if (!chemical) return null;
+
+    const identifierGroups = new Map();
+    const identifierList = Array.isArray(chemical.chemicalIdentifiers) ? chemical.chemicalIdentifiers : [];
+    for (const item of identifierList) {
+      if (!item || typeof item !== 'object') continue;
+      const type = item.type || item.identifier_key || '';
+      if (!type) continue;
+      const rawValue = item.value !== undefined ? item.value : item.identifier_value;
+      const values = Array.isArray(rawValue) ? rawValue : (rawValue != null ? [rawValue] : []);
+      if (!identifierGroups.has(type)) {
+        identifierGroups.set(type, {
+          identifier_key: String(type).toLowerCase(),
+          identifier_name: String(type),
+          identifier_value: []
+        });
+      }
+      const group = identifierGroups.get(type);
+      for (const v of values) {
+        if (v == null || v === '') continue;
+        group.identifier_value.push(String(v));
+      }
+    }
+    const identifiers = Array.from(identifierGroups.values());
+
+    const metaList = Array.isArray(chemical.chemicalMeta) ? chemical.chemicalMeta : [];
+    const meta = metaList.map((item) => {
+      const key = (item && (item.key || item.meta_key)) || '';
+      const rawValue = item && (item.value !== undefined ? item.value : item.meta_value_text);
+      const valueArr = Array.isArray(rawValue)
+        ? rawValue.map((v) => String(v))
+        : (rawValue != null ? [String(rawValue)] : []);
+      const unit = item && (item.unit || item.meta_value_unit);
+      if (unit && valueArr.length > 0) {
+        valueArr[valueArr.length - 1] = `${valueArr[valueArr.length - 1]} ${unit}`;
+      }
+      return {
+        meta_key: String(key).toLowerCase(),
+        meta_value_text: valueArr
+      };
+    });
+
+    const synonyms = Array.isArray(chemical.chemicalSynonyms) ? chemical.chemicalSynonyms : [];
+
+    return {
+      chemical_set_identifier: chemical.sourceId || '',
+      chemical_primary_name: chemical.chemicalName || '',
+      chemical_names: synonyms,
+      chemical_synonyms: synonyms,
+      chemical_categories: chemical.chemicalCategories || [],
+      chemical_identifiers: identifiers,
+      chemical_meta: meta,
+      chemical_created_at: chemical.createdAt,
+      chemical_updated_at: chemical.updatedAt
+    };
+  }
+
   _mapChemicalRow(row) {
     if (!row) return null;
     return {
@@ -833,22 +924,32 @@ class ChemicalsService {
     }
 
     try {
+      const variations = getCasNumberVariations(searchTerm);
+      const shouldClauses = [];
+      for (const v of variations) {
+        shouldClauses.push(
+          { term: { 'chemical_name.keyword': { value: v, boost: SEARCH_BOOST_EXACT_PRIMARY, case_insensitive: true } } },
+          { prefix: { 'chemical_name.keyword': { value: v, boost: SEARCH_BOOST_PREFIX_PRIMARY, case_insensitive: true } } },
+          { term: { 'synonyms.keyword': { value: v, boost: SEARCH_BOOST_EXACT_SECONDARY, case_insensitive: true } } },
+          { prefix: { 'synonyms.keyword': { value: v, boost: SEARCH_BOOST_PREFIX_SECONDARY, case_insensitive: true } } },
+          { term: { 'cas_numbers': { value: v, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
+          { prefix: { 'cas_numbers': { value: v, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
+          { term: { 'identifier_values': { value: v, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
+          { prefix: { 'identifier_values': { value: v, boost: SEARCH_BOOST_PREFIX_SECONDARY } } },
+          { match: { 'chemical_name': { query: v, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
+          { match: { 'synonyms': { query: v, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
+          { match_phrase_prefix: { 'chemical_name': { query: v, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
+          { match_phrase_prefix: { 'synonyms': { query: v, boost: SEARCH_BOOST_PREFIX_SECONDARY } } }
+        );
+      }
+
       const result = await this.connection.invokeOpenSearch({
         operation: 'search',
         body: {
           size: limit,
           query: {
             bool: {
-              should: [
-                { term: { 'chemical_name.keyword': { value: searchTerm, boost: SEARCH_BOOST_EXACT_PRIMARY, case_insensitive: true } } },
-                { prefix: { 'chemical_name.keyword': { value: searchTerm, boost: SEARCH_BOOST_PREFIX_PRIMARY, case_insensitive: true } } },
-                { term: { 'synonyms.keyword': { value: searchTerm, boost: SEARCH_BOOST_EXACT_SECONDARY, case_insensitive: true } } },
-                { prefix: { 'synonyms.keyword': { value: searchTerm, boost: SEARCH_BOOST_PREFIX_SECONDARY, case_insensitive: true } } },
-                { match: { 'chemical_name': { query: searchTerm, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
-                { match: { 'synonyms': { query: searchTerm, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
-                { match_phrase_prefix: { 'chemical_name': { query: searchTerm, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
-                { match_phrase_prefix: { 'synonyms': { query: searchTerm, boost: SEARCH_BOOST_PREFIX_SECONDARY } } }
-              ],
+              should: shouldClauses,
               minimum_should_match: 1
             }
           },
@@ -888,22 +989,32 @@ class ChemicalsService {
     }
 
     try {
+      const variations = getCasNumberVariations(synonymTerm);
+      const shouldClauses = [];
+      for (const v of variations) {
+        shouldClauses.push(
+          { term: { 'synonyms.keyword': { value: v, boost: SEARCH_BOOST_EXACT_PRIMARY, case_insensitive: true } } },
+          { prefix: { 'synonyms.keyword': { value: v, boost: SEARCH_BOOST_PREFIX_PRIMARY, case_insensitive: true } } },
+          { term: { 'chemical_name.keyword': { value: v, boost: SEARCH_BOOST_EXACT_SECONDARY, case_insensitive: true } } },
+          { prefix: { 'chemical_name.keyword': { value: v, boost: SEARCH_BOOST_PREFIX_SECONDARY, case_insensitive: true } } },
+          { term: { 'cas_numbers': { value: v, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
+          { prefix: { 'cas_numbers': { value: v, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
+          { term: { 'identifier_values': { value: v, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
+          { prefix: { 'identifier_values': { value: v, boost: SEARCH_BOOST_PREFIX_SECONDARY } } },
+          { match: { 'synonyms': { query: v, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
+          { match: { 'chemical_name': { query: v, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
+          { match_phrase_prefix: { 'synonyms': { query: v, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
+          { match_phrase_prefix: { 'chemical_name': { query: v, boost: SEARCH_BOOST_PREFIX_SECONDARY } } }
+        );
+      }
+
       const result = await this.connection.invokeOpenSearch({
         operation: 'search',
         body: {
           size: limit,
           query: {
             bool: {
-              should: [
-                { term: { 'synonyms.keyword': { value: synonymTerm, boost: SEARCH_BOOST_EXACT_PRIMARY, case_insensitive: true } } },
-                { prefix: { 'synonyms.keyword': { value: synonymTerm, boost: SEARCH_BOOST_PREFIX_PRIMARY, case_insensitive: true } } },
-                { term: { 'chemical_name.keyword': { value: synonymTerm, boost: SEARCH_BOOST_EXACT_SECONDARY, case_insensitive: true } } },
-                { prefix: { 'chemical_name.keyword': { value: synonymTerm, boost: SEARCH_BOOST_PREFIX_SECONDARY, case_insensitive: true } } },
-                { match: { 'synonyms': { query: synonymTerm, boost: SEARCH_BOOST_EXACT_PRIMARY } } },
-                { match: { 'chemical_name': { query: synonymTerm, boost: SEARCH_BOOST_EXACT_SECONDARY } } },
-                { match_phrase_prefix: { 'synonyms': { query: synonymTerm, boost: SEARCH_BOOST_PREFIX_PRIMARY } } },
-                { match_phrase_prefix: { 'chemical_name': { query: synonymTerm, boost: SEARCH_BOOST_PREFIX_SECONDARY } } }
-              ],
+              should: shouldClauses,
               minimum_should_match: 1
             }
           },
@@ -1102,24 +1213,16 @@ class ChemicalsService {
     
       get: async (params) => {
         const id = params.id;
-        let source = null;
+        let chemical = await this.getChemicalBySourceId(id);
 
-        const chemical = await this.getChemicalBySourceId(id);
-        if (chemical) {
-          source = this._chemicalRowToLegacySource(chemical);
-        } else {
+        if (!chemical) {
           const hit = await this.findChemicalByIdentifier(id);
-          if (hit) {
-            source = this._toLegacyChemicalSource({
-              name: hit.name,
-              cas: hit.cas,
-              identifiers: hit.identifiers,
-              id: hit.id
-            });
+          if (hit && hit.id) {
+            chemical = await this.getChemicalById(hit.id);
           }
         }
 
-        if (!source) {
+        if (!chemical) {
           return {
             body: {
               _index: params.index,
@@ -1130,6 +1233,10 @@ class ChemicalsService {
           };
         }
 
+        const source = (params.index === 'chemical_data_index')
+          ? this._chemicalRowToCDISource(chemical)
+          : this._chemicalRowToLegacySource(chemical);
+
         return {
           body: {
             _index: params.index,

package/lib/db/index.js

@@ -4,6 +4,16 @@ function getFieldValue(field) {
   if ('longValue' in field) return field.longValue;
   if ('doubleValue' in field) return field.doubleValue;
   if ('booleanValue' in field) return field.booleanValue;
+  if ('blobValue' in field) return field.blobValue;
+  if ('arrayValue' in field && field.arrayValue) {
+    const av = field.arrayValue;
+    if (Array.isArray(av.stringValues)) return av.stringValues;
+    if (Array.isArray(av.longValues)) return av.longValues;
+    if (Array.isArray(av.doubleValues)) return av.doubleValues;
+    if (Array.isArray(av.booleanValues)) return av.booleanValues;
+    if (Array.isArray(av.arrayValues)) return av.arrayValues;
+    return [];
+  }
   return null;
 }
 

package/lib/search.js

@@ -383,3 +383,4 @@ class SearchService {
 }
 
 module.exports = SearchService;
+module.exports.getCasNumberVariations = getCasNumberVariations;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.2.8",
+  "version": "1.2.11",
   "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
   "type": "commonjs",