@toxplanet/pegasus-sdk 1.1.19 → 1.1.20

package/config/environment.acc.js

@@ -3,24 +3,13 @@ module.exports = {
   region: 'us-east-1',
   awsAccountId: '605134466764',
   sourceService: 'pegasus-sdk',
-  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',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:605134466764:secret:rds!cluster-9b502dde-5e2a-49db-b2c5-9801141ee40b-gkHbLm',
+  clusterArn: 'arn:aws:rds:us-east-1:605134466764:cluster:cr-chemicals-acc',
   database: {
-    host: 'cr-chemicals-acc.cluster-czgc4c20yerz.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
-  postgres: {
-    maxConnections: 2,
-    minConnections: 0,
-    idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 5000,
-    statementTimeout: 30000,
-    queryTimeout: 30000,
-    ssl: {
-      rejectUnauthorized: false
-    }
-  },
+  openSearchEndpoint: 'https://1pbu0yqr197lq07hfcjh.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
   indexRoutes: {
     chemicals: ['chemicals*'],
     documents: ['documents*'],

package/config/environment.dev.js

@@ -3,24 +3,13 @@ module.exports = {
   region: 'us-east-1',
   awsAccountId: '292931567094',
   sourceService: 'pegasus-sdk',
-  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',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:292931567094:secret:rds!cluster-b851c3ce-58cc-41cd-aeae-05cc7f5e031a-ZYSjiI',
+  clusterArn: 'arn:aws:rds:us-east-1:292931567094:cluster:cr-chemicals',
   database: {
-    host: 'cr-chemicals.cluster-cz0iqdg8irhb.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
-  postgres: {
-    maxConnections: 2,
-    minConnections: 1,
-    idleTimeoutMillis: 0,
-    connectionTimeoutMillis: 15000,
-    statementTimeout: 30000,
-    queryTimeout: 30000,
-    ssl: {
-      rejectUnauthorized: false
-    }
-  },
+  openSearchEndpoint: 'https://war8lk73nzswquk8dcz1.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
   indexRoutes: {
     chemicals: ['chemicals*'],
     documents: ['documents*'],

package/config/environment.prod.js

@@ -3,24 +3,13 @@ module.exports = {
   region: 'us-east-1',
   awsAccountId: '147997144422',
   sourceService: 'pegasus-sdk',
-  secretName: 'rds!cluster-25483b3f-3758-43ed-9548-26c91de16c2d',
-  openSearchEndpoint: 'https://odusb11s00j5hyy5r6.us-east-1.aoss.amazonaws.com',
-  openSearchIndex: 'chemicals',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:147997144422:secret:rds!cluster-25483b3f-3758-43ed-9548-26c91de16c2d',
+  clusterArn: 'arn:aws:rds:us-east-1:147997144422:cluster:cr-chemicals-prod',
   database: {
-    host: 'cr-chemicals-qa.cluster-c7gakqksq9m4.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
-  postgres: {
-    maxConnections: 10,
-    minConnections: 2,
-    idleTimeoutMillis: 120000,
-    connectionTimeoutMillis: 15000,
-    statementTimeout: 120000,
-    queryTimeout: 120000,
-    ssl: {
-      rejectUnauthorized: true
-    }
-  },
+  openSearchEndpoint: 'https://odusb11s00j5hyy5r6.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
   indexRoutes: {
     chemicals: ['chemicals*'],
     documents: ['documents*'],

package/config/environment.qa.js

@@ -3,24 +3,13 @@ module.exports = {
   region: 'us-east-1',
   awsAccountId: '147997144422',
   sourceService: 'pegasus-sdk',
-  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',
+  secretArn: 'arn:aws:secretsmanager:us-east-1:147997144422:secret:rds!cluster-25483b3f-3758-43ed-9548-26c91de16c2d-oYjysU',
+  clusterArn: 'arn:aws:rds:us-east-1:147997144422:cluster:cr-chemicals-qa',
   database: {
-    host: 'cr-chemicals-qa.cluster-c7gakqksq9m4.us-east-1.rds.amazonaws.com',
     name: 'chemicals'
   },
-  postgres: {
-    maxConnections: 5,
-    minConnections: 1,
-    idleTimeoutMillis: 60000,
-    connectionTimeoutMillis: 10000,
-    statementTimeout: 60000,
-    queryTimeout: 60000,
-    ssl: {
-      rejectUnauthorized: true
-    }
-  },
+  openSearchEndpoint: 'https://odusb11s00j5hyy5r6.us-east-1.aoss.amazonaws.com',
+  openSearchIndex: 'chemicals',
   indexRoutes: {
     chemicals: ['chemicals*'],
     documents: ['documents*'],

package/lib/chemicals.js

@@ -22,11 +22,8 @@ class ChemicalsService {
   }
 
   async getDb() {
-    const reconnected = await this.connection.ensureConnected();
-    if (reconnected || !this.db) {
-      this.db = getDrizzle(this.connection.pgPool);
-    }
-    return this.db;
+    await this.connection.ensureConnected();
+    return this.connection.db;
   }
 
   async sendSqlWriteFailure({ sql, parameters, error, retryCount, failedAt }) {
@@ -76,28 +73,28 @@ class ChemicalsService {
   _buildChemicalUpsertSql(chemical) {
     const sql = [
       'INSERT INTO chemicals (source_id, chemical_name, chemical_meta, chemical_identifiers, chemical_synonyms, chemical_categories, created_at, updated_at)',
-      'VALUES (@source_id, @chemical_name, @chemical_meta::jsonb, @chemical_identifiers::jsonb, @chemical_synonyms, @chemical_categories, @created_at, @updated_at)',
+      'VALUES (:source_id, :chemical_name, :chemical_meta::jsonb, :chemical_identifiers::jsonb, :chemical_synonyms, :chemical_categories, :created_at, :updated_at)',
       'ON CONFLICT (source_id) DO UPDATE SET',
-      '  chemical_name = @chemical_name,',
-      '  chemical_meta = @chemical_meta::jsonb,',
-      '  chemical_identifiers = @chemical_identifiers::jsonb,',
-      '  chemical_synonyms = @chemical_synonyms,',
-      '  chemical_categories = @chemical_categories,',
-      '  updated_at = @updated_at'
+      '  chemical_name = :chemical_name,',
+      '  chemical_meta = :chemical_meta::jsonb,',
+      '  chemical_identifiers = :chemical_identifiers::jsonb,',
+      '  chemical_synonyms = :chemical_synonyms,',
+      '  chemical_categories = :chemical_categories,',
+      '  updated_at = :updated_at'
     ].join('\n');
 
     const serializeDate = (d) => d instanceof Date ? d.toISOString() : d;
 
-    const parameters = {
-      '@source_id': chemical.sourceId,
-      '@chemical_name': chemical.chemicalName,
-      '@chemical_meta': JSON.stringify(chemical.chemicalMeta ?? {}),
-      '@chemical_identifiers': JSON.stringify(chemical.chemicalIdentifiers ?? {}),
-      '@chemical_synonyms': JSON.stringify(chemical.chemicalSynonyms ?? []),
-      '@chemical_categories': JSON.stringify(chemical.chemicalCategories ?? []),
-      '@created_at': serializeDate(chemical.createdAt),
-      '@updated_at': serializeDate(chemical.updatedAt)
-    };
+    const parameters = [
+      { name: 'source_id', value: { stringValue: chemical.sourceId } },
+      { name: 'chemical_name', value: { stringValue: chemical.chemicalName } },
+      { name: 'chemical_meta', value: { stringValue: JSON.stringify(chemical.chemicalMeta ?? {}) } },
+      { name: 'chemical_identifiers', value: { stringValue: JSON.stringify(chemical.chemicalIdentifiers ?? {}) } },
+      { name: 'chemical_synonyms', value: { stringValue: JSON.stringify(chemical.chemicalSynonyms ?? []) } },
+      { name: 'chemical_categories', value: { stringValue: JSON.stringify(chemical.chemicalCategories ?? []) } },
+      { name: 'created_at', value: { stringValue: serializeDate(chemical.createdAt) } },
+      { name: 'updated_at', value: { stringValue: serializeDate(chemical.updatedAt) } }
+    ];
 
     return { sql, parameters };
   }
@@ -175,14 +172,6 @@ class ChemicalsService {
         logInfo('pegasus-sdk', `[bulkIndexFielded] Prepared chemical object: sourceId=${chemical.sourceId}, chemicalName=${chemical.chemicalName}`);
         logInfo('pegasus-sdk', `[bulkIndexFielded] DEBUG SQL for document ${i}:\n${this._buildDebugSql(chemical)}`);
 
-        const isConnectionError = (err) =>
-          err.message?.toLowerCase().includes('timeout') ||
-          err.message?.toLowerCase().includes('connection') ||
-          err.code === 'ECONNREFUSED' ||
-          err.code === 'ETIMEDOUT';
-
-        // Use this.getDb() on each attempt so a reconnect mid-loop automatically
-        // gets a fresh Drizzle instance bound to the new pool.
         const attemptUpsert = async () => {
           const freshDb = await this.getDb();
           return freshDb.insert(schema.chemicals)
@@ -211,38 +200,20 @@ class ChemicalsService {
         try {
           const [result] = await attemptUpsert();
           logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} indexed successfully: ${result?.chemicalId || 'no ID returned'}`);
-          this.connection.recordActivity();
           results.push({ index: i, success: true, result });
           continue;
         } catch (firstErr) {
           lastError = firstErr;
-
-          if (isConnectionError(firstErr)) {
-            // Stale pool — rebuild the connection and try once more before queuing
-            logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} connection error (${firstErr.message}), reconnecting pool and retrying`);
-            try {
-              await this.connection.reconnect();
-              const [result] = await attemptUpsert();
-              logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} indexed successfully after reconnect: ${result?.chemicalId || 'no ID returned'}`);
-              this.connection.recordActivity();
-              results.push({ index: i, success: true, result });
-              continue;
-            } catch (reconnectErr) {
-              lastError = reconnectErr;
-              retryCount = 1;
-            }
-          } else {
-            logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} first attempt failed (${firstErr.message}), retrying once`);
-            try {
-              const [result] = await attemptUpsert();
-              logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} indexed successfully on retry: ${result?.chemicalId || 'no ID returned'}`);
-              this.connection.recordActivity();
-              results.push({ index: i, success: true, result });
-              continue;
-            } catch (retryErr) {
-              lastError = retryErr;
-              retryCount = 1;
-            }
+          logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} first attempt failed (${firstErr.message}), retrying once`);
+
+          try {
+            const [result] = await attemptUpsert();
+            logInfo('pegasus-sdk', `[bulkIndexFielded] Document ${i} indexed successfully on retry: ${result?.chemicalId || 'no ID returned'}`);
+            results.push({ index: i, success: true, result });
+            continue;
+          } catch (retryErr) {
+            lastError = retryErr;
+            retryCount = 1;
           }
         }
 

package/lib/connection.js

@@ -1,8 +1,8 @@
-const { Pool } = require('pg');
-const { Client } = require('@opensearch-project/opensearch');
-const { SecretsManagerClient, GetSecretValueCommand } = require('@aws-sdk/client-secrets-manager');
+const { Client: OpenSearchClient } = require('@opensearch-project/opensearch');
+const { RDSDataClient, ExecuteStatementCommand } = require('@aws-sdk/client-rds-data');
 const { AwsSigv4Signer } = require('@opensearch-project/opensearch/aws');
 const { fromNodeProviderChain } = require('@aws-sdk/credential-providers');
+const { getDrizzle, schema } = require('./db');
 const { loadConfig } = require('../config');
 const { logInfo, logError } = require('@toxplanet/tphelper/logging');
 
@@ -13,38 +13,16 @@ class PegasusConnection {
     this.config = { ...envConfig, ...config };
     this.environment = this.config.environment;
     this.region = this.config.region;
-    this.secretName = this.config.secretName;
+    this.secretArn = this.config.secretArn;
+    this.clusterArn = this.config.clusterArn;
     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.rdsDataClient = null;
+    this.db = null;
     this.osClient = null;
-    this.secretsClient = null;
-    this.cachedSecret = null;
     this.isConnected = false;
-    this.lastActivityAt = null;
-  }
-
-  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() {
@@ -52,52 +30,32 @@ class PegasusConnection {
       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,
-      keepAlive: true,
-      keepAliveInitialDelayMillis: 10000,
-      ssl: this.config.postgres.ssl,
-      statement_timeout: this.config.postgres.statementTimeout,
-      query_timeout: this.config.postgres.queryTimeout
-    };
-
-    this.pgPool = new Pool(poolConfig);
+    this.rdsDataClient = new RDSDataClient({ region: this.region });
 
-    this.pgPool.on('error', (err) => {
-      logError('pegasus-sdk', 'PegasusConnection', 'pgPool.error', err);
+    this.db = getDrizzle(this.rdsDataClient, {
+      resourceArn: this.clusterArn,
+      secretArn: this.secretArn,
+      database: this.databaseName
     });
 
-    this.pgPool.on('connect', () => {
-      this.lastActivityAt = Date.now();
-      logInfo('pegasus-sdk', 'PostgreSQL client connected');
-    });
+    logInfo('pegasus-sdk', 'RDS Data API client initialized');
 
-    this.pgPool.on('remove', () => {
-      logInfo('pegasus-sdk', 'PostgreSQL client removed from pool');
-    });
-
-    // Eagerly verify the connection is actually reachable before declaring
-    // isConnected = true. Without this, new Pool() never opens a socket and
-    // isConnected would be a lie — the first real query would pay the full
-    // TCP+SSL+auth cost while racing the connectionTimeoutMillis.
-    const verifyClient = await this.pgPool.connect();
-    await verifyClient.query('SELECT 1');
-    verifyClient.release();
-    this.lastActivityAt = Date.now();
-    logInfo('pegasus-sdk', 'PostgreSQL connection verified and ready');
+    try {
+      const command = new ExecuteStatementCommand({
+        resourceArn: this.clusterArn,
+        secretArn: this.secretArn,
+        database: this.databaseName,
+        sql: 'SELECT 1'
+      });
+      await this.rdsDataClient.send(command);
+      logInfo('pegasus-sdk', 'RDS Data API connection verified and ready');
+    } catch (err) {
+      logError('pegasus-sdk', 'PegasusConnection', 'connect.verification', err);
+      throw err;
+    }
 
     if (this.openSearchEndpoint) {
-      this.osClient = new Client({
+      this.osClient = new OpenSearchClient({
         ...AwsSigv4Signer({
           region: this.region,
           service: 'aoss',
@@ -113,77 +71,36 @@ class PegasusConnection {
     this.isConnected = true;
   }
 
-  async reconnect() {
-    logInfo('pegasus-sdk', 'Reconnecting PostgreSQL pool (stale connection detected)');
-    if (this.pgPool) {
-      try {
-        await this.pgPool.end();
-      } catch (err) {
-        logError('pegasus-sdk', 'PegasusConnection', 'reconnect.end', err);
-      }
-      this.pgPool = null;
-    }
-    this.isConnected = false;
-    this.lastActivityAt = null;
-    await this.connect();
-  }
-
   /**
-   * Call this after any successful database operation so ensureConnected()
-   * knows the connection was recently healthy and can skip the liveness check.
-   */
-  recordActivity() {
-    this.lastActivityAt = Date.now();
-  }
-
-  /**
-   * Proactively verify the connection is alive before executing a batch of
-   * queries. If the pool has been idle long enough that connections may have
-   * gone stale, a lightweight SELECT 1 is issued first. If that fails, the
-   * pool is rebuilt before the caller's real query fires — avoiding the full
-   * connectionTimeoutMillis wait on the real query.
+   * With the RDS Data API, there are no stale connections or pool idleness.
+   * Each call is stateless. Just ensure the client is initialized.
    *
-   * @returns {Promise<boolean>} true if a reconnect happened (caller should
-   *   reset any cached Drizzle db instance), false if connection is healthy.
+   * @returns {Promise<boolean>} true if a connect happened, false if already connected.
    */
   async ensureConnected() {
-    if (!this.pgPool || !this.isConnected) {
+    if (!this.isConnected || !this.db) {
       await this.connect();
       return true;
     }
+    return false;
+  }
 
-    // If we used this connection recently, trust it's still alive.
-    const FRESH_THRESHOLD_MS = 60_000;
-    const idleSince = Date.now() - (this.lastActivityAt || 0);
-    if (idleSince < FRESH_THRESHOLD_MS) {
-      return false;
-    }
-
-    logInfo('pegasus-sdk', `[ensureConnected] Pool inactive for ${Math.round(idleSince / 1000)}s — running liveness check before query`);
+  /**
+   * Data API is stateless, so reconnect simply means re-initializing.
+   * Called in fallback scenarios but not necessary for stale connections.
+   */
+  async reconnect() {
+    logInfo('pegasus-sdk', 'Reconnecting RDS Data API client');
+    this.db = null;
+    this.isConnected = false;
+    await this.connect();
+  }
 
-    let client;
-    try {
-      // Use a short race timeout so a dead connection fails fast rather than
-      // waiting the full connectionTimeoutMillis before we know to reconnect.
-      client = await Promise.race([
-        this.pgPool.connect(),
-        new Promise((_, reject) =>
-          setTimeout(() => reject(new Error('liveness check timeout')), 3000)
-        )
-      ]);
-      await client.query('SELECT 1');
-      client.release();
-      this.lastActivityAt = Date.now();
-      logInfo('pegasus-sdk', '[ensureConnected] Liveness check passed');
-      return false;
-    } catch (err) {
-      if (client) {
-        try { client.release(true); } catch (_) {}
-      }
-      logInfo('pegasus-sdk', `[ensureConnected] Liveness check failed (${err.message}) — reconnecting pool proactively`);
-      await this.reconnect();
-      return true;
-    }
+  /**
+   * With stateless Data API, there is no meaningful "activity" tracking needed.
+   * This is a no-op for backward compatibility.
+   */
+  recordActivity() {
   }
 
   async disconnect() {
@@ -191,21 +108,18 @@ class PegasusConnection {
       return;
     }
 
-    if (this.pgPool) {
-      await this.pgPool.end();
-      this.pgPool = null;
-    }
-
+    this.db = null;
+    this.rdsDataClient = null;
     this.osClient = null;
     this.isConnected = false;
-    this.cachedSecret = null;
+    logInfo('pegasus-sdk', 'RDS Data API client disconnected');
   }
 
   getPostgresClient() {
-    if (!this.pgPool) {
-      throw new Error('PostgreSQL connection not established. Call connect() first.');
+    if (!this.db) {
+      throw new Error('RDS Data API not initialized. Call connect() first.');
     }
-    return this.pgPool;
+    return this.db;
   }
 
   getOpenSearchClient() {
@@ -221,54 +135,57 @@ class PegasusConnection {
 
   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
-        };
+      if (!this.db) {
+        throw new Error('RDS Data API not initialized');
+      }
+
+      const command = new ExecuteStatementCommand({
+        resourceArn: this.clusterArn,
+        secretArn: this.secretArn,
+        database: this.databaseName,
+        sql: 'SELECT NOW() as current_time, version() as pg_version'
+      });
+      
+      const result = await this.rdsDataClient.send(command);
+      const row = result.records?.[0];
+      
+      const pgStatus = {
+        connected: true,
+        timestamp: row?.[0]?.stringValue,
+        version: row?.[1]?.stringValue
+      };
 
-        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' }
-                }
+      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
-            };
-          }
+            }
+          });
+          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');
+
+      return {
+        postgres: pgStatus,
+        opensearch: osStatus,
+        environment: this.environment,
+        region: this.region
+      };
     } catch (error) {
       return {
         postgres: { connected: false, error: error.message },
@@ -280,33 +197,34 @@ class PegasusConnection {
   }
 
   async query(sql, params) {
-    const pool = this.getPostgresClient();
     const start = Date.now();
     logInfo('pegasus-sdk', `[SQL] ${sql}${params ? ` -- params: ${JSON.stringify(params)}` : ''}`);
-    const result = await pool.query(sql, params);
-    logInfo('pegasus-sdk', `[SQL] rowCount: ${result.rowCount} duration: ${Date.now() - start}ms`);
-    return result;
-  }
+    
+    const command = new ExecuteStatementCommand({
+      resourceArn: this.clusterArn,
+      secretArn: this.secretArn,
+      database: this.databaseName,
+      sql,
+      parameters: params || []
+    });
 
-  async getClient() {
-    const pool = this.getPostgresClient();
-    return pool.connect();
+    const result = await this.rdsDataClient.send(command);
+    logInfo('pegasus-sdk', `[SQL] rowCount: ${result.numberOfRecordsUpdated || 0} duration: ${Date.now() - start}ms`);
+    
+    return {
+      rowCount: result.numberOfRecordsUpdated || result.records?.length || 0,
+      rows: result.records || [],
+      command: result
+    };
   }
 
   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();
+    if (!this.db) {
+      throw new Error('RDS Data API not initialized. Call connect() first.');
     }
+    return await this.db.transaction(async (trx) => {
+      return await callback(trx);
+    });
   }
 }
 

package/lib/db/index.js

@@ -1,4 +1,4 @@
-const { drizzle } = require('drizzle-orm/node-postgres');
+const { drizzle } = require('drizzle-orm/aws-data-api/pg');
 const { logInfo } = require('@toxplanet/tphelper/logging');
 const schema = require('./schema');
 
@@ -8,8 +8,8 @@ const logger = {
   }
 };
 
-function getDrizzle(pgPool) {
-  return drizzle(pgPool, { schema, logger });
+function getDrizzle(rdsDataClient, { resourceArn, secretArn, database }) {
+  return drizzle(rdsDataClient, { schema, logger, resourceArn, secretArn, database });
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.1.19",
+  "version": "1.1.20",
   "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
   "type": "commonjs",
@@ -25,10 +25,9 @@
   "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-secrets-manager": "^3.490.0",
+    "@aws-sdk/client-rds-data": "^3.490.0",
     "@aws-sdk/client-sqs": "^3.490.0",
     "@aws-sdk/credential-providers": "^3.490.0"
   },