agenda vs bee-queue vs bree vs bull vs kue vs node-resque
Job and Queue Management
Search packages..
agendabee-queuebreebullkuenode-resqueSimilar Packages:

Job and Queue Management

Job and Queue Management Libraries in Node.js provide tools for handling background tasks, scheduling jobs, and managing queues of tasks to be processed asynchronously. These libraries help improve application performance by offloading time-consuming tasks from the main event loop, allowing for better scalability and responsiveness. They offer features like job prioritization, retries, scheduling, and monitoring, making them essential for building efficient and reliable applications that handle asynchronous processing. These libraries are particularly useful for tasks like sending emails, processing images, or performing data migrations without blocking the main application flow.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
agenda09,649297 kB211 days agoMIT
bee-queue04,026107 kB474 months agoMIT
bree03,28592 kB292 months agoMIT
bull016,245309 kB148a year agoMIT
kue09,457-2889 years agoMIT
node-resque01,410708 kB232 months agoApache-2.0

Feature Comparison: agenda vs bee-queue vs bree vs bull vs kue vs node-resque

Storage Backend

  • agenda:

    agenda uses MongoDB as its storage backend, which allows for persistent job storage, scheduling, and retrieval. This makes it suitable for applications that require long-term job storage and reliability, as jobs can be stored even if the application restarts.

  • bee-queue:

    bee-queue uses Redis as its storage backend, providing fast and ephemeral job storage. It is designed for low-latency job processing, making it ideal for applications that need quick job execution without the overhead of persistent storage.

  • bree:

    bree does not require any external storage backend, as it uses worker threads to execute jobs directly. This makes it lightweight and efficient for running jobs in memory, but it does not provide persistent job storage or queuing.

  • bull:

    bull uses Redis as its storage backend, offering both persistent and ephemeral job storage. It provides advanced features like job retries, delayed jobs, and rate limiting, making it suitable for applications that require robust queue management and reliability.

  • kue:

    kue uses Redis as its storage backend, providing persistent job storage with support for job prioritization and retries. It also includes a built-in UI for monitoring job progress, making it suitable for applications that need visual management of job queues.

  • node-resque:

    node-resque supports multiple storage backends, including Redis and MongoDB, allowing for flexible job storage options. It provides features like job scheduling, retries, and plugins, making it a versatile choice for applications that require a customizable queue system.

Job Scheduling

  • agenda:

    agenda supports advanced job scheduling, including recurring jobs, delayed jobs, and one-time jobs. It allows for flexible scheduling using cron-like syntax, making it suitable for applications that require complex scheduling capabilities.

  • bee-queue:

    bee-queue focuses on simple job queuing and does not provide built-in support for job scheduling. It is designed for fast, on-demand job processing rather than scheduled tasks.

  • bree:

    bree supports job scheduling using cron syntax, allowing for both one-time and recurring jobs. It leverages worker threads for executing scheduled jobs, providing better performance for CPU-intensive tasks.

  • bull:

    bull supports job scheduling, including delayed jobs and recurring jobs (with additional plugins). It provides a robust queuing mechanism with support for job prioritization and retries, making it suitable for complex job workflows.

  • kue:

    kue supports job scheduling with delayed jobs and prioritization. It allows for creating jobs with specific delay times and priority levels, making it suitable for applications that require controlled job execution.

  • node-resque:

    node-resque supports job scheduling, including delayed jobs and recurring jobs, through its flexible API. It allows for creating jobs with specified delays and supports custom scheduling logic, making it a versatile choice for time-based job execution.

UI and Monitoring

  • agenda:

    agenda does not provide a built-in UI for monitoring jobs, but it allows for integration with external monitoring tools. Developers can create custom dashboards to visualize job status and metrics using the data stored in MongoDB.

  • bee-queue:

    bee-queue provides a simple API for monitoring job status, but it does not include a built-in UI. Developers can create custom monitoring solutions using the provided API to track job progress and failures.

  • bree:

    bree does not include a built-in UI for monitoring jobs, but it provides detailed logging and event hooks that can be used to track job execution. Developers can integrate third-party monitoring tools for better visibility.

  • bull:

    bull does not provide a built-in UI for monitoring jobs, but it allows for integration with external monitoring tools. Developers can create custom dashboards to visualize job status and metrics using the data stored in Redis.

  • kue:

    kue includes a built-in UI for monitoring job queues, displaying job status, progress, and failure rates. The UI provides a visual representation of job queues, making it easy to manage and monitor jobs in real-time.

  • node-resque:

    node-resque does not provide a built-in UI, but it allows for integration with external monitoring tools. Developers can create custom dashboards to visualize job status and metrics using the data stored in the chosen backend.

