@toxplanet/pegasus-sdk 1.1.19 → 1.1.21

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 { mapRecords } = require('./db');
 const { loadConfig } = require('../config');
 const { logInfo, logError } = require('@toxplanet/tphelper/logging');
 
@@ -13,38 +13,15 @@ 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.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 +29,26 @@ 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.pgPool.on('error', (err) => {
-      logError('pegasus-sdk', 'PegasusConnection', 'pgPool.error', err);
-    });
-
-    this.pgPool.on('connect', () => {
-      this.lastActivityAt = Date.now();
-      logInfo('pegasus-sdk', 'PostgreSQL client connected');
-    });
+    this.rdsDataClient = new RDSDataClient({ region: this.region });
 
-    this.pgPool.on('remove', () => {
-      logInfo('pegasus-sdk', 'PostgreSQL client removed from pool');
-    });
+    logInfo('pegasus-sdk', 'RDS Data API client initialized');
 
-    // 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 +64,35 @@ 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) {
       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.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 +100,10 @@ class PegasusConnection {
       return;
     }
 
-    if (this.pgPool) {
-      await this.pgPool.end();
-      this.pgPool = null;
-    }
-
+    this.rdsDataClient = 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;
+    logInfo('pegasus-sdk', 'RDS Data API client disconnected');
   }
 
   getOpenSearchClient() {
@@ -221,54 +119,59 @@ 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.rdsDataClient) {
+        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',
+        includeResultMetadata: true
+      });
+      
+      const result = await this.rdsDataClient.send(command);
+      const rows = mapRecords(result.records, result.columnMetadata);
+      const row = rows?.[0];
+      
+      const pgStatus = {
+        connected: true,
+        timestamp: row?.current_time,
+        version: row?.pg_version
+      };
 
-        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 +183,25 @@ 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;
-  }
-
-  async getClient() {
-    const pool = this.getPostgresClient();
-    return pool.connect();
-  }
+    
+    const command = new ExecuteStatementCommand({
+      resourceArn: this.clusterArn,
+      secretArn: this.secretArn,
+      database: this.databaseName,
+      sql,
+      parameters: params || [],
+      includeResultMetadata: true
+    });
 
-  async transaction(callback) {
-    const client = await this.getClient();
+    const result = await this.rdsDataClient.send(command);
+    logInfo('pegasus-sdk', `[SQL] rowCount: ${result.numberOfRecordsUpdated || 0} duration: ${Date.now() - start}ms`);
     
-    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();
-    }
+    return {
+      rowCount: result.numberOfRecordsUpdated || result.records?.length || 0,
+      rows: mapRecords(result.records, result.columnMetadata)
+    };
   }
 }
 

package/lib/db/index.js

@@ -1,18 +1,26 @@
-const { drizzle } = require('drizzle-orm/node-postgres');
-const { logInfo } = require('@toxplanet/tphelper/logging');
-const schema = require('./schema');
+function getFieldValue(field) {
+  if (!field || field.isNull) return null;
+  if ('stringValue' in field) return field.stringValue;
+  if ('longValue' in field) return field.longValue;
+  if ('doubleValue' in field) return field.doubleValue;
+  if ('booleanValue' in field) return field.booleanValue;
+  return null;
+}
 
-const logger = {
-  logQuery(query, params) {
-    logInfo('pegasus-sdk', `[SQL] ${query}${params?.length ? ` -- params: ${JSON.stringify(params)}` : ''}`);
-  }
-};
+function mapRecord(record, columnMetadata) {
+  const obj = {};
+  columnMetadata.forEach((col, i) => {
+    obj[col.name] = getFieldValue(record[i]);
+  });
+  return obj;
+}
 
-function getDrizzle(pgPool) {
-  return drizzle(pgPool, { schema, logger });
+function mapRecords(records = [], columnMetadata = []) {
+  return records.map(r => mapRecord(r, columnMetadata));
 }
 
 module.exports = {
-  getDrizzle,
-  schema
+  getFieldValue,
+  mapRecord,
+  mapRecords
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toxplanet/pegasus-sdk",
-  "version": "1.1.19",
+  "version": "1.1.21",
   "description": "SDK for migrating chemical data to Pegasus PostgreSQL + OpenSearch architecture with Elasticsearch client compatibility",
   "main": "index.js",
   "type": "commonjs",
@@ -25,10 +25,8 @@
   "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"
   },

package/lib/db/schema.js

@@ -1,27 +0,0 @@
-const { pgTable, uuid, text, jsonb, timestamp, index } = 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 {
-    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
-};