@toxplanet/pegasus-sdk 1.0.1 → 1.1.0

package/lib/chemicals.js

@@ -1,229 +1,293 @@
-const { logError } = require('@toxplanet/tphelper/logging');
-const { getDrizzle, schema } = require('./db');
-const { eq } = require('drizzle-orm');
-
-class ChemicalsService {
-  constructor(connection) {
-    this.connection = connection;
-    this.db = null;
-  }
-
-  getDb() {
-    if (!this.db) {
-      this.db = getDrizzle(this.connection.pgPool);
-    }
-    return this.db;
-  }
-
-  async bulkIndexFielded(documents) {}
-
-  async bulkIndexFulltext(documents) {}
-
-  async bulkIndexSubstances(substances) {}
-
-  async createChemical(chemical) {
-    try {
-      const db = this.getDb();
-      
-      const [result] = await db
-        .insert(schema.chemicals)
-        .values({
-          sourceId: chemical.source_id,
-          chemicalName: chemical.chemical_name,
-          chemicalMeta: chemical.chemical_meta,
-          chemicalIdentifiers: chemical.chemical_identifiers,
-          chemicalSynonyms: chemical.chemical_synonyms,
-          chemicalCategories: chemical.chemical_categories,
-          createdAt: chemical.created_at || new Date(),
-          updatedAt: chemical.updated_at || new Date(),
-          ...(chemical.imported_at && { importedAt: chemical.imported_at }),
-          ...(chemical.chemical_id && { chemicalId: chemical.chemical_id })
-        })
-        .returning();
-
-      return result;
-    } catch (error) {
-      logError('pegasus-sdk', 'ChemicalsService', 'createChemical', error);
-      throw error;
-    }
-  }
-
-  async updateChemical(chemicalId, updates) {}
-
-  async deleteChemical(chemicalId) {
-    try {
-      const db = this.getDb();
-      
-      const [deleted] = await db
-        .delete(schema.chemicals)
-        .where(eq(schema.chemicals.chemicalId, chemicalId))
-        .returning();
-
-      return deleted || null;
-    } catch (error) {
-      logError('pegasus-sdk', 'ChemicalsService', 'deleteChemical', error);
-      throw error;
-    }
-  }
-
-  async deleteBySourceId(sourceId) {}
-
-  async deleteCollection(collectionName) {}
-
-  async updateCollectionProperty(collectionName, propertyPath, newValue) {}
-
-  async bulkUpdateProperty(filter, propertyPath, newValue) {}
-
-  async getChemicalById(chemicalId) {
-    try {
-      const db = this.getDb();
-      
-      const [result] = await db
-        .select()
-        .from(schema.chemicals)
-        .where(eq(schema.chemicals.chemicalId, chemicalId))
-        .limit(1);
-
-      return result || null;
-    } catch (error) {
-      logError('pegasus-sdk', 'ChemicalsService', 'getChemicalById', error);
-      throw error;
-    }
-  }
-
-  async getChemicalBySourceId(sourceId) {}
-
-  async getChemicalsByCAS(casNumber) {}
-
-  async getChemicalsByIdentifier(identifierType, identifierValue) {}
-
-  async countAll() {}
-
-  async countByCollection(collectionName) {}
-
-  async countByIdentifier(identifierValue) {}
-
-  async countByCAS(casNumber) {}
-
-  async getTotalSynonymCount() {}
-
-  async getSynonymCount(synonymTerm) {}
-
-  async convertIdentifier(fromIdentifier, toIdentifierType) {}
-
-  async convertIdentifiersBatch(fromIdentifiers, toIdentifierType) {}
-
-  /**
-   * Search for chemicals by name using OpenSearch
-   * @param {string} searchTerm - Name to search for
-   * @param {number} limit - Maximum number of results (default: 10)
-   * @returns {Promise<Object>} Search results
-   */
-  async searchByName(searchTerm, limit = 10) {
-    if (!searchTerm) {
-      return { results: [] };
-    }
-
-    try {
-      const opensearchClient = this.connection.getOpenSearchClient();
-      const indexName = this.connection.getOpenSearchIndex();
-      
-      const response = await opensearchClient.search({
-        index: indexName,
-        body: {
-          size: limit,
-          query: {
-            bool: {
-              should: [
-                // Prioritize exact name matches
-                { term: { 'chemical_name.keyword': { value: searchTerm, boost: 100, case_insensitive: true } } },
-                // Then prefix matches
-                { prefix: { 'chemical_name.keyword': { value: searchTerm, boost: 50, case_insensitive: true } } },
-                // Include synonym matches as secondary
-                { term: { 'synonyms.keyword': { value: searchTerm, boost: 30, case_insensitive: true } } },
-                { prefix: { 'synonyms.keyword': { value: searchTerm, boost: 10, case_insensitive: true } } }
-              ],
-              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', 'ChemicalsService', 'searchByName', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Search for chemicals by synonym using OpenSearch
-   * @param {string} synonymTerm - Synonym to search for
-   * @param {number} limit - Maximum number of results (default: 10)
-   * @returns {Promise<Object>} Search results
-   */
-  async searchBySynonym(synonymTerm, limit = 10) {
-    if (!synonymTerm) {
-      return { results: [] };
-    }
-
-    try {
-      const opensearchClient = this.connection.getOpenSearchClient();
-      const indexName = this.connection.getOpenSearchIndex();
-      
-      const response = await opensearchClient.search({
-        index: indexName,
-        body: {
-          size: limit,
-          query: {
-            bool: {
-              should: [
-                // Prioritize exact synonym matches
-                { term: { 'synonyms.keyword': { value: synonymTerm, boost: 100, case_insensitive: true } } },
-                // Then prefix matches
-                { prefix: { 'synonyms.keyword': { value: synonymTerm, boost: 50, case_insensitive: true } } },
-                // Include name matches as secondary
-                { term: { 'chemical_name.keyword': { value: synonymTerm, boost: 30, case_insensitive: true } } },
-                { prefix: { 'chemical_name.keyword': { value: synonymTerm, boost: 10, case_insensitive: true } } }
-              ],
-              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', 'ChemicalsService', 'searchBySynonym', error);
-      throw error;
-    }
-  }
-
-  async findChemicalsWithoutDocuments(collectionName, searchTerm, pageSize) {}
-
-  async countChemicalsWithoutDocuments(collectionName) {}
-}
-
-module.exports = ChemicalsService;
+const { logError } = require('@toxplanet/tphelper/logging');
+const { getDrizzle, schema } = require('./db');
+const { eq } = require('drizzle-orm');
+
+class ChemicalsService {
+  constructor(connection) {
+    this.connection = connection;
+    this.db = null;
+  }
+
+  getDb() {
+    if (!this.db) {
+      this.db = getDrizzle(this.connection.pgPool);
+    }
+    return this.db;
+  }
+
+  async bulkIndexFielded(documents) {}
+
+  async bulkIndexFulltext(documents) {}
+
+  async bulkIndexSubstances(substances) {}
+
+  async createChemical(chemical) {
+    try {
+      const db = this.getDb();
+      
+      const [result] = await db
+        .insert(schema.chemicals)
+        .values({
+          sourceId: chemical.source_id,
+          chemicalName: chemical.chemical_name,
+          chemicalMeta: chemical.chemical_meta,
+          chemicalIdentifiers: chemical.chemical_identifiers,
+          chemicalSynonyms: chemical.chemical_synonyms,
+          chemicalCategories: chemical.chemical_categories,
+          createdAt: chemical.created_at || new Date(),
+          updatedAt: chemical.updated_at || new Date(),
+          ...(chemical.imported_at && { importedAt: chemical.imported_at }),
+          ...(chemical.chemical_id && { chemicalId: chemical.chemical_id })
+        })
+        .returning();
+
+      return result;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'createChemical', error);
+      throw error;
+    }
+  }
+
+  async updateChemical(chemicalId, updates) {}
+
+  async deleteChemical(chemicalId) {
+    try {
+      const db = this.getDb();
+      
+      const [deleted] = await db
+        .delete(schema.chemicals)
+        .where(eq(schema.chemicals.chemicalId, chemicalId))
+        .returning();
+
+      return deleted || null;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'deleteChemical', error);
+      throw error;
+    }
+  }
+
+  async deleteBySourceId(sourceId) {}
+
+  async deleteCollection(collectionName) {}
+
+  async updateCollectionProperty(collectionName, propertyPath, newValue) {}
+
+  async bulkUpdateProperty(filter, propertyPath, newValue) {}
+
+  async getChemicalById(chemicalId) {
+    try {
+      const db = this.getDb();
+      
+      const [result] = await db
+        .select()
+        .from(schema.chemicals)
+        .where(eq(schema.chemicals.chemicalId, chemicalId))
+        .limit(1);
+
+      return result || null;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'getChemicalById', error);
+      throw error;
+    }
+  }
+
+  async getChemicalBySourceId(sourceId) {}
+
+  async getChemicalsByCAS(casNumber) {}
+
+  async getChemicalsByIdentifier(identifierType, identifierValue) {}
+
+  async countByCollection(collectionName) {}
+
+  async countByIdentifier(identifierValue) {}
+
+  async countByCAS(casNumber) {}
+
+  async getTotalSynonymCount() {}
+
+  async getSynonymCount(synonymTerm) {}
+
+  async convertIdentifier(fromIdentifier, toIdentifierType) {}
+
+  async convertIdentifiersBatch(fromIdentifiers, toIdentifierType) {}
+
+  /**
+   * Search for chemicals by name using OpenSearch
+   * @param {string} searchTerm - Name to search for
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByName(searchTerm, limit = 10) {
+    if (!searchTerm) {
+      return { results: [] };
+    }
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: [
+                // Prioritize exact name matches
+                { term: { 'chemical_name.keyword': { value: searchTerm, boost: 100, case_insensitive: true } } },
+                // Then prefix matches
+                { prefix: { 'chemical_name.keyword': { value: searchTerm, boost: 50, case_insensitive: true } } },
+                // Include synonym matches as secondary
+                { term: { 'synonyms.keyword': { value: searchTerm, boost: 30, case_insensitive: true } } },
+                { prefix: { 'synonyms.keyword': { value: searchTerm, boost: 10, case_insensitive: true } } }
+              ],
+              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', 'ChemicalsService', 'searchByName', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Search for chemicals by synonym using OpenSearch
+   * @param {string} synonymTerm - Synonym to search for
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchBySynonym(synonymTerm, limit = 10) {
+    if (!synonymTerm) {
+      return { results: [] };
+    }
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: [
+                // Prioritize exact synonym matches
+                { term: { 'synonyms.keyword': { value: synonymTerm, boost: 100, case_insensitive: true } } },
+                // Then prefix matches
+                { prefix: { 'synonyms.keyword': { value: synonymTerm, boost: 50, case_insensitive: true } } },
+                // Include name matches as secondary
+                { term: { 'chemical_name.keyword': { value: synonymTerm, boost: 30, case_insensitive: true } } },
+                { prefix: { 'chemical_name.keyword': { value: synonymTerm, boost: 10, case_insensitive: true } } }
+              ],
+              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', 'ChemicalsService', 'searchBySynonym', error);
+      throw error;
+    }
+  }
+
+  async countAll() {
+    try {
+      const db = this.getDb();
+      const result = await db.select({ count: sql`count(*)::int` }).from(schema.chemicals);
+      return { count: result[0].count };
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'countAll', error);
+      throw error;
+    }
+  }
+
+  async findChemicalsWithoutDocuments(collectionName, searchTerm, pageSize) {}
+
+  async countChemicalsWithoutDocuments(collectionName) {}
+
+  registerElasticsearchHandlers(elasticsearchService) {
+    const indexPatterns = this.connection.config.indexRoutes?.chemicals || ['chemicals*'];
+    
+    indexPatterns.forEach(pattern => {
+      elasticsearchService.registerIndexRoute(pattern, {
+      index: async (params) => {
+        const chemical = params.body;
+        return await this.createChemical(chemical);
+      },
+      
+      bulk: async (params) => {
+        const operations = params.body || params.operations;
+        const documents = [];
+        
+        for (let i = 0; i < operations.length; i += 2) {
+          const action = operations[i];
+          const document = operations[i + 1];
+          
+          if (action.index || action.create) {
+            documents.push(document);
+          }
+        }
+        
+        return await this.bulkIndexFielded(documents);
+      },
+      
+      get: async (params) => {
+        return await this.getChemicalById(params.id);
+      },
+      
+      update: async (params) => {
+        return await this.updateChemical(params.id, params.body);
+      },
+      
+      delete: async (params) => {
+        return await this.deleteChemical(params.id);
+      },
+      
+      search: async (params) => {
+        const query = params.body?.query;
+        const searchTerm = query?.match?.chemical_name || 
+                          query?.term?.chemical_name || 
+                          query?.query_string?.query || '';
+        const limit = params.body?.size || 10;
+        
+        return await this.searchByName(searchTerm, limit);
+      },
+      
+      count: async (params) => {
+        return await this.countAll();
+      }
+      });
+    });
+  }
+}
+
+module.exports = ChemicalsService;