Como posso melhorar a eficiência de um Google Apps Script (buscar solicitação no Salesforce, gravar dados na planilha do Google)

Tenho um aplicativo AppSheet que usa uma planilha do Google como fonte de dados para suas tabelas, embora a fonte de dados subjacente para a planilha do Google seja o Salesforce. O Salesforce sObject é enorme (mais de 660 colunas, centenas de milhares de registros), então não consigo usar a integração AppSheet/Salesforce porque é muito ineficiente sincronizar todos esses dados quando preciso apenas de uma pequena parte deles para cada usuário.

Estou usando um script do Google Apps para enviar uma solicitação GET ao Salesforce que retorna um payload de 'Workers', geralmente menos de cem linhas com 10 colunas por linha. A solicitação GET seleciona Workers no 'turf' do usuário logado do aplicativo.

A tabela Workers contém o turf para todos os usuários, já que pode haver mais de um usuário conectado a qualquer momento, mas o aplicativo só renderiza o turf para o usuário conectado no momento na interface do usuário.

Não há UI para os usuários modificarem registros de Worker no aplicativo, os dados são necessários apenas para ler e selecionar registros de Worker para fazer atualizações em uma tabela relacionada, que grava de volta no Salesforce. Então o Salesforce sempre tem os dados mais atualizados para Workers, e eu não preciso de uma sincronização bidirecional com a planilha do Google.

O script está funcionando, mas é muito lento. Todo o processo loadTurf leva cerca de 30 segundos para um conjunto de cerca de 100 registros com 10 colunas por registro, e estou tentando descobrir como melhorar o script para torná-lo mais rápido. Não consigo controlar a velocidade da parte de autenticação do Salesforce/troca JWT/solicitação GET, mas essa parte leva apenas de 3 a 5 segundos, e o restante é o processamento que acontece depois que a carga útil da API é retornada: verificar duplicatas, excluir linhas que precisam ser substituídas por dados novos e gravar os novos dados na planilha.

Eu sei que tem que haver uma maneira mais rápida de fazer isso. A verificação de duplicatas e seções de exclusão parecem particularmente ineficientes, iterando sobre o intervalo uma linha por vez com forEach, mas não consegui descobrir uma maneira de processar a exclusão em lote, porque o turf poderia teoricamente estar em linhas não sequenciais. Existe uma maneira de excluir um intervalo filtrado inteiro em um lote sem iterar sobre ele uma linha por vez? Verificar cada linha para colunas atualizadas em relação à carga útil do Salesforce parecia ser ainda mais lento do que apenas excluí-las todas e colar as linhas novas retornadas do Salesforce.

De qualquer forma, aqui está meu código, as partes mais lentas parecem ser a verificação de duplicatas e operações de exclusão, que levam cerca de 10-11 segundos cada em um lote de 100 registros. Alguém pode sugerir alguma maneira de melhorar isso?

const fieldsArray = [ ... list of fields ... ];
const ss = SpreadsheetApp.openByUrl( ... url ...);
const workers = ss.getSheetByName( ... sheetName ...); 
const contactIds = workers.getRange("A2:A").getValues().flat().filter(Boolean);

async function loadUserTurf(employer) {
  let records;
  if (employer) {
    try {
      const qp = new QueryParameters();
      qp.setSelect(fieldsArray.toString());
      qp.setFrom("Contact");
      qp.setWhere(`Employer_Name_Text__c = \'${employer}\' AND Active_Worker__c = TRUE`);

      records = await get(qp);
      setUserTurf(employer, records);
    } catch (err) {
      logErrorFunctions('loadUserTurf', employer, records, err);
    }

  } else {
    console.log(`loadUserTurf > 24: no employer provided`);
  }
  
}

const confirmUniqueContactId = (id) => !contactIds.includes(id);

function appendNewRows(data, sheet) { // data = array of objects
    try {
      data.forEach(obj => {
        if (confirmUniqueContactId(obj.Id)) {
          // flatten object to array
          const row = Object.values(obj).slice(1);
          sheet.appendRow(row);
        }        
      })
    } catch (err) {
      logErrorFunctions('appendNewRows', [data, sheet], '', err);
    }
}

function setUserTurf(employerName, payload) {
  // Check for matching rows -- has this turf been pulled before?
  // create an array of all matching row indices so we can delete them
  // and replace them with fresh data from Salesforce

  const allData = workers.getDataRange().getValues();
  const turfIndices = allData.map((row, index) => {
    if (row[3] === employerName) {
      return index + 1;
    }
  }).filter(n => n); // remove null values
  
  // If no matching rows found (user's first login)
  // create new rows to append the payload from Salesforce
  if (!turfIndices.length) {
    // append new rows with data from payload from loadTurf function
    try {
      appendNewRows(payload, workers);    
    } catch (err) {
      console.log(err);
      logErrorFunctions('setUserTurf', turfIndices, '', err);
    }
  } else {
    // otherwise, delete all existing rows in that turf and replace them with fresh data from Salesforce
    // because checking for differences at the individual cell level seems even more inefficient?
    try {
      turfIndices.forEach(index => workers.deleteRow(index));
      // append new rows with data from payload from loadTurf function
      appendNewRows(payload, workers); 
    } catch (err) {
      logErrorFunctions('setUserTurf', turfIndices, '', err);
    }
  }
}