Batch Orchestrator

A powerful, type-safe batch processing library for TypeScript that provides structured execution of sequential steps. Customizable logging, error handling, and retry mechanisms are built-in.

Features

• 🚀 Type-Safe: TypeScript-first design with advanced generic type inference
• 📊 Comprehensive Logging: Built-in logging with multiple transports (console, file, stream)
• 🔄 Retry Mechanisms: Configurable retry strategies with exponential backoff
• 🛡️ Error Handling: Graceful error recovery with catch/finally handlers
• 📈 Performance Monitoring: Memory usage tracking and execution timing
• 🔗 Composable: Support for nested batches and step chaining
• ⚡ Async Support: Full async/await support throughout

Installation

npm install batch-orchestrator
# or
yarn add batch-orchestrator
# or
pnpm add batch-orchestrator

Quick Start

Take a look at the samples to see the library in action. Samples might not be exhaustive, but they should give you a good idea about what you can achieve with the library.

Advanced Features

Retry Configuration

.addStep({
  name: 'API Call',
  description: 'Call external API with retry logic',
  executable: {
    run: async ({ input }) => {
      return await fetchData(input);
    }
  },
  retry: {
    attempts: 3,
    delay: 1_000,
    backoff: 'exponential',
    maxDelay: 10_000,
    shouldRetry: (error) => error.message.includes('timeout')
  }
})

Error Handling

.addStep({
  name: 'Risky Operation',
  description: 'Operation that might fail',
  executable: {
    run: async ({ input }) => {
      return processData(input);
    },
    catch: async ({ error, runContext }) => {
      console.log('Operation failed, using fallback');
      return { data: getFallbackData() };
    },
    finally: async ({ runContext, result }) => {
      await cleanupResources();
    }
  }
})

Nested Batches

const subBatch = new Batch({
   name: 'Sub Process',
   description: 'Handle specific data processing',
}).addStep({
   name: 'Sub Step',
   description: 'Process sub data',
   executable: {
      run: async ({ input }) => ({ data: input.processed }),
   },
});

const mainBatch = new Batch({
   name: 'Main Process',
   description: 'Main processing pipeline',
})
   .addStep({
      name: 'Initial Step',
      description: 'Initial processing',
      executable: {
         run: async ({ input }) => ({ data: input }),
      },
   })
   .addBatch(subBatch);

Logging

The library provides comprehensive logging with multiple output options:

const result = await batch.run({
   loggerConfig: {
      // For each transport, you can set its minimum log level
      console: 'info',
      file: 'debug',
      stream: 'trace',
   },
});

Log Levels

• trace: Most verbose, includes all logs
• debug: Debug information and above
• info: General information and above
• warn: Warnings and errors only
• error: Errors only