Job Retries

  • agenda:

    agenda supports job retries in case of failure, allowing developers to configure retry logic and failure handling. It provides hooks for handling failed jobs and implementing custom retry strategies.

  • bee-queue:

    bee-queue supports job retries with configurable retry limits. It allows for automatic retries of failed jobs, making it suitable for handling transient errors in job processing.

  • bree:

    bree supports job retries through custom implementation, but it does not provide built-in retry functionality. Developers can implement their own retry logic using the provided job events and hooks.

  • bull:

    bull supports advanced job retries with configurable retry limits, backoff strategies, and failure handling. It provides robust support for handling failed jobs and implementing complex retry logic.

  • kue:

    kue supports job retries with configurable retry limits and failure handling. It allows for automatic retries of failed jobs, making it suitable for handling errors and ensuring job completion.

  • node-resque:

    node-resque supports job retries with configurable retry limits and backoff strategies. It provides flexible failure handling and allows for custom retry logic to be implemented.

Ease of Use: Code Examples

  • agenda:

    Simple Job Scheduling with agenda

    const Agenda = require('agenda');
const mongoConnectionString = 'mongodb://localhost:27017/agenda';
const agenda = new Agenda({ db: { address: mongoConnectionString } });

// Define a job
agenda.define('send email', async (job) => {
  console.log('Sending email...');
});

// Schedule a job
agenda.schedule('in 10 seconds', 'send email');

// Start the agenda
agenda.start();
  • bee-queue:

    Simple Job Queue with bee-queue

    const Queue = require('bee-queue');
const queue = new Queue('my-queue');

// Process jobs
queue.process(async (job) => {
  console.log(`Processing job ${job.id}`);
});

// Add a job to the queue
queue.createJob({ data: 'my data' }).save();
  • bree:

    Simple Job Scheduling with bree

    const Bree = require('bree');
const bree = new Bree({
  jobs: [{
    name: 'my-job',
    interval: '10s',
  }],
});

// Start the scheduler
bree.start();
  • bull:

    Simple Job Queue with bull

    const Queue = require('bull');
const myQueue = new Queue('my-queue');

// Process jobs
myQueue.process(async (job) => {
  console.log(`Processing job ${job.id}`);
});

// Add a job to the queue
myQueue.add({ data: 'my data' });
  • kue:

    Simple Job Queue with kue

    const kue = require('kue');
const queue = kue.createQueue();

// Create a job
const job = queue.create('email', { to: 'example@example.com' }).save();

// Process the job
queue.process('email', (job, done) => {
  console.log(`Sending email to ${job.data.to}`);
  done();
});
  • node-resque:

    Simple Job Queue with node-resque

    const { Queue, Worker } = require('node-resque');
const queue = new Queue({
  myQueue: { jobs: ['myJob'] },
});
const worker = new Worker({ queue });

// Define a job
worker.on('myJob', (job, done) => {
  console.log(`Processing job ${job.id}`);
  done();
});

// Start the worker
worker.start();

How to Choose: agenda vs bee-queue vs bree vs bull vs kue vs node-resque

  • agenda:

    Choose agenda if you need a job scheduler with MongoDB integration that supports recurring jobs, delayed jobs, and job prioritization. It is ideal for applications that require flexible scheduling and persistence of job states.

  • bee-queue:

    Choose bee-queue if you need a simple and lightweight queue system with Redis support, focusing on performance and low latency. It is suitable for applications that require fast job processing with minimal overhead.

  • bree:

    Choose bree if you want a modern job scheduler that uses worker threads for executing jobs, providing better performance and resource utilization. It is ideal for applications that need to run CPU-intensive tasks without blocking the event loop.

  • bull:

    Choose bull if you need a feature-rich queue system with Redis support that offers advanced features like job retries, rate limiting, and delayed jobs. It is suitable for applications that require robust queue management and scalability.

  • kue:

    Choose kue if you need a priority job queue backed by Redis with a built-in UI for monitoring jobs. It is ideal for applications that require visual monitoring and management of job queues.

  • node-resque:

    Choose node-resque if you need a flexible and extensible job queue system that supports multiple backends (Redis, MongoDB, etc.) and provides features like job scheduling, retries, and plugins. It is suitable for applications that require a highly customizable queue system.

