@toxplanet/pegasus-sdk 1.0.1 → 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

@@ -1,5 +1,5 @@
 module.exports = {
-  environment: 'development',
+  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',
@@ -18,5 +18,10 @@ module.exports = {
     ssl: {
       rejectUnauthorized: false
     }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
   }
 };

package/config/environment.prod.js

@@ -1,5 +1,5 @@
 module.exports = {
-  environment: 'production',
+  environment: 'prod',
   region: 'us-east-1',
   secretName: 'pegasus/production/database',
   openSearchEndpoint: null,
@@ -18,5 +18,10 @@ module.exports = {
     ssl: {
       rejectUnauthorized: true
     }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
   }
 };

package/config/environment.qa.js

@@ -18,5 +18,10 @@ module.exports = {
     ssl: {
       rejectUnauthorized: true
     }
+  },
+  indexRoutes: {
+    chemicals: ['chemicals*'],
+    documents: ['documents*'],
+    search: [/^(chemicals|substances|search)/]
   }
 };

package/config/index.js

@@ -1,7 +1,7 @@
 const { logInfo } = require('@toxplanet/tphelper/logging');
 
 function loadConfig(envOverride = null) {
-  const env = envOverride || process.env.NODE_ENV || 'development';
+  const env = envOverride || process.env.NODE_ENV || 'dev';
   
   let envConfig;
   try {

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

@@ -97,8 +97,6 @@ class ChemicalsService {
 
   async getChemicalsByIdentifier(identifierType, identifierValue) {}
 
-  async countAll() {}
-
   async countByCollection(collectionName) {}
 
   async countByIdentifier(identifierValue) {}
@@ -221,9 +219,75 @@ class ChemicalsService {
     }
   }
 
+  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/documents.js

@@ -1,5 +1,7 @@
 class DocumentsService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
 
   async createDocument(documentPath, casNumbers) {}
 
@@ -42,6 +44,51 @@ class DocumentsService {
   async extractCASFromText(text) {}
 
   async processDocument(documentPath, documentData) {}
+
+  registerElasticsearchHandlers(elasticsearchService) {
+    const indexPatterns = this.connection.config.indexRoutes?.documents || ['documents*'];
+    
+    indexPatterns.forEach(pattern => {
+      elasticsearchService.registerIndexRoute(pattern, {
+      index: async (params) => {
+        const document = params.body;
+        return await this.createDocument(document.document_path, document.cas_numbers || []);
+      },
+      
+      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.bulkCreateDocuments(documents);
+      },
+      
+      get: async (params) => {
+        return await this.getDocumentById(params.id);
+      },
+      
+      update: async (params) => {
+        return await this.updateDocument(params.id, params.body);
+      },
+      
+      delete: async (params) => {
+        return await this.deleteDocument(params.id);
+      },
+      
+      count: async (params) => {
+        return await this.countDocuments();
+      }
+      });
+    });
+  }
 }
 
 module.exports = DocumentsService;

package/lib/elasticsearch.js

@@ -0,0 +1,404 @@
+class ElasticsearchService {
+  constructor(connection) {
+    this.connection = connection;
+    this.indexRoutes = new Map();
+  }
+
+  /**
+   * Returns an Elasticsearch client interface that routes operations through registered handlers.
+   * This method provides compatibility with legacy elasticsearch client usage patterns.
+   * @returns {ElasticsearchService} The service instance itself, which implements the client interface
+   */
+  client() {
+    return this;
+  }
+
+  registerIndexRoute(indexPattern, handler) {
+    this.indexRoutes.set(indexPattern, handler);
+  }
+
+  getRouteHandler(indexName) {
+    for (const [pattern, handler] of this.indexRoutes.entries()) {
+      if (typeof pattern === 'string' && indexName === pattern) {
+        return handler;
+      }
+      if (pattern instanceof RegExp && pattern.test(indexName)) {
+        return handler;
+      }
+    }
+    return null;
+  }
+
+
+  // example flow:
+  // external application
+    // 1. initialize the sdk
+    // 2. call elastic search search
+    // 3. sdk will call the appropriate handler based on the index name
+    // 4. handler will be called with the appropriate parameters
+    // 5. handler will return the result
+    // 6. sdk will return the result to the external application
+
+  async search(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.search) {
+      return await handler.search(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async msearch(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.msearch) {
+      return await handler.msearch(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async index(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.index) {
+      return await handler.index(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async bulk(params) {
+    const operations = params.body || params.operations;
+    if (!Array.isArray(operations) || operations.length === 0) {
+      throw new Error('Bulk operations must be a non-empty array');
+    }
+
+    const firstOp = operations[0];
+    const indexName = firstOp?.index?._index || firstOp?.index?.index || firstOp?.create?._index || firstOp?.create?.index || params.index;
+    
+    if (!indexName) {
+      throw new Error('Could not determine index from bulk operations');
+    }
+
+    const handler = this.getRouteHandler(indexName);
+    if (handler && handler.bulk) {
+      return await handler.bulk(params);
+    }
+    throw new Error(`No handler registered for index: ${indexName}`);
+  }
+
+  async get(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.get) {
+      return await handler.get(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async mget(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.mget) {
+      return await handler.mget(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async update(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.update) {
+      return await handler.update(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async updateByQuery(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.updateByQuery) {
+      return await handler.updateByQuery(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async delete(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.delete) {
+      return await handler.delete(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async deleteByQuery(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.deleteByQuery) {
+      return await handler.deleteByQuery(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async exists(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.exists) {
+      return await handler.exists(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async count(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.count) {
+      return await handler.count(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async scroll(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.scroll) {
+      return await handler.scroll(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async clearScroll(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.clearScroll) {
+      return await handler.clearScroll(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async reindex(params) {
+    const sourceIndex = params.body?.source?.index;
+    const destIndex = params.body?.dest?.index;
+    
+    const handler = this.getRouteHandler(destIndex || sourceIndex);
+    if (handler && handler.reindex) {
+      return await handler.reindex(params);
+    }
+    throw new Error(`No handler registered for index: ${destIndex || sourceIndex}`);
+  }
+
+  indices() {
+    return {
+      create: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.create) {
+          return await handler.indices.create(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      delete: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.delete) {
+          return await handler.indices.delete(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      exists: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.exists) {
+          return await handler.indices.exists(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      refresh: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.refresh) {
+          return await handler.indices.refresh(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      flush: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.flush) {
+          return await handler.indices.flush(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putMapping: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putMapping) {
+          return await handler.indices.putMapping(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getMapping: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getMapping) {
+          return await handler.indices.getMapping(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putSettings: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putSettings) {
+          return await handler.indices.putSettings(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getSettings: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getSettings) {
+          return await handler.indices.getSettings(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      stats: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.stats) {
+          return await handler.indices.stats(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      get: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.get) {
+          return await handler.indices.get(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      putAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.putAlias) {
+          return await handler.indices.putAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      deleteAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.deleteAlias) {
+          return await handler.indices.deleteAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      getAlias: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.getAlias) {
+          return await handler.indices.getAlias(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      analyze: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.analyze) {
+          return await handler.indices.analyze(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      close: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.close) {
+          return await handler.indices.close(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      },
+      open: async (params) => {
+        const handler = this.getRouteHandler(params.index);
+        if (handler && handler.indices && handler.indices.open) {
+          return await handler.indices.open(params);
+        }
+        throw new Error(`No handler registered for index: ${params.index}`);
+      }
+    };
+  }
+
+  cat() {
+    return {
+      indices: async (params) => {
+        throw new Error('cat.indices not implemented');
+      },
+      health: async (params) => {
+        throw new Error('cat.health not implemented');
+      },
+      count: async (params) => {
+        throw new Error('cat.count not implemented');
+      },
+      aliases: async (params) => {
+        throw new Error('cat.aliases not implemented');
+      }
+    };
+  }
+
+  cluster() {
+    return {
+      health: async (params) => {
+        throw new Error('cluster.health not implemented');
+      },
+      stats: async (params) => {
+        throw new Error('cluster.stats not implemented');
+      },
+      putSettings: async (params) => {
+        throw new Error('cluster.putSettings not implemented');
+      },
+      getSettings: async (params) => {
+        throw new Error('cluster.getSettings not implemented');
+      }
+    };
+  }
+
+  async ping() {
+    return true;
+  }
+
+  async info() {
+    return {
+      name: 'pegasus-sdk',
+      version: '1.0.0',
+      cluster_name: 'pegasus'
+    };
+  }
+
+  async explain(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.explain) {
+      return await handler.explain(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async termvectors(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.termvectors) {
+      return await handler.termvectors(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async mtermvectors(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.mtermvectors) {
+      return await handler.mtermvectors(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async searchTemplate(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.searchTemplate) {
+      return await handler.searchTemplate(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async renderSearchTemplate(params) {
+    throw new Error('renderSearchTemplate not implemented');
+  }
+
+  async fieldCaps(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.fieldCaps) {
+      return await handler.fieldCaps(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async rankEval(params) {
+    const handler = this.getRouteHandler(params.index);
+    if (handler && handler.rankEval) {
+      return await handler.rankEval(params);
+    }
+    throw new Error(`No handler registered for index: ${params.index}`);
+  }
+
+  async scriptsPainlessExecute(params) {
+    throw new Error('scriptsPainlessExecute not implemented');
+  }
+}
+
+module.exports = ElasticsearchService;

package/lib/search.js

@@ -302,6 +302,35 @@ class SearchService {
   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;

package/lib/sync.js

@@ -1,5 +1,7 @@
 class SyncService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
 
   async syncBatch(batchSize) {}
 

package/lib/utils.js

@@ -1,5 +1,7 @@
 class UtilsService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
 
   async executeBatch(operations, batchSize, concurrency) {}
 

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.0.1",
-  "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture",
+  "version": "1.0.2",
+  "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
+  "type": "commonjs",
   "scripts": {
-    "test:search": "node tests/search.js",
-    "test:chemicals": "node tests/chemicals.js"
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui"
   },
   "keywords": [
+    "elasticsearch",
+    "opensearch",
+    "postgresql",
+    "aws",
+    "chemicals",
+    "database",
+    "search",
+    "sdk",
+    "pegasus",
+    "migration"
   ],
   "author": "Chemical Research Development Team",
   "license": "MIT",
@@ -21,5 +33,16 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "lib/",
+    "config/",
+    "README.md",
+    "ELASTICSEARCH_CLIENT.md",
+    "LICENSE"
+  ],
+  "devDependencies": {
+    "vitest": "^1.2.0"
   }
 }

package/env.example

@@ -1,21 +0,0 @@
-NODE_ENV=development
-
-# Pegasus SDK Configuration Overrides
-PEGASUS_SDK_DB_SECRET_ARN=arn:aws:secretsmanager:us-east-1:292931567094:secret:rds!cluster-b851c3ce-58cc-41cd-aeae-05cc7f5e031a-ZYSjiI
-PEGASUS_SDK_OPENSEARCH_ENDPOINT=https://war8lk73nzswquk8dcz1.us-east-1.aoss.amazonaws.com
-PEGASUS_SDK_AWS_REGION=us-east-1
-
-# Database Configuration
-PEGASUS_SDK_DATABASE_HOST=cr-chemicals.cluster-cz0iqdg8irhb.us-east-1.rds.amazonaws.com
-PEGASUS_SDK_DATABASE_NAME=chemicals
-
-# OpenSearch Configuration
-PEGASUS_SDK_OPENSEARCH_INDEX=chemicals
-
-# PostgreSQL Connection Pool Settings (optional)
-PEGASUS_SDK_MAX_CONNECTIONS=2
-PEGASUS_SDK_MIN_CONNECTIONS=0
-PEGASUS_SDK_IDLE_TIMEOUT=30000
-PEGASUS_SDK_CONNECTION_TIMEOUT=5000
-PEGASUS_SDK_STATEMENT_TIMEOUT=30000
-PEGASUS_SDK_QUERY_TIMEOUT=30000

package/index.d.ts

@@ -1,252 +0,0 @@
-export interface PostgresConfig {
-  maxConnections?: number;
-  minConnections?: number;
-  idleTimeoutMillis?: number;
-  connectionTimeoutMillis?: number;
-  statementTimeout?: number;
-  queryTimeout?: number;
-}
-
-export interface DatabaseConfig {
-  host?: string;
-  name?: string;
-}
-
-export interface PegasusConfig {
-  environment?: string;
-  region?: string;
-  secretName?: string;
-  openSearchEndpoint?: string;
-  openSearchIndex?: string;
-  database?: DatabaseConfig;
-  postgres?: PostgresConfig;
-}
-
-export interface Chemical {
-  chemical_id?: string;
-  source_id: string;
-  chemical_name: string;
-  chemical_identifiers: Identifier[];
-  chemical_synonyms: string[];
-  chemical_categories: string[];
-  chemical_meta: Record<string, any>;
-  created_at?: Date;
-  updated_at?: Date;
-}
-
-export interface Identifier {
-  type: string;
-  value: string;
-}
-
-export interface Document {
-  document_id?: string;
-  document_path: string;
-  processed_at?: Date;
-  cas_count?: number;
-}
-
-export interface OutboxEntry {
-  outbox_id: number;
-  chemical_id: string;
-  operation: 'INSERT' | 'UPDATE' | 'DELETE';
-  created_at: Date;
-  processed_at?: Date;
-  retry_count: number;
-  last_error?: string;
-}
-
-export interface ConnectionStatus {
-  postgres: {
-    connected: boolean;
-    timestamp?: Date;
-    version?: string;
-    poolSize?: number;
-    idleConnections?: number;
-    waitingRequests?: number;
-    error?: string;
-  };
-  opensearch: {
-    connected: boolean;
-    version?: string;
-    cluster?: string;
-    error?: string;
-  } | null;
-  environment: string;
-  region: string;
-}
-
-export declare class PegasusConnection {
-  constructor(config?: PegasusConfig);
-  getSecret(): Promise<any>;
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  getPostgresClient(): any;
-  getOpenSearchClient(): any;
-  getOpenSearchIndex(): string;
-  testConnection(): Promise<ConnectionStatus>;
-  query(sql: string, params?: any[]): Promise<any>;
-  getClient(): Promise<any>;
-  transaction(callback: (client: any) => Promise<any>): Promise<any>;
-}
-
-export declare class ChemicalsService {
-  constructor(connection: PegasusConnection);
-  bulkIndexFielded(documents: any[]): Promise<void>;
-  bulkIndexFulltext(documents: any[]): Promise<void>;
-  bulkIndexSubstances(substances: any[]): Promise<void>;
-  createChemical(chemical: Chemical): Promise<Chemical>;
-  updateChemical(chemicalId: string, updates: Partial<Chemical>): Promise<Chemical>;
-  deleteChemical(chemicalId: string): Promise<void>;
-  deleteBySourceId(sourceId: string): Promise<void>;
-  deleteCollection(collectionName: string): Promise<number>;
-  updateCollectionProperty(collectionName: string, propertyPath: string, newValue: any): Promise<number>;
-  bulkUpdateProperty(filter: any, propertyPath: string, newValue: any): Promise<number>;
-  getChemicalById(chemicalId: string): Promise<Chemical>;
-  getChemicalBySourceId(sourceId: string): Promise<Chemical>;
-  getChemicalsByCAS(casNumber: string): Promise<Chemical[]>;
-  getChemicalsByIdentifier(identifierType: string, identifierValue: string): Promise<Chemical[]>;
-  countAll(): Promise<number>;
-  countByCollection(collectionName: string): Promise<number>;
-  countByIdentifier(identifierValue: string): Promise<number>;
-  countByCAS(casNumber: string): Promise<number>;
-  getTotalSynonymCount(): Promise<number>;
-  getSynonymCount(synonymTerm: string): Promise<number>;
-  convertIdentifier(fromIdentifier: string, toIdentifierType: string): Promise<any>;
-  convertIdentifiersBatch(fromIdentifiers: string[], toIdentifierType: string): Promise<any[]>;
-  searchByName(searchTerm: string, limit?: number): Promise<SearchResults>;
-  searchBySynonym(synonymTerm: string, limit?: number): Promise<SearchResults>;
-  findChemicalsWithoutDocuments(collectionName: string, searchTerm: string, pageSize: number): Promise<Chemical[]>;
-  countChemicalsWithoutDocuments(collectionName: string): Promise<number>;
-}
-
-export declare class DocumentsService {
-  constructor(connection: PegasusConnection);
-  createDocument(documentPath: string, casNumbers: string[]): Promise<Document>;
-  bulkCreateDocuments(documents: any[]): Promise<void>;
-  updateDocument(documentId: string, updates: Partial<Document>): Promise<Document>;
-  deleteDocument(documentId: string): Promise<void>;
-  deleteDocumentByPath(documentPath: string): Promise<void>;
-  getDocumentById(documentId: string): Promise<Document>;
-  getDocumentByPath(documentPath: string): Promise<Document>;
-  getDocumentsByCAS(casNumber: string): Promise<Document[]>;
-  getCASByDocument(documentId: string): Promise<string[]>;
-  getCASByDocumentPath(documentPath: string): Promise<string[]>;
-  addCASToDocument(documentId: string, casNumber: string): Promise<void>;
-  addCASToDocumentBatch(documentId: string, casNumbers: string[]): Promise<void>;
-  removeCASFromDocument(documentId: string, casNumber: string): Promise<void>;
-  findDocumentsWithMultipleCAS(casNumbers: string[], requireAll: boolean): Promise<Document[]>;
-  countDocuments(): Promise<number>;
-  countDocumentsByCAS(casNumber: string): Promise<number>;
-  countUniqueCAS(): Promise<number>;
-  getTopCASByDocumentCount(limit: number): Promise<any[]>;
-  extractTextFromPDF(pdfBuffer: Buffer): Promise<string>;
-  extractCASFromText(text: string): Promise<string[]>;
-  processDocument(documentPath: string, documentData: any): Promise<Document>;
-}
-
-export interface SearchOptions {
-  limit?: number;
-  casExact?: number;
-  casPrefix?: number;
-  nameExact?: number;
-  namePrefix?: number;
-  identifierExact?: number;
-  identifierPrefix?: number;
-  synonymExact?: number;
-  synonymPrefix?: number;
-}
-
-export interface ChemicalSearchResult {
-  id: number;
-  name: string;
-  cas: string[];
-  identifiers: string[];
-  synonyms: string[];
-  score: number;
-}
-
-export interface SearchResults {
-  results: ChemicalSearchResult[];
-}
-
-export declare class SearchService {
-  constructor(connection: PegasusConnection);
-  searchChemicals(query: string, options?: SearchOptions): Promise<SearchResults>;
-  searchStartsWith(searchTerm: string, limit?: number): Promise<SearchResults>;
-  searchContains(searchTerm: string, limit?: number): Promise<SearchResults>;
-  searchExact(searchTerm: string, limit?: number): Promise<SearchResults>;
-  searchByCAS(casNumber: string, searchType?: string): Promise<SearchResults>;
-  searchByIdentifier(identifierValue: string, searchType?: string): Promise<SearchResults>;
-  searchBySynonym(synonymTerm: string, searchType?: string): Promise<SearchResults>;
-  advancedSearch(queryBuilder: any): Promise<any[]>;
-  searchWithFilters(searchTerm: string, filters: any, limit: number): Promise<any[]>;
-  searchByCollection(collectionName: string, searchTerm: string, limit: number): Promise<any[]>;
-  aggregateByCategory(): Promise<any>;
-  aggregateByIdentifierType(): Promise<any>;
-  getSearchSuggestions(partialTerm: string, limit: number): Promise<string[]>;
-  findSimilarChemicals(chemicalId: string, limit: number): Promise<any[]>;
-}
-
-export declare class SyncService {
-  constructor(connection: PegasusConnection);
-  syncBatch(batchSize: number): Promise<number>;
-  syncAll(): Promise<number>;
-  syncContinuous(intervalMs: number): Promise<void>;
-  stopContinuousSync(): Promise<void>;
-  getPendingCount(): Promise<number>;
-  getOldestPending(): Promise<Date>;
-  getSyncLag(): Promise<number>;
-  getFailedEntries(minRetryCount: number): Promise<OutboxEntry[]>;
-  retryFailed(outboxId: number): Promise<void>;
-  retryAllFailed(): Promise<number>;
-  markAsProcessed(outboxId: number): Promise<void>;
-  deleteProcessedOlderThan(days: number): Promise<number>;
-  cleanupOutbox(daysToKeep: number): Promise<number>;
-  getSyncStats(timeWindowMinutes: number): Promise<any>;
-  getSyncThroughput(): Promise<number>;
-  verifySync(chemicalId: string): Promise<boolean>;
-  forceResync(chemicalId: string): Promise<void>;
-  getOutboxHealth(): Promise<any>;
-}
-
-
-export declare class UtilsService {
-  constructor(connection: PegasusConnection);
-  executeBatch(operations: any[], batchSize: number, concurrency: number): Promise<void>;
-  withTransaction(callback: () => Promise<any>): Promise<any>;
-  withRetry(operation: () => Promise<any>, maxRetries: number, backoffMs: number): Promise<any>;
-  validateChemical(chemical: Chemical): boolean;
-  validateDocument(document: Document): boolean;
-  validateIdentifier(identifier: Identifier): boolean;
-  validateCAS(casNumber: string): boolean;
-  transformForOpenSearch(chemical: Chemical): any;
-  transformFromElasticsearch(esDocument: any): Chemical;
-  transformFromDynamoDB(dynamoItem: any): Chemical;
-  buildOpenSearchQuery(searchTerm: string, searchType: string): any;
-  buildPostgresFilter(filters: any): any;
-  parseChemicalIdentifiers(identifiers: any): Identifier[];
-  parseSynonyms(synonyms: any): string[];
-  extractCASFromText(text: string): string[];
-  sanitizeSearchTerm(term: string): string;
-  generateSourceId(chemical: Chemical): string;
-  calculateChecksum(data: any): string;
-  formatError(error: Error): any;
-  logOperation(operation: string, duration: number, metadata: any): void;
-  getTimestamp(): Date;
-}
-
-
-export default class PegasusSDK {
-  connection: PegasusConnection;
-  chemicals: ChemicalsService;
-  documents: DocumentsService;
-  search: SearchService;
-  sync: SyncService;
-  utils: UtilsService;
-
-  constructor(config: PegasusConfig);
-  connect(): Promise<void>;
-  disconnect(): Promise<void>;
-  healthCheck(): Promise<any>;
-}

package/tests/chemicals.js

@@ -1,165 +0,0 @@
-const PegasusSDK = require('../index');
-const { logInfo, logError } = require('@toxplanet/tphelper/logging');
-
-const ICONS = {
-  PASS: '[OK]',
-  FAIL: '[!!]',
-  WARN: '[?]'
-};
-
-async function runChemicalTests() {
-  const sdk = new PegasusSDK();
-  let testsPassed = 0;
-  let testsFailed = 0;
-
-  const log = (test, status, details = '') => {
-    logInfo('pegasus-sdk-tests', `${test}: ${status} ${details}`);
-    if (status === ICONS.PASS) testsPassed++;
-    else if (status === ICONS.FAIL) testsFailed++;
-  };
-
-  const print = (message) => {
-    logInfo('pegasus-sdk-tests', message);
-  };
-
-  let createdChemicalId = null;
-
-  try {
-    await sdk.connect();
-    log('Connection', ICONS.PASS);
-
-    const testChemical = {
-      source_id: `test-chemical-${Date.now()}`,
-      chemical_name: 'Test Chemical (Benzene)',
-      chemical_meta: {
-        test: true,
-        description: 'This is a test chemical record'
-      },
-      chemical_identifiers: [
-        { type: 'cas', value: '71-43-2' },
-        { type: 'pubchem_cid', value: 'CID241' }
-      ],
-      chemical_synonyms: ['Test Synonym 1', 'Test Synonym 2'],
-      chemical_categories: ['test', 'aromatic'],
-      created_at: new Date(),
-      updated_at: new Date()
-    };
-
-    print('\n' + '='.repeat(60));
-    print('TEST 1: Create Chemical');
-    print('='.repeat(60));
-
-    const created = await sdk.chemicals.createChemical(testChemical);
-    createdChemicalId = created.chemicalId;
-
-    if (created && created.chemicalId) {
-      log('Create Chemical', ICONS.PASS, `(ID: ${created.chemicalId.substring(0, 8)}...)`);
-      print(`  Source ID: ${created.sourceId}`);
-      print(`  Name: ${created.chemicalName}`);
-      print(`  Identifiers: ${created.chemicalIdentifiers.length} found`);
-      print(`  Synonyms: ${created.chemicalSynonyms.length} found`);
-    } else {
-      log('Create Chemical', ICONS.FAIL, 'No ID returned');
-      testsFailed++;
-    }
-
-    print('\n' + '='.repeat(60));
-    print('TEST 2: Get Chemical By ID');
-    print('='.repeat(60));
-
-    const retrieved = await sdk.chemicals.getChemicalById(createdChemicalId);
-
-    if (retrieved && retrieved.chemicalId === createdChemicalId) {
-      log('Get Chemical By ID', ICONS.PASS);
-      print(`  Retrieved Name: ${retrieved.chemicalName}`);
-      print(`  Source ID: ${retrieved.sourceId}`);
-      
-      if (retrieved.chemicalName === testChemical.chemical_name) {
-        log('Name Match', ICONS.PASS);
-      } else {
-        log('Name Match', ICONS.FAIL, `Expected: ${testChemical.chemical_name}, Got: ${retrieved.chemicalName}`);
-      }
-
-      if (retrieved.sourceId === testChemical.source_id) {
-        log('Source ID Match', ICONS.PASS);
-      } else {
-        log('Source ID Match', ICONS.FAIL);
-      }
-
-      if (Array.isArray(retrieved.chemicalIdentifiers) && retrieved.chemicalIdentifiers.length === 2) {
-        log('Identifiers Match', ICONS.PASS, `(${retrieved.chemicalIdentifiers.length} identifiers)`);
-      } else {
-        log('Identifiers Match', ICONS.FAIL);
-      }
-
-      if (Array.isArray(retrieved.chemicalSynonyms) && retrieved.chemicalSynonyms.length === 2) {
-        log('Synonyms Match', ICONS.PASS, `(${retrieved.chemicalSynonyms.length} synonyms)`);
-      } else {
-        log('Synonyms Match', ICONS.FAIL);
-      }
-    } else {
-      log('Get Chemical By ID', ICONS.FAIL, 'Chemical not found or ID mismatch');
-    }
-
-    print('\n' + '='.repeat(60));
-    print('TEST 3: Get Non-Existent Chemical');
-    print('='.repeat(60));
-
-    const nonExistent = await sdk.chemicals.getChemicalById('00000000-0000-0000-0000-000000000000');
-    
-    if (nonExistent === null) {
-      log('Get Non-Existent', ICONS.PASS, '(Correctly returned null)');
-    } else {
-      log('Get Non-Existent', ICONS.FAIL, 'Should return null for non-existent ID');
-    }
-
-    print('\n' + '='.repeat(60));
-    print('TEST 4: Delete Chemical');
-    print('='.repeat(60));
-
-    const deleted = await sdk.chemicals.deleteChemical(createdChemicalId);
-
-    if (deleted && deleted.chemicalId === createdChemicalId) {
-      log('Delete Chemical', ICONS.PASS, `(Deleted ID: ${deleted.chemicalId.substring(0, 8)}...)`);
-    } else {
-      log('Delete Chemical', ICONS.FAIL, 'Delete did not return expected result');
-    }
-
-    print('\n' + '='.repeat(60));
-    print('TEST 5: Verify Deletion');
-    print('='.repeat(60));
-
-    const shouldBeGone = await sdk.chemicals.getChemicalById(createdChemicalId);
-
-    if (shouldBeGone === null) {
-      log('Verify Deletion', ICONS.PASS, '(Chemical no longer exists)');
-    } else {
-      log('Verify Deletion', ICONS.FAIL, 'Chemical still exists after deletion');
-    }
-
-    print('\n' + '='.repeat(60));
-    print(`${ICONS.PASS} Tests Passed: ${testsPassed}`);
-    if (testsFailed > 0) print(`${ICONS.FAIL} Tests Failed: ${testsFailed}`);
-    print('='.repeat(60));
-
-  } catch (error) {
-    logError('pegasus-sdk-tests', 'chemicals-tests', 'runChemicalTests', error);
-    print(`\n${ICONS.FAIL} Test Failed: ${error.message}`);
-    
-    if (createdChemicalId) {
-      print('\nCleaning up test chemical...');
-      try {
-        await sdk.chemicals.deleteChemical(createdChemicalId);
-        print('Cleanup successful');
-      } catch (cleanupError) {
-        print('Cleanup failed (chemical may need manual deletion)');
-      }
-    }
-    
-    process.exit(1);
-  } finally {
-    await sdk.disconnect();
-  }
-}
-
-runChemicalTests();

package/tests/search.js

@@ -1,138 +0,0 @@
-const PegasusSDK = require('../index');
-const { logInfo, logError } = require('@toxplanet/tphelper/logging');
-
-const ICONS = {
-  PASS: '[OK]',
-  FAIL: '[!!]',
-  WARN: '[?]'
-};
-
-async function runTests() {
-  const sdk = new PegasusSDK();
-  let testsPassed = 0;
-  let testsFailed = 0;
-
-  const log = (test, status, details = '') => {
-    logInfo('pegasus-sdk-tests', `${test}: ${status} ${details}`);
-    if (status === ICONS.PASS) testsPassed++;
-    else if (status === ICONS.FAIL) testsFailed++;
-  };
-
-  const print = (message) => {
-    logInfo('pegasus-sdk-tests', message);
-  };
-
-  try {
-    await sdk.connect();
-    log('Connection', ICONS.PASS);
-
-    const health = await sdk.healthCheck();
-    const pgStatus = health.postgres.connected ? ICONS.PASS : ICONS.FAIL;
-    const osStatus = health.opensearch?.connected ? ICONS.PASS : ICONS.WARN;
-    log('Health Check', health.postgres.connected && health.opensearch?.connected ? ICONS.PASS : ICONS.WARN, `(PG:${pgStatus} OS:${osStatus})`);
-
-    if (!sdk.search?.searchChemicals) throw new Error('Search service not found');
-    log('Search Service', ICONS.PASS);
-
-    const emptyResult = await sdk.search.searchChemicals('');
-    if (emptyResult.results.length !== 0) throw new Error('Empty query should return no results');
-    log('Empty Query', ICONS.PASS);
-
-    const basicResult = await sdk.search.searchChemicals('test', { limit: 5 });
-    if (!Array.isArray(basicResult.results)) throw new Error('Invalid result structure');
-    log('Basic Search', ICONS.PASS, `(${basicResult.results.length} results)`);
-
-    const customResult = await sdk.search.searchChemicals('carbon', {
-      limit: 3,
-      casExact: 100,
-      nameExact: 50,
-      synonymExact: 75
-    });
-    log('Custom Boost', ICONS.PASS, `(${customResult.results.length} results)`);
-
-    const casResult = await sdk.search.searchChemicals('7440-06-4', { limit: 3 });
-    log('CAS Search', ICONS.PASS, `(${casResult.results.length} results)`);
-
-    const reversedCasResult = await sdk.search.searchChemicals('06/4/7440', { limit: 3 });
-    log('CAS Reversed Format', ICONS.PASS, `(${reversedCasResult.results.length} results)`);
-
-    if (basicResult.results.length > 0) {
-      const result = basicResult.results[0];
-      const requiredFields = ['id', 'name', 'cas', 'identifiers', 'synonyms', 'score'];
-      const missingFields = requiredFields.filter(field => !(field in result));
-      if (missingFields.length > 0) throw new Error(`Missing fields: ${missingFields.join(', ')}`);
-      if (!Array.isArray(result.cas) || !Array.isArray(result.identifiers) || !Array.isArray(result.synonyms)) {
-        throw new Error('Array fields invalid');
-      }
-      if (typeof result.score !== 'number') throw new Error('Score not a number');
-      log('Result Structure', ICONS.PASS);
-    } else {
-      log('Result Structure', ICONS.WARN, '(no results to validate)');
-    }
-
-    const startsWithResult = await sdk.search.searchStartsWith('test', 3);
-    const containsResult = await sdk.search.searchContains('test', 3);
-    const exactResult = await sdk.search.searchExact('test', 3);
-    if (!startsWithResult.results || !containsResult.results || !exactResult.results) {
-      throw new Error('Forwarding methods failed');
-    }
-    log('SearchService Methods', ICONS.PASS, `(starts:${startsWithResult.results.length} contains:${containsResult.results.length} exact:${exactResult.results.length})`);
-
-    const casExactResult = await sdk.search.searchByCAS('7440-06-4', 'exact');
-    const casPrefixResult = await sdk.search.searchByCAS('7440', 'prefix');
-    log('CAS Methods', ICONS.PASS, `(exact:${casExactResult.results.length} prefix:${casPrefixResult.results.length})`);
-
-    const identifierResult = await sdk.search.searchByIdentifier('CCCO', 'exact');
-    log('Identifier Method', ICONS.PASS, `(${identifierResult.results.length} results)`);
-
-    const synonymExactResult = await sdk.search.searchBySynonym('grain alcohol', 'exact');
-    const synonymPrefixResult = await sdk.search.searchBySynonym('alco', 'prefix');
-    log('Synonym Methods', ICONS.PASS, `(exact:${synonymExactResult.results.length} prefix:${synonymPrefixResult.results.length})`);
-
-    const nameSearchResult = await sdk.chemicals.searchByName('platinum', 3);
-    const synonymSearchResult = await sdk.chemicals.searchBySynonym('alcohol', 3);
-    if (!nameSearchResult.results || !synonymSearchResult.results) {
-      throw new Error('ChemicalsService methods failed');
-    }
-    log('ChemicalsService Methods', ICONS.PASS, `(name:${nameSearchResult.results.length} synonym:${synonymSearchResult.results.length})`);
-
-    const highLimitResult = await sdk.search.searchChemicals('carbon', { limit: 20 });
-    log('High Limit Search', ICONS.PASS, `(${highLimitResult.results.length} results)`);
-
-    print(`\n${'='.repeat(60)}`);
-    print('FINAL TEST: Benzene Search Results');
-    print('='.repeat(60));
-    const benzeneResults = await sdk.search.searchChemicals('benzene', { limit: 3 });
-    print(`Found ${benzeneResults.results.length} results for "benzene":\n`);
-    benzeneResults.results.forEach((result, i) => {
-      print(`${i + 1}. ${result.name}`);
-      print(`   CAS: ${result.cas.join(', ') || 'N/A'}`);
-      print(`   Score: ${result.score.toFixed(2)}`);
-      if (result.synonyms.length > 0) {
-        print(`   Synonyms: ${result.synonyms.slice(0, 3).join(', ')}${result.synonyms.length > 3 ? '...' : ''}`);
-      }
-      print('');
-    });
-
-    print('='.repeat(60));
-    print(`${ICONS.PASS} Tests Passed: ${testsPassed}`);
-    if (testsFailed > 0) print(`${ICONS.FAIL} Tests Failed: ${testsFailed}`);
-    print('='.repeat(60));
-
-  } catch (error) {
-    logError('pegasus-sdk-tests', 'search-tests', 'runTests', error);
-    print(`\n${ICONS.FAIL} Test Failed: ${error.message}`);
-    process.exit(1);
-  } finally {
-    await sdk.disconnect();
-  }
-}
-
-if (require.main === module) {
-  runTests().catch((error) => {
-    logError('pegasus-sdk-tests', 'search-tests', 'main', error);
-    process.exit(1);
-  });
-}
-
-module.exports = runTests;