@toxplanet/pegasus-sdk 1.0.1 → 1.1.0

package/lib/connection.js

@@ -1,223 +1,223 @@
-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 { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
-const { loadConfig } = require('../config');
-const { logInfo, logError } = require('@toxplanet/tphelper/logging');
-
-class PegasusConnection {
-  constructor(config = {}) {
-    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;
-    this.secretsClient = null;
-    this.cachedSecret = null;
-    this.isConnected = false;
-  }
-
-  async getSecret() {
-    if (this.cachedSecret) {
-      return this.cachedSecret;
-    }
-
-    if (!this.secretsClient) {
-      this.secretsClient = new SecretsManagerClient({ region: this.region });
-    }
-
-    const command = new GetSecretValueCommand({ SecretId: this.secretName });
-    const response = await this.secretsClient.send(command);
-    
-    if (response.SecretString) {
-      this.cachedSecret = JSON.parse(response.SecretString);
-      return this.cachedSecret;
-    }
-    
-    throw new Error(`Secret ${this.secretName} does not contain SecretString`);
-  }
-
-  async connect() {
-    if (this.isConnected) {
-      return;
-    }
-
-    const secret = await this.getSecret();
-    
-    const poolConfig = {
-      host: this.databaseHost,
-      port: 5432,
-      database: this.databaseName,
-      user: secret.username,
-      password: secret.password,
-      max: this.config.postgres.maxConnections,
-      min: this.config.postgres.minConnections,
-      idleTimeoutMillis: this.config.postgres.idleTimeoutMillis,
-      connectionTimeoutMillis: this.config.postgres.connectionTimeoutMillis,
-      allowExitOnIdle: true,
-      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) => {
-      logError('pegasus-sdk', 'PegasusConnection', 'pgPool.error', err);
-    });
-
-    this.pgPool.on('connect', () => {
-      logInfo('pegasus-sdk', 'PostgreSQL client connected');
-    });
-
-    this.pgPool.on('remove', () => {
-      logInfo('pegasus-sdk', 'PostgreSQL client removed from pool');
-    });
-
-    if (this.openSearchEndpoint) {
-      this.osClient = new Client({
-        ...AwsSigv4Signer({
-          region: this.region,
-          service: 'aoss',
-          getCredentials: () => {
-            const credentialsProvider = fromNodeProviderChain();
-            return credentialsProvider();
-          }
-        }),
-        node: this.openSearchEndpoint
-      });
-    }
-
-    this.isConnected = true;
-  }
-
-  async disconnect() {
-    if (!this.isConnected) {
-      return;
-    }
-
-    if (this.pgPool) {
-      await this.pgPool.end();
-      this.pgPool = null;
-    }
-
-    this.osClient = null;
-    this.isConnected = false;
-    this.cachedSecret = null;
-  }
-
-  getPostgresClient() {
-    if (!this.pgPool) {
-      throw new Error('PostgreSQL connection not established. Call connect() first.');
-    }
-    return this.pgPool;
-  }
-
-  getOpenSearchClient() {
-    if (!this.osClient) {
-      throw new Error('OpenSearch connection not established. Call connect() first or provide openSearchEndpoint.');
-    }
-    return this.osClient;
-  }
-
-  getOpenSearchIndex() {
-    return this.openSearchIndex || 'chemicals';
-  }
-
-  async testConnection() {
-    try {
-      if (this.pgPool) {
-        const client = await this.pgPool.connect();
-        const result = await client.query('SELECT NOW() as current_time, version() as pg_version');
-        client.release();
-        
-        const pgStatus = {
-          connected: true,
-          timestamp: result.rows[0].current_time,
-          version: result.rows[0].pg_version,
-          poolSize: this.pgPool.totalCount,
-          idleConnections: this.pgPool.idleCount,
-          waitingRequests: this.pgPool.waitingCount
-        };
-
-        let osStatus = null;
-        if (this.osClient) {
-          try {
-            const indexName = this.getOpenSearchIndex();
-            const testSearch = await this.osClient.search({
-              index: indexName,
-              body: {
-                size: 1,
-                query: {
-                  match: { chemical_name: 'benzene' }
-                }
-              }
-            });
-            osStatus = {
-              connected: true,
-              resultsFound: testSearch.body.hits.total.value || 0
-            };
-          } catch (osError) {
-            osStatus = {
-              connected: false,
-              error: osError.message
-            };
-          }
-        }
-
-        return {
-          postgres: pgStatus,
-          opensearch: osStatus,
-          environment: this.environment,
-          region: this.region
-        };
-      }
-      
-      throw new Error('No active connections');
-    } catch (error) {
-      return {
-        postgres: { connected: false, error: error.message },
-        opensearch: null,
-        environment: this.environment,
-        region: this.region
-      };
-    }
-  }
-
-  async query(sql, params) {
-    const pool = this.getPostgresClient();
-    return pool.query(sql, params);
-  }
-
-  async getClient() {
-    const pool = this.getPostgresClient();
-    return pool.connect();
-  }
-
-  async transaction(callback) {
-    const client = await this.getClient();
-    
-    try {
-      await client.query('BEGIN');
-      const result = await callback(client);
-      await client.query('COMMIT');
-      return result;
-    } catch (error) {
-      await client.query('ROLLBACK');
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-}
-
-module.exports = PegasusConnection;
+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 { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
+const { loadConfig } = require('../config');
+const { logInfo, logError } = require('@toxplanet/tphelper/logging');
+
+class PegasusConnection {
+  constructor(config = {}) {
+    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;
+    this.secretsClient = null;
+    this.cachedSecret = null;
+    this.isConnected = false;
+  }
+
+  async getSecret() {
+    if (this.cachedSecret) {
+      return this.cachedSecret;
+    }
+
+    if (!this.secretsClient) {
+      this.secretsClient = new SecretsManagerClient({ region: this.region });
+    }
+
+    const command = new GetSecretValueCommand({ SecretId: this.secretName });
+    const response = await this.secretsClient.send(command);
+    
+    if (response.SecretString) {
+      this.cachedSecret = JSON.parse(response.SecretString);
+      return this.cachedSecret;
+    }
+    
+    throw new Error(`Secret ${this.secretName} does not contain SecretString`);
+  }
+
+  async connect() {
+    if (this.isConnected) {
+      return;
+    }
+
+    const secret = await this.getSecret();
+    
+    const poolConfig = {
+      host: this.databaseHost,
+      port: 5432,
+      database: this.databaseName,
+      user: secret.username,
+      password: secret.password,
+      max: this.config.postgres.maxConnections,
+      min: this.config.postgres.minConnections,
+      idleTimeoutMillis: this.config.postgres.idleTimeoutMillis,
+      connectionTimeoutMillis: this.config.postgres.connectionTimeoutMillis,
+      allowExitOnIdle: true,
+      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) => {
+      logError('pegasus-sdk', 'PegasusConnection', 'pgPool.error', err);
+    });
+
+    this.pgPool.on('connect', () => {
+      logInfo('pegasus-sdk', 'PostgreSQL client connected');
+    });
+
+    this.pgPool.on('remove', () => {
+      logInfo('pegasus-sdk', 'PostgreSQL client removed from pool');
+    });
+
+    if (this.openSearchEndpoint) {
+      this.osClient = new Client({
+        ...AwsSigv4Signer({
+          region: this.region,
+          service: 'aoss',
+          getCredentials: () => {
+            const credentialsProvider = fromNodeProviderChain();
+            return credentialsProvider();
+          }
+        }),
+        node: this.openSearchEndpoint
+      });
+    }
+
+    this.isConnected = true;
+  }
+
+  async disconnect() {
+    if (!this.isConnected) {
+      return;
+    }
+
+    if (this.pgPool) {
+      await this.pgPool.end();
+      this.pgPool = null;
+    }
+
+    this.osClient = null;
+    this.isConnected = false;
+    this.cachedSecret = null;
+  }
+
+  getPostgresClient() {
+    if (!this.pgPool) {
+      throw new Error('PostgreSQL connection not established. Call connect() first.');
+    }
+    return this.pgPool;
+  }
+
+  getOpenSearchClient() {
+    if (!this.osClient) {
+      throw new Error('OpenSearch connection not established. Call connect() first or provide openSearchEndpoint.');
+    }
+    return this.osClient;
+  }
+
+  getOpenSearchIndex() {
+    return this.openSearchIndex || 'chemicals';
+  }
+
+  async testConnection() {
+    try {
+      if (this.pgPool) {
+        const client = await this.pgPool.connect();
+        const result = await client.query('SELECT NOW() as current_time, version() as pg_version');
+        client.release();
+        
+        const pgStatus = {
+          connected: true,
+          timestamp: result.rows[0].current_time,
+          version: result.rows[0].pg_version,
+          poolSize: this.pgPool.totalCount,
+          idleConnections: this.pgPool.idleCount,
+          waitingRequests: this.pgPool.waitingCount
+        };
+
+        let osStatus = null;
+        if (this.osClient) {
+          try {
+            const indexName = this.getOpenSearchIndex();
+            const testSearch = await this.osClient.search({
+              index: indexName,
+              body: {
+                size: 1,
+                query: {
+                  match: { chemical_name: 'benzene' }
+                }
+              }
+            });
+            osStatus = {
+              connected: true,
+              resultsFound: testSearch.body.hits.total.value || 0
+            };
+          } catch (osError) {
+            osStatus = {
+              connected: false,
+              error: osError.message
+            };
+          }
+        }
+
+        return {
+          postgres: pgStatus,
+          opensearch: osStatus,
+          environment: this.environment,
+          region: this.region
+        };
+      }
+      
+      throw new Error('No active connections');
+    } catch (error) {
+      return {
+        postgres: { connected: false, error: error.message },
+        opensearch: null,
+        environment: this.environment,
+        region: this.region
+      };
+    }
+  }
+
+  async query(sql, params) {
+    const pool = this.getPostgresClient();
+    return pool.query(sql, params);
+  }
+
+  async getClient() {
+    const pool = this.getPostgresClient();
+    return pool.connect();
+  }
+
+  async transaction(callback) {
+    const client = await this.getClient();
+    
+    try {
+      await client.query('BEGIN');
+      const result = await callback(client);
+      await client.query('COMMIT');
+      return result;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+}
+
+module.exports = PegasusConnection;

package/lib/documents.js

@@ -1,47 +1,94 @@
-class DocumentsService {
-  constructor(connection) {}
-
-  async createDocument(documentPath, casNumbers) {}
-
-  async bulkCreateDocuments(documents) {}
-
-  async updateDocument(documentId, updates) {}
-
-  async deleteDocument(documentId) {}
-
-  async deleteDocumentByPath(documentPath) {}
-
-  async getDocumentById(documentId) {}
-
-  async getDocumentByPath(documentPath) {}
-
-  async getDocumentsByCAS(casNumber) {}
-
-  async getCASByDocument(documentId) {}
-
-  async getCASByDocumentPath(documentPath) {}
-
-  async addCASToDocument(documentId, casNumber) {}
-
-  async addCASToDocumentBatch(documentId, casNumbers) {}
-
-  async removeCASFromDocument(documentId, casNumber) {}
-
-  async findDocumentsWithMultipleCAS(casNumbers, requireAll) {}
-
-  async countDocuments() {}
-
-  async countDocumentsByCAS(casNumber) {}
-
-  async countUniqueCAS() {}
-
-  async getTopCASByDocumentCount(limit) {}
-
-  async extractTextFromPDF(pdfBuffer) {}
-
-  async extractCASFromText(text) {}
-
-  async processDocument(documentPath, documentData) {}
-}
-
-module.exports = DocumentsService;
+class DocumentsService {
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  async createDocument(documentPath, casNumbers) {}
+
+  async bulkCreateDocuments(documents) {}
+
+  async updateDocument(documentId, updates) {}
+
+  async deleteDocument(documentId) {}
+
+  async deleteDocumentByPath(documentPath) {}
+
+  async getDocumentById(documentId) {}
+
+  async getDocumentByPath(documentPath) {}
+
+  async getDocumentsByCAS(casNumber) {}
+
+  async getCASByDocument(documentId) {}
+
+  async getCASByDocumentPath(documentPath) {}
+
+  async addCASToDocument(documentId, casNumber) {}
+
+  async addCASToDocumentBatch(documentId, casNumbers) {}
+
+  async removeCASFromDocument(documentId, casNumber) {}
+
+  async findDocumentsWithMultipleCAS(casNumbers, requireAll) {}
+
+  async countDocuments() {}
+
+  async countDocumentsByCAS(casNumber) {}
+
+  async countUniqueCAS() {}
+
+  async getTopCASByDocumentCount(limit) {}
+
+  async extractTextFromPDF(pdfBuffer) {}
+
+  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;