@toxplanet/pegasus-sdk 1.1.19 → 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,19 +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() {
-    const reconnected = await this.connection.ensureConnected();
-    if (reconnected || !this.db) {
-      this.db = getDrizzle(this.connection.pgPool);
-    }
-    return this.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 }) {
@@ -74,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 = {
-      '@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 ?? {}) }, 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: upsertSql, parameters };
+  }
 
-    return { sql, 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) {
@@ -175,33 +231,9 @@ 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)
-            .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;
@@ -211,38 +243,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;
           }
         }
 
@@ -310,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;
@@ -337,23 +362,40 @@ class ChemicalsService {
 
   async updateChemical(chemicalId, updates) {
     try {
-      const db = await this.getDb();
+      await this.connection.ensureConnected();
       
-      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;
+      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' });
+      
+      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;
@@ -362,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;
@@ -378,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;
@@ -394,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);
@@ -410,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;
@@ -432,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;
@@ -465,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;
@@ -482,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;
@@ -499,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;
@@ -519,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;
@@ -535,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;
@@ -551,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;
@@ -568,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;
@@ -584,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;
@@ -599,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;
@@ -615,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];
 
@@ -763,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;
@@ -776,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;
@@ -806,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;