Skip to main content

Best Practices

Follow these best practices to ensure a secure and efficient integration with TraderPal Connect.

API Integration​

Rate Limiting​

  • Implement exponential backoff for rate limit errors
  • Cache frequently accessed data
  • Use bulk endpoints when possible
// Example: Implementing exponential backoff
async function fetchWithRetry(url, options, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      const response = await fetch(url, options);
      if (response.status !== 429) return response;
      
      const backoffTime = Math.pow(2, i) * 1000;
      await new Promise(resolve => setTimeout(resolve, backoffTime));
    } catch (error) {
      if (i === maxRetries - 1) throw error;
    }
  }
}

Error Handling​

  • Always check response status codes
  • Log errors with appropriate context
  • Implement proper error recovery
async function handleApiRequest(endpoint, options) {
  try {
    const response = await fetch(endpoint, options);
    
    if (!response.ok) {
      const error = await response.json();
      logger.error('API Error', {
        endpoint,
        status: response.status,
        error
      });
      throw new ApiError(error);
    }
    
    return await response.json();
  } catch (error) {
    // Handle network errors
    logger.error('Network Error', {
      endpoint,
      error: error.message
    });
    throw error;
  }
}

Security​

API Keys​

  • Store API keys in environment variables
  • Rotate keys regularly
  • Use different keys for different environments
// Example: Loading API keys from environment
require('dotenv').config();

const client = new TraderPalConnect({
  apiKey: process.env.TRADERPAL_API_KEY,
  apiSecret: process.env.TRADERPAL_API_SECRET,
  environment: process.env.NODE_ENV === 'production' ? 'production' : 'sandbox'
});

Request Validation​

  • Validate all user input
  • Sanitize data before sending to API
  • Implement request signing correctly
function validateOrderRequest(order) {
  const schema = {
    symbol: (s) => typeof s === 'string' && s.length > 0,
    quantity: (q) => typeof q === 'number' && q > 0,
    side: (s) => ['buy', 'sell'].includes(s)
  };
  
  return Object.entries(schema).every(([key, validate]) => 
    validate(order[key])
  );
}

Performance​

Connection Management​

  • Reuse HTTP connections
  • Implement connection pooling
  • Handle connection timeouts
const https = require('https');
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 100,
  timeout: 20000
});

const client = new TraderPalConnect({
  // ... other options
  httpAgent: agent
});

Caching​

  • Cache static data
  • Implement proper cache invalidation
  • Use appropriate cache durations
const cache = new Map();
const CACHE_TTL = 60000; // 1 minute

async function getCachedData(key, fetchFn) {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
  
  const data = await fetchFn();
  cache.set(key, {
    data,
    timestamp: Date.now()
  });
  
  return data;
}

Testing​

Environment Usage​

  • Use sandbox environment for testing
  • Never test with production credentials
  • Maintain separate test data
const client = new TraderPalConnect({
  // ... other options
  environment: process.env.NODE_ENV === 'test' ? 'sandbox' : 'production'
});

Integration Testing​

  • Test error scenarios
  • Validate webhook handling
  • Monitor API response times
describe('Order API', () => {
  it('should handle rate limits', async () => {
    const promises = Array(10).fill().map(() => 
      client.trading.createOrder({
        symbol: 'AAPL',
        quantity: 1,
        side: 'buy'
      })
    );
    
    const results = await Promise.allSettled(promises);
    expect(results.some(r => r.status === 'rejected')).toBe(true);
  });
});

Monitoring​

Logging​

  • Implement structured logging
  • Include request IDs
  • Log appropriate detail levels
const logger = {
  info: (message, context) => {
    console.log(JSON.stringify({
      level: 'info',
      timestamp: new Date().toISOString(),
      message,
      requestId: context.requestId,
      ...context
    }));
  }
};

Metrics​

  • Track API response times
  • Monitor error rates
  • Set up alerts for anomalies

Next Steps​