eLabSDK.Proxy

// GET request to external API
eLabSDK.ready(function() {
  eLabSDK.Proxy.call(
    'https://api.external.com/data',
    'GET',
    null,
    function(response) {
      console.log('Data received:', response);
      displayData(response);
    }
  );
});

// POST request with data and headers
eLabSDK.ready(function() {
  eLabSDK.Proxy.call(
    'https://api.external.com/items',
    'POST',
    { 
      name: 'Sample A',
      price: '99.99',
      category: 'chemicals'
    },
    function(response) {
      console.log('Item created:', response);
      alert('Item ID: ' + response.id);
    },
    {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer your-token-here'
    }
  );
});

// Fetch weather data from third-party API
eLabSDK.ready(function() {
  eLabSDK.Proxy.call(
    'https://api.weather.com/current?city=Amsterdam',
    'GET',
    null,
    function(weatherData) {
      if (weatherData && weatherData.temperature) {
        var temp = weatherData.temperature;
        $('#temperature').text(temp + '°C');
        $('#conditions').text(weatherData.conditions);
      } else {
        console.error('Invalid weather data received');
      }
    }
  );
});

// PUT request to update existing resource
eLabSDK.ready(function() {
  eLabSDK.Proxy.call(
    'https://api.external.com/items/123',
    'PUT',
    {
      name: 'Updated Sample Name',
      status: 'active'
    },
    function(response) {
      console.log('Update successful:', response);
      refreshDisplayedData();
    },
    {
      'Authorization': 'Bearer your-token'
    }
  );
});

// Migration example - old call() vs new callAsPromise()
// Old way (callback-based):
eLabSDK.Proxy.call(
  'https://api.example.com/data',
  'GET',
  null,
  function(data) {
    console.log(data);
    processData(data);
  }
);

// New recommended way (Promise-based):
eLabSDK.Proxy.callAsPromise({
  proxyUrl: 'https://api.example.com/data',
  method: 'GET'
}).then(function(data) {
  console.log(data);
  processData(data);
}).catch(function(error) {
  console.error('Error:', error);
});

// POST request with form data (multipart/form-data)
// This is the most common use case for sending structured data
eLabSDK.ready(function() {
  var headers = [
    { 'Accept': 'application/json' },
    { 'Authorization': 'Bearer your-token-here' }
  ];
  
  var data = [
    { 'name': 'Sample A' },
    { 'price': '99.99' },  // Note: Must be string, not number
    { 'quantity': '5' }
  ];
  
  var proxyCfg = {
    proxyUrl: 'https://api.external.com/items',
    method: 'POST',
    headers: headers,
    data: JSON.stringify(data)  // Must stringify the array
  };
  
  eLabSDK.Proxy.callAsPromise(proxyCfg)
    .then(function(response) {
      console.log('Success:', response);
      alert('Item created with ID: ' + response.id);
    })
    .catch(function(error) {
      console.error('Error:', error);
      alert('Failed to create item');
    });
});

// GET request with async/await
eLabSDK.ready(function() {
  async function fetchWeatherData() {
    try {
      var response = await eLabSDK.Proxy.callAsPromise({
        proxyUrl: 'https://api.weather.com/current?city=Amsterdam',
        method: 'GET',
        headers: [
          { 'API-Key': 'your-api-key' }
        ]
      });
      
      console.log('Weather data:', response);
      $('#temperature').text(response.temperature + '°C');
      $('#conditions').text(response.conditions);
    } catch (error) {
      console.error('Failed to fetch weather:', error);
      $('#weather').text('Weather data unavailable');
    }
  }
  
  fetchWeatherData();
});

