JavaScript Async-Await API Handler for Serverless API Interactions

🚀 JavaScript Async-Await API Handler for Serverless Functions

Here's a template for a reusable JavaScript API handler using async-await, designed for serverless environments. This approach enhances code readability and simplifies error handling when interacting with APIs.

Key Benefits:

• ✨ Improved Readability: Async-await makes asynchronous code look and behave a bit more like synchronous code, which is easier to understand.
• 💪 Simplified Error Handling: Using try...catch blocks simplifies error management in asynchronous operations.
• ♻️ Reusability: Encapsulate API call logic into a reusable function.

Template:

async function apiHandler(url, options = {}) {
 try {
 const response = await fetch(url, options);

 if (!response.ok) {
 throw new Error(`HTTP error! status: ${response.status}`);
 }

 const data = await response.json();
 return data;
 } catch (error) {
 console.error('API call failed:', error);
 throw error; // Re-throw to allow the caller to handle it
 }
}

// Example usage:
async function fetchData() {
 try {
 const result = await apiHandler('https://api.example.com/data');
 console.log('Data fetched:', result);
 } catch (error) {
 console.error('Failed to fetch data:', error);
 }
}

fetchData();

Explanation:

1. apiHandler(url, options) Function:
   • Takes the API endpoint URL and an optional options object (for method, headers, body, etc.).
   • Uses fetch with await to make the API request.
   • Checks if the response is successful (response.ok). If not, throws an error.
   • Parses the JSON response with await response.json().
   • Returns the parsed data.
2. Error Handling:
   • Wraps the fetch call in a try...catch block to handle network errors or API issues.
   • Logs the error and re-throws it, allowing the calling function to handle the error as well.
3. Example Usage:
   • The fetchData function demonstrates how to use the apiHandler.
   • Calls apiHandler with the API endpoint.
   • Logs the fetched data or any errors that occur.

Customization:

• Headers: Modify the options object to include custom headers (e.g., authorization tokens).
• HTTP Methods: Set the method in the options to 'POST', 'PUT', 'DELETE', etc.
• Body: Include a body in the options for POST or PUT requests, stringified as JSON.

Example with POST Request:

async function postData(data) {
 try {
 const options = {
 method: 'POST',
 headers: {
 'Content-Type': 'application/json'
 },
 body: JSON.stringify(data)
 };
 const result = await apiHandler('https://api.example.com/items', options);
 console.log('Item created:', result);
 } catch (error) {
 console.error('Failed to create item:', error);
 }
}

postData({ name: 'New Item', value: 123 });

Conclusion:

This template provides a robust and readable way to handle API interactions in serverless JavaScript functions. By encapsulating the API call logic in a reusable function, you can maintain cleaner and more maintainable code.