JavaScript Advanced Concepts: Asynchronous Programming with Promises and Async/Await

const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    const success = Math.random() > 0.5;
    if (success) {
      resolve("Operation completed successfully");
    } else {
      reject(new Error("Operation failed"));
    }
  }, 1000);
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error.message));

const fetchUserData = (userId) => 
  fetch(`/api/users/${userId}`)
    .then(response => response.json());

const fetchUserPosts = (userId) => 
  fetch(`/api/users/${userId}/posts`)
    .then(response => response.json());

const processUser = (userId) => {
  return fetchUserData(userId)
    .then(user => {
      console.log("User data:", user);
      return fetchUserPosts(user.id);
    })
    .then(posts => {
      console.log("User posts:", posts);
      return { user: user, posts: posts };
    })
    .catch(error => {
      console.error("Error processing user:", error);
      throw error;
    });
};

// Using Promise.all for concurrent operations
const fetchMultipleResources = async () => {
  try {
    const [users, posts, comments] = await Promise.all([
      fetch('/api/users').then(r => r.json()),
      fetch('/api/posts').then(r => r.json()),
      fetch('/api/comments').then(r => r.json())
    ]);
    
    return { users, posts, comments };
  } catch (error) {
    console.error("One or more requests failed:", error);
    throw error;
  }
};

// Using Promise.race for timeout implementation
const withTimeout = (promise, timeoutMs) => {
  const timeoutPromise = new Promise((_, reject) => {
    setTimeout(() => reject(new Error("Operation timed out")), timeoutMs);
  });
  
  return Promise.race([promise, timeoutPromise]);
};

// Comprehensive error handling with finally
const robustAsyncOperation = async (url) => {
  let result;
  try {
    result = await fetch(url);
    const data = await result.json();
    return data;
  } catch (error) {
    console.error("Fetch failed:", error.message);
    throw error;
  } finally {
    console.log("Cleanup operations completed");
  }
};

// Custom error handling with retry logic
const fetchWithRetry = async (url, retries = 3) => {
  for (let i = 0; i < retries; i++) {
    try {
      const response = await fetch(url);
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      return await response.json();
    } catch (error) {
      console.log(`Attempt ${i + 1} failed:`, error.message);
      if (i === retries - 1) throw error;
      await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1)));
    }
  }
};

// Good: Proper async/await usage with error handling
const processData = async () => {
  try {
    const data = await fetch('/api/data').then(r => r.json());
    const processed = await transformData(data);
    const result = await saveData(processed);
    return result;
  } catch (error) {
    console.error("Processing failed:", error);
    throw error;
  }
};

// Avoid: Nested async/await without proper structure
const badExample = async () => {
  const data1 = await fetch('/api/data1').then(r => r.json());
  const data2 = await fetch('/api/data2').then(r => r.json());
  const data3 = await fetch('/api/data3').then(r => r.json());
  // This approach lacks parallel execution optimization
};

// Good: Parallel execution with async/await
const goodExample = async () => {
  const [data1, data2, data3] = await Promise.all([
    fetch('/api/data1').then(r => r.json()),
    fetch('/api/data2').then(r => r.json()),
    fetch('/api/data3').then(r => r.json())
  ]);
  
  // Process all data in parallel
  const results = await Promise.all([
    processItem(data1),
    processItem(data2),
    processItem(data3)
  ]);
  
  return results;
};

// Debouncing async operations
class AsyncDebouncer {
  constructor(delay) {
    this.delay = delay;
    this.timeoutId = null;
    this.pendingPromise = null;
  }
  
  async execute(asyncFunction, ...args) {
    if (this.timeoutId) {
      clearTimeout(this.timeoutId);
    }
    
    return new Promise((resolve, reject) => {
      this.timeoutId = setTimeout(async () => {
        try {
          const result = await asyncFunction(...args);
          resolve(result);
        } catch (error) {
          reject(error);
        }
      }, this.delay);
    });
  }
}

// Rate limiting with semaphore
class Semaphore {
  constructor(maxConcurrent) {
    this.maxConcurrent = maxConcurrent;
    this.currentConcurrent = 0;
    this.queue = [];
  }
  
  async acquire() {
    return new Promise((resolve) => {
      if (this.currentConcurrent < this.maxConcurrent) {
        this.currentConcurrent++;
        resolve();
      } else {
        this.queue.push(resolve);
      }
    });
  }
  
  release() {
    this.currentConcurrent--;
    if (this.queue.length > 0) {
      this.currentConcurrent++;
      const resolve = this.queue.shift();
      resolve();
    }
  }
}

// Caching with Promise memoization
const memoizePromise = (fn) => {
  const cache = new Map();
  
  return async (...args) => {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      return cache.get(key);
    }
    
    const promise = fn(...args);
    cache.set(key, promise);
    
    try {
      const result = await promise;
      return result;
    } catch (error) {
      cache.delete(key);
      throw error;
    }
  };
};

// Batch processing for better performance
const batchProcess = async (items, batchSize = 10) => {
  const results = [];
  
  for (let i = 0; i < items.length; i += batchSize) {
    const batch = items.slice(i, i + batchSize);
    const batchResults = await Promise.all(
      batch.map(item => processItem(item))
    );
    results.push(...batchResults);
  }
  
  return results;
};