Reading and Writing Data Using the Teamleader API

Hey there, fellow JavaScript enthusiasts! Ready to dive into the world of Teamleader API integration? Let's roll up our sleeves and get our hands dirty with some code.

The Lowdown on Teamleader API

Teamleader's API is your ticket to seamlessly syncing data between your app and their CRM. We're talking contacts, deals, invoices - the whole shebang. Let's make your users' lives easier with some slick integration.

Authentication: Your VIP Pass

First things first - we need to get past the bouncer. Teamleader uses OAuth 2.0, so let's break it down:

const axios = require('axios');

async function getAccessToken(code) {
  const response = await axios.post('https://app.teamleader.eu/oauth2/access_token', {
    client_id: 'YOUR_CLIENT_ID',
    client_secret: 'YOUR_CLIENT_SECRET',
    code: code,
    grant_type: 'authorization_code',
    redirect_uri: 'YOUR_REDIRECT_URI'
  });
  
  return response.data.access_token;
}

Pro tip: Don't forget to refresh that token before it expires!

Reading Data: Time to Feast

Now that we're in, let's grab some data. Here's how you might fetch contacts:

async function getContacts(accessToken, page = 1) {
  const response = await axios.get('https://api.teamleader.eu/contacts.list', {
    headers: { Authorization: `Bearer ${accessToken}` },
    params: { page: { size: 100, number: page } }
  });
  
  return response.data;
}

Pagination is your friend here. Keep fetching until you've got all the data you need.

Writing Data: Leave Your Mark

Got some data to push to Teamleader? Here's how you might create a new contact:

async function createContact(accessToken, contactData) {
  try {
    const response = await axios.post('https://api.teamleader.eu/contacts.add', contactData, {
      headers: { Authorization: `Bearer ${accessToken}` }
    });
    return response.data;
  } catch (error) {
    console.error('Oops! Validation error:', error.response.data);
    throw error;
  }
}

Always handle those validation errors gracefully. Your users will thank you!

Syncing Strategies: Stay Fresh

For keeping things up-to-date, you've got options:

1. Use the modified_since parameter when fetching data.
2. Set up webhooks for real-time updates.

Here's a quick webhook handler:

app.post('/webhook', (req, res) => {
  const event = req.body;
  if (event.type === 'contact.created') {
    // Do something with the new contact
    console.log('New contact:', event.data);
  }
  res.sendStatus(200);
});

Error Handling and Rate Limiting: Play Nice

Teamleader's API has rate limits. Be a good citizen:

const rateLimit = require('axios-rate-limit');

const api = rateLimit(axios.create(), { maxRequests: 20, perMilliseconds: 1000 });

And always implement retry logic for those pesky network hiccups!

Data Transformation: Shape It Up

Your app's data structure might not match Teamleader's. No worries, just transform it:

function transformContact(teamleaderContact) {
  return {
    id: teamleaderContact.id,
    name: `${teamleaderContact.first_name} ${teamleaderContact.last_name}`,
    email: teamleaderContact.emails[0]?.email,
    // ... more fields
  };
}

Optimizing Performance: Speed Demon

Want to go faster? Try batch operations when you can:

async function batchCreateContacts(accessToken, contacts) {
  const batchRequests = contacts.map(contact => ({
    method: 'POST',
    uri: '/contacts.add',
    body: contact
  }));
  
  const response = await axios.post('https://api.teamleader.eu/batch', { requests: batchRequests }, {
    headers: { Authorization: `Bearer ${accessToken}` }
  });
  
  return response.data;
}

And don't forget to cache frequently accessed data!

Testing and Debugging: Trust, but Verify

Teamleader provides a sandbox environment. Use it! It's your playground for testing without fear.

And log, log, log. Your future self will thank you when debugging:

const logger = require('your-favorite-logger');

logger.info('Fetching contacts', { page: 1 });
const contacts = await getContacts(accessToken, 1);
logger.info('Contacts fetched', { count: contacts.length });

Wrapping Up

There you have it, folks! You're now armed with the knowledge to build a robust Teamleader integration. Remember:

• Always handle errors gracefully
• Respect rate limits
• Keep your data in sync
• Test thoroughly

Now go forth and code! And if you hit any snags, the Teamleader API docs are your best friend. Happy coding!