@toxplanet/pegasus-sdk 1.0.2 → 1.1.1

package/index.js

@@ -1,44 +1,44 @@
-const PegasusConnection = require('./lib/connection');
-const ChemicalsService = require('./lib/chemicals');
-const DocumentsService = require('./lib/documents');
-const SearchService = require('./lib/search');
-const SyncService = require('./lib/sync');
-const UtilsService = require('./lib/utils');
-const ElasticsearchService = require('./lib/elasticsearch');
-
-class PegasusSDK {
-  constructor(config) {
-    this.connection = new PegasusConnection(config);
-    this.elasticsearch = new ElasticsearchService(this.connection);
-    this.chemicals = new ChemicalsService(this.connection);
-    this.documents = new DocumentsService(this.connection);
-    this.search = new SearchService(this.connection);
-    this.sync = new SyncService(this.connection);
-    this.utils = new UtilsService(this.connection);
-    
-    this.chemicals.registerElasticsearchHandlers(this.elasticsearch);
-    this.documents.registerElasticsearchHandlers(this.elasticsearch);
-    this.search.registerElasticsearchHandlers(this.elasticsearch);
-  }
-
-  async connect() {
-    return this.connection.connect();
-  }
-
-  async disconnect() {
-    return this.connection.disconnect();
-  }
-
-  async healthCheck() {
-    return this.connection.testConnection();
-  }
-}
-
-module.exports = PegasusSDK;
-module.exports.PegasusConnection = PegasusConnection;
-module.exports.ChemicalsService = ChemicalsService;
-module.exports.DocumentsService = DocumentsService;
-module.exports.SearchService = SearchService;
-module.exports.SyncService = SyncService;
-module.exports.UtilsService = UtilsService;
+const PegasusConnection = require('./lib/connection');
+const ChemicalsService = require('./lib/chemicals');
+const DocumentsService = require('./lib/documents');
+const SearchService = require('./lib/search');
+const SyncService = require('./lib/sync');
+const UtilsService = require('./lib/utils');
+const ElasticsearchService = require('./lib/elasticsearch');
+
+class PegasusSDK {
+  constructor(config) {
+    this.connection = new PegasusConnection(config);
+    this.elasticsearch = new ElasticsearchService(this.connection);
+    this.chemicals = new ChemicalsService(this.connection);
+    this.documents = new DocumentsService(this.connection);
+    this.search = new SearchService(this.connection);
+    this.sync = new SyncService(this.connection);
+    this.utils = new UtilsService(this.connection);
+    
+    this.chemicals.registerElasticsearchHandlers(this.elasticsearch);
+    this.documents.registerElasticsearchHandlers(this.elasticsearch);
+    this.search.registerElasticsearchHandlers(this.elasticsearch);
+  }
+
+  async connect() {
+    return this.connection.connect();
+  }
+
+  async disconnect() {
+    return this.connection.disconnect();
+  }
+
+  async healthCheck() {
+    return this.connection.testConnection();
+  }
+}
+
+module.exports = PegasusSDK;
+module.exports.PegasusConnection = PegasusConnection;
+module.exports.ChemicalsService = ChemicalsService;
+module.exports.DocumentsService = DocumentsService;
+module.exports.SearchService = SearchService;
+module.exports.SyncService = SyncService;
+module.exports.UtilsService = UtilsService;
 module.exports.ElasticsearchService = ElasticsearchService;

package/lib/chemicals.js

@@ -1,293 +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 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;
+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;