@toxplanet/pegasus-sdk 1.1.20 → 1.1.21

package/lib/chemicals.js

@@ -1,6 +1,4 @@
 const { logError, logInfo } = require('@toxplanet/tphelper/logging');
-const { getDrizzle, schema } = require('./db');
-const { eq, sql, and, inArray, arrayContains } = require('drizzle-orm');
 const { SQSClient, SendMessageCommand } = require('@aws-sdk/client-sqs');
 
 const SEARCH_BOOST_EXACT_PRIMARY = 100;
@@ -14,16 +12,66 @@ function escapeLikePattern(value) {
   return value.replace(/[%_\\]/g, '\\$&');
 }
 
+function parsePostgresArray(str) {
+  if (!str || str === '{}') return [];
+  const trimmed = str.slice(1, -1);
+  if (!trimmed) return [];
+  const result = [];
+  let current = '';
+  let inQuotes = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const char = trimmed[i];
+    if (char === '"') {
+      if (inQuotes && trimmed[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === ',' && !inQuotes) {
+      result.push(current);
+      current = '';
+    } else {
+      current += char;
+    }
+  }
+  if (current) result.push(current);
+  return result;
+}
+
 class ChemicalsService {
   constructor(connection) {
     this.connection = connection;
-    this.db = null;
     this.sqsClient = null;
   }
 
-  async getDb() {
-    await this.connection.ensureConnected();
-    return this.connection.db;
+  _parsePostgresArray(str) {
+    return parsePostgresArray(str);
+  }
+
+  _toPostgresArray(arr) {
+    if (!Array.isArray(arr) || arr.length === 0) return '{}';
+    return '{' + arr.map(s => `"${String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`).join(',') + '}';
+  }
+
+  _serializeDate(d) {
+    return d instanceof Date ? d.toISOString() : (d || new Date().toISOString());
+  }
+
+  _mapChemicalRow(row) {
+    if (!row) return null;
+    return {
+      chemicalId: row.chemical_id,
+      sourceId: row.source_id,
+      chemicalName: row.chemical_name,
+      chemicalMeta: row.chemical_meta ? JSON.parse(row.chemical_meta) : null,
+      chemicalIdentifiers: row.chemical_identifiers ? JSON.parse(row.chemical_identifiers) : null,
+      chemicalSynonyms: this._parsePostgresArray(row.chemical_synonyms),
+      chemicalCategories: this._parsePostgresArray(row.chemical_categories),
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      importedAt: row.imported_at
+    };
   }
 
   async sendSqlWriteFailure({ sql, parameters, error, retryCount, failedAt }) {
@@ -71,32 +119,43 @@ class ChemicalsService {
   }
 
   _buildChemicalUpsertSql(chemical) {
-    const sql = [
+    const upsertSql = [
       '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::text[], :chemical_categories::text[], :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 = EXCLUDED.chemical_name,',
+      '  chemical_meta = EXCLUDED.chemical_meta,',
+      '  chemical_identifiers = EXCLUDED.chemical_identifiers,',
+      '  chemical_synonyms = EXCLUDED.chemical_synonyms,',
+      '  chemical_categories = EXCLUDED.chemical_categories,',
+      '  updated_at = EXCLUDED.updated_at',
+      'RETURNING chemical_id, source_id'
     ].join('\n');
 
-    const serializeDate = (d) => d instanceof Date ? d.toISOString() : d;
-
     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) } }
+      { name: 'chemical_meta', value: { stringValue: JSON.stringify(chemical.chemicalMeta ?? {}) }, typeHint: 'JSON' },
+      { name: 'chemical_identifiers', value: { stringValue: JSON.stringify(chemical.chemicalIdentifiers ?? {}) }, typeHint: 'JSON' },
+      { name: 'chemical_synonyms', value: { stringValue: this._toPostgresArray(chemical.chemicalSynonyms ?? []) } },
+      { name: 'chemical_categories', value: { stringValue: this._toPostgresArray(chemical.chemicalCategories ?? []) } },
+      { name: 'created_at', value: { stringValue: this._serializeDate(chemical.createdAt) }, typeHint: 'TIMESTAMP' },
+      { name: 'updated_at', value: { stringValue: this._serializeDate(chemical.updatedAt) }, typeHint: 'TIMESTAMP' }
     ];
 
-    return { sql, parameters };
+    return { sql: upsertSql, parameters };
+  }
+
+  async _executeChemicalUpsert(chemical) {
+    await this.connection.ensureConnected();
+    const { sql, parameters } = this._buildChemicalUpsertSql(chemical);
+    const queryResult = await this.connection.query(sql, parameters);
+    const row = queryResult.rows?.[0];
+    if (!row) return null;
+    return {
+      chemicalId: row.chemical_id,
+      sourceId: row.source_id
+    };
   }
 
   _buildDebugSql(chemical) {
@@ -173,24 +232,8 @@ class ChemicalsService {
         logInfo('pegasus-sdk', `[bulkIndexFielded] DEBUG SQL for document ${i}:\n${this._buildDebugSql(chemical)}`);
 
         const attemptUpsert = async () => {
-          const freshDb = await this.getDb();
-          return freshDb.insert(schema.chemicals)
-            .values(chemical)
-            .onConflictDoUpdate({
-              target: schema.chemicals.sourceId,
-              set: {
-                chemicalName: chemical.chemicalName,
-                chemicalMeta: chemical.chemicalMeta,
-                chemicalIdentifiers: chemical.chemicalIdentifiers,
-                chemicalSynonyms: chemical.chemicalSynonyms,
-                chemicalCategories: chemical.chemicalCategories,
-                updatedAt: new Date()
-              }
-            })
-            .returning({
-              chemicalId: schema.chemicals.chemicalId,
-              sourceId: schema.chemicals.sourceId
-            });
+          const result = await this._executeChemicalUpsert(chemical);
+          return result ? [result] : [];
         };
 
         let lastError = null;
@@ -281,25 +324,36 @@ class ChemicalsService {
 
   async createChemical(chemical) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      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;
+      const columns = ['source_id', 'chemical_name', 'chemical_meta', 'chemical_identifiers', 'chemical_synonyms', 'chemical_categories', 'created_at', 'updated_at'];
+      const values = [':source_id', ':chemical_name', ':chemical_meta::jsonb', ':chemical_identifiers::jsonb', ':chemical_synonyms::text[]', ':chemical_categories::text[]', ':created_at', ':updated_at'];
+      const params = [
+        { name: 'source_id', value: { stringValue: chemical.source_id } },
+        { name: 'chemical_name', value: { stringValue: chemical.chemical_name } },
+        { name: 'chemical_meta', value: { stringValue: JSON.stringify(chemical.chemical_meta || {}) }, typeHint: 'JSON' },
+        { name: 'chemical_identifiers', value: { stringValue: JSON.stringify(chemical.chemical_identifiers || {}) }, typeHint: 'JSON' },
+        { name: 'chemical_synonyms', value: { stringValue: this._toPostgresArray(chemical.chemical_synonyms || []) } },
+        { name: 'chemical_categories', value: { stringValue: this._toPostgresArray(chemical.chemical_categories || []) } },
+        { name: 'created_at', value: { stringValue: this._serializeDate(chemical.created_at || new Date()) }, typeHint: 'TIMESTAMP' },
+        { name: 'updated_at', value: { stringValue: this._serializeDate(chemical.updated_at || new Date()) }, typeHint: 'TIMESTAMP' }
+      ];
+
+      if (chemical.imported_at) {
+        columns.push('imported_at');
+        values.push(':imported_at');
+        params.push({ name: 'imported_at', value: { stringValue: this._serializeDate(chemical.imported_at) }, typeHint: 'TIMESTAMP' });
+      }
+
+      if (chemical.chemical_id) {
+        columns.push('chemical_id');
+        values.push(':chemical_id');
+        params.push({ name: 'chemical_id', value: { stringValue: chemical.chemical_id } });
+      }
+
+      const sql = `INSERT INTO chemicals (${columns.join(', ')}) VALUES (${values.join(', ')}) RETURNING *`;
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]);
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'createChemical', error);
       throw error;
@@ -308,23 +362,40 @@ class ChemicalsService {
 
   async updateChemical(chemicalId, updates) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
+      
+      const setClauses = [];
+      const params = [];
+      
+      if (updates.chemical_name) {
+        setClauses.push('chemical_name = :chemical_name');
+        params.push({ name: 'chemical_name', value: { stringValue: updates.chemical_name } });
+      }
+      if (updates.chemical_meta) {
+        setClauses.push('chemical_meta = :chemical_meta::jsonb');
+        params.push({ name: 'chemical_meta', value: { stringValue: JSON.stringify(updates.chemical_meta) }, typeHint: 'JSON' });
+      }
+      if (updates.chemical_identifiers) {
+        setClauses.push('chemical_identifiers = :chemical_identifiers::jsonb');
+        params.push({ name: 'chemical_identifiers', value: { stringValue: JSON.stringify(updates.chemical_identifiers) }, typeHint: 'JSON' });
+      }
+      if (updates.chemical_synonyms) {
+        setClauses.push('chemical_synonyms = :chemical_synonyms::text[]');
+        params.push({ name: 'chemical_synonyms', value: { stringValue: this._toPostgresArray(updates.chemical_synonyms) } });
+      }
+      if (updates.chemical_categories) {
+        setClauses.push('chemical_categories = :chemical_categories::text[]');
+        params.push({ name: 'chemical_categories', value: { stringValue: this._toPostgresArray(updates.chemical_categories) } });
+      }
+      
+      setClauses.push('updated_at = :updated_at');
+      params.push({ name: 'updated_at', value: { stringValue: this._serializeDate(new Date()) }, typeHint: 'TIMESTAMP' });
       
-      const updateData = {};
-      if (updates.chemical_name) updateData.chemicalName = updates.chemical_name;
-      if (updates.chemical_meta) updateData.chemicalMeta = updates.chemical_meta;
-      if (updates.chemical_identifiers) updateData.chemicalIdentifiers = updates.chemical_identifiers;
-      if (updates.chemical_synonyms) updateData.chemicalSynonyms = updates.chemical_synonyms;
-      if (updates.chemical_categories) updateData.chemicalCategories = updates.chemical_categories;
-      updateData.updatedAt = new Date();
-
-      const [result] = await db
-        .update(schema.chemicals)
-        .set(updateData)
-        .where(eq(schema.chemicals.chemicalId, chemicalId))
-        .returning();
-
-      return result || null;
+      params.push({ name: 'id', value: { stringValue: chemicalId } });
+      
+      const sql = `UPDATE chemicals SET ${setClauses.join(', ')} WHERE chemical_id = :id::uuid RETURNING *`;
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]) || null;
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'updateChemical', error);
       throw error;
