@toxplanet/pegasus-sdk 1.0.0 → 1.0.1

package/config/environment.dev.js

@@ -0,0 +1,22 @@
+module.exports = {
+  environment: 'development',
+  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
+    }
+  }
+};

package/config/environment.prod.js

@@ -0,0 +1,22 @@
+module.exports = {
+  environment: 'production',
+  region: 'us-east-1',
+  secretName: 'pegasus/production/database',
+  openSearchEndpoint: null,
+  openSearchIndex: 'chemicals',
+  database: {
+    host: null,
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 10,
+    minConnections: 2,
+    idleTimeoutMillis: 120000,
+    connectionTimeoutMillis: 15000,
+    statementTimeout: 120000,
+    queryTimeout: 120000,
+    ssl: {
+      rejectUnauthorized: true
+    }
+  }
+};

package/config/environment.qa.js

@@ -0,0 +1,22 @@
+module.exports = {
+  environment: 'qa',
+  region: 'us-east-1',
+  secretName: 'pegasus/qa/database',
+  openSearchEndpoint: null,
+  openSearchIndex: 'chemicals',
+  database: {
+    host: null,
+    name: 'chemicals'
+  },
+  postgres: {
+    maxConnections: 5,
+    minConnections: 1,
+    idleTimeoutMillis: 60000,
+    connectionTimeoutMillis: 10000,
+    statementTimeout: 60000,
+    queryTimeout: 60000,
+    ssl: {
+      rejectUnauthorized: true
+    }
+  }
+};

package/config/index.js

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

package/env.example

@@ -1,3 +1,21 @@
-NODE_ENV=development
-AWS_REGION=us-east-1
-OPENSEARCH_ENDPOINT=https://your-collection.us-east-1.aoss.amazonaws.com
+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,8 +1,4 @@
-export interface PegasusConfig {
-  environment?: string;
-  region?: string;
-  secretName?: string;
-  openSearchEndpoint?: string;
+export interface PostgresConfig {
   maxConnections?: number;
   minConnections?: number;
   idleTimeoutMillis?: number;
@@ -11,6 +7,21 @@ export interface PegasusConfig {
   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;
@@ -72,6 +83,7 @@ export declare class PegasusConnection {
   disconnect(): Promise<void>;
   getPostgresClient(): any;
   getOpenSearchClient(): any;
+  getOpenSearchIndex(): string;
   testConnection(): Promise<ConnectionStatus>;
   query(sql: string, params?: any[]): Promise<any>;
   getClient(): Promise<any>;
@@ -102,8 +114,8 @@ export declare class ChemicalsService {
   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<Chemical[]>;
-  searchBySynonym(synonymTerm: string, limit: number): Promise<Chemical[]>;
+  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>;
 }
@@ -133,15 +145,40 @@ export declare class DocumentsService {
   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(searchTerm: string, searchType: string, limit: number, offset: number): Promise<any[]>;
-  searchStartsWith(searchTerm: string, limit: number): Promise<any[]>;
-  searchContains(searchTerm: string, limit: number): Promise<any[]>;
-  searchExact(searchTerm: string, limit: number): Promise<any[]>;
-  searchByCAS(casNumber: string, searchType: string): Promise<any[]>;
-  searchByIdentifier(identifierValue: string, searchType: string): Promise<any[]>;
-  searchBySynonym(synonymTerm: string, searchType: string): Promise<any[]>;
+  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[]>;

package/lib/chemicals.js

@@ -1,5 +1,19 @@
+const { logError } = require('@toxplanet/tphelper/logging');
+const { getDrizzle, schema } = require('./db');
+const { eq } = require('drizzle-orm');
+
 class ChemicalsService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+    this.db = null;
+  }
+
+  getDb() {
+    if (!this.db) {
+      this.db = getDrizzle(this.connection.pgPool);
+    }
+    return this.db;
+  }
 
   async bulkIndexFielded(documents) {}
 
@@ -7,11 +21,50 @@ class ChemicalsService {
 
   async bulkIndexSubstances(substances) {}
 
-  async createChemical(chemical) {}
+  async createChemical(chemical) {
+    try {
+      const db = this.getDb();
+      
+      const [result] = await db
+        .insert(schema.chemicals)
+        .values({
+          sourceId: chemical.source_id,
+          chemicalName: chemical.chemical_name,
+          chemicalMeta: chemical.chemical_meta,
+          chemicalIdentifiers: chemical.chemical_identifiers,
+          chemicalSynonyms: chemical.chemical_synonyms,
+          chemicalCategories: chemical.chemical_categories,
+          createdAt: chemical.created_at || new Date(),
+          updatedAt: chemical.updated_at || new Date(),
+          ...(chemical.imported_at && { importedAt: chemical.imported_at }),
+          ...(chemical.chemical_id && { chemicalId: chemical.chemical_id })
+        })
+        .returning();
+
+      return result;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'createChemical', error);
+      throw error;
+    }
+  }
 
   async updateChemical(chemicalId, updates) {}
 
-  async deleteChemical(chemicalId) {}
+  async deleteChemical(chemicalId) {
+    try {
+      const db = this.getDb();
+      
+      const [deleted] = await db
+        .delete(schema.chemicals)
+        .where(eq(schema.chemicals.chemicalId, chemicalId))
+        .returning();
+
+      return deleted || null;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'deleteChemical', error);
+      throw error;
+    }
+  }
 
   async deleteBySourceId(sourceId) {}
 
@@ -21,7 +74,22 @@ class ChemicalsService {
 
   async bulkUpdateProperty(filter, propertyPath, newValue) {}
 
-  async getChemicalById(chemicalId) {}
+  async getChemicalById(chemicalId) {
+    try {
+      const db = this.getDb();
+      
+      const [result] = await db
+        .select()
+        .from(schema.chemicals)
+        .where(eq(schema.chemicals.chemicalId, chemicalId))
+        .limit(1);
+
+      return result || null;
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'getChemicalById', error);
+      throw error;
+    }
+  }
 
   async getChemicalBySourceId(sourceId) {}
 
@@ -45,9 +113,113 @@ class ChemicalsService {
 
   async convertIdentifiersBatch(fromIdentifiers, toIdentifierType) {}
 
-  async searchByName(searchTerm, limit) {}
-
-  async searchBySynonym(synonymTerm, limit) {}
+  /**
+   * Search for chemicals by name using OpenSearch
+   * @param {string} searchTerm - Name to search for
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByName(searchTerm, limit = 10) {
+    if (!searchTerm) {
+      return { results: [] };
+    }
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: [
+                // Prioritize exact name matches
+                { term: { 'chemical_name.keyword': { value: searchTerm, boost: 100, case_insensitive: true } } },
+                // Then prefix matches
+                { prefix: { 'chemical_name.keyword': { value: searchTerm, boost: 50, case_insensitive: true } } },
+                // Include synonym matches as secondary
+                { term: { 'synonyms.keyword': { value: searchTerm, boost: 30, case_insensitive: true } } },
+                { prefix: { 'synonyms.keyword': { value: searchTerm, boost: 10, case_insensitive: true } } }
+              ],
+              minimum_should_match: 1
+            }
+          },
+          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+        }
+      });
+
+      const hits = response.body?.hits?.hits || [];
+      const results = hits.map((hit) => ({
+        id: hit._source.postgres_id,
+        name: hit._source.chemical_name,
+        cas: hit._source.cas_numbers || [],
+        identifiers: hit._source.identifier_values || [],
+        synonyms: hit._source.synonyms || [],
+        score: hit._score
+      }));
+
+      return { results };
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'searchByName', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Search for chemicals by synonym using OpenSearch
+   * @param {string} synonymTerm - Synonym to search for
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchBySynonym(synonymTerm, limit = 10) {
+    if (!synonymTerm) {
+      return { results: [] };
+    }
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: [
+                // Prioritize exact synonym matches
+                { term: { 'synonyms.keyword': { value: synonymTerm, boost: 100, case_insensitive: true } } },
+                // Then prefix matches
+                { prefix: { 'synonyms.keyword': { value: synonymTerm, boost: 50, case_insensitive: true } } },
+                // Include name matches as secondary
+                { term: { 'chemical_name.keyword': { value: synonymTerm, boost: 30, case_insensitive: true } } },
+                { prefix: { 'chemical_name.keyword': { value: synonymTerm, boost: 10, case_insensitive: true } } }
+              ],
+              minimum_should_match: 1
+            }
+          },
+          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+        }
+      });
+
+      const hits = response.body?.hits?.hits || [];
+      const results = hits.map((hit) => ({
+        id: hit._source.postgres_id,
+        name: hit._source.chemical_name,
+        cas: hit._source.cas_numbers || [],
+        identifiers: hit._source.identifier_values || [],
+        synonyms: hit._source.synonyms || [],
+        score: hit._score
+      }));
+
+      return { results };
+    } catch (error) {
+      logError('pegasus-sdk', 'ChemicalsService', 'searchBySynonym', error);
+      throw error;
+    }
+  }
 
   async findChemicalsWithoutDocuments(collectionName, searchTerm, pageSize) {}
 

package/lib/connection.js

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

package/lib/db/index.js

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

package/lib/db/schema.js

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

package/lib/search.js

@@ -1,19 +1,293 @@
+const { logInfo, logError } = require('@toxplanet/tphelper/logging');
+
+/**
+ * Detect if query looks like a CAS number (numbers with - or / separators)
+ * Returns array of alternative formats to try
+ * 
+ * CAS format: XXXXXXX-XX-X (registry-sequence-check)
+ * - First part: 2-7 digits (registry number)
+ * - Second part: ALWAYS 2 digits (zero-padded)
+ * - Third part: ALWAYS 1 digit (check digit)
+ */
+function getCasNumberVariations(query) {
+  // Check if it's all numbers and separators (-, /)
+  if (!/^[\d\-\/]+$/.test(query)) {
+    return [query]; // Not a CAS-like format, return as-is
+  }
+  
+  // Check if it has at least one separator
+  if (!query.includes('-') && !query.includes('/')) {
+    return [query]; // No separator, return as-is
+  }
+  
+  // Generate variations
+  const variations = new Set();
+  
+  // Add original
+  variations.add(query);
+  
+  // Split by any separator
+  const parts = query.split(/[-\/]/);
+  
+  if (parts.length === 3) {
+    // Three parts detected
+    // Could be:
+    // 1. Standard: registry-sequence-check (e.g., "7440-06-4")
+    // 2. Reversed: sequence/check/registry (e.g., "6/4/7440")
+    
+    const [part1, part2, part3] = parts;
+    
+    // Check if it looks like reversed format
+    // (small first part, small second part, large third part)
+    const isLikelyReversed = part1.length <= 2 && part2.length <= 2 && part3.length >= 3;
+    
+    if (isLikelyReversed) {
+      // Format: sequence/check/registry → registry-sequence-check
+      const registry = part3;
+      const sequence = part1.padStart(2, '0'); // Zero-pad to 2 digits
+      const check = part2;
+      
+      // Add properly formatted CAS
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    } else {
+      // Looks like standard format, try both separators
+      const registry = part1;
+      const sequence = part2.padStart(2, '0'); // Ensure 2 digits
+      const check = part3;
+      
+      variations.add(`${registry}-${sequence}-${check}`);
+      variations.add(`${registry}/${sequence}/${check}`);
+    }
+    
+    // Also try with different separator on original parts
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  } else if (parts.length === 2) {
+    // Two parts - just try both separators
+    variations.add(parts.join('-'));
+    variations.add(parts.join('/'));
+  }
+  
+  return Array.from(variations);
+}
+
 class SearchService {
-  constructor(connection) {}
+  constructor(connection) {
+    this.connection = connection;
+  }
+
+  /**
+   * Search chemicals using OpenSearch with configurable boost parameters
+   * @param {string} query - Search query string
+   * @param {Object} options - Search options
+   * @param {number} options.limit - Maximum number of results (default: 10)
+   * @param {number} options.casExact - Boost for exact CAS matches (default: 50)
+   * @param {number} options.casPrefix - Boost for CAS prefix matches (default: 10)
+   * @param {number} options.nameExact - Boost for exact name matches (default: 40)
+   * @param {number} options.namePrefix - Boost for name prefix matches (default: 8)
+   * @param {number} options.identifierExact - Boost for exact identifier matches (default: 30)
+   * @param {number} options.identifierPrefix - Boost for identifier prefix matches (default: 5)
+   * @param {number} options.synonymExact - Boost for exact synonym matches (default: 100)
+   * @param {number} options.synonymPrefix - Boost for synonym prefix matches (default: 3)
+   * @returns {Promise<Object>} Search results with chemicals array
+   */
+  async searchChemicals(query, options = {}) {
+    if (!query) {
+      return { results: [] };
+    }
+
+    // Extract options with defaults
+    const limit = options.limit || 10;
+    const casExact = options.casExact !== undefined ? options.casExact : 50;
+    const casPrefix = options.casPrefix !== undefined ? options.casPrefix : 10;
+    const nameExact = options.nameExact !== undefined ? options.nameExact : 40;
+    const namePrefix = options.namePrefix !== undefined ? options.namePrefix : 8;
+    const identifierExact = options.identifierExact !== undefined ? options.identifierExact : 30;
+    const identifierPrefix = options.identifierPrefix !== undefined ? options.identifierPrefix : 5;
+    const synonymExact = options.synonymExact !== undefined ? options.synonymExact : 100;
+    const synonymPrefix = options.synonymPrefix !== undefined ? options.synonymPrefix : 3;
+
+    try {
+      const opensearchClient = this.connection.getOpenSearchClient();
+      
+      // Get CAS number variations (if applicable)
+      const queryVariations = getCasNumberVariations(query);
+      
+      // Log if we're trying multiple variations
+      if (queryVariations.length > 1) {
+        logInfo('pegasus-sdk', `CAS format detection: trying ${queryVariations.length} variations for "${query}": ${JSON.stringify(queryVariations)}`);
+      }
+      
+      // Build should clauses for all query variations
+      const shouldClauses = [];
+      
+      for (const queryVariation of queryVariations) {
+        // Exact matches (configurable priority)
+        shouldClauses.push(
+          { term: { 'cas_numbers': { value: queryVariation, boost: casExact } } },
+          { term: { 'chemical_name.keyword': { value: queryVariation, boost: nameExact, case_insensitive: true } } },
+          { term: { 'identifier_values': { value: queryVariation, boost: identifierExact } } },
+          { term: { 'synonyms.keyword': { value: queryVariation, boost: synonymExact, case_insensitive: true } } },
+          // Prefix matches (configurable priority)
+          { prefix: { 'cas_numbers': { value: queryVariation, boost: casPrefix } } },
+          { prefix: { 'chemical_name.keyword': { value: queryVariation, boost: namePrefix, case_insensitive: true } } },
+          { prefix: { 'identifier_values': { value: queryVariation, boost: identifierPrefix } } },
+          { prefix: { 'synonyms.keyword': { value: queryVariation, boost: synonymPrefix, case_insensitive: true } } }
+        );
+      }
+      
+      const indexName = this.connection.getOpenSearchIndex();
+      
+      const response = await opensearchClient.search({
+        index: indexName,
+        body: {
+          size: limit,
+          query: {
+            bool: {
+              should: shouldClauses,
+              minimum_should_match: 1
+            }
+          },
+          _source: ['postgres_id', 'chemical_name', 'cas_numbers', 'identifier_values', 'synonyms']
+        }
+      });
+
+      const hits = response.body?.hits?.hits || [];
+      const results = hits.map((hit) => ({
+        id: hit._source.postgres_id,
+        name: hit._source.chemical_name,
+        cas: hit._source.cas_numbers || [],
+        identifiers: hit._source.identifier_values || [],
+        synonyms: hit._source.synonyms || [],
+        score: hit._score
+      }));
 
-  async searchChemicals(searchTerm, searchType, limit, offset) {}
+      return { results };
+    } catch (error) {
+      logError('pegasus-sdk', 'SearchService', 'searchChemicals', error);
+      throw error;
+    }
+  }
 
-  async searchStartsWith(searchTerm, limit) {}
+  /**
+   * Search for chemicals with prefix matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchStartsWith(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize prefix matches over exact matches
+      casPrefix: 50,
+      casExact: 20,
+      namePrefix: 40,
+      nameExact: 15,
+      identifierPrefix: 30,
+      identifierExact: 10,
+      synonymPrefix: 35,
+      synonymExact: 10
+    });
+  }
 
-  async searchContains(searchTerm, limit) {}
+  /**
+   * Search for chemicals (alias for general search)
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchContains(searchTerm, limit = 10) {
+    // Use default balanced weights for contains search
+    return this.searchChemicals(searchTerm, { limit });
+  }
 
-  async searchExact(searchTerm, limit) {}
+  /**
+   * Search for chemicals with exact matching priority
+   * @param {string} searchTerm - Search term
+   * @param {number} limit - Maximum number of results (default: 10)
+   * @returns {Promise<Object>} Search results
+   */
+  async searchExact(searchTerm, limit = 10) {
+    return this.searchChemicals(searchTerm, {
+      limit,
+      // Prioritize exact matches, minimize prefix matches
+      casExact: 100,
+      casPrefix: 1,
+      nameExact: 80,
+      namePrefix: 1,
+      identifierExact: 60,
+      identifierPrefix: 1,
+      synonymExact: 150,
+      synonymPrefix: 1
+    });
+  }
 
-  async searchByCAS(casNumber, searchType) {}
+  /**
+   * Search for chemicals by CAS number
+   * @param {string} casNumber - CAS number to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByCAS(casNumber, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(casNumber, {
+      limit: 10,
+      // Heavily prioritize CAS field
+      casExact: isExact ? 200 : 50,
+      casPrefix: isExact ? 10 : 100,
+      nameExact: 5,
+      namePrefix: 1,
+      identifierExact: 5,
+      identifierPrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
 
-  async searchByIdentifier(identifierValue, searchType) {}
+  /**
+   * Search for chemicals by identifier value
+   * @param {string} identifierValue - Identifier value to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchByIdentifier(identifierValue, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(identifierValue, {
+      limit: 10,
+      // Heavily prioritize identifier field
+      identifierExact: isExact ? 200 : 50,
+      identifierPrefix: isExact ? 10 : 100,
+      casExact: 10,
+      casPrefix: 5,
+      nameExact: 5,
+      namePrefix: 1,
+      synonymExact: 5,
+      synonymPrefix: 1
+    });
+  }
 
-  async searchBySynonym(synonymTerm, searchType) {}
+  /**
+   * Search for chemicals by synonym
+   * @param {string} synonymTerm - Synonym term to search for
+   * @param {string} searchType - Search type: 'exact' or 'prefix' (default: 'exact')
+   * @returns {Promise<Object>} Search results
+   */
+  async searchBySynonym(synonymTerm, searchType = 'exact') {
+    const isExact = searchType === 'exact';
+    return this.searchChemicals(synonymTerm, {
+      limit: 10,
+      // Heavily prioritize synonym field
+      synonymExact: isExact ? 200 : 50,
+      synonymPrefix: isExact ? 10 : 100,
+      nameExact: 20,
+      namePrefix: 5,
+      casExact: 10,
+      casPrefix: 5,
+      identifierExact: 5,
+      identifierPrefix: 1
+    });
+  }
 
   async advancedSearch(queryBuilder) {}
 

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture",
   "main": "index.js",
   "scripts": {
+    "test:search": "node tests/search.js",
+    "test:chemicals": "node tests/chemicals.js"
   },
   "keywords": [
   ],
   "author": "Chemical Research Development Team",
   "license": "MIT",
   "dependencies": {
+    "@toxplanet/tphelper": "1.2.8",
     "pg": "^8.11.3",
+    "drizzle-orm": "^0.30.0",
     "@opensearch-project/opensearch": "^2.5.0",
-    "@aws-sdk/client-opensearch-serverless": "^3.490.0",
     "@aws-sdk/client-secrets-manager": "^3.490.0",
-    "@aws-sdk/credential-providers": "^3.490.0",
-    "aws4fetch": "^1.0.18"
+    "@aws-sdk/credential-providers": "^3.490.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/tests/chemicals.js

@@ -0,0 +1,165 @@
+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

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