index.js

require('dotenv').config();
const express = require('express');
const path = require('path');
const { init } = require('@heroku/applink');

const port = process.env.PORT || 5006;
const app = express();

// Initialize Salesforce SDK
const sdk = init();

// Get connection names from environment variable
const connectionNames = process.env.CONNECTION_NAMES ? process.env.CONNECTION_NAMES.split(',') : [];

app.use(express.static(path.join(__dirname, 'public')));
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');

app.get('/', async (req, res) => {
  try {
    // Query accounts from all connected orgs
    const accountsByOrg = await Promise.all(
      connectionNames.map(async (connectionName) => {
        try {
          // Initialize connection for this org
          const org = await sdk.addons.applink.getAuthorization(connectionName.trim());
          console.log('Connected to Salesforce org:', {
            orgId: org.id,
            username: org.user.username,
          });

          // Execute SOQL query
          const queryResult = await org.dataApi.query('SELECT Name, Id FROM Account');
          console.log('Query results:', {
            totalSize: queryResult.totalSize,
            done: queryResult.done,
            recordCount: queryResult.records.length,
          });

          // Transform the records to the expected format
          const accounts = queryResult.records.map((record) => ({
            Name: record.fields.Name,
            Id: record.fields.Id,
          }));

          return {
            connectionName: connectionName.trim(),
            accounts,
          };
        } catch (error) {
          console.error(`Error querying org ${connectionName}:`, error);
          return {
            connectionName: connectionName.trim(),
            error: error.message,
            accounts: [],
          };
        }
      })
    );

    res.render('pages/index', { accountsByOrg });
  } catch (error) {
    console.error('Error rendering index:', error);
    res.status(500).send(error.message);
  }
});

/**
 * Bulk API Demo Endpoint
 *
 * Technical Notes on Duplicate Handling:
 * ------------------------------------
 * This demo intentionally showcases real-world scenarios including error handling for duplicate records.
 * Some account insertions may fail due to Salesforce's duplicate detection rules, which is expected behavior.
 *
 * Key Points:
 * 1. Partial Success: Even if some records fail due to duplicates, successfully inserted records will still
 *    appear on the main page, demonstrating resilient bulk processing.
 * 2. Error Handling: The monitorBulkJob function logs failed records, providing visibility into which
 *    insertions failed and why.
 * 3. Options for Users:
 *    - Accept partial success as a demonstration of error handling
 *    - Temporarily disable duplicate rules in Salesforce to allow all insertions
 *    - Review failed records in the application logs for debugging
 *
 * This behavior actually provides a valuable demonstration of:
 * - Real-world bulk data handling
 * - Salesforce duplicate management in action
 * - Robust error handling in bulk operations
 * - Integration resilience
 */
app.get('/bulk-demo', async (req, res) => {
  try {
    const emptyOrgName = 'empty-org';

    if (!connectionNames.includes(emptyOrgName)) {
      return res.status(400).send('empty-org connection not found');
    }

    // Initialize connection for empty-org
    const org = await sdk.addons.applink.getAuthorization(emptyOrgName);
    console.log('Connected to empty-org:', {
      orgId: org.id,
      username: org.user.username,
    });

    // First check for existing records using regular query
    const queryResult = await org.dataApi.query(
      "SELECT Id FROM Account WHERE Name LIKE 'Bulk Account%'"
    );
    console.log('Query results:', {
      totalSize: queryResult.totalSize,
      done: queryResult.done,
      recordCount: queryResult.records.length,
    });

    if (queryResult.records.length === 0) {
      // No existing bulk records, create them using Bulk API
      console.log("Starting Bulk API process for 'empty-org'");

      // Create a data table for bulk insert
      const columns = [
        'Name',
        'BillingStreet',
        'BillingCity',
        'BillingState',
        'BillingPostalCode',
        'BillingCountry',
      ];
      const dataTableBuilder = org.bulkApi.createDataTableBuilder(columns);

      // Add 1000 records to the data table
      for (let i = 1; i <= 1000; i++) {
        const address = generateAddress();
        const record = new Map();
        record.set('Name', generateBusinessName());
        record.set('BillingStreet', address.street);
        record.set('BillingCity', address.city);
        record.set('BillingState', address.state);
        record.set('BillingPostalCode', address.zip);
        record.set('BillingCountry', 'United States');
        dataTableBuilder.addRow(record);
      }

      // Create bulk job for inserting accounts
      const ingestResults = await org.bulkApi.ingest({
        object: 'Account',
        operation: 'insert',
        dataTable: dataTableBuilder.build(),
      });

      // Start monitoring process in background
      monitorBulkJob(org, ingestResults[0]);

      return res.json({
        message: 'Bulk insert job started',
        jobId: ingestResults[0].id,
      });
    }

    res.json({
      message: `Found ${queryResult.records.length} existing bulk-created records`,
      status: 'EXISTING_RECORDS',
    });
  } catch (error) {
    console.error('Error in bulk demo:', error);
    res.status(500).send(error.message);
  }
});