@@ -333,14 +404,12 @@ class ChemicalsService {
 
   async deleteChemical(chemicalId) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const [deleted] = await db
-        .delete(schema.chemicals)
-        .where(eq(schema.chemicals.chemicalId, chemicalId))
-        .returning();
-
-      return deleted || null;
+      const sql = 'DELETE FROM chemicals WHERE chemical_id = :id::uuid RETURNING *';
+      const params = [{ name: 'id', value: { stringValue: chemicalId } }];
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]) || null;
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'deleteChemical', error);
       throw error;
@@ -349,14 +418,12 @@ class ChemicalsService {
 
   async deleteBySourceId(sourceId) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const [deleted] = await db
-        .delete(schema.chemicals)
-        .where(eq(schema.chemicals.sourceId, sourceId))
-        .returning();
-
-      return deleted || null;
+      const sql = 'DELETE FROM chemicals WHERE source_id = :source_id RETURNING *';
+      const params = [{ name: 'source_id', value: { stringValue: sourceId } }];
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]) || null;
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'deleteBySourceId', error);
       throw error;
@@ -365,13 +432,12 @@ class ChemicalsService {
 
   async deleteCollection(collectionName) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const deleted = await db
-        .delete(schema.chemicals)
-        .where(arrayContains(schema.chemicals.chemicalCategories, [collectionName]))
-        .returning();
-
+      const sql = 'DELETE FROM chemicals WHERE :collection_name = ANY(chemical_categories) RETURNING *';
+      const params = [{ name: 'collection_name', value: { stringValue: collectionName } }];
+      const result = await this.connection.query(sql, params);
+      const deleted = result.rows.map(row => this._mapChemicalRow(row));
       return { deletedCount: deleted.length, deleted };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'deleteCollection', error);