// POST with raw data (application/x-www-form-urlencoded)
// Use this when the API expects URL-encoded form data
eLabSDK.ready(function() {
  var proxyCfg = {
    proxyUrl: 'https://api.external.com/legacy-endpoint',
    method: 'POST',
    dataType: 'raw',  // Don't convert to multipart/form-data
    data: 'name=test&price=1&category=samples',  // URL-encoded string
    headers: [
      { 'Content-Type': 'application/x-www-form-urlencoded' }
    ]
  };
  
  eLabSDK.Proxy.callAsPromise(proxyCfg)
    .then(function(response) {
      console.log('Response:', response);
    })
    .catch(function(error) {
      console.error('Error:', error);
    });
});

// With basic authentication
// Use this when the external API requires HTTP Basic Auth
eLabSDK.ready(function() {
  async function fetchSecureData() {
    try {
      var response = await eLabSDK.Proxy.callAsPromise({
        proxyUrl: 'https://api.secure-service.com/data',
        method: 'GET',
        authentication: {
          authType: 'basic',
          username: 'your-username',
          password: 'your-password'
        }
      });
      
      console.log('Secure data retrieved:', response);
      displayData(response);
    } catch (error) {
      console.error('Authentication failed:', error);
    }
  }
  
  fetchSecureData();
});

// OAuth workflow - authenticate then use token
// Common pattern for APIs requiring OAuth-style authentication
eLabSDK.ready(function() {
  async function syncWithExternalService() {
    try {
      // Step 1: Authenticate and get token
      var authResponse = await eLabSDK.Proxy.callAsPromise({
        proxyUrl: 'https://api.external.com/oauth/token',
        method: 'POST',
        data: JSON.stringify([
          { 'grant_type': 'client_credentials' },
          { 'client_id': 'your-client-id' },
          { 'client_secret': 'your-client-secret' }
        ])
      });
      
      var accessToken = authResponse.access_token;
      console.log('Authenticated, token received');
      
      // Step 2: Use token to make authenticated request
      var dataResponse = await eLabSDK.Proxy.callAsPromise({
        proxyUrl: 'https://api.external.com/data/export',
        method: 'POST',
        headers: [
          { 'Authorization': 'Bearer ' + accessToken },
          { 'Content-Type': 'application/json' }
        ],
        data: JSON.stringify([
          { 'startDate': '2024-01-01' },
          { 'endDate': '2024-12-31' },
          { 'format': 'json' }
        ])
      });
      
      console.log('Data exported:', dataResponse);
      processExportedData(dataResponse);
      
    } catch (error) {
      console.error('Sync failed:', error);
      alert('Failed to sync with external service');
    }
  }
  
  syncWithExternalService();
});

// Error handling with specific actions
eLabSDK.ready(function() {
  async function robustApiCall() {
    var maxRetries = 3;
    var retryDelay = 2000;
    
    for (var attempt = 1; attempt <= maxRetries; attempt++) {
      try {
        var response = await eLabSDK.Proxy.callAsPromise({
          proxyUrl: 'https://api.sometimes-unreliable.com/data',
          method: 'GET'
        });
        
        console.log('Success on attempt ' + attempt);
        return response;
        
      } catch (error) {
        console.warn('Attempt ' + attempt + ' failed:', error);
        
        if (attempt === maxRetries) {
          alert('Failed after ' + maxRetries + ' attempts');
          throw error;
        }
        
        // Wait before retrying
        await new Promise(resolve => setTimeout(resolve, retryDelay));
      }
    }
  }
  
  robustApiCall();
});

// Common mistake - incorrect header format (DO NOT DO THIS)
// ❌ WRONG - Headers as single object:
var wrongConfig = {
  proxyUrl: 'https://api.example.com',
  method: 'POST',
  headers: {
    'Accept': 'application/json',        // ❌ Wrong format!
    'Authorization': 'Bearer token'      // ❌ This won't work!
  }
};

// ✅ CORRECT - Headers as array of objects:
var correctConfig = {
  proxyUrl: 'https://api.example.com',
  method: 'POST',
  headers: [
    { 'Accept': 'application/json' },    // ✅ Each header is separate object
    { 'Authorization': 'Bearer token' }  // ✅ This will work!
  ]
};