Batch

const Batch = require('batch');

import Batch from 'batch';

const Batch = require('batch');

// Create a new batch
const batch = new Batch();

// Configure concurrency (optional)
batch.concurrency(4);

// Add functions to the batch
['user1', 'user2', 'user3'].forEach(userId => {
  batch.push(function(done) {
    // Simulate async operation
    setTimeout(() => {
      done(null, { id: userId, name: `User ${userId}` });
    }, Math.random() * 1000);
  });
});

// Track progress (optional)
batch.on('progress', function(e) {
  console.log(`Progress: ${e.percent}% (${e.complete}/${e.total})`);
});

// Execute the batch
batch.end(function(err, results) {
  if (err) {
    console.error('Batch failed:', err);
  } else {
    console.log('All operations completed:', results);
  }
});

/**
 * Create a new Batch instance
 * @param {...Function} functions - Optional functions to add immediately
 * @returns {Batch} New Batch instance
 */
function Batch(...functions);

// All equivalent ways to create a batch
const batch1 = new Batch();
const batch2 = Batch();
const batch3 = new Batch(fn1, fn2, fn3); // Pre-populate with functions

/**
 * Set concurrency level
 * @param {number} n - Maximum number of concurrent operations
 * @returns {Batch} This instance for chaining
 */
concurrency(n);

const batch = new Batch();
batch.concurrency(3); // Max 3 operations at once
// Default is Infinity (no limit)

/**
 * Add a function to the batch queue
 * @param {Function} fn - Async function that accepts a callback
 * @returns {Batch} This instance for chaining
 */
push(fn);

batch.push(function(callback) {
  // Perform async operation
  someAsyncOperation((err, result) => {
    callback(err, result); // Call callback with (error, result)
  });
});

/**
 * Configure error handling behavior
 * @param {boolean} throws - If true, stop on first error; if false, collect all errors
 * @returns {Batch} This instance for chaining
 */
throws(throws);

// Default behavior: stop on first error
const batch1 = new Batch();
batch1.throws(true); // Default

// Collect all errors and results
const batch2 = new Batch();
batch2.throws(false);

/**
 * Execute all queued functions
 * @param {Function} callback - Completion callback
 * @returns {Batch} This instance
 */
end(callback);

// Fail-fast mode (default)
batch.end(function(err, results) {
  if (err) {
    console.error('First error:', err);
  } else {
    console.log('All results:', results);
  }
});

// Collect-all mode  
batch.throws(false);
batch.end(function(errors, results) {
  errors.forEach((err, index) => {
    if (err) console.error(`Function ${index} failed:`, err);
  });
  console.log('All results:', results);
});

/**
 * Progress event data
 */
interface ProgressEvent {
  index: number;        // Zero-based index of completed function
  value: any;          // Return value from the function
  error: Error | null; // Error from the function, if any
  pending: number;     // Number of functions still pending
  total: number;       // Total number of functions in batch
  complete: number;    // Number of completed functions
  percent: number;     // Completion percentage (0-100, integer)
  start: Date;         // Start time of this function
  end: Date;           // End time of this function  
  duration: number;    // Execution duration in milliseconds
}

batch.on('progress', function(e) {
  console.log(`Function ${e.index} completed in ${e.duration}ms`);
  console.log(`Progress: ${e.percent}% (${e.complete}/${e.total})`);
  
  if (e.error) {
    console.warn(`Function ${e.index} had error:`, e.error);
  } else {
    console.log(`Function ${e.index} result:`, e.value);
  }
});

/**
 * EventEmitter methods available on Batch instances
 */
on(event, listener);          // Add event listener
emit(event, ...args);         // Emit event
removeListener(event, listener); // Remove specific listener
removeAllListeners(event);    // Remove all listeners for event
once(event, listener);        // Add one-time listener
listenerCount(event);         // Count listeners for event

const batch = new Batch();
batch.throws(true); // Default behavior

batch.push(fn1);
batch.push(fn2); // If this fails, execution stops
batch.push(fn3); // This won't execute if fn2 fails

batch.end((err, results) => {
  // err is the first error encountered
  // results contains results from successful functions only
});

const batch = new Batch();
batch.throws(false);

batch.push(fn1);
batch.push(fn2); // Even if this fails, fn3 still executes
batch.push(fn3);

batch.end((errors, results) => {
  // errors[0] = null or error from fn1
  // errors[1] = null or error from fn2
  // errors[2] = null or error from fn3
  // results[0] = result from fn1 or undefined
  // results[1] = result from fn2 or undefined  
  // results[2] = result from fn3 or undefined
});

{
  "browser": {
    "emitter": "events"
  }
}

const batch = new Batch();
batch.concurrency(2); // Limit to 2 concurrent API calls

apiEndpoints.forEach(url => {
  batch.push(callback => {
    fetch(url)
      .then(response => response.json())
      .then(data => callback(null, data))
      .catch(err => callback(err));
  });
});

const batch = new Batch();
batch.concurrency(5);

files.forEach(file => {
  batch.push(callback => {
    fs.readFile(file, 'utf8', (err, content) => {
      if (err) return callback(err);
      // Process content
      const processed = processContent(content);
      callback(null, { file, processed });
    });
  });
});

const batch = new Batch();
batch.concurrency(10);

userIds.forEach(id => {
  batch.push(callback => {
    db.users.findById(id, callback);
  });
});

batch.end((err, users) => {
  if (err) {
    console.error('Database batch failed:', err);
  } else {
    console.log(`Loaded ${users.length} users`);
  }
});