Similar Npm Packages to agenda

agenda is a job scheduling library for Node.js that allows developers to manage and execute background jobs easily. It is built on top of MongoDB, enabling persistent job storage and providing a flexible API for scheduling tasks. With agenda, you can define recurring jobs, manage job priorities, and handle job failures gracefully. This makes it a great choice for applications that require reliable job scheduling and processing.

While agenda is a powerful tool, there are several alternatives available in the Node.js ecosystem that also provide job scheduling capabilities. Here are a couple of notable alternatives:

  • bull is a robust queue and job scheduling library for Node.js that is built on Redis. It offers a rich set of features, including delayed jobs, job retries, and concurrency control. Bull is particularly well-suited for applications that need to handle a high volume of jobs or require advanced job management capabilities. Its performance and reliability make it a popular choice for developers looking to implement job queues in their applications.

  • node-schedule is a flexible job scheduling library for Node.js that allows you to schedule jobs using cron-like syntax. It is lightweight and easy to use, making it ideal for applications that require simple scheduling without the overhead of a persistent job store. Node-schedule is perfect for scenarios where you need to run tasks at specific intervals or times without the need for complex job management features.

To see how agenda compares with bull and node-schedule, check out the comparison: Comparing agenda vs bull vs node-schedule.

Similar Npm Packages to bee-queue

bee-queue is a simple and efficient queue library for Node.js, designed for handling background jobs and tasks. It is built on top of Redis and provides a straightforward API for creating and managing job queues. With its focus on performance and simplicity, bee-queue is particularly well-suited for applications that require a lightweight solution for processing jobs asynchronously.

While bee-queue is a great option, there are several alternatives available in the Node.js ecosystem that offer different features and capabilities:

  • agenda is a job scheduling library for Node.js that uses MongoDB as its backend. It allows you to define jobs and schedule them to run at specific times or intervals. agenda is particularly useful for applications that require recurring tasks or scheduled jobs, making it a good choice for cron-like functionality.
  • bull is a robust queue library for Node.js that also utilizes Redis. It offers advanced features such as job prioritization, delayed jobs, and rate limiting. bull is designed for high-performance applications and is suitable for handling large volumes of jobs efficiently. If your application requires more complex queue management capabilities, bull is an excellent alternative.
  • kue is another Redis-based job queue library for Node.js. It provides a rich set of features, including job retries, event listeners, and a user-friendly UI for managing jobs. While kue is powerful, it is worth noting that it is no longer actively maintained, so developers should consider this when choosing a queue library for new projects.
  • p-queue is a promise-based queue library that allows you to manage asynchronous tasks with ease. It provides features such as concurrency control and priority support, making it suitable for scenarios where you need to limit the number of concurrent operations. p-queue is a good choice for applications that require fine-grained control over task execution.

For a comprehensive comparison of these libraries, check out the following link: Comparing agenda vs bee-queue vs bull vs kue vs p-queue.

Similar Npm Packages to bree

bree is a job scheduling library for Node.js that allows developers to run background tasks and scheduled jobs with ease. It is designed to be simple and efficient, providing a straightforward API for scheduling tasks at specific intervals or times. Bree supports both cron-like scheduling and more complex job scheduling scenarios, making it a versatile choice for managing background tasks in Node.js applications.

