How to Integrate Replit with Salesforce

1// salesforce-auth.js — OAuth token management
2const axios = require('axios');
3
4let tokenCache = null;
5let tokenExpiry = 0;
6
7async function getSalesforceToken() {
8  // Return cached token if still valid (with 5-minute buffer)
9  if (tokenCache && Date.now() < tokenExpiry - 300000) {
10    return tokenCache;
11  }
12
13  const loginUrl = process.env.SF_LOGIN_URL;
14  const params = new URLSearchParams({
15    grant_type: 'password',
16    client_id: process.env.SF_CLIENT_ID,
17    client_secret: process.env.SF_CLIENT_SECRET,
18    username: process.env.SF_USERNAME,
19    // Append security token directly to password (no space)
20    password: process.env.SF_PASSWORD + process.env.SF_SECURITY_TOKEN
21  });
22
23  try {
24    const response = await axios.post(
25      `${loginUrl}/services/oauth2/token`,
26      params.toString(),
27      { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
28    );
29
30    tokenCache = {
31      accessToken: response.data.access_token,
32      instanceUrl: response.data.instance_url
33    };
34    // Salesforce tokens typically valid for 2 hours; cache for 90 minutes
35    tokenExpiry = Date.now() + 90 * 60 * 1000;
36
37    console.log('Salesforce token acquired, instance:', tokenCache.instanceUrl);
38    return tokenCache;
39  } catch (error) {
40    const msg = error.response?.data?.error_description || error.message;
41    throw new Error(`Salesforce auth failed: ${msg}`);
42  }
43}
44
45module.exports = { getSalesforceToken };

1// server.js — Salesforce REST API integration
2const express = require('express');
3const axios = require('axios');
4const { getSalesforceToken } = require('./salesforce-auth');
5
6const app = express();
7app.use(express.json());
8
9const SF_API_VERSION = 'v59.0';
10
11// Helper: make authenticated Salesforce API call
12async function sfRequest(method, path, data = null) {
13  const { accessToken, instanceUrl } = await getSalesforceToken();
14  const url = `${instanceUrl}/services/data/${SF_API_VERSION}${path}`;
15  const config = {
16    method,
17    url,
18    headers: {
19      'Authorization': `Bearer ${accessToken}`,
20      'Content-Type': 'application/json'
21    }
22  };
23  if (data) config.data = data;
24  const response = await axios(config);
25  return response.data;
26}
27
28// GET /leads — query recent leads with SOQL
29app.get('/leads', async (req, res) => {
30  try {
31    const soql = `SELECT Id, FirstName, LastName, Email, Company, Status,
32      CreatedDate FROM Lead
33      WHERE CreatedDate = LAST_N_DAYS:30
34      ORDER BY CreatedDate DESC
35      LIMIT 50`;
36    const result = await sfRequest('GET',
37      `/query?q=${encodeURIComponent(soql)}`);
38    res.json({
39      total: result.totalSize,
40      leads: result.records
41    });
42  } catch (err) {
43    res.status(500).json({ error: err.message });
44  }
45});
46
47// GET /opportunities — open pipeline
48app.get('/opportunities', async (req, res) => {
49  try {
50    const soql = `SELECT Id, Name, StageName, Amount, CloseDate,
51      Account.Name FROM Opportunity
52      WHERE IsClosed = false
53      ORDER BY CloseDate ASC
54      LIMIT 100`;
55    const result = await sfRequest('GET',
56      `/query?q=${encodeURIComponent(soql)}`);
57    res.json({ opportunities: result.records });
58  } catch (err) {
59    res.status(500).json({ error: err.message });
60  }
61});
62
63// POST /leads — create a new Lead
64app.post('/leads', async (req, res) => {
65  try {
66    const { firstName, lastName, email, company, phone } = req.body;
67    if (!lastName || !email || !company) {
68      return res.status(400).json({
69        error: 'lastName, email, and company are required'
70      });
71    }
72    const lead = {
73      FirstName: firstName || '',
74      LastName: lastName,
75      Email: email,
76      Company: company,
77      Phone: phone || '',
78      LeadSource: 'Web'
79    };
80    const result = await sfRequest('POST', '/sobjects/Lead', lead);
81    res.json({ id: result.id, success: result.success });
82  } catch (err) {
83    res.status(500).json({ error: err.message });
84  }
85});
86
87app.listen(3000, '0.0.0.0', () => {
88  console.log('Salesforce integration server running on port 3000');
89});

1# webhook_handler.py — Salesforce outbound message receiver
2import os
3from flask import Flask, request
4import xml.etree.ElementTree as ET
5
6app = Flask(__name__)
7
8@app.route('/salesforce-webhook', methods=['POST'])
9def salesforce_webhook():
10    """Receive Salesforce outbound message (SOAP XML)"""
11    try:
12        body = request.data.decode('utf-8')
13        # Parse the SOAP envelope
14        root = ET.fromstring(body)
15
16        # Salesforce uses SOAP namespaces
17        ns = {
18            'soapenv': 'http://schemas.xmlsoap.org/soap/envelope/',
19            'sf': 'urn:sobject.enterprise.soap.sforce.com'
20        }
21
22        # Extract notifications from the Body
23        notifications = root.findall(
24            './/soapenv:Body//Notification', ns
25        )
26
27        for notif in notifications:
28            # Extract object fields — adjust element names to match
29            # the fields you selected in the Outbound Message config
30            sf_id = notif.findtext('sObject/Id', namespaces=ns)
31            name = notif.findtext('sObject/Name', namespaces=ns)
32            stage = notif.findtext('sObject/StageName', namespaces=ns)
33            print(f'Salesforce update: {sf_id} | {name} | {stage}')
34
35            # Add your business logic here:
36            # - Forward to Slack
37            # - Update external database
38            # - Trigger another workflow
39
40        # Return required SOAP acknowledgment
41        ack = '''<?xml version="1.0" encoding="UTF-8"?>
42<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
43  <soapenv:Body>
44    <notificationsResponse>
45      <Ack>true</Ack>
46    </notificationsResponse>
47  </soapenv:Body>
48</soapenv:Envelope>'''
49        return ack, 200, {'Content-Type': 'text/xml'}
50
51    except Exception as e:
52        print(f'Webhook error: {e}')
53        # Return false Ack to trigger Salesforce retry
54        return '<Ack>false</Ack>', 500
55
56if __name__ == '__main__':
57    app.run(host='0.0.0.0', port=3000)