How to fix Warning: Memory leak detected. Unresolved promise prevents garbage collection in Node.js

function promiseWithTimeout(promise, timeoutMs = 5000) {
  return Promise.race([
    promise,
    new Promise((_, reject) =>
      setTimeout(() => reject(new Error('Operation timed out')), timeoutMs)
    )
  ]);
}

// Usage
const result = await promiseWithTimeout(
  fetch('https://api.example.com/data'),
  3000
);

// BAD: Creates infinite chain
async function retryForever() {
  try {
    return await riskyOperation();
  } catch (error) {
    return retryForever(); // Chain grows indefinitely
  }
}

// GOOD: Break the chain
function retryWithLimit(maxRetries = 5) {
  let attempts = 0;

  function attempt() {
    return riskyOperation().catch(error => {
      attempts++;
      if (attempts >= maxRetries) {
        throw error;
      }
      // Don't return - creates new chain instead
      return new Promise(resolve =>
        setTimeout(() => resolve(attempt()), 1000)
      );
    });
  }

  return attempt();
}

// BAD: Missing catch can leave promise pending
async function processData(items) {
  const promises = items.map(item => saveToDatabase(item));
  return Promise.all(promises);
}

// GOOD: Handle errors to ensure settlement
async function processData(items) {
  const promises = items.map(item =>
    saveToDatabase(item).catch(error => {
      console.error(`Failed to save item ${item.id}:`, error);
      return null; // Resolve with null instead of hanging
    })
  );

  const results = await Promise.all(promises);
  return results.filter(r => r !== null);
}

const controller = new AbortController();
const signal = controller.signal;

// Set timeout
setTimeout(() => controller.abort(), 5000);

try {
  const response = await fetch('https://api.example.com/data', { signal });
  const data = await response.json();
  console.log(data);
} catch (error) {
  if (error.name === 'AbortError') {
    console.log('Request was aborted');
  } else {
    throw error;
  }
}

// Add to your application for debugging
const v8 = require('v8');
const fs = require('fs');

function takeHeapSnapshot() {
  const filename = `heap-${Date.now()}.heapsnapshot`;
  const heapSnapshot = v8.writeHeapSnapshot(filename);
  console.log('Heap snapshot written to:', heapSnapshot);
}

// Take snapshots before and after suspected leak
takeHeapSnapshot();
// ... run your code
setTimeout(takeHeapSnapshot, 60000);

const pendingPromises = new Set();

function trackPromise(promise, label) {
  const tracked = { promise, label, created: Date.now() };
  pendingPromises.add(tracked);

  promise.finally(() => {
    pendingPromises.delete(tracked);
  });

  return promise;
}

// Periodically check for old promises
setInterval(() => {
  const now = Date.now();
  pendingPromises.forEach(p => {
    const age = now - p.created;
    if (age > 10000) { // 10 seconds
      console.warn(`Long-pending promise: ${p.label} (${age}ms old)`);
    }
  });
}, 5000);

// Usage
await trackPromise(fetchData(), 'User data fetch');