While Bree is a powerful tool for job scheduling, there are several alternatives in the Node.js ecosystem that offer similar functionalities. Here are a few notable options:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its persistence layer. It provides a simple API for scheduling jobs and supports recurring jobs, delayed jobs, and more. Agenda is a great choice if you are already using MongoDB in your application and want a seamless way to manage background tasks without introducing additional dependencies.

  • bull is a robust job and message queue library for Node.js that is built on Redis. It offers advanced features such as job prioritization, delayed jobs, and concurrency control. Bull is ideal for applications that require high performance and reliability in job processing, especially when dealing with a large number of jobs or complex workflows.

  • cron is a simple and straightforward library for scheduling tasks using cron syntax. It allows you to run tasks at specific intervals defined by cron expressions. If you are looking for a lightweight solution for running scheduled tasks without the overhead of a full job queue, cron is a solid choice.

  • later is a flexible scheduling library that allows you to define schedules using a variety of formats, including cron-like syntax. It provides a powerful API for scheduling tasks and can handle complex scheduling scenarios. Later is suitable for applications that require advanced scheduling capabilities beyond standard cron expressions.

  • node-cron is another simple cron-based job scheduler for Node.js. It allows you to schedule tasks using cron syntax and is easy to integrate into existing applications. Node-cron is a good option for developers who prefer a straightforward approach to scheduling tasks without additional complexity.

  • node-schedule is a flexible job scheduling library for Node.js that allows you to schedule jobs using cron-like syntax or JavaScript Date objects. It supports recurring jobs and provides a simple API for managing scheduled tasks. Node-schedule is a great choice for applications that need a flexible and easy-to-use scheduling solution.

To see how Bree compares with these alternatives, check out the comparison: Comparing agenda vs bree vs bull vs cron vs later vs node-cron vs node-schedule.

Similar Npm Packages to bull

bull is a robust queue library for Node.js, designed to handle distributed jobs and messages in a scalable manner. It is built on top of Redis and provides a simple API for creating and managing job queues. Bull is particularly useful for applications that require background processing, such as sending emails, processing images, or handling other time-consuming tasks. With features like job retries, delayed jobs, and concurrency control, Bull makes it easy to manage complex workflows efficiently.

While Bull is a popular choice for job and queue management, there are several alternatives that cater to different needs and preferences:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It allows you to schedule jobs to run at specific times or intervals, making it suitable for applications that require cron-like functionality. Agenda is easy to set up and provides a simple API for defining and managing jobs, making it a good choice for applications that already use MongoDB and need a straightforward scheduling solution.

  • bee-queue is another lightweight queue library for Node.js that focuses on simplicity and performance. It is designed for handling jobs in a single Redis instance and provides a minimalistic API for creating and processing jobs. Bee-Queue is particularly well-suited for applications that require fast job processing with low overhead, making it a great alternative for developers looking for a straightforward queuing solution.

  • bullmq is the successor to Bull, offering a more modern and feature-rich approach to job and queue management. It introduces a new architecture and API, providing improved performance and additional features such as rate limiting, job prioritization, and more. If you are starting a new project or looking to upgrade from Bull, BullMQ is the recommended choice for its enhanced capabilities and flexibility.

  • kue is a priority job queue backed by Redis, designed for handling distributed jobs in Node.js applications. It provides a rich set of features, including job prioritization, delayed jobs, and a user interface for monitoring job progress. Kue is suitable for applications that require a more comprehensive job management solution with a focus on monitoring and visualization.

  • node-resque is a Redis-backed library for creating background jobs in Node.js. It supports multiple backends and provides a flexible API for defining and managing jobs. Node-resque is ideal for applications that need a customizable job processing solution and want to leverage the power of Redis for job management.

To explore how these libraries compare, check out the following link: Comparing agenda vs bee-queue vs bull vs bullmq vs kue vs node-resque.

Similar Npm Packages to kue

