How to fix Error: Callback did not include error parameter (node-style callback convention) in Node.js

// Before: Missing error parameter
fs.readFile('file.txt', 'utf8', (data) => {
  console.log(data);
});

// After: Correct error-first callback
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log(data);
});

function processData(callback) {
  // Correct: Check error first
  someAsyncOperation((err, result) => {
    if (err) {
      return callback(err); // Propagate error
    }
    // Only use result if no error
    const processed = transform(result);
    callback(null, processed); // null indicates success
  });
}

// Incorrect: No error check
function badProcessData(callback) {
  someAsyncOperation((err, result) => {
    const processed = transform(result); // May crash if err exists
    callback(processed); // Missing error parameter
  });
}

function readUserData(userId, callback) {
  database.query('SELECT * FROM users WHERE id = ?', [userId], (err, rows) => {
    if (err) {
      // Pass error as first argument
      return callback(new Error(`Failed to read user: ${err.message}`));
    }
    
    if (rows.length === 0) {
      // Pass error for not found
      return callback(new Error('User not found'));
    }
    
    // Pass null for error, data as second argument
    callback(null, rows[0]);
  });
}

// Usage
readUserData(123, (err, user) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log('User:', user);
});

const util = require('util');

// Promise-based function
async function fetchData(url) {
  const response = await fetch(url);
  return response.json();
}

// Convert to callback-style (automatically follows error-first convention)
const fetchDataCallback = util.callbackify(fetchData);

// Now usable with callbacks
fetchDataCallback('https://api.example.com/data', (err, data) => {
  if (err) {
    console.error('Fetch failed:', err);
    return;
  }
  console.log('Data:', data);
});

/**
 * Processes a file asynchronously
 * @param {string} filePath - Path to the file
 * @param {Function} callback - Callback with signature (err, result)
 * @callback callback
 * @param {Error|null} err - Error object or null if successful
 * @param {string} result - Processed file content
 */
function processFile(filePath, callback) {
  // Type check the callback
  if (typeof callback !== 'function') {
    throw new TypeError('Callback must be a function');
  }
  
  fs.readFile(filePath, 'utf8', (err, data) => {
    if (err) {
      return callback(err);
    }
    
    try {
      const processed = data.toUpperCase();
      callback(null, processed);
    } catch (processingError) {
      callback(processingError);
    }
  });
}