avifenesh/glide-mq/glide-mq-migrate-bullmq

npm remove bullmq
npm install glide-mq

// Before
import { Queue, Worker, Job, QueueEvents, FlowProducer } from 'bullmq';
// After
import { Queue, Worker, Job, QueueEvents, FlowProducer } from 'glide-mq';

// BEFORE (BullMQ)
const connection = { host: 'localhost', port: 6379 };

// AFTER (glide-mq)
const connection = { addresses: [{ host: 'localhost', port: 6379 }] };

// BEFORE
const queue = new Queue('tasks', { connection });
await queue.add('send-email', { to: 'user@example.com' });

// AFTER - only the connection changes
const queue = new Queue('tasks', { connection });
await queue.add('send-email', { to: 'user@example.com' });

// BEFORE
const worker = new Worker(
  'tasks',
  async (job) => {
    await sendEmail(job.data.to);
  },
  { connection: { host: 'localhost', port: 6379 }, concurrency: 10 },
);

// AFTER
const worker = new Worker(
  'tasks',
  async (job) => {
    await sendEmail(job.data.to);
  },
  { connection: { addresses: [{ host: 'localhost', port: 6379 }] }, concurrency: 10 },
);

// Both - same usage, only connection format differs
const flow = new FlowProducer({ connection });
await flow.add({
  name: 'parent',
  queueName: 'tasks',
  data: { step: 'final' }, // NOTE: data is required in glide-mq
  children: [
    { name: 'child-1', queueName: 'tasks', data: { step: '1' } },
    { name: 'child-2', queueName: 'tasks', data: { step: '2' } },
  ],
});

// Both - same, only connection format differs
const qe = new QueueEvents('tasks', { connection });
qe.on('completed', ({ jobId }) => console.log(jobId, 'done'));
qe.on('failed', ({ jobId, failedReason }) => console.error(jobId, failedReason));

// BullMQ
await worker.close();
await queue.close();

// glide-mq - identical
await worker.close();
await queue.close();

// Both
import { UnrecoverableError } from 'glide-mq'; // was 'bullmq'
throw new UnrecoverableError('permanent failure');

// BEFORE - opts.repeat (deprecated in BullMQ v5)
await queue.add('report', data, {
  repeat: { pattern: '0 9 * * *', tz: 'America/New_York' },
});

// AFTER - upsertJobScheduler
await queue.upsertJobScheduler(
  'report',
  { pattern: '0 9 * * *', tz: 'America/New_York' },
  { name: 'report', data: { v: 1 } },
);

// BEFORE
const worker = new Worker('q', processor, {
  connection,
  settings: {
    backoffStrategy: (attemptsMade, type, delay, err) => {
      if (type === 'jitter') return delay + Math.random() * delay;
      return delay * attemptsMade;
    },
  },
});

// AFTER
const worker = new Worker('q', processor, {
  connection,
  backoffStrategies: {
    jitter: (attemptsMade, err) => 1000 + Math.random() * 1000,
    linear: (attemptsMade, err) => 1000 * attemptsMade,
  },
});

// BEFORE
const queue = new Queue('tasks', {
  connection,
  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 1000 } },
});

// AFTER - wrap add() with your defaults
const DEFAULTS = { attempts: 3, backoff: { type: 'exponential', delay: 1000 } } as const;
const add = (name: string, data: unknown, opts?: JobOptions) => queue.add(name, data, { ...DEFAULTS, ...opts });

// BEFORE
const jobs = await queue.getJobs(['waiting', 'active'], 0, 99);

// AFTER
const [waiting, active] = await Promise.all([queue.getJobs('waiting', 0, 99), queue.getJobs('active', 0, 99)]);
const jobs = [...waiting, ...active];

// BEFORE
const qe = new QueueEvents('tasks', { connection });
const result = await job.waitUntilFinished(qe, 30000);

// AFTER - no QueueEvents needed
const state = await job.waitUntilFinished(500, 30000);
// args: pollIntervalMs (default 500), timeoutMs (default 30000)
// resolves to 'completed' or 'failed'; read the result with queue.getJob(job.id)
// or use queue.addAndWait() when you need the return value

// BEFORE (BullMQ Pro)
await queue.add('job', data, {
  group: { id: 'tenant-123', limit: { max: 2, duration: 0 } },
});

// AFTER (glide-mq, open source)
await queue.add('job', data, {
  ordering: { key: 'tenant-123', concurrency: 2 },
});