kue is a priority job queue library for Node.js that allows developers to manage and process jobs in a reliable and efficient manner. It provides a simple API for creating, processing, and managing jobs, making it a popular choice for applications that require background processing or task scheduling. While kue is a robust solution for job management, there are several alternatives that developers might consider based on their specific needs:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It allows you to define jobs with a simple API and provides features like recurring jobs, job prioritization, and job cancellation. If your application already uses MongoDB and you need a straightforward way to schedule jobs, agenda is a great option that integrates seamlessly with your existing database.
  • bee-queue is a simple and fast job queue library for Node.js that is designed for performance and ease of use. It is built on Redis and focuses on providing a minimalistic API for job processing. bee-queue is ideal for applications that require a lightweight solution for managing background jobs without the overhead of more complex libraries.
  • bree is a job scheduler for Node.js that is designed to be simple and efficient. It allows you to run jobs in the background using worker threads, which can improve performance for CPU-intensive tasks. If you need a scheduler that can handle both background jobs and recurring tasks while leveraging the power of worker threads, bree is an excellent choice.
  • bull is a robust job and message queue library for Node.js that is built on Redis. It offers advanced features such as job retries, delayed jobs, and rate limiting, making it suitable for applications that require more complex job processing capabilities. If you need a powerful and feature-rich solution for managing jobs, bull is a strong contender.
  • node-resque is a job processing library for Node.js that is designed to work with Redis. It provides a flexible API for defining and processing jobs, as well as support for scheduled jobs and job prioritization. If you are looking for a library that offers a balance between simplicity and functionality, node-resque is worth considering.

For a detailed comparison of these job queue libraries, check out the link: Comparing agenda vs bee-queue vs bree vs bull vs kue vs node-resque.

Similar Npm Packages to node-resque

node-resque is a robust job queue library for Node.js applications. It allows developers to manage background jobs and scheduled tasks efficiently, providing a flexible and reliable way to handle asynchronous processing. With support for Redis, node-resque enables distributed job processing, making it suitable for applications that require scalability and resilience. While node-resque is a powerful option for job management, there are several alternatives in the Node.js ecosystem that offer similar functionalities. Here are a few noteworthy alternatives:

  • agenda is a lightweight job scheduling library for Node.js that uses MongoDB as its backend. It provides a simple API for defining jobs and scheduling them to run at specific intervals or times. Agenda is particularly well-suited for applications that already utilize MongoDB and require a straightforward way to manage recurring tasks or delayed jobs. Its ease of use and integration with MongoDB make it a popular choice for developers looking for a minimalistic job scheduler.

  • bee-queue is a simple and fast job queue library for Node.js that is designed for handling jobs in a Redis-backed queue. It focuses on simplicity and performance, making it a great choice for applications that require quick job processing without the overhead of more complex job management systems. Bee-queue is ideal for applications that need to process jobs in real-time and want a straightforward API for managing job queues.

  • bull is a powerful Redis-based job and message queue for Node.js. It offers advanced features such as job prioritization, delayed jobs, and rate-limited processing, making it suitable for applications with complex job processing needs. Bull's robust architecture allows for efficient job management and monitoring, making it a popular choice among developers who require a feature-rich job queue solution.

  • bullmq is the successor to Bull, designed to provide a more modern and flexible API for job management. It builds on the strengths of Bull while introducing new features and improvements, such as support for TypeScript and better performance. Bullmq is ideal for developers looking for a cutting-edge job queue solution that leverages the latest advancements in Node.js and Redis.

  • kue is another job queue library for Node.js that uses Redis as its backend. It offers a rich set of features, including job priority, delayed jobs, and job event listeners. Kue provides a user-friendly dashboard for monitoring job progress and status, making it a suitable choice for applications that require visibility into job processing.

For a comprehensive comparison of these job queue libraries, check out the following link: Comparing agenda vs bee-queue vs bull vs bullmq vs kue vs node-resque.

README for agenda

Agenda

Agenda

A light-weight job scheduling library for Node.js

NPM Version NPM Downloads

Migrating from v5? See the Migration Guide for all breaking changes.

Agenda 6.x

Agenda 6.x is a complete TypeScript rewrite with a focus on modularity and flexibility:

  • Pluggable storage backends - Choose from MongoDB, PostgreSQL, Redis, or implement your own. Each backend is a separate package - install only what you need.

  • Pluggable notification channels - Move beyond polling with real-time job notifications via Redis, PostgreSQL LISTEN/NOTIFY, or other pub/sub systems. Jobs get processed immediately when saved, not on the next poll cycle.

  • Modern stack - ESM-only, Node.js 18+, full TypeScript with strict typing.

