@toxplanet/pegasus-sdk 1.2.8 → 1.2.9

package/lib/chemicals.js

@@ -8,6 +8,16 @@ 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, '\\$&');
 }
@@ -159,6 +169,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 = this._expandIdentifierAliases(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 out = {
+        meta_key: String(key).toLowerCase(),
+        meta_value_text: valueArr
+      };
+      const unit = item && (item.unit || item.meta_value_unit);
+      if (unit) out.meta_value_unit = unit;
+      return out;
+    });
+
+    const synonyms = Array.isArray(chemical.chemicalSynonyms) ? chemical.chemicalSynonyms : [];
+    const names = [chemical.chemicalName, ...synonyms].filter(Boolean);
+
+    return {
+      chemical_set_identifier: chemical.sourceId || '',
+      chemical_primary_name: chemical.chemicalName || '',
+      chemical_names: names,
+      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 {
@@ -1102,24 +1191,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 +1211,10 @@ class ChemicalsService {
           };
         }
 
+        const source = (params.index === 'chemical_data_index')
+          ? this._chemicalRowToCDISource(chemical)
+          : this._chemicalRowToLegacySource(chemical);
+
         return {
           body: {
             _index: params.index,

package/package.json

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