@@ -381,20 +447,20 @@ class ChemicalsService {
 
   async updateCollectionProperty(collectionName, propertyPath, newValue) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
+      
       const pathArray = propertyPath.split('.');
-      const valueJson = JSON.stringify(newValue);
-
-      const results = await db
-        .update(schema.chemicals)
-        .set({
-          chemicalMeta: sql`jsonb_set(${schema.chemicals.chemicalMeta}, ${pathArray}::text[], ${valueJson}::jsonb)`,
-          updatedAt: new Date()
-        })
-        .where(arrayContains(schema.chemicals.chemicalCategories, [collectionName]))
-        .returning();
-
-      return { updatedCount: results.length, updated: results };
+      const sql = 'UPDATE chemicals SET chemical_meta = jsonb_set(chemical_meta, :path::text[], :value::jsonb), updated_at = :updated_at WHERE :collection_name = ANY(chemical_categories) RETURNING *';
+      const params = [
+        { name: 'path', value: { stringValue: JSON.stringify(pathArray) }, typeHint: 'JSON' },
+        { name: 'value', value: { stringValue: JSON.stringify(newValue) }, typeHint: 'JSON' },
+        { name: 'updated_at', value: { stringValue: this._serializeDate(new Date()) }, typeHint: 'TIMESTAMP' },
+        { name: 'collection_name', value: { stringValue: collectionName } }
+      ];
+      
+      const result = await this.connection.query(sql, params);
+      const updated = result.rows.map(row => this._mapChemicalRow(row));
+      return { updatedCount: updated.length, updated };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'updateCollectionProperty', error);
       throw error;