See the 6.x Roadmap for details and progress.

Features

  • Minimal overhead job scheduling
  • Pluggable storage backends (MongoDB, PostgreSQL, Redis)
  • TypeScript support with full typing
  • Scheduling via cron or human-readable syntax
  • Configurable concurrency and locking
  • Real-time job notifications (optional)
  • Sandboxed worker execution via fork mode
  • TypeScript decorators for class-based job definitions

Installation

Install the core package and your preferred backend:

# For MongoDB
npm install agenda @agendajs/mongo-backend

# For PostgreSQL
npm install agenda @agendajs/postgres-backend

# For Redis
npm install agenda @agendajs/redis-backend

Requirements:

  • Node.js 18+
  • Database of your choice (MongoDB 4+, PostgreSQL, or Redis)

Quick Start

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

const agenda = new Agenda({
  backend: new MongoBackend({ address: 'mongodb://localhost/agenda' })
});

// Define a job
agenda.define('send email', async (job) => {
  const { to, subject } = job.attrs.data;
  await sendEmail(to, subject);
});

// Start processing
await agenda.start();

// Schedule jobs
await agenda.every('1 hour', 'send email', { to: 'user@example.com', subject: 'Hello' });
await agenda.schedule('in 5 minutes', 'send email', { to: 'admin@example.com', subject: 'Report' });
await agenda.now('send email', { to: 'support@example.com', subject: 'Urgent' });

Official Backend Packages

PackageBackendNotificationsInstall
@agendajs/mongo-backendMongoDBPolling onlynpm install @agendajs/mongo-backend
@agendajs/postgres-backendPostgreSQLLISTEN/NOTIFYnpm install @agendajs/postgres-backend
@agendajs/redis-backendRedisPub/Subnpm install @agendajs/redis-backend

Backend Capabilities

BackendStorageNotificationsNotes
MongoDB (MongoBackend)✅❌Storage only. Combine with external notification channel for real-time.
PostgreSQL (PostgresBackend)✅✅Full backend. Uses LISTEN/NOTIFY for notifications.
Redis (RedisBackend)✅✅Full backend. Uses Pub/Sub for notifications.
InMemoryNotificationChannel❌✅Notifications only. For single-process/testing.

Backend Configuration

MongoDB

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

// Via connection string
const agenda = new Agenda({
  backend: new MongoBackend({ address: 'mongodb://localhost/agenda' })
});

// Via existing MongoDB connection
const agenda = new Agenda({
  backend: new MongoBackend({ mongo: existingDb })
});

// With options
const agenda = new Agenda({
  backend: new MongoBackend({
    mongo: db,
    collection: 'jobs'        // Collection name (default: 'agendaJobs')
  }),
  processEvery: '30 seconds', // Job polling interval
  maxConcurrency: 20,         // Max concurrent jobs
  defaultConcurrency: 5       // Default per job type
});

PostgreSQL

import { Agenda } from 'agenda';
import { PostgresBackend } from '@agendajs/postgres-backend';

const agenda = new Agenda({
  backend: new PostgresBackend({
    connectionString: 'postgresql://user:pass@localhost:5432/mydb'
  })
});

Redis

import { Agenda } from 'agenda';
import { RedisBackend } from '@agendajs/redis-backend';

const agenda = new Agenda({
  backend: new RedisBackend({
    connectionString: 'redis://localhost:6379'
  })
});

Real-Time Notifications

For faster job processing across distributed systems:

import { Agenda, InMemoryNotificationChannel } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';

const agenda = new Agenda({
  backend: new MongoBackend({ mongo: db }),
  notificationChannel: new InMemoryNotificationChannel()
});

Mixing Storage and Notification Backends

You can use MongoDB for storage while using a different system for real-time notifications:

import { Agenda } from 'agenda';
import { MongoBackend } from '@agendajs/mongo-backend';
import { RedisBackend } from '@agendajs/redis-backend';

// MongoDB for storage + Redis for real-time notifications
const redisBackend = new RedisBackend({ connectionString: 'redis://localhost:6379' });
const agenda = new Agenda({
  backend: new MongoBackend({ mongo: db }),
  notificationChannel: redisBackend.notificationChannel
});

