@toxplanet/pegasus-sdk 1.2.7 → 1.2.9

package/lib/chemicals.js

@@ -8,9 +8,15 @@ const SEARCH_BOOST_PREFIX_SECONDARY = 10;
 
 const ALLOWED_IDENTIFIER_TYPES = new Set(['CAS', 'SMILES', 'InChI', 'InChIKey', 'PubChem', 'CID', 'DTXSID', 'EINECS', 'EC']);
 
-const INCHIKEY_PATTERN = /^[A-Z0-9]{14}-[A-Z0-9]{8,10}-[A-Z0-9]$/;
-const EC_PATTERN = /^\d{3}-\d{3}-\d$/;
-const CID_PATTERN = /^CID/i;
+// 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, '\\$&');
@@ -65,18 +71,29 @@ function transformChemicalMeta(meta) {
 
 function transformChemicalIdentifiers(identifiers) {
   if (!identifiers || typeof identifiers !== 'object') return [];
+
   if (Array.isArray(identifiers)) {
-    // If it's already in new format, return as-is
-    if (identifiers.length > 0 && identifiers[0].type !== undefined) {
-      return identifiers;
-    }
-    // Transform from old format { identifier_key, identifier_value, ... } to new format { type, value }
+    if (identifiers.length === 0) return [];
+    if (identifiers[0].type !== undefined) return identifiers;
+    // Legacy { identifier_key, identifier_value } row form
     return identifiers.map(item => ({
       type: item.identifier_key || item.type,
       value: Array.isArray(item.identifier_value) ? item.identifier_value[0] : (item.value || item.identifier_value)
     }));
   }
-  return [];
+
+  // Legacy ES-doc form: { CAS: ["71-43-2"], CID: ["241"], InChIKey: "ABC..." }
+  // Flatten one entry per value, preserving multi-valued types.
+  const result = [];
+  for (const [type, value] of Object.entries(identifiers)) {
+    if (value == null) continue;
+    const values = Array.isArray(value) ? value : [value];
+    for (const v of values) {
+      if (v == null || v === '') continue;
+      result.push({ type, value: String(v) });
+    }
+  }
+  return result;
 }
 
 class ChemicalsService {
@@ -152,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 {
@@ -658,7 +754,7 @@ class ChemicalsService {
       }
 
       await this.connection.ensureConnected();
-      
+
       const sql = `SELECT * FROM chemicals WHERE chemical_identifiers->>'${identifierType}' = :value OR chemical_identifiers->'${identifierType}' ? :value`;
       const params = [{ name: 'value', value: { stringValue: identifierValue } }];
       const result = await this.connection.query(sql, params);
@@ -669,6 +765,36 @@ class ChemicalsService {
     }
   }
 
+  async findChemicalByIdentifier(identifierValue) {
+    if (!identifierValue) return null;
+    const result = await this.connection.invokeOpenSearch({
+      operation: 'search',
+      body: {
+        size: 1,
+        query: {
+          bool: {
+            should: [
+              { term: { 'cas_numbers.keyword': identifierValue } },
+              { term: { 'identifier_values.keyword': identifierValue } }
+            ],
+            minimum_should_match: 1
+          }
+        },
+        _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+      }
+    });
+
+    const hit = result?.hits?.hits?.[0]?._source;
+    if (!hit) return null;
+    return {
+      id: hit.postgres_id,
+      name: hit.chemical_name,
+      cas: hit.cas_numbers || [],
+      identifiers: hit.identifier_values || [],
+      synonyms: hit.synonyms || []
+    };
+  }
+
   async countByCollection(collectionName) {
     try {
       await this.connection.ensureConnected();
@@ -1068,22 +1194,9 @@ class ChemicalsService {
         let chemical = await this.getChemicalBySourceId(id);
 
         if (!chemical) {
-          const casMatches = await this.getChemicalsByCAS(id);
-          if (casMatches.length > 0) chemical = casMatches[0];
-        }
-
-        if (!chemical) {
-          let identifierType = null;
-          if (CID_PATTERN.test(id)) {
-            identifierType = 'CID';
-          } else if (INCHIKEY_PATTERN.test(id)) {
-            identifierType = 'InChIKey';
-          } else if (EC_PATTERN.test(id)) {
-            identifierType = 'EC';
-          }
-          if (identifierType) {
-            const matches = await this.getChemicalsByIdentifier(identifierType, id);
-            if (matches.length > 0) chemical = matches[0];
+          const hit = await this.findChemicalByIdentifier(id);
+          if (hit && hit.id) {
+            chemical = await this.getChemicalById(hit.id);
           }
         }
 
@@ -1098,13 +1211,17 @@ class ChemicalsService {
           };
         }
 
+        const source = (params.index === 'chemical_data_index')
+          ? this._chemicalRowToCDISource(chemical)
+          : this._chemicalRowToLegacySource(chemical);
+
         return {
           body: {
             _index: params.index,
             _id: params.id,
             _version: 1,
             found: true,
-            _source: this._chemicalRowToLegacySource(chemical)
+            _source: source
           },
           statusCode: 200
         };

package/package.json

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