refactor: Update Salesforce authentication logic

Author: pacholoamit

src/services/salesforce/auth.ts

@@ -5,28 +5,36 @@ import { Logger } from "@/utils/types";
 const createSalesforceAuth = (opts: ConnectionOptions, logger: Logger) => {
   return {
     async authenticate(): Promise<Connection> {
-      return new Promise<Connection>(async (resolve, reject) => {
-        logger.info("Authenticating/Reauthenticating to Salesforce");
-        const client = new Connection(opts);
-
-        const data = await client.oauth2.refreshToken(opts.refreshToken, (err, res) => {
-          if (err) {
-            logger.error({ message: "Error authenticating to Salesforce" });
-            reject(err);
-          }
+      logger.info("Authenticating/Reauthenticating to Salesforce");
+
+      // Create the initial connection using full credentials.
+      // Make sure opts includes refreshToken, clientId, and clientSecret.
+      const client = new Connection(opts);
+
+      try {
+        // Wrap the callback-based refreshToken method into a Promise.
+        const data = await new Promise<any>((resolve, reject) => {
+          client.oauth2.refreshToken(opts.refreshToken, (err, res) => {
+            if (err) {
+              logger.error({ message: "Error refreshing token", err });
+              return reject(err);
+            }
+            resolve(res);
+          });
         });
 
-        logger.debug(`Salesforce OAuth2 Refreshed: ${JSON.stringify(data, null, 2)}`);
-
-        const newClient = new Connection({
-          accessToken: data.access_token,
-          instanceUrl: data["instance_url"],
-        });
+        // Instead of creating a new connection, update the existing connection.
+        client.accessToken = data.access_token;
+        client.instanceUrl = data.instance_url;
 
+        logger.debug(`Salesforce OAuth2 Refreshed: ${JSON.stringify(data, null, 2)}`);
         logger.info("Authentication/Reauthentication Successful");
 
-        resolve(newClient);
-      });
+        return client;
+      } catch (err) {
+        logger.error({ message: "Error authenticating to Salesforce", err });
+        throw err;
+      }
     },
   };
 };

src/services/salesforce/service.ts

@@ -1,41 +1,39 @@
 import { Connection, ConnectionOptions } from "jsforce";
 
-import redisService from "@/services/redis/service";
 import createSalesforceAuth from "@/services/salesforce/auth";
 import createSalesforceMutations from "@/services/salesforce/mutations";
 import createSalesforceQueries from "@/services/salesforce/query";
 import createSalesforceStream from "@/services/salesforce/stream";
 import createLogger from "@/utils/logger";
 import { SalesforceServiceType } from "@/utils/types";
 
-/**
- * Create a singleton SalesforceService instance. Handles automatic authentication
- * and re-authentication to Salesforce APIs, making it suitable for long-running processes.
- */
-
 const logger = createLogger("Salesforce Service");
 
 const createSalesforceService = async (params: ConnectionOptions): Promise<SalesforceServiceType> => {
   try {
+    // Authenticate using our auth helper.
     const client = await createSalesforceAuth(params, logger).authenticate();
 
     if (!client) {
       throw new Error("Failed to authenticate with Salesforce");
     }
 
+    // Attach a listener for token refresh events.
     client.on("refresh", async (accessToken: string, res: any) => {
       logger.debug(`Salesforce OAuth2 Refreshed: ${JSON.stringify(accessToken, null, 2)}`);
     });
 
     logger.info("Salesforce connection established");
 
+    // Return the service object with query, mutation, and stream methods.
     return {
       query: createSalesforceQueries(client, logger),
       mutation: createSalesforceMutations(client, logger),
       stream: createSalesforceStream(client, logger),
     };
   } catch (err) {
     logger.error({ message: "Error authenticating to Salesforce", err });
+    throw err;
   }
 };