How to fix TimeoutError: Operation timed out after 5000ms in Node.js

// HTTP client timeout
const response = await fetch('https://api.example.com', {
  signal: AbortSignal.timeout(5000) // 5 second timeout
});

// Promise timeout with Promise.race()
const timeout = new Promise((_, reject) =>
  setTimeout(() => reject(new Error('TimeoutError: Operation timed out')), 5000)
);
const result = await Promise.race([operation(), timeout]);

// Database client timeout
const result = await db.query('SELECT * FROM users', {
  timeout: 5000
});

const startTime = Date.now();
try {
  const result = await someAsyncOperation();
  console.log(`Operation completed in ${Date.now() - startTime}ms`);
} catch (error) {
  console.log(`Operation failed after ${Date.now() - startTime}ms`);
  console.error(error);
}

// Using AbortSignal.timeout() (Node.js 16+)
const response = await fetch('https://slow-api.example.com', {
  signal: AbortSignal.timeout(30000) // Increase to 30 seconds
});

// Using Promise.race()
const timeout = (ms) => new Promise((_, reject) =>
  setTimeout(() => reject(new Error(`Timeout after ${ms}ms`)), ms)
);

const result = await Promise.race([
  longRunningOperation(),
  timeout(30000) // 30 second timeout
]);

// Add indexes for frequently queried fields
// Before: slow full table scan
const users = await db.users.findMany({
  where: { email: '[email protected]' }
});

// After: create index on email column
// CREATE INDEX idx_users_email ON users(email);

// Use connection pooling
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 50
});

// Cache frequently accessed data
const cachedData = cache.get(key);
if (cachedData) return cachedData;

const freshData = await fetchFromAPI();
cache.set(key, freshData, 300); // 5 min TTL

// Serial (slow)
const user = await fetchUser(id);
const posts = await fetchPosts(id);
const comments = await fetchComments(id);

// Parallel (fast)
const [user, posts, comments] = await Promise.all([
  fetchUser(id),
  fetchPosts(id),
  fetchComments(id)
]);

async function fetchWithRetry(url, options = {}, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      const response = await fetch(url, {
        ...options,
        signal: AbortSignal.timeout(5000)
      });
      return response;
    } catch (error) {
      if (error.name === 'TimeoutError' && attempt < maxRetries) {
        console.log(`Attempt ${attempt} timed out, retrying...`);
        await new Promise(resolve => setTimeout(resolve, 1000 * attempt)); // Exponential backoff
        continue;
      }
      throw error;
    }
  }
}

// Usage
try {
  const data = await fetchWithRetry('https://api.example.com/data');
} catch (error) {
  if (error.name === 'TimeoutError') {
    console.error('Operation timed out after multiple retries');
    // Show user-friendly message
  }
}

const controller = new AbortController();
const timeoutId = setTimeout(() => controller.abort(), 5000);

try {
  const response = await fetch('https://api.example.com', {
    signal: controller.signal
  });
  clearTimeout(timeoutId); // Clear if successful
  return await response.json();
} catch (error) {
  if (error.name === 'AbortError') {
    throw new Error('TimeoutError: Operation timed out after 5000ms');
  }
  throw error;
}