@@ -403,31 +469,38 @@ class ChemicalsService {
 
   async bulkUpdateProperty(filter, propertyPath, newValue) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      let whereCondition = sql`1=1`;
+      let whereClause = '1=1';
+      const params = [];
       
       if (filter.chemicalIds && filter.chemicalIds.length > 0) {
-        whereCondition = inArray(schema.chemicals.chemicalId, filter.chemicalIds);
+        const ids = filter.chemicalIds.map((id, i) => `:cid_${i}`).join(',');
+        whereClause = `chemical_id = ANY(ARRAY[${ids}]::uuid[])`;
+        filter.chemicalIds.forEach((id, i) => {
+          params.push({ name: `cid_${i}`, value: { stringValue: id } });
+        });
       } else if (filter.sourceIds && filter.sourceIds.length > 0) {
-        whereCondition = inArray(schema.chemicals.sourceId, filter.sourceIds);
+        const ids = filter.sourceIds.map((id, i) => `:sid_${i}`).join(',');
+        whereClause = `source_id = ANY(ARRAY[${ids}]::text[])`;
+        filter.sourceIds.forEach((id, i) => {
+          params.push({ name: `sid_${i}`, value: { stringValue: id } });
+        });
       } else if (filter.category) {
-        whereCondition = arrayContains(schema.chemicals.chemicalCategories, [filter.category]);
+        whereClause = ':category = ANY(chemical_categories)';
+        params.push({ name: 'category', value: { stringValue: filter.category } });
       }
 
       const pathArray = propertyPath.split('.');
-      const valueJson = JSON.stringify(newValue);
-
-      const results = await db
-        .update(schema.chemicals)
-        .set({
-          chemicalMeta: sql`jsonb_set(COALESCE(${schema.chemicals.chemicalMeta}, '{}'), ${pathArray}::text[], ${valueJson}::jsonb)`,
-          updatedAt: new Date()
-        })
-        .where(whereCondition)
-        .returning();
-
-      return { updatedCount: results.length, updated: results };
+      const sql = `UPDATE chemicals SET chemical_meta = jsonb_set(COALESCE(chemical_meta, '{}'), :path::text[], :value::jsonb), updated_at = :updated_at WHERE ${whereClause} RETURNING *`;
+      
+      params.push({ name: 'path', value: { stringValue: JSON.stringify(pathArray) }, typeHint: 'JSON' });
+      params.push({ name: 'value', value: { stringValue: JSON.stringify(newValue) }, typeHint: 'JSON' });
+      params.push({ name: 'updated_at', value: { stringValue: this._serializeDate(new Date()) }, typeHint: 'TIMESTAMP' });
+      
+      const result = await this.connection.query(sql, params);
+      const updated = result.rows.map(row => this._mapChemicalRow(row));
+      return { updatedCount: updated.length, updated };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'bulkUpdateProperty', error);
       throw error;