This is useful when you want MongoDB's proven durability and flexible queries for job storage, but need faster real-time notifications across multiple processes.

API Overview

Defining Jobs

// Simple async handler
agenda.define('my-job', async (job) => {
  console.log('Processing:', job.attrs.data);
});

// With options
agenda.define('my-job', async (job) => { /* ... */ }, {
  concurrency: 10,
  lockLimit: 5,
  lockLifetime: 10 * 60 * 1000, // 10 minutes
  priority: 'high'
});

Defining Jobs with Decorators

For a class-based approach, use TypeScript decorators:

import { JobsController, Define, Every, registerJobs, Job } from 'agenda';

@JobsController({ namespace: 'email' })
class EmailJobs {
  @Define({ concurrency: 5 })
  async sendWelcome(job: Job<{ userId: string }>) {
    console.log('Sending welcome to:', job.attrs.data.userId);
  }

  @Every('1 hour')
  async cleanupBounced(job: Job) {
    console.log('Cleaning up bounced emails');
  }
}

registerJobs(agenda, [new EmailJobs()]);
await agenda.start();

// Schedule using namespaced name
await agenda.now('email.sendWelcome', { userId: '123' });

See Decorators Documentation for full details.

Scheduling Jobs

// Run immediately
await agenda.now('my-job', { userId: '123' });

// Run at specific time
await agenda.schedule('tomorrow at noon', 'my-job', data);
await agenda.schedule(new Date('2024-12-25'), 'my-job', data);

// Run repeatedly
await agenda.every('5 minutes', 'my-job');
await agenda.every('0 * * * *', 'my-job'); // Cron syntax

Job Control

// Cancel jobs matching a filter (removes from database)
await agenda.cancel({ name: 'my-job' });
await agenda.cancel({ name: 'my-job', data: { userId: 123 } });

// Cancel ALL jobs unconditionally
await agenda.cancelAll();

// Disable/enable jobs globally (by query)
await agenda.disable({ name: 'my-job' });  // Disable all jobs matching query
await agenda.enable({ name: 'my-job' });   // Enable all jobs matching query

// Disable/enable individual jobs
const job = await agenda.create('my-job', data);
job.disable();
await job.save();

// Progress tracking
agenda.define('long-job', async (job) => {
  for (let i = 0; i <= 100; i += 10) {
    await doWork();
    await job.touch(i); // Report progress 0-100
  }
});

Stopping / Draining

// Stop immediately - unlocks running jobs so other workers can pick them up
await agenda.stop();

// Drain - waits for running jobs to complete before stopping
await agenda.drain();

// Drain with timeout (30 seconds) - for cloud platforms with shutdown deadlines
const result = await agenda.drain(30000);
if (result.timedOut) {
    console.log(`${result.running} jobs still running after timeout`);
}

// Drain with AbortSignal - for external control
const controller = new AbortController();
setTimeout(() => controller.abort(), 30000);
await agenda.drain({ signal: controller.signal });

Use drain() for graceful shutdowns where you want in-progress jobs to finish their work.

Events

agenda.on('start', (job) => console.log('Job started:', job.attrs.name));
agenda.on('complete', (job) => console.log('Job completed:', job.attrs.name));
agenda.on('success', (job) => console.log('Job succeeded:', job.attrs.name));
agenda.on('fail', (err, job) => console.log('Job failed:', job.attrs.name, err));

// Job-specific events
agenda.on('start:send email', (job) => { /* ... */ });
agenda.on('fail:send email', (err, job) => { /* ... */ });

Custom Backend

For databases other than MongoDB, PostgreSQL, or Redis, implement AgendaBackend:

import { AgendaBackend, JobRepository } from 'agenda';

class SQLiteBackend implements AgendaBackend {
  readonly repository: JobRepository;
  readonly notificationChannel = undefined; // Or implement NotificationChannel

  async connect() { /* ... */ }
  async disconnect() { /* ... */ }
}

const agenda = new Agenda({
  backend: new SQLiteBackend({ path: './jobs.db' })
});

See Custom Backend Driver for details.

Documentation

Related Packages

Official Backend Packages:

Tools:

License

MIT

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.