@toxplanet/pegasus-sdk 1.0.1 → 1.1.0

package/lib/search.js

@@ -1,307 +1,336 @@
-const { logInfo, logError } = require('@toxplanet/tphelper/logging');
-
-/**
- * Detect if query looks like a CAS number (numbers with - or / separators)
- * Returns array of alternative formats to try
- * 
- * CAS format: XXXXXXX-XX-X (registry-sequence-check)
- * - First part: 2-7 digits (registry number)
- * - Second part: ALWAYS 2 digits (zero-padded)
- * - Third part: ALWAYS 1 digit (check digit)
- */
-function getCasNumberVariations(query) {
-  // Check if it's all numbers and separators (-, /)
-  if (!/^[\d\-\/]+$/.test(query)) {
-    return [query]; // Not a CAS-like format, return as-is
-  }
-  
-  // Check if it has at least one separator
-  if (!query.includes('-') && !query.includes('/')) {
-    return [query]; // No separator, return as-is
-  }
-  
-  // Generate variations
-  const variations = new Set();
-  
-  // Add original
-  variations.add(query);
-  
-  // Split by any separator
-  const parts = query.split(/[-\/]/);
-  
-  if (parts.length === 3) {
-    // Three parts detected
-    // Could be:
-    // 1. Standard: registry-sequence-check (e.g., "7440-06-4")
-    // 2. Reversed: sequence/check/registry (e.g., "6/4/7440")
-    
-    const [part1, part2, part3] = parts;
-    
-    // Check if it looks like reversed format
-    // (small first part, small second part, large third part)
-    const isLikelyReversed = part1.length <= 2 && part2.length <= 2 && part3.length >= 3;
-    
-    if (isLikelyReversed) {
-      // Format: sequence/check/registry → registry-sequence-check
-      const registry = part3;
-      const sequence = part1.padStart(2, '0'); // Zero-pad to 2 digits
-      const check = part2;
-      
-      // Add properly formatted CAS
-      variations.add(`${registry}-${sequence}-${check}`);
-      variations.add(`${registry}/${sequence}/${check}`);
-    } else {
-      // Looks like standard format, try both separators
-      const registry = part1;
-      const sequence = part2.padStart(2, '0'); // Ensure 2 digits
-      const check = part3;
-      
-      variations.add(`${registry}-${sequence}-${check}`);
-      variations.add(`${registry}/${sequence}/${check}`);
-    }
-    
-    // Also try with different separator on original parts
-    variations.add(parts.join('-'));
-    variations.add(parts.join('/'));
-  } else if (parts.length === 2) {
-    // Two parts - just try both separators
-    variations.add(parts.join('-'));
-    variations.add(parts.join('/'));
-  }
-  
-  return Array.from(variations);
-}
-
-class SearchService {
-  constructor(connection) {
-    this.connection = connection;
-  }
-
-  /**
-   * Search chemicals using OpenSearch with configurable boost parameters
-   * @param {string} query - Search query string
-   * @param {Object} options - Search options
-   * @param {number} options.limit - Maximum number of results (default: 10)
-   * @param {number} options.casExact - Boost for exact CAS matches (default: 50)
-   * @param {number} options.casPrefix - Boost for CAS prefix matches (default: 10)
-   * @param {number} options.nameExact - Boost for exact name matches (default: 40)
-   * @param {number} options.namePrefix - Boost for name prefix matches (default: 8)
-   * @param {number} options.identifierExact - Boost for exact identifier matches (default: 30)
-   * @param {number} options.identifierPrefix - Boost for identifier prefix matches (default: 5)
-   * @param {number} options.synonymExact - Boost for exact synonym matches (default: 100)
-   * @param {number} options.synonymPrefix - Boost for synonym prefix matches (default: 3)
-   * @returns {Promise<Object>} Search results with chemicals array
-   */
-  async searchChemicals(query, options = {}) {
-    if (!query) {
-      return { results: [] };
-    }
-
-    // Extract options with defaults
-    const limit = options.limit || 10;
-    const casExact = options.casExact !== undefined ? options.casExact : 50;
-    const casPrefix = options.casPrefix !== undefined ? options.casPrefix : 10;
-    const nameExact = options.nameExact !== undefined ? options.nameExact : 40;
-    const namePrefix = options.namePrefix !== undefined ? options.namePrefix : 8;
-    const identifierExact = options.identifierExact !== undefined ? options.identifierExact : 30;
-    const identifierPrefix = options.identifierPrefix !== undefined ? options.identifierPrefix : 5;
-    const synonymExact = options.synonymExact !== undefined ? options.synonymExact : 100;
-    const synonymPrefix = options.synonymPrefix !== undefined ? options.synonymPrefix : 3;
-
-    try {
-      const opensearchClient = this.connection.getOpenSearchClient();
-      
-      // Get CAS number variations (if applicable)
-      const queryVariations = getCasNumberVariations(query);
-      
-      // Log if we're trying multiple variations
-      if (queryVariations.length > 1) {
-        logInfo('pegasus-sdk', `CAS format detection: trying ${queryVariations.length} variations for "${query}": ${JSON.stringify(queryVariations)}`);
-      }
-      
-      // Build should clauses for all query variations
-      const shouldClauses = [];
-      
-      for (const queryVariation of queryVariations) {
-        // Exact matches (configurable priority)
-        shouldClauses.push(
-          { term: { 'cas_numbers': { value: queryVariation, boost: casExact } } },
-          { term: { 'chemical_name.keyword': { value: queryVariation, boost: nameExact, case_insensitive: true } } },
-          { term: { 'identifier_values': { value: queryVariation, boost: identifierExact } } },
-          { term: { 'synonyms.keyword': { value: queryVariation, boost: synonymExact, case_insensitive: true } } },
-          // Prefix matches (configurable priority)
-          { prefix: { 'cas_numbers': { value: queryVariation, boost: casPrefix } } },
-          { prefix: { 'chemical_name.keyword': { value: queryVariation, boost: namePrefix, case_insensitive: true } } },
-          { prefix: { 'identifier_values': { value: queryVariation, boost: identifierPrefix } } },
-          { prefix: { 'synonyms.keyword': { value: queryVariation, boost: synonymPrefix, case_insensitive: true } } }
-        );
-      }
-      
-      const indexName = this.connection.getOpenSearchIndex();
-      
-      const response = await opensearchClient.search({
-        index: indexName,
-        body: {
-          size: limit,
-          query: {
-            bool: {
-              should: shouldClauses,
-              minimum_should_match: 1
-            }
-          },
-          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
-        }
-      });
-
-      const hits = response.body?.hits?.hits || [];
-      const results = hits.map((hit) => ({
-        id: hit._source.postgres_id,
-        name: hit._source.chemical_name,
-        cas: hit._source.cas_numbers || [],
-        identifiers: hit._source.identifier_values || [],
-        synonyms: hit._source.synonyms || [],
-        score: hit._score
-      }));
-
-      return { results };
-    } catch (error) {
-      logError('pegasus-sdk', 'SearchService', 'searchChemicals', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Search for chemicals with prefix matching priority
-   * @param {string} searchTerm - Search term
-   * @param {number} limit - Maximum number of results (default: 10)
-   * @returns {Promise<Object>} Search results
-   */
-  async searchStartsWith(searchTerm, limit = 10) {
-    return this.searchChemicals(searchTerm, {
-      limit,
-      // Prioritize prefix matches over exact matches
-      casPrefix: 50,
-      casExact: 20,
-      namePrefix: 40,
-      nameExact: 15,
-      identifierPrefix: 30,
-      identifierExact: 10,
-      synonymPrefix: 35,
-      synonymExact: 10
-    });
-  }
-
-  /**
-   * Search for chemicals (alias for general search)
-   * @param {string} searchTerm - Search term
-   * @param {number} limit - Maximum number of results (default: 10)
-   * @returns {Promise<Object>} Search results
-   */
-  async searchContains(searchTerm, limit = 10) {
-    // Use default balanced weights for contains search
-    return this.searchChemicals(searchTerm, { limit });
-  }
-
-  /**
-   * Search for chemicals with exact matching priority
-   * @param {string} searchTerm - Search term
-   * @param {number} limit - Maximum number of results (default: 10)
-   * @returns {Promise<Object>} Search results
-   */
-  async searchExact(searchTerm, limit = 10) {
-    return this.searchChemicals(searchTerm, {
-      limit,
-      // Prioritize exact matches, minimize prefix matches
-      casExact: 100,
-      casPrefix: 1,
-      nameExact: 80,
-      namePrefix: 1,
-      identifierExact: 60,
-      identifierPrefix: 1,
-      synonymExact: 150,
-      synonymPrefix: 1
-    });
-  }
-
-  /**
-   * Search for chemicals by CAS number
-   * @param {string} casNumber - CAS number to search for
-   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
-   * @returns {Promise<Object>} Search results
-   */
-  async searchByCAS(casNumber, searchType = 'exact') {
-    const isExact = searchType === 'exact';
-    return this.searchChemicals(casNumber, {
-      limit: 10,
-      // Heavily prioritize CAS field
-      casExact: isExact ? 200 : 50,
-      casPrefix: isExact ? 10 : 100,
-      nameExact: 5,
-      namePrefix: 1,
-      identifierExact: 5,
-      identifierPrefix: 1,
-      synonymExact: 5,
-      synonymPrefix: 1
-    });
-  }
-
-  /**
-   * Search for chemicals by identifier value
-   * @param {string} identifierValue - Identifier value to search for
-   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
-   * @returns {Promise<Object>} Search results
-   */
-  async searchByIdentifier(identifierValue, searchType = 'exact') {
-    const isExact = searchType === 'exact';
-    return this.searchChemicals(identifierValue, {
-      limit: 10,
-      // Heavily prioritize identifier field
-      identifierExact: isExact ? 200 : 50,
-      identifierPrefix: isExact ? 10 : 100,
-      casExact: 10,
-      casPrefix: 5,
-      nameExact: 5,
-      namePrefix: 1,
-      synonymExact: 5,
-      synonymPrefix: 1
-    });
-  }
-
-  /**
-   * Search for chemicals by synonym
-   * @param {string} synonymTerm - Synonym term to search for
-   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
-   * @returns {Promise<Object>} Search results
-   */
-  async searchBySynonym(synonymTerm, searchType = 'exact') {
-    const isExact = searchType === 'exact';
-    return this.searchChemicals(synonymTerm, {
-      limit: 10,
-      // Heavily prioritize synonym field
-      synonymExact: isExact ? 200 : 50,
-      synonymPrefix: isExact ? 10 : 100,
-      nameExact: 20,
-      namePrefix: 5,
-      casExact: 10,
-      casPrefix: 5,
-      identifierExact: 5,
-      identifierPrefix: 1
-    });
-  }
-
-  async advancedSearch(queryBuilder) {}
-
-  async searchWithFilters(searchTerm, filters, limit) {}
-
-  async searchByCollection(collectionName, searchTerm, limit) {}
-
-  async aggregateByCategory() {}
-
-  async aggregateByIdentifierType() {}
-
-  async getSearchSuggestions(partialTerm, limit) {}
-
-  async findSimilarChemicals(chemicalId, limit) {}
-}
-
-module.exports = SearchService;
+const { logInfo, logError } = require('@toxplanet/tphelper/logging');
+
+/**
+ * Detect if query looks like a CAS number (numbers with - or / separators)
+ * Returns array of alternative formats to try
+ * 
+ * CAS format: XXXXXXX-XX-X (registry-sequence-check)
+ * - First part: 2-7 digits (registry number)
+ * - Second part: ALWAYS 2 digits (zero-padded)
+ * - Third part: ALWAYS 1 digit (check digit)
+ */
+function getCasNumberVariations(query) {
+  // Check if it's all numbers and separators (-, /)
+  if (!/^[\d\-\/]+$/.test(query)) {
+    return [query]; // Not a CAS-like format, return as-is
+  }
+  
+  // Check if it has at least one separator
+  if (!query.includes('-') && !query.includes('/')) {
+    return [query]; // No separator, return as-is
+  }
+  
+  // Generate variations
+  const variations = new Set();
+  
+  // Add original
+  variations.add(query);
+  
+  // Split by any separator
+  const parts = query.split(/[-\/]/);
+  
+  if (parts.length === 3) {
+    // Three parts detected
+    // Could be:
+    // 1. Standard: registry-sequence-check (e.g., "7440-06-4")
+    // 2. Reversed: sequence/check/registry (e.g., "6/4/7440")
+    
+    const [part1, part2, part3] = parts;
+    
+    // Check if it looks like reversed format
+    // (small first part, small second part, large third part)
+    const isLikelyReversed = part1.length <= 2 && part2.length <= 2 && part3.length >= 3;
+    
+    if (isLikelyReversed) {
+      // Format: sequence/check/registry → registry-sequence-check
+      const registry = part3;
+      const sequence = part1.padStart(2, '0'); // Zero-pad to 2 digits
+      const check = part2;
+      
+      // Add properly formatted CAS
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    } else {
+      // Looks like standard format, try both separators
+      const registry = part1;
+      const sequence = part2.padStart(2, '0'); // Ensure 2 digits
+      const check = part3;
+      
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    }
+    
+    // Also try with different separator on original parts
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  } else if (parts.length === 2) {
+    // Two parts - just try both separators
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  }
+  
+  return Array.from(variations);
+}
+
+class SearchService {
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Search chemicals using OpenSearch with configurable boost parameters
+   * @param {string} query - Search query string
+   * @param {Object} options - Search options
+   * @param {number} options.limit - Maximum number of results (default: 10)
+   * @param {number} options.casExact - Boost for exact CAS matches (default: 50)
+   * @param {number} options.casPrefix - Boost for CAS prefix matches (default: 10)
+   * @param {number} options.nameExact - Boost for exact name matches (default: 40)
+   * @param {number} options.namePrefix - Boost for name prefix matches (default: 8)
+   * @param {number} options.identifierExact - Boost for exact identifier matches (default: 30)
+   * @param {number} options.identifierPrefix - Boost for identifier prefix matches (default: 5)
+   * @param {number} options.synonymExact - Boost for exact synonym matches (default: 100)
+   * @param {number} options.synonymPrefix - Boost for synonym prefix matches (default: 3)
+   * @returns {Promise<Object>} Search results with chemicals array
+   */
+  async searchChemicals(query, options = {}) {
+    if (!query) {
+      return { results: [] };
+    }
+
+    // Extract options with defaults
+    const limit = options.limit || 10;
+    const casExact = options.casExact !== undefined ? options.casExact : 50;
+    const casPrefix = options.casPrefix !== undefined ? options.casPrefix : 10;
+    const nameExact = options.nameExact !== undefined ? options.nameExact : 40;
+    const namePrefix = options.namePrefix !== undefined ? options.namePrefix : 8;
+    const identifierExact = options.identifierExact !== undefined ? options.identifierExact : 30;
+    const identifierPrefix = options.identifierPrefix !== undefined ? options.identifierPrefix : 5;
+    const synonymExact = options.synonymExact !== undefined ? options.synonymExact : 100;
+    const synonymPrefix = options.synonymPrefix !== undefined ? options.synonymPrefix : 3;
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      
+      // Get CAS number variations (if applicable)
+      const queryVariations = getCasNumberVariations(query);
+      
+      // Log if we're trying multiple variations
+      if (queryVariations.length > 1) {
+        logInfo('pegasus-sdk', `CAS format detection: trying ${queryVariations.length} variations for "${query}": ${JSON.stringify(queryVariations)}`);
+      }
+      
+      // Build should clauses for all query variations
+      const shouldClauses = [];
+      
+      for (const queryVariation of queryVariations) {
+        // Exact matches (configurable priority)
+        shouldClauses.push(
+          { term: { 'cas_numbers': { value: queryVariation, boost: casExact } } },
+          { term: { 'chemical_name.keyword': { value: queryVariation, boost: nameExact, case_insensitive: true } } },
+          { term: { 'identifier_values': { value: queryVariation, boost: identifierExact } } },
+          { term: { 'synonyms.keyword': { value: queryVariation, boost: synonymExact, case_insensitive: true } } },
+          // Prefix matches (configurable priority)
+          { prefix: { 'cas_numbers': { value: queryVariation, boost: casPrefix } } },
+          { prefix: { 'chemical_name.keyword': { value: queryVariation, boost: namePrefix, case_insensitive: true } } },
+          { prefix: { 'identifier_values': { value: queryVariation, boost: identifierPrefix } } },
+          { prefix: { 'synonyms.keyword': { value: queryVariation, boost: synonymPrefix, case_insensitive: true } } }
+        );
+      }
+      
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: shouldClauses,
+              minimum_should_match: 1
+            }
+          },
+          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+        }
+      });
+
+      const hits = response.body?.hits?.hits || [];
+      const results = hits.map((hit) => ({
+        id: hit._source.postgres_id,
+        name: hit._source.chemical_name,
+        cas: hit._source.cas_numbers || [],
+        identifiers: hit._source.identifier_values || [],
+        synonyms: hit._source.synonyms || [],
+        score: hit._score
+      }));
+
+      return { results };
+    } catch (error) {
+      logError('pegasus-sdk', 'SearchService', 'searchChemicals', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Search for chemicals with prefix matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchStartsWith(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize prefix matches over exact matches
+      casPrefix: 50,
+      casExact: 20,
+      namePrefix: 40,
+      nameExact: 15,
+      identifierPrefix: 30,
+      identifierExact: 10,
+      synonymPrefix: 35,
+      synonymExact: 10
+    });
+  }
+
+  /**
+   * Search for chemicals (alias for general search)
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchContains(searchTerm, limit = 10) {
+    // Use default balanced weights for contains search
+    return this.searchChemicals(searchTerm, { limit });
+  }
+
+  /**
+   * Search for chemicals with exact matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchExact(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize exact matches, minimize prefix matches
+      casExact: 100,
+      casPrefix: 1,
+      nameExact: 80,
+      namePrefix: 1,
+      identifierExact: 60,
+      identifierPrefix: 1,
+      synonymExact: 150,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by CAS number
+   * @param {string} casNumber - CAS number to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByCAS(casNumber, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(casNumber, {
+      limit: 10,
+      // Heavily prioritize CAS field
+      casExact: isExact ? 200 : 50,
+      casPrefix: isExact ? 10 : 100,
+      nameExact: 5,
+      namePrefix: 1,
+      identifierExact: 5,
+      identifierPrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by identifier value
+   * @param {string} identifierValue - Identifier value to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByIdentifier(identifierValue, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(identifierValue, {
+      limit: 10,
+      // Heavily prioritize identifier field
+      identifierExact: isExact ? 200 : 50,
+      identifierPrefix: isExact ? 10 : 100,
+      casExact: 10,
+      casPrefix: 5,
+      nameExact: 5,
+      namePrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
+
+  /**
+   * Search for chemicals by synonym
+   * @param {string} synonymTerm - Synonym term to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchBySynonym(synonymTerm, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(synonymTerm, {
+      limit: 10,
+      // Heavily prioritize synonym field
+      synonymExact: isExact ? 200 : 50,
+      synonymPrefix: isExact ? 10 : 100,
+      nameExact: 20,
+      namePrefix: 5,
+      casExact: 10,
+      casPrefix: 5,
+      identifierExact: 5,
+      identifierPrefix: 1
+    });
+  }
+
+  async advancedSearch(queryBuilder) {}
+
+  async searchWithFilters(searchTerm, filters, limit) {}
+
+  async searchByCollection(collectionName, searchTerm, limit) {}
+
+  async aggregateByCategory() {}
+
+  async aggregateByIdentifierType() {}
+
+  async getSearchSuggestions(partialTerm, limit) {}
+
+  async findSimilarChemicals(chemicalId, limit) {}
+
+  registerElasticsearchHandlers(elasticsearchService) {
+    const indexPatterns = this.connection.config.indexRoutes?.search || [/^(chemicals|substances|search)/];
+    
+    indexPatterns.forEach(pattern => {
+      elasticsearchService.registerIndexRoute(pattern, {
+      search: async (params) => {
+        const query = params.body?.query;
+        const searchTerm = query?.match?.chemical_name || 
+                          query?.term?.chemical_name || 
+                          query?.query_string?.query || 
+                          query?.match_all ? '*' : '';
+        const limit = params.body?.size || 10;
+        
+        return await this.searchChemicals(searchTerm, { limit });
+      },
+      
+      count: async (params) => {
+        const query = params.body?.query;
+        const searchTerm = query?.match?.chemical_name || 
+                          query?.term?.chemical_name || 
+                          query?.query_string?.query || '';
+        
+        const results = await this.searchChemicals(searchTerm, { limit: 10000 });
+        return { count: results.results.length };
+      }
+      });
+    });
+  }
+}
+
+module.exports = SearchService;