DelayedError

class DelayedError extends Error {
  constructor(message?: string);
}

import { Worker, DelayedError } from 'bullmq';

const worker = new Worker('myQueue', async (job) => {
  // Check if conditions are met to process
  const ready = await checkIfReady(job.data);
  
  if (!ready) {
    // Move back to delayed state
    throw new DelayedError('Conditions not met, delaying job');
  }
  
  // Process the job
  return await processJob(job.data);
});

const processor = async (job) => {
  // Check if required data is available
  const data = await getData(job.data.dataId);
  
  if (!data) {
    // Data not ready yet, delay and try again later
    throw new DelayedError(
      `Data ${job.data.dataId} not available yet`
    );
  }
  
  return await processData(data);
};

const processor = async (job) => {
  const { scheduledTime } = job.data;
  
  if (Date.now() < scheduledTime) {
    // Too early to process
    throw new DelayedError(
      `Job scheduled for ${new Date(scheduledTime).toISOString()}`
    );
  }
  
  return await executeScheduledTask(job.data);
};

const processor = async (job) => {
  const resource = await getResource();
  
  if (resource.isBusy) {
    // Resource busy, delay until later
    throw new DelayedError('Resource is busy');
  }
  
  try {
    resource.lock();
    return await useResource(resource, job.data);
  } finally {
    resource.unlock();
  }
};

const processor = async (job) => {
  const serviceStatus = await checkServiceStatus();
  
  if (serviceStatus === 'maintenance') {
    throw new DelayedError(
      'External service is in maintenance mode'
    );
  }
  
  return await callExternalService(job.data);
};

// Set initial delay when adding the job
await queue.add('task', { data }, {
  delay: 5000,  // 5 seconds delay for DelayedError retries
});

const processor = async (job) => {
  const ready = await checkIfReady();
  
  if (!ready) {
    // Change delay before throwing
    await job.changeDelay(10000);  // 10 seconds
    throw new DelayedError('Not ready');
  }
  
  return await process(job.data);
};

// With DelayedError (doesn't count as attempt)
const processor1 = async (job) => {
  if (!ready) {
    throw new DelayedError('Not ready');
    // Job goes to delayed, attemptsMade unchanged
  }
};

// With regular error (counts as attempt)
const processor2 = async (job) => {
  if (!ready) {
    throw new Error('Not ready');
    // Job may retry or fail based on attempts setting
  }
};

// With DelayedError
const processor1 = async (job) => {
  if (!ready) {
    throw new DelayedError('Waiting for resource');
  }
  return await process(job.data);
};

// Manual approach (less efficient)
const processor2 = async (job) => {
  while (!await checkIfReady()) {
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
  return await process(job.data);
};

const processor = async (job) => {
  // Track how many times we've delayed
  const delayCount = job.data.delayCount || 0;
  
  if (delayCount > 10) {
    throw new Error('Exceeded maximum delay count');
  }
  
  const ready = await checkIfReady();
  
  if (!ready) {
    // Increment delay counter
    await job.updateData({
      ...job.data,
      delayCount: delayCount + 1,
    });
    
    throw new DelayedError(`Not ready (attempt ${delayCount + 1})`);
  }
  
  return await process(job.data);
};

import { Worker, DelayedError } from 'bullmq';

const worker = new Worker('myQueue', processor);

worker.on('failed', (job, error) => {
  if (error.name === 'DelayedError') {
    console.log(`Job ${job.id} delayed:`, error.message);
    // This is expected behavior, not a real failure
  } else {
    console.error(`Job ${job.id} failed:`, error.message);
  }
});