@toxplanet/pegasus-sdk 1.2.6 → 1.2.8

package/lib/chemicals.js

@@ -6,7 +6,7 @@ const SEARCH_BOOST_PREFIX_PRIMARY = 50;
 const SEARCH_BOOST_EXACT_SECONDARY = 30;
 const SEARCH_BOOST_PREFIX_SECONDARY = 10;
 
-const ALLOWED_IDENTIFIER_TYPES = new Set(['CAS', 'SMILES', 'InChI', 'InChIKey', 'PubChem', 'DTXSID', 'EINECS', 'EC']);
+const ALLOWED_IDENTIFIER_TYPES = new Set(['CAS', 'SMILES', 'InChI', 'InChIKey', 'PubChem', 'CID', 'DTXSID', 'EINECS', 'EC']);
 
 function escapeLikePattern(value) {
   return value.replace(/[%_\\]/g, '\\$&');
@@ -61,18 +61,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 {
@@ -94,6 +105,60 @@ class ChemicalsService {
     return d instanceof Date ? d.toISOString() : (d || new Date().toISOString());
   }
 
+  _toLegacyChemicalSource({ name = '', cas = [], identifiers = [], id = '', formula = null } = {}) {
+    return {
+      chemical_name: name,
+      chemical_name_sensitive: name,
+      chemical_name_sort: (name || '').toLowerCase(),
+      chemical_identifier: [...cas, ...identifiers],
+      chemical_set_identifier: cas[0] || id || '',
+      chemical_formula: formula
+    };
+  }
+
+  _chemicalRowToLegacySource(chemical) {
+    if (!chemical) return null;
+    const identifierObj = chemical.chemicalIdentifiers;
+    const cas = [];
+    const other = [];
+    let formula = null;
+
+    const visit = (type, value) => {
+      if (!type) return;
+      const values = Array.isArray(value) ? value : (value != null ? [value] : []);
+      const stringValues = values.map((v) => String(v)).filter((v) => v.length > 0);
+      if (type === 'CAS') {
+        cas.push(...stringValues);
+      } else if (type === 'formula' || type === 'Formula' || type === 'chemical_formula') {
+        if (formula == null && stringValues.length > 0) formula = stringValues[0];
+      } else {
+        other.push(...stringValues);
+      }
+    };
+
+    if (Array.isArray(identifierObj)) {
+      for (const item of identifierObj) {
+        if (item && typeof item === 'object') {
+          const type = item.type || item.identifier_key;
+          const value = item.value !== undefined ? item.value : item.identifier_value;
+          visit(type, value);
+        }
+      }
+    } else if (identifierObj && typeof identifierObj === 'object') {
+      for (const [type, value] of Object.entries(identifierObj)) {
+        visit(type, value);
+      }
+    }
+
+    return this._toLegacyChemicalSource({
+      name: chemical.chemicalName || '',
+      cas,
+      identifiers: other,
+      id: chemical.sourceId,
+      formula
+    });
+  }
+
   _mapChemicalRow(row) {
     if (!row) return null;
     return {
@@ -600,7 +665,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);
@@ -611,6 +676,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();
@@ -1006,9 +1101,25 @@ class ChemicalsService {
       },
     
       get: async (params) => {
-        const result = await this.getChemicalBySourceId(params.id);
+        const id = params.id;
+        let source = null;
 
-        if (!result) {
+        const chemical = await this.getChemicalBySourceId(id);
+        if (chemical) {
+          source = this._chemicalRowToLegacySource(chemical);
+        } else {
+          const hit = await this.findChemicalByIdentifier(id);
+          if (hit) {
+            source = this._toLegacyChemicalSource({
+              name: hit.name,
+              cas: hit.cas,
+              identifiers: hit.identifiers,
+              id: hit.id
+            });
+          }
+        }
+
+        if (!source) {
           return {
             body: {
               _index: params.index,
@@ -1025,7 +1136,7 @@ class ChemicalsService {
             _id: params.id,
             _version: 1,
             found: true,
-            _source: result
+            _source: source
           },
           statusCode: 200
         };
@@ -1088,12 +1199,11 @@ class ChemicalsService {
         let searchTerm = '';
         let limit = params.body?.size || 10;
         
-        const toLegacySource = (r) => ({
-          chemical_name: r.name,
-          chemical_name_sensitive: r.name,
-          chemical_name_sort: (r.name || '').toLowerCase(),
-          chemical_identifier: [...(r.cas || []), ...(r.identifiers || [])],
-          chemical_set_identifier: (r.cas && r.cas[0]) || r.id || ''
+        const toLegacySource = (r) => this._toLegacyChemicalSource({
+          name: r.name,
+          cas: r.cas || [],
+          identifiers: r.identifiers || [],
+          id: r.id
         });
 
         if (params.index === 'synonym_lookup_index') {

package/package.json

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