// Background job monitoring function
async function monitorBulkJob(org, result) {
  try {
    let isComplete = false;
    while (!isComplete) {
      const jobInfo = await org.bulkApi.getInfo(result);
      console.log('Bulk job status:', {
        id: result.id,
        state: jobInfo.state,
        numberRecordsProcessed: jobInfo.numberRecordsProcessed,
        numberRecordsFailed: jobInfo.numberRecordsFailed,
      });

      isComplete = ['JobComplete', 'Failed', 'Aborted'].includes(jobInfo.state);

      if (isComplete) {
        if (jobInfo.state === 'JobComplete') {
          if (jobInfo.numberRecordsFailed > 0) {
            const failedResults = await org.bulkApi.getFailedResults(result);
            console.error('Failed records:', failedResults);
          } else {
            console.log(
              `Job ${result.id} completed successfully. Processed ${jobInfo.numberRecordsProcessed} records`
            );
          }
        } else {
          console.error(`Job ${result.id} ended in state: ${jobInfo.state}`);
        }
      } else {
        // Wait 5 seconds before next status check
        await new Promise((resolve) => setTimeout(resolve, 5000));
      }
    }
  } catch (error) {
    console.error('Error monitoring bulk job:', error);
  }
}

const server = app.listen(port, () => {
  console.log(`Listening on ${port}`);
});

process.on('SIGTERM', async () => {
  console.log('SIGTERM signal received: gracefully shutting down');
  if (server) {
    server.close(() => {
      console.log('HTTP server closed');
    });
  }
});

// List of business name components for random generation
const businessTypes = [
  'Tech',
  'Global',
  'Advanced',
  'Innovative',
  'Strategic',
  'Premier',
  'Elite',
  'Dynamic',
  'Pacific',
  'Atlantic',
  'Modern',
  'Future',
  'Smart',
  'Connected',
  'Digital',
  'Quantum',
  'Unified',
  'Integrated',
  'Precision',
  'Summit',
];

const businessNames = [
  'Solutions',
  'Systems',
  'Enterprises',
  'Industries',
  'Dynamics',
  'Partners',
  'Networks',
  'Technologies',
  'Services',
  'Innovations',
  'Analytics',
  'Consulting',
  'Operations',
  'Group',
  'Corporation',
  'Associates',
  'International',
  'Management',
  'Ventures',
  'Labs',
];

const industries = [
  'Manufacturing',
  'Software',
  'Healthcare',
  'Logistics',
  'Energy',
  'Communications',
  'Engineering',
  'Research',
  'Development',
  'Robotics',
];

// Address components for random generation
const streetTypes = [
  'Street',
  'Avenue',
  'Boulevard',
  'Road',
  'Drive',
  'Lane',
  'Way',
  'Circle',
  'Court',
  'Place',
  'Square',
  'Terrace',
  'Parkway',
  'Plaza',
];

const streetNames = [
  'Maple',
  'Oak',
  'Cedar',
  'Pine',
  'Elm',
  'Washington',
  'Lincoln',
  'Park',
  'Lake',
  'River',
  'Mountain',
  'Valley',
  'Forest',
  'Meadow',
  'Spring',
  'Sunset',
  'Highland',
  'Madison',
  'Jefferson',
  'Franklin',
];

const cities = [
  'San Francisco',
  'New York',
  'Chicago',
  'Los Angeles',
  'Seattle',
  'Boston',
  'Austin',
  'Denver',
  'Miami',
  'Portland',
  'Atlanta',
  'Dallas',
  'Houston',
  'Phoenix',
  'Minneapolis',
];

const states = [
  { name: 'California', abbr: 'CA' },
  { name: 'New York', abbr: 'NY' },
  { name: 'Texas', abbr: 'TX' },
  { name: 'Florida', abbr: 'FL' },
  { name: 'Illinois', abbr: 'IL' },
  { name: 'Washington', abbr: 'WA' },
  { name: 'Massachusetts', abbr: 'MA' },
  { name: 'Colorado', abbr: 'CO' },
  { name: 'Oregon', abbr: 'OR' },
  { name: 'Georgia', abbr: 'GA' },
];

// Function to generate a random address
function generateAddress() {
  const streetNumber = Math.floor(Math.random() * 9900) + 100; // 100-9999
  const streetName = streetNames[Math.floor(Math.random() * streetNames.length)];
  const streetType = streetTypes[Math.floor(Math.random() * streetTypes.length)];
  const city = cities[Math.floor(Math.random() * cities.length)];
  const state = states[Math.floor(Math.random() * states.length)];
  const zip = Math.floor(Math.random() * 90000) + 10000; // 10000-99999

  return {
    street: `${streetNumber} ${streetName} ${streetType}`,
    city: city,
    state: state.name,
    stateAbbr: state.abbr,
    zip: zip.toString(),
  };
}

// Function to generate a random business name
function generateBusinessName() {
  const type = businessTypes[Math.floor(Math.random() * businessTypes.length)];
  const name = businessNames[Math.floor(Math.random() * businessNames.length)];
  const industry = industries[Math.floor(Math.random() * industries.length)];
  const timestamp = Date.now().toString().slice(-4);
  const randomSuffix = Math.random().toString(36).substring(2, 5).toUpperCase();

  // Always prefix with 'Bulk Account' but add random elements after
  const formats = [
    `Bulk Account ${type} ${name} ${randomSuffix}`,
    `Bulk Account ${type} ${industry} ${randomSuffix}`,
    `Bulk Account ${industry} ${name} ${timestamp}`,
    `Bulk Account ${type} ${name} ${industry} ${randomSuffix}`,
  ];

  const generatedName = formats[Math.floor(Math.random() * formats.length)];

  // Ensure name doesn't exceed Salesforce's 255-character limit
  if (generatedName.length > 255) {
    // If somehow too long, return a shorter format
    return `Bulk Account ${type} ${randomSuffix}`;
  }

  return generatedName;
}