@toxplanet/pegasus-sdk 1.0.0 → 1.0.2

package/config/environment.acc.js

@@ -0,0 +1,27 @@
+module.exports = {
+  environment: 'acc',
+  region: 'us-east-1',
+  secretName: 'arn:aws:secretsmanager:us-east-1:292931567094:secret:rds!cluster-b851c3ce-58cc-41cd-aeae-05cc7f5e031a-ZYSjiI',
+  openSearchEndpoint: 'https://war8lk73nzswquk8dcz1.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
+  database: {
+    host: 'cr-chemicals.cluster-cz0iqdg8irhb.us-east-1.rds.amazonaws.com',
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 2,
+    minConnections: 0,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 5000,
+    statementTimeout: 30000,
+    queryTimeout: 30000,
+    ssl: {
+      rejectUnauthorized: false
+    }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
+  }
+};

package/config/environment.dev.js

@@ -0,0 +1,27 @@
+module.exports = {
+  environment: 'dev',
+  region: 'us-east-1',
+  secretName: 'arn:aws:secretsmanager:us-east-1:292931567094:secret:rds!cluster-b851c3ce-58cc-41cd-aeae-05cc7f5e031a-ZYSjiI',
+  openSearchEndpoint: 'https://war8lk73nzswquk8dcz1.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
+  database: {
+    host: 'cr-chemicals.cluster-cz0iqdg8irhb.us-east-1.rds.amazonaws.com',
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 2,
+    minConnections: 0,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 5000,
+    statementTimeout: 30000,
+    queryTimeout: 30000,
+    ssl: {
+      rejectUnauthorized: false
+    }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
+  }
+};

package/config/environment.prod.js

@@ -0,0 +1,27 @@
+module.exports = {
+  environment: 'prod',
+  region: 'us-east-1',
+  secretName: 'pegasus/production/database',
+  openSearchEndpoint: null,
+  openSearchIndex: 'chemicals',
+  database: {
+    host: null,
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 10,
+    minConnections: 2,
+    idleTimeoutMillis: 120000,
+    connectionTimeoutMillis: 15000,
+    statementTimeout: 120000,
+    queryTimeout: 120000,
+    ssl: {
+      rejectUnauthorized: true
+    }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
+  }
+};

package/config/environment.qa.js

@@ -0,0 +1,27 @@
+module.exports = {
+  environment: 'qa',
+  region: 'us-east-1',
+  secretName: 'pegasus/qa/database',
+  openSearchEndpoint: null,
+  openSearchIndex: 'chemicals',
+  database: {
+    host: null,
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 5,
+    minConnections: 1,
+    idleTimeoutMillis: 60000,
+    connectionTimeoutMillis: 10000,
+    statementTimeout: 60000,
+    queryTimeout: 60000,
+    ssl: {
+      rejectUnauthorized: true
+    }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
+  }
+};

package/config/index.js

@@ -0,0 +1,67 @@
+const { logInfo } = require('@toxplanet/tphelper/logging');
+
+function loadConfig(envOverride = null) {
+  const env = envOverride || process.env.NODE_ENV || 'dev';
+  
+  let envConfig;
+  try {
+    envConfig = require(`./environment.${env}.js`);
+  } catch (error) {
+    logInfo('pegasus-sdk', `Warning: Could not load config for environment "${env}", falling back to development`);
+    envConfig = require('./environment.dev.js');
+  }
+
+  const config = { ...envConfig };
+
+  if (process.env.PEGASUS_SDK_DB_SECRET_ARN) {
+    config.secretName = process.env.PEGASUS_SDK_DB_SECRET_ARN;
+  }
+
+  if (process.env.PEGASUS_SDK_OPENSEARCH_ENDPOINT) {
+    config.openSearchEndpoint = process.env.PEGASUS_SDK_OPENSEARCH_ENDPOINT;
+  }
+
+  if (process.env.PEGASUS_SDK_OPENSEARCH_INDEX) {
+    config.openSearchIndex = process.env.PEGASUS_SDK_OPENSEARCH_INDEX;
+  }
+
+  if (process.env.PEGASUS_SDK_DATABASE_HOST) {
+    config.database.host = process.env.PEGASUS_SDK_DATABASE_HOST;
+  }
+
+  if (process.env.PEGASUS_SDK_DATABASE_NAME) {
+    config.database.name = process.env.PEGASUS_SDK_DATABASE_NAME;
+  }
+
+  if (process.env.PEGASUS_SDK_AWS_REGION) {
+    config.region = process.env.PEGASUS_SDK_AWS_REGION;
+  }
+
+  if (process.env.PEGASUS_SDK_MAX_CONNECTIONS) {
+    config.postgres.maxConnections = parseInt(process.env.PEGASUS_SDK_MAX_CONNECTIONS, 10);
+  }
+
+  if (process.env.PEGASUS_SDK_MIN_CONNECTIONS) {
+    config.postgres.minConnections = parseInt(process.env.PEGASUS_SDK_MIN_CONNECTIONS, 10);
+  }
+
+  if (process.env.PEGASUS_SDK_IDLE_TIMEOUT) {
+    config.postgres.idleTimeoutMillis = parseInt(process.env.PEGASUS_SDK_IDLE_TIMEOUT, 10);
+  }
+
+  if (process.env.PEGASUS_SDK_CONNECTION_TIMEOUT) {
+    config.postgres.connectionTimeoutMillis = parseInt(process.env.PEGASUS_SDK_CONNECTION_TIMEOUT, 10);
+  }
+
+  if (process.env.PEGASUS_SDK_STATEMENT_TIMEOUT) {
+    config.postgres.statementTimeout = parseInt(process.env.PEGASUS_SDK_STATEMENT_TIMEOUT, 10);
+  }
+
+  if (process.env.PEGASUS_SDK_QUERY_TIMEOUT) {
+    config.postgres.queryTimeout = parseInt(process.env.PEGASUS_SDK_QUERY_TIMEOUT, 10);
+  }
+
+  return config;
+}
+
+module.exports = { loadConfig };

package/index.js

@@ -4,15 +4,21 @@ 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() {
@@ -35,3 +41,4 @@ 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,5 +1,19 @@
+const { logError } = require('@toxplanet/tphelper/logging');
+const { getDrizzle, schema } = require('./db');
+const { eq } = require('drizzle-orm');
+
 class ChemicalsService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+    this.db = null;
+  }
+
+  getDb() {
+    if (!this.db) {
+      this.db = getDrizzle(this.connection.pgPool);
+    }
+    return this.db;
+  }
 
   async bulkIndexFielded(documents) {}
 
@@ -7,11 +21,50 @@ class ChemicalsService {
 
   async bulkIndexSubstances(substances) {}
 
-  async createChemical(chemical) {}
+  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) {}
+  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) {}
 
@@ -21,7 +74,22 @@ class ChemicalsService {
 
   async bulkUpdateProperty(filter, propertyPath, newValue) {}
 
-  async getChemicalById(chemicalId) {}
+  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) {}
 
@@ -29,8 +97,6 @@ class ChemicalsService {
 
   async getChemicalsByIdentifier(identifierType, identifierValue) {}
 
-  async countAll() {}
-
   async countByCollection(collectionName) {}
 
   async countByIdentifier(identifierValue) {}
@@ -45,13 +111,183 @@ class ChemicalsService {
 
   async convertIdentifiersBatch(fromIdentifiers, toIdentifierType) {}
 
-  async searchByName(searchTerm, limit) {}
+  /**
+   * 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']
+        }
+      });
 
-  async searchBySynonym(synonymTerm, limit) {}
+      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;

package/lib/connection.js

@@ -2,15 +2,22 @@ const { Pool } = require('pg');
 const { Client } = require('@opensearch-project/opensearch');
 const { SecretsManagerClient, GetSecretValueCommand } = require('@aws-sdk/client-secrets-manager');
 const { AwsSigv4Signer } = require('@opensearch-project/opensearch/aws');
-const { defaultProvider } = require('@aws-sdk/credential-providers');
+const { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
+const { loadConfig } = require('../config');
+const { logInfo, logError } = require('@toxplanet/tphelper/logging');
 
 class PegasusConnection {
   constructor(config = {}) {
-    this.config = config;
-    this.environment = config.environment || process.env.NODE_ENV || 'development';
-    this.region = config.region || process.env.AWS_REGION || 'us-east-1';
-    this.secretName = config.secretName || `pegasus/${this.environment}/database`;
-    this.openSearchEndpoint = config.openSearchEndpoint || process.env.OPENSEARCH_ENDPOINT;
+    const envConfig = loadConfig(config.environment);
+    
+    this.config = { ...envConfig, ...config };
+    this.environment = this.config.environment;
+    this.region = this.config.region;
+    this.secretName = this.config.secretName;
+    this.openSearchEndpoint = this.config.openSearchEndpoint;
+    this.openSearchIndex = this.config.openSearchIndex;
+    this.databaseHost = this.config.database?.host;
+    this.databaseName = this.config.database?.name;
     
     this.pgPool = null;
     this.osClient = null;
@@ -47,35 +54,33 @@ class PegasusConnection {
     const secret = await this.getSecret();
     
     const poolConfig = {
-      host: secret.host || secret.endpoint,
-      port: secret.port || 5432,
-      database: secret.database || secret.dbname || 'chemicals',
-      user: secret.username || secret.user,
+      host: this.databaseHost,
+      port: 5432,
+      database: this.databaseName,
+      user: secret.username,
       password: secret.password,
-      max: this.config.maxConnections || 2,
-      min: this.config.minConnections || 0,
-      idleTimeoutMillis: this.config.idleTimeoutMillis || 30000,
-      connectionTimeoutMillis: this.config.connectionTimeoutMillis || 5000,
+      max: this.config.postgres.maxConnections,
+      min: this.config.postgres.minConnections,
+      idleTimeoutMillis: this.config.postgres.idleTimeoutMillis,
+      connectionTimeoutMillis: this.config.postgres.connectionTimeoutMillis,
       allowExitOnIdle: true,
-      ssl: {
-        rejectUnauthorized: true
-      },
-      statement_timeout: this.config.statementTimeout || 30000,
-      query_timeout: this.config.queryTimeout || 30000
+      ssl: this.config.postgres.ssl,
+      statement_timeout: this.config.postgres.statementTimeout,
+      query_timeout: this.config.postgres.queryTimeout
     };
 
     this.pgPool = new Pool(poolConfig);
 
     this.pgPool.on('error', (err) => {
-      console.error('Unexpected PostgreSQL pool error:', err);
+      logError('pegasus-sdk', 'PegasusConnection', 'pgPool.error', err);
     });
 
     this.pgPool.on('connect', () => {
-      console.log('PostgreSQL client connected');
+      logInfo('pegasus-sdk', 'PostgreSQL client connected');
     });
 
     this.pgPool.on('remove', () => {
-      console.log('PostgreSQL client removed from pool');
+      logInfo('pegasus-sdk', 'PostgreSQL client removed from pool');
     });
 
     if (this.openSearchEndpoint) {
@@ -84,7 +89,7 @@ class PegasusConnection {
           region: this.region,
           service: 'aoss',
           getCredentials: () => {
-            const credentialsProvider = defaultProvider();
+            const credentialsProvider = fromNodeProviderChain();
             return credentialsProvider();
           }
         }),
@@ -124,6 +129,10 @@ class PegasusConnection {
     return this.osClient;
   }
 
+  getOpenSearchIndex() {
+    return this.openSearchIndex || 'chemicals';
+  }
+
   async testConnection() {
     try {
       if (this.pgPool) {
@@ -143,11 +152,19 @@ class PegasusConnection {
         let osStatus = null;
         if (this.osClient) {
           try {
-            const osInfo = await this.osClient.info();
+            const indexName = this.getOpenSearchIndex();
+            const testSearch = await this.osClient.search({
+              index: indexName,
+              body: {
+                size: 1,
+                query: {
+                  match: { chemical_name: 'benzene' }
+                }
+              }
+            });
             osStatus = {
               connected: true,
-              version: osInfo.body.version.number,
-              cluster: osInfo.body.cluster_name
+              resultsFound: testSearch.body.hits.total.value || 0
             };
           } catch (osError) {
             osStatus = {

package/lib/db/index.js

@@ -0,0 +1,11 @@
+const { drizzle } = require('drizzle-orm/node-postgres');
+const schema = require('./schema');
+
+function getDrizzle(pgPool) {
+  return drizzle(pgPool, { schema });
+}
+
+module.exports = {
+  getDrizzle,
+  schema
+};

package/lib/db/schema.js

@@ -0,0 +1,28 @@
+const { pgTable, uuid, text, jsonb, timestamp, index, uniqueIndex } = require('drizzle-orm/pg-core');
+const { sql } = require('drizzle-orm');
+
+const chemicals = pgTable('chemicals', {
+  chemicalId: uuid('chemical_id').defaultRandom().primaryKey(),
+  sourceId: text('source_id').notNull().unique(),
+  chemicalName: text('chemical_name').notNull(),
+  chemicalMeta: jsonb('chemical_meta'),
+  chemicalIdentifiers: jsonb('chemical_identifiers'),
+  chemicalSynonyms: text('chemical_synonyms').array(),
+  chemicalCategories: text('chemical_categories').array(),
+  createdAt: timestamp('created_at', { withTimezone: true }).notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).notNull(),
+  importedAt: timestamp('imported_at', { withTimezone: true }).defaultNow()
+}, (table) => {
+  return {
+    sourceIdIdx: uniqueIndex('idx_chemicals_source_id').on(table.sourceId),
+    nameIdx: index('idx_chemicals_name').on(table.chemicalName),
+    createdAtIdx: index('idx_chemicals_created_at').on(table.createdAt),
+    updatedAtIdx: index('idx_chemicals_updated_at').on(table.updatedAt),
+    identifiersGinIdx: index('idx_chemicals_identifiers_gin').on(table.chemicalIdentifiers),
+    synonymsGinIdx: index('idx_chemicals_synonyms_gin').on(table.chemicalSynonyms)
+  };
+});
+
+module.exports = {
+  chemicals
+};