Intermediate JavaScript Exercise: Asynchronous Programming in E-Commerce Scenario

[akash-coded]

Intermediate JavaScript Exercise: Asynchronous Programming in E-Commerce Scenario

Objective

Develop an understanding of asynchronous programming in JavaScript through a series of tasks simulating e-commerce operations, such as fetching product details, checking inventory, and processing orders. Focus on using Promises, async-await, and callbacks without relying on server-side frameworks.

Environment Setup

Since this exercise avoids server-side complexities like Express, we'll simulate asynchronous operations using the fetch API for network requests and setTimeout for mimicking delays in local operations.

Scenario Overview

You are tasked with building several functions to handle operations for an online store. These include fetching product details from a mock API, checking inventory levels, and processing customer orders.

Task 1: Fetching Product Details with Promises

• Objective: Use the fetch API to retrieve product details from a mock API endpoint.
• Task: Write a function fetchProductDetails(productId) that takes a product ID and returns a promise with the product details.
• Mock API: Use https://fakestoreapi.com/products/ as your base URL. Append the product ID to fetch details for a specific product.
• Details: Use .then() and .catch() to handle the promise returned by the fetch API.

Task 2: Checking Inventory with Callbacks

• Objective: Simulate an inventory check using callbacks.
• Task: Create a function checkInventory(productId, callback) that simulates checking inventory for a given product ID. Use setTimeout to mimic a delay.
• Details: The callback should follow the standard Node.js convention of callback(error, result). If the product is in stock, return true as the result; otherwise, false.

Task 3: Processing Orders with Async/Await

• Objective: Combine fetching product details and checking inventory in an order processing function using async-await.
• Task: Implement an async function processOrder(productId) that awaits both the product details and the inventory check before proceeding.
• Error Handling: Use try/catch blocks to handle errors and log appropriate messages.

Task 4: Handling Multiple Orders Concurrently

• Objective: Process multiple orders concurrently and efficiently.
• Task: Write a function processMultipleOrders(productIds) that takes an array of product IDs and processes each order concurrently.
• Details: Use Promise.all to await all orders. Ensure to handle both successful and failed order processing.

Task 5: Implementing Retry Logic for Network Requests

• Objective: Add retry logic to the fetchProductDetails function to handle transient network errors.
• Task: Enhance fetchProductDetails to retry the fetch request up to 3 times in case of failure before giving up.
• Details: Implement exponential backoff for retry delays to minimize server load and improve the chances of recovery from temporary errors.

Task 6: Creating a Robust Order Processing Function

• Objective: Ensure the order processing function is robust and handles various edge cases.
• Task: Refine processOrder to check for invalid product IDs, out-of-stock items, and network issues, providing clear feedback for each scenario.
• Details: Consider edge cases like invalid product IDs (resulting in a 404 from the API) and simulate out-of-stock scenarios using a predefined list of out-of-stock product IDs.

Best Practices and Cautions

• Error Handling: Always handle both operational errors and programming errors gracefully.
• Promises: Avoid the "Promise Hell" by using async-await or chaining promises properly.
• Callbacks: Follow the Node.js convention for callbacks, handling errors first.
• Concurrency: Use Promise.all with care, as it rejects immediately upon any of the promises rejecting.

Deliverables

• JavaScript code implementing all the tasks with comments explaining key decisions.
• A document summarizing the approach to asynchronous programming, challenges encountered, and solutions applied.

Additional Learning Activities

• Rate Limiting: Implement rate limiting for fetchProductDetails to avoid hitting the API too frequently.
• Cancellation: Explore how to cancel a fetch request if the operation takes too long, using either the AbortController or other mechanisms.

This exercise aims to solidify intermediate-level asynchronous programming concepts in a practical, scenario-based manner, focusing on real-world application in the e-commerce domain.