@@ -436,15 +509,12 @@ class ChemicalsService {
 
   async getChemicalById(chemicalId) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const [result] = await db
-        .select()
-        .from(schema.chemicals)
-        .where(eq(schema.chemicals.chemicalId, chemicalId))
-        .limit(1);
-
-      return result || null;
+      const sql = 'SELECT * FROM chemicals WHERE chemical_id = :id::uuid LIMIT 1';
+      const params = [{ name: 'id', value: { stringValue: chemicalId } }];
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]) || null;
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getChemicalById', error);
       throw error;
@@ -453,15 +523,12 @@ class ChemicalsService {
 
   async getChemicalBySourceId(sourceId) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const [result] = await db
-        .select()
-        .from(schema.chemicals)
-        .where(eq(schema.chemicals.sourceId, sourceId))
-        .limit(1);
-
-      return result || null;
+      const sql = 'SELECT * FROM chemicals WHERE source_id = :source_id LIMIT 1';
+      const params = [{ name: 'source_id', value: { stringValue: sourceId } }];
+      const result = await this.connection.query(sql, params);
+      return this._mapChemicalRow(result.rows?.[0]) || null;
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getChemicalBySourceId', error);
       throw error;
@@ -470,14 +537,12 @@ class ChemicalsService {
 
   async getChemicalsByCAS(casNumber) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const results = await db
-        .select()
-        .from(schema.chemicals)
-        .where(sql`${schema.chemicals.chemicalIdentifiers}->>'CAS' = ${casNumber} OR ${schema.chemicals.chemicalIdentifiers}->'CAS' ? ${casNumber}`);
-
-      return results;
+      const sql = "SELECT * FROM chemicals WHERE chemical_identifiers->>'CAS' = :cas OR chemical_identifiers->'CAS' ? :cas";
+      const params = [{ name: 'cas', value: { stringValue: casNumber } }];
+      const result = await this.connection.query(sql, params);
+      return result.rows.map(row => this._mapChemicalRow(row));
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getChemicalsByCAS', error);
       throw error;
@@ -490,14 +555,12 @@ class ChemicalsService {
         throw new Error(`Invalid identifier type: ${identifierType}`);
       }
 
-      const db = await this.getDb();
-
-      const results = await db
-        .select()
-        .from(schema.chemicals)
-        .where(sql`${schema.chemicals.chemicalIdentifiers}->>${identifierType} = ${identifierValue} OR ${schema.chemicals.chemicalIdentifiers}->${identifierType} ? ${identifierValue}`);
-
-      return results;
+      await this.connection.ensureConnected();
+      
+      const sql = `SELECT * FROM chemicals WHERE chemical_identifiers->>'${identifierType}' = :value OR chemical_identifiers->'${identifierType}' ? :value`;
+      const params = [{ name: 'value', value: { stringValue: identifierValue } }];
+      const result = await this.connection.query(sql, params);
+      return result.rows.map(row => this._mapChemicalRow(row));
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getChemicalsByIdentifier', error);
       throw error;
@@ -506,14 +569,12 @@ class ChemicalsService {
 
   async countByCollection(collectionName) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals)
-        .where(arrayContains(schema.chemicals.chemicalCategories, [collectionName]));
-
-      return { count: result[0].count };
+      const sql = 'SELECT count(*)::int AS count FROM chemicals WHERE :collection_name = ANY(chemical_categories)';
+      const params = [{ name: 'collection_name', value: { stringValue: collectionName } }];
+      const result = await this.connection.query(sql, params);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'countByCollection', error);
       throw error;
@@ -522,15 +583,13 @@ class ChemicalsService {
 
   async countByIdentifier(identifierValue) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
 
       const searchPattern = `%${escapeLikePattern(identifierValue)}%`;
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals)
-        .where(sql`${schema.chemicals.chemicalIdentifiers}::text LIKE ${searchPattern}`);
-
-      return { count: result[0].count };
+      const sql = 'SELECT count(*)::int AS count FROM chemicals WHERE chemical_identifiers::text LIKE :pattern';
+      const params = [{ name: 'pattern', value: { stringValue: searchPattern } }];
+      const result = await this.connection.query(sql, params);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'countByIdentifier', error);
       throw error;
@@ -539,14 +598,12 @@ class ChemicalsService {
 
   async countByCAS(casNumber) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals)
-        .where(sql`${schema.chemicals.chemicalIdentifiers}->>'CAS' = ${casNumber} OR ${schema.chemicals.chemicalIdentifiers}->'CAS' ? ${casNumber}`);
-
-      return { count: result[0].count };
+      const sql = "SELECT count(*)::int AS count FROM chemicals WHERE chemical_identifiers->>'CAS' = :cas OR chemical_identifiers->'CAS' ? :cas";
+      const params = [{ name: 'cas', value: { stringValue: casNumber } }];
+      const result = await this.connection.query(sql, params);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'countByCAS', error);
       throw error;
@@ -555,13 +612,11 @@ class ChemicalsService {
 
   async getTotalSynonymCount() {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const result = await db
-        .select({ count: sql`sum(array_length(${schema.chemicals.chemicalSynonyms}, 1))::int` })
-        .from(schema.chemicals);
-
-      return { count: result[0].count || 0 };
+      const sql = 'SELECT sum(array_length(chemical_synonyms, 1))::int AS count FROM chemicals';
+      const result = await this.connection.query(sql, []);
+      return { count: result.rows[0]?.count || 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getTotalSynonymCount', error);
       throw error;
@@ -570,14 +625,12 @@ class ChemicalsService {
 
   async getSynonymCount(synonymTerm) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals)
-        .where(arrayContains(schema.chemicals.chemicalSynonyms, [synonymTerm]));
-
-      return { count: result[0].count };
+      const sql = 'SELECT count(*)::int AS count FROM chemicals WHERE :term = ANY(chemical_synonyms)';
+      const params = [{ name: 'term', value: { stringValue: synonymTerm } }];
+      const result = await this.connection.query(sql, params);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'getSynonymCount', error);
       throw error;
@@ -586,19 +639,18 @@ class ChemicalsService {
 
   async convertIdentifier(fromIdentifier, toIdentifierType) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
 
       const searchPattern = `%${escapeLikePattern(fromIdentifier)}%`;
-      const chemicals = await db
-        .select()
-        .from(schema.chemicals)
-        .where(sql`${schema.chemicals.chemicalIdentifiers}::text LIKE ${searchPattern}`);
+      const sql = 'SELECT * FROM chemicals WHERE chemical_identifiers::text LIKE :pattern LIMIT 1';
+      const params = [{ name: 'pattern', value: { stringValue: searchPattern } }];
+      const result = await this.connection.query(sql, params);
 
-      if (chemicals.length === 0) {
+      if (result.rows.length === 0) {
         return null;
       }
 
-      const chemical = chemicals[0];
+      const chemical = this._mapChemicalRow(result.rows[0]);
       const identifiers = chemical.chemicalIdentifiers || {};
       const toIdentifier = identifiers[toIdentifierType];
 
@@ -734,11 +786,10 @@ class ChemicalsService {
 
   async countAll() {
     try {
-      const db = await this.getDb();
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals);
-      return { count: result[0].count };
+      await this.connection.ensureConnected();
+      const sql = 'SELECT count(*)::int AS count FROM chemicals';
+      const result = await this.connection.query(sql, []);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'countAll', error);
       throw error;
@@ -747,28 +798,28 @@ class ChemicalsService {
 
   async findChemicalsWithoutDocuments(collectionName, searchTerm, pageSize = 100) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      let whereConditions = [];
+      let whereFragments = [];
+      const params = [];
       
       if (collectionName) {
-        whereConditions.push(arrayContains(schema.chemicals.chemicalCategories, [collectionName]));
+        whereFragments.push(':collection_name = ANY(chemical_categories)');
+        params.push({ name: 'collection_name', value: { stringValue: collectionName } });
       }
       
       if (searchTerm) {
         const searchPattern = `%${escapeLikePattern(searchTerm)}%`;
-        whereConditions.push(sql`${schema.chemicals.chemicalName} ILIKE ${searchPattern}`);
+        whereFragments.push('chemical_name ILIKE :search_term');
+        params.push({ name: 'search_term', value: { stringValue: searchPattern } });
       }
       
-      const whereClause = whereConditions.length > 0 ? and(...whereConditions) : undefined;
+      const whereClause = whereFragments.length > 0 ? 'WHERE ' + whereFragments.join(' AND ') : '';
+      params.push({ name: 'page_size', value: { longValue: pageSize } });
       
-      const results = await db
-        .select()
-        .from(schema.chemicals)
-        .where(whereClause)
-        .limit(pageSize);
-
-      return results;
+      const sql = `SELECT * FROM chemicals ${whereClause} LIMIT :page_size`;
+      const result = await this.connection.query(sql, params);
+      return result.rows.map(row => this._mapChemicalRow(row));
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'findChemicalsWithoutDocuments', error);
       throw error;
@@ -777,18 +828,17 @@ class ChemicalsService {
 
   async countChemicalsWithoutDocuments(collectionName) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      const whereClause = collectionName 
-        ? arrayContains(schema.chemicals.chemicalCategories, [collectionName])
-        : undefined;
+      let sql = 'SELECT count(*)::int AS count FROM chemicals';
+      const params = [];
+      if (collectionName) {
+        sql += ' WHERE :collection_name = ANY(chemical_categories)';
+        params.push({ name: 'collection_name', value: { stringValue: collectionName } });
+      }
       
-      const result = await db
-        .select({ count: sql`count(*)::int` })
-        .from(schema.chemicals)
-        .where(whereClause);
-
-      return { count: result[0].count };
+      const result = await this.connection.query(sql, params);
+      return { count: result.rows[0]?.count ?? 0 };
     } catch (error) {
       logError('pegasus-sdk', 'ChemicalsService', 'countChemicalsWithoutDocuments', error);
       throw error;

package/lib/connection.js

@@ -2,7 +2,7 @@ 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 { mapRecords } = require('./db');
 const { loadConfig } = require('../config');
 const { logInfo, logError } = require('@toxplanet/tphelper/logging');
 
@@ -20,7 +20,6 @@ class PegasusConnection {
     this.databaseName = this.config.database?.name;
     
     this.rdsDataClient = null;
-    this.db = null;
     this.osClient = null;
     this.isConnected = false;
   }
@@ -32,12 +31,6 @@ class PegasusConnection {
 
     this.rdsDataClient = new RDSDataClient({ region: this.region });
 
-    this.db = getDrizzle(this.rdsDataClient, {
-      resourceArn: this.clusterArn,
-      secretArn: this.secretArn,
-      database: this.databaseName
-    });
-
     logInfo('pegasus-sdk', 'RDS Data API client initialized');
 
     try {
@@ -78,7 +71,7 @@ class PegasusConnection {
    * @returns {Promise<boolean>} true if a connect happened, false if already connected.
    */
   async ensureConnected() {
-    if (!this.isConnected || !this.db) {
+    if (!this.isConnected) {
       await this.connect();
       return true;
     }
@@ -91,7 +84,6 @@ class PegasusConnection {
    */
   async reconnect() {
     logInfo('pegasus-sdk', 'Reconnecting RDS Data API client');
-    this.db = null;
     this.isConnected = false;
     await this.connect();
   }
@@ -108,20 +100,12 @@ class PegasusConnection {
       return;
     }
 
-    this.db = null;
     this.rdsDataClient = null;
     this.osClient = null;
     this.isConnected = false;
     logInfo('pegasus-sdk', 'RDS Data API client disconnected');
   }
 
-  getPostgresClient() {
-    if (!this.db) {
-      throw new Error('RDS Data API not initialized. Call connect() first.');
-    }
-    return this.db;
-  }
-
   getOpenSearchClient() {
     if (!this.osClient) {
       throw new Error('OpenSearch connection not established. Call connect() first or provide openSearchEndpoint.');
@@ -135,7 +119,7 @@ class PegasusConnection {
 
   async testConnection() {
     try {
-      if (!this.db) {
+      if (!this.rdsDataClient) {
         throw new Error('RDS Data API not initialized');
       }
 
@@ -143,16 +127,18 @@ class PegasusConnection {
         resourceArn: this.clusterArn,
         secretArn: this.secretArn,
         database: this.databaseName,
-        sql: 'SELECT NOW() as current_time, version() as pg_version'
+        sql: 'SELECT NOW() as current_time, version() as pg_version',
+        includeResultMetadata: true
       });
       
       const result = await this.rdsDataClient.send(command);
-      const row = result.records?.[0];
+      const rows = mapRecords(result.records, result.columnMetadata);
+      const row = rows?.[0];
       
       const pgStatus = {
         connected: true,
-        timestamp: row?.[0]?.stringValue,
-        version: row?.[1]?.stringValue
+        timestamp: row?.current_time,
+        version: row?.pg_version
       };
 
       let osStatus = null;
@@ -205,7 +191,8 @@ class PegasusConnection {
       secretArn: this.secretArn,
       database: this.databaseName,
       sql,
-      parameters: params || []
+      parameters: params || [],
+      includeResultMetadata: true
     });
 
     const result = await this.rdsDataClient.send(command);
@@ -213,19 +200,9 @@ class PegasusConnection {
     
     return {
       rowCount: result.numberOfRecordsUpdated || result.records?.length || 0,
-      rows: result.records || [],
-      command: result
+      rows: mapRecords(result.records, result.columnMetadata)
     };
   }
-
-  async transaction(callback) {
-    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);
-    });
-  }
 }
 
 module.exports = PegasusConnection;

package/lib/db/index.js

@@ -1,18 +1,26 @@
-const { drizzle } = require('drizzle-orm/aws-data-api/pg');
-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(rdsDataClient, { resourceArn, secretArn, database }) {
-  return drizzle(rdsDataClient, { schema, logger, resourceArn, secretArn, database });
+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.20",
+  "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,7 +25,6 @@
   "license": "MIT",
   "dependencies": {
     "@toxplanet/tphelper": "1.2.8",
-    "drizzle-orm": "^0.30.0",
     "@opensearch-project/opensearch": "^2.5.0",
     "@aws-sdk/client-rds-data": "^3.490.0",
     "@aws-sdk/client-sqs": "^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
-};