@toxplanet/pegasus-sdk 1.1.3 → 1.1.5

package/config/environment.acc.js

@@ -1,11 +1,11 @@
 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',
+  secretName: 'arn:aws:secretsmanager:us-east-1:605134466764:secret:rds!cluster-9b502dde-5e2a-49db-b2c5-9801141ee40b-gkHbLm',
+  openSearchEndpoint: 'https://1pbu0yqr197lq07hfcjh.us-east-1.aoss.amazonaws.com',
   openSearchIndex: 'chemicals',
   database: {
-    host: 'cr-chemicals.cluster-cz0iqdg8irhb.us-east-1.rds.amazonaws.com',
+    host: 'cr-chemicals-acc.cluster-czgc4c20yerz.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
   postgres: {
@@ -20,7 +20,7 @@ module.exports = {
     }
   },
   indexRoutes: {
-    chemicals: ['chemicals*'],
+    chemicals: ['*'],
     documents: ['documents*'],
     search: [/^(chemicals|substances|search)/]
   }

package/config/environment.prod.js

@@ -1,11 +1,11 @@
 module.exports = {
   environment: 'prod',
   region: 'us-east-1',
-  secretName: 'pegasus/production/database',
-  openSearchEndpoint: null,
+  secretName: 'rds!cluster-25483b3f-3758-43ed-9548-26c91de16c2d',
+  openSearchEndpoint: 'https://odusb11s00j5hyy5r6.us-east-1.aoss.amazonaws.com',
   openSearchIndex: 'chemicals',
   database: {
-    host: null,
+    host: 'cr-chemicals-qa.cluster-c7gakqksq9m4.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
   postgres: {

package/config/environment.qa.js

@@ -1,11 +1,11 @@
 module.exports = {
   environment: 'qa',
   region: 'us-east-1',
-  secretName: 'pegasus/qa/database',
-  openSearchEndpoint: null,
+  secretName: 'arn:aws:secretsmanager:us-east-1:147997144422:secret:rds!cluster-25483b3f-3758-43ed-9548-26c91de16c2d-oYjysU',
+  openSearchEndpoint: 'https://odusb11s00j5hyy5r6.us-east-1.aoss.amazonaws.com',
   openSearchIndex: 'chemicals',
   database: {
-    host: null,
+    host: 'cr-chemicals-qa.cluster-c7gakqksq9m4.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
   postgres: {
@@ -20,7 +20,7 @@ module.exports = {
     }
   },
   indexRoutes: {
-    chemicals: ['chemicals*'],
+    chemicals: ['*'],
     documents: ['documents*'],
     search: [/^(chemicals|substances|search)/]
   }

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

@@ -692,7 +692,7 @@ class ChemicalsService {
             items
           };
         },
-        
+      
         get: async (params) => {
           const result = await this.getChemicalById(params.id);
           

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

package/lib/search.js

@@ -310,22 +310,66 @@ class SearchService {
       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 });
+          const from = params.body?.from || 0;
+          const size = params.body?.size || 10;
+
+          // Determine search term and type from the ES-style query
+          let rawTerm = '';
+          let searchFn = (term, limit) => this.searchChemicals(term, { limit });
+
+          if (query?.query_string?.query) {
+            const qs = query.query_string.query;
+            if (qs.endsWith('*')) {
+              rawTerm = qs.slice(0, -1);
+              searchFn = (term, limit) => this.searchStartsWith(term, limit);
+            } else {
+              rawTerm = qs;
+            }
+          } else if (query?.match_phrase_prefix) {
+            const key = Object.keys(query.match_phrase_prefix)[0];
+            const val = query.match_phrase_prefix[key];
+            rawTerm = (typeof val === 'object' ? val.query : val) || '';
+            searchFn = (term, limit) => this.searchContains(term, limit);
+          } else if (query?.match?.chemical_name) {
+            rawTerm = query.match.chemical_name;
+          } else if (query?.term?.chemical_name) {
+            rawTerm = query.term.chemical_name;
+          } else if (query?.match_all !== undefined) {
+            rawTerm = '*';
+          }
+
+          const pegasusResults = await searchFn(rawTerm, from + size);
+          const hits = pegasusResults.results.slice(from);
+
+          return {
+            body: {
+              hits: {
+                hits: hits.map(r => ({
+                  _id: r.id,
+                  _source: {
+                    chemical_name: r.name,
+                    chemical_name_sensitive: r.name,
+                    chemical_name_sort: (r.name || '').toLowerCase(),
+                    chemical_identifier: [...(r.cas || []), ...(r.identifiers || [])],
+                    chemical_set_identifier: (r.cas && r.cas[0]) || r.id || '',
+                  }
+                })),
+                total: { value: pegasusResults.results.length, relation: 'eq' }
+              },
+              timed_out: false,
+              _shards: { total: 1, successful: 1, failed: 0 }
+            }
+          };
         },
         
         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 });
+          let rawTerm = query?.match?.chemical_name || 
+                        query?.term?.chemical_name || 
+                        query?.query_string?.query || '';
+          if (rawTerm.endsWith('*')) rawTerm = rawTerm.slice(0, -1);
+
+          const results = await this.searchChemicals(rawTerm, { limit: 10000 });
           return { count: results.results.length };
         }
       });

package/lib/sync.js

@@ -1,43 +1,43 @@
-class SyncService {
-  constructor(connection) {
-    this.connection = connection;
-  }
-
-  async syncBatch(batchSize) {}
-
-  async syncAll() {}
-
-  async syncContinuous(intervalMs) {}
-
-  async stopContinuousSync() {}
-
-  async getPendingCount() {}
-
-  async getOldestPending() {}
-
-  async getSyncLag() {}
-
-  async getFailedEntries(minRetryCount) {}
-
-  async retryFailed(outboxId) {}
-
-  async retryAllFailed() {}
-
-  async markAsProcessed(outboxId) {}
-
-  async deleteProcessedOlderThan(days) {}
-
-  async cleanupOutbox(daysToKeep) {}
-
-  async getSyncStats(timeWindowMinutes) {}
-
-  async getSyncThroughput() {}
-
-  async verifySync(chemicalId) {}
-
-  async forceResync(chemicalId) {}
-
-  async getOutboxHealth() {}
-}
-
-module.exports = SyncService;
+class SyncService {
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  async syncBatch(batchSize) {}
+
+  async syncAll() {}
+
+  async syncContinuous(intervalMs) {}
+
+  async stopContinuousSync() {}
+
+  async getPendingCount() {}
+
+  async getOldestPending() {}
+
+  async getSyncLag() {}
+
+  async getFailedEntries(minRetryCount) {}
+
+  async retryFailed(outboxId) {}
+
+  async retryAllFailed() {}
+
+  async markAsProcessed(outboxId) {}
+
+  async deleteProcessedOlderThan(days) {}
+
+  async cleanupOutbox(daysToKeep) {}
+
+  async getSyncStats(timeWindowMinutes) {}
+
+  async getSyncThroughput() {}
+
+  async verifySync(chemicalId) {}
+
+  async forceResync(chemicalId) {}
+
+  async getOutboxHealth() {}
+}
+
+module.exports = SyncService;

package/lib/utils.js

@@ -1,49 +1,49 @@
-class UtilsService {
-  constructor(connection) {
-    this.connection = connection;
-  }
-
-  async executeBatch(operations, batchSize, concurrency) {}
-
-  async withTransaction(callback) {}
-
-  async withRetry(operation, maxRetries, backoffMs) {}
-
-  validateChemical(chemical) {}
-
-  validateDocument(document) {}
-
-  validateIdentifier(identifier) {}
-
-  validateCAS(casNumber) {}
-
-  transformForOpenSearch(chemical) {}
-
-  transformFromElasticsearch(esDocument) {}
-
-  transformFromDynamoDB(dynamoItem) {}
-
-  buildOpenSearchQuery(searchTerm, searchType) {}
-
-  buildPostgresFilter(filters) {}
-
-  parseChemicalIdentifiers(identifiers) {}
-
-  parseSynonyms(synonyms) {}
-
-  extractCASFromText(text) {}
-
-  sanitizeSearchTerm(term) {}
-
-  generateSourceId(chemical) {}
-
-  calculateChecksum(data) {}
-
-  formatError(error) {}
-
-  logOperation(operation, duration, metadata) {}
-
-  getTimestamp() {}
-}
-
-module.exports = UtilsService;
+class UtilsService {
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  async executeBatch(operations, batchSize, concurrency) {}
+
+  async withTransaction(callback) {}
+
+  async withRetry(operation, maxRetries, backoffMs) {}
+
+  validateChemical(chemical) {}
+
+  validateDocument(document) {}
+
+  validateIdentifier(identifier) {}
+
+  validateCAS(casNumber) {}
+
+  transformForOpenSearch(chemical) {}
+
+  transformFromElasticsearch(esDocument) {}
+
+  transformFromDynamoDB(dynamoItem) {}
+
+  buildOpenSearchQuery(searchTerm, searchType) {}
+
+  buildPostgresFilter(filters) {}
+
+  parseChemicalIdentifiers(identifiers) {}
+
+  parseSynonyms(synonyms) {}
+
+  extractCASFromText(text) {}
+
+  sanitizeSearchTerm(term) {}
+
+  generateSourceId(chemical) {}
+
+  calculateChecksum(data) {}
+
+  formatError(error) {}
+
+  logOperation(operation, duration, metadata) {}
+
+  getTimestamp() {}
+}
+
+module.exports = UtilsService;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
   "type": "commonjs",