import { Job } from '@boringnode/queue'
import type { JobContext, JobOptions } from '@boringnode/queue/types'

interface SendEmailPayload {
  to: string
}

export default class SendEmailJob extends Job<SendEmailPayload> {
  static readonly jobName = 'SendEmailJob'

  static options: JobOptions = {
    queue: 'email',
  }

  async execute(): Promise<void> {
    console.log(`[Attempt ${this.context.attempt}] Sending email to: ${this.payload.to}`)
  }
}

import { QueueManager } from '@boringnode/queue'
import { redis } from '@boringnode/queue/drivers/redis_adapter'
import { sync } from '@boringnode/queue/drivers/sync_adapter'
import { Redis } from 'ioredis'

const redisConnection = new Redis({
  host: 'localhost',
  port: 6379,
  keyPrefix: 'boringnode::queue::',
  db: 0,
})

const config = {
  default: 'redis',

  adapters: {
    sync: sync(),
    redis: redis(redisConnection),
  },

  worker: {
    concurrency: 5,
    idleDelay: '2s',
  },

  locations: ['./app/jobs/**/*.ts'],
}

await QueueManager.init(config)

import SendEmailJob from './jobs/send_email_job.ts'

// Dispatch immediately
await SendEmailJob.dispatch({ to: '[email protected]' })

// Dispatch with delay
await SendEmailJob.dispatch({ to: '[email protected]' }).in('5m')

import { Worker } from '@boringnode/queue'

const worker = new Worker(config)
await worker.start(['default', 'email', 'reports'])

interface QueueManagerConfig {
  // Default adapter to use
  default: string

  // Available queue adapters
  adapters: {
    [key: string]: QueueAdapter
  }

  // Worker configuration
  worker: {
    concurrency: number
    idleDelay: Duration
  }

  // Job discovery locations
  locations: string[]
}

static options: JobOptions = {
  queue: 'email',       // Queue name (default: 'default')
  adapter: 'redis',     // Override default adapter
  priority: 1,          // Lower number = higher priority (default: 5)
  maxRetries: 3,        // Maximum retry attempts
  timeout: '30s',       // Job timeout duration
  failOnTimeout: true,  // Fail permanently on timeout (default: false, will retry)
}

import { redis } from '@boringnode/queue/drivers/redis_adapter'
import { Redis } from 'ioredis'

const redisConnection = new Redis({
  host: 'localhost',
  port: 6379,
  keyPrefix: 'boringnode::queue::',
})

const adapter = redis(redisConnection)

import { sync } from '@boringnode/queue/drivers/sync_adapter'

const adapter = sync()

import { knex } from '@boringnode/queue/drivers/knex_adapter'

// With configuration (adapter manages connection lifecycle)
const adapter = knex({
  client: 'pg',
  connection: {
    host: 'localhost',
    port: 5432,
    user: 'postgres',
    password: 'postgres',
    database: 'myapp',
  },
})

// Or with an existing Knex instance (you manage connection lifecycle)
import Knex from 'knex'

const connection = Knex({ client: 'pg', connection: '...' })
const adapter = knex(connection)

const adapter = knex(config, 'custom_jobs_table')

const worker = new Worker(config)

// Process specific queues
await worker.start(['default', 'email', 'reports'])

// Worker will:
// - Process jobs with configured concurrency
// - Poll queues at the configured interval
// - Execute jobs in the order they were queued

// Various time formats
await SendEmailJob.dispatch(payload).in('30s') // 30 seconds
await SendEmailJob.dispatch(payload).in('5m')  // 5 minutes
await SendEmailJob.dispatch(payload).in('2h')  // 2 hours
await SendEmailJob.dispatch(payload).in('1d')  // 1 day

export default class UrgentJob extends Job<Payload> {
  static readonly jobName = 'UrgentJob'

  static options: JobOptions = {
    priority: 1, // Processed before default priority (5)
  }

  async execute(): Promise<void> {
    // ...
  }
}

import { exponentialBackoff, linearBackoff, fixedBackoff } from '@boringnode/queue'

export default class ReliableJob extends Job<Payload> {
  static readonly jobName = 'ReliableJob'

  static options: JobOptions = {
    maxRetries: 5,
    retry: {
      backoff: () =>
        exponentialBackoff({
          baseDelay: '1s',
          maxDelay: '1m',
          multiplier: 2,
          jitter: true,
        }),
    },
  }

  async execute(): Promise<void> {
    // ...
  }
}

export default class LimitedJob extends Job<Payload> {
  static readonly jobName = 'LimitedJob'

  static options: JobOptions = {
    timeout: '30s', // Maximum execution time
    failOnTimeout: false, // Retry on timeout (default)
  }

  async execute(): Promise<void> {
    // Long running operation...
  }
}

const config = {
  worker: {
    timeout: '1m', // Default timeout for all jobs
  },
}

import { Job } from '@boringnode/queue'
import type { JobContext } from '@boringnode/queue'

export default class MyJob extends Job<Payload> {
  constructor(payload: Payload, context: JobContext) {
    super(payload, context)
  }

  async execute(): Promise<void> {
    console.log(`Job ID: ${this.context.jobId}`)
    console.log(`Attempt: ${this.context.attempt}`) // 1, 2, 3...
    console.log(`Queue: ${this.context.queue}`)
    console.log(`Priority: ${this.context.priority}`)
    console.log(`Acquired at: ${this.context.acquiredAt}`)

    if (this.context.attempt > 1) {
      console.log('This is a retry!')
    }
  }
}

import { QueueManager } from '@boringnode/queue'

await QueueManager.init({
  default: 'redis',
  adapters: { redis: redis(connection) },
  jobFactory: async (JobClass, payload, context) => {
    // Use your IoC container to instantiate jobs
    return app.container.make(JobClass, [payload, context])
  },
})

import { Job } from '@boringnode/queue'
import type { JobContext } from '@boringnode/queue'

interface SendEmailPayload {
  to: string
  subject: string
}

export default class SendEmailJob extends Job<SendEmailPayload> {
  static readonly jobName = 'SendEmailJob'

  constructor(
    payload: SendEmailPayload,
    context: JobContext,
    private mailer: MailerService, // Injected by IoC container
    private logger: Logger // Injected by IoC container
  ) {
    super(payload, context)
  }

  async execute(): Promise<void> {
    this.logger.info(`[Attempt ${this.context.attempt}] Sending email to ${this.payload.to}`)
    await this.mailer.send(this.payload)
  }
}

import { Schedule } from '@boringnode/queue'

// Run every 10 seconds (uses job name as schedule ID by default)
const { scheduleId } = await MetricsJob.schedule({ endpoint: '/api/health' }).every('10s').run()

// Run on a cron schedule with custom ID
await CleanupJob.schedule({ days: 30 })
  .id('daily-cleanup') // Custom ID (optional, defaults to job name)
  .cron('0 * * * *') // Every hour at minute 0
  .timezone('Europe/Paris') // Optional timezone (default: UTC)
  .run()

// Schedule with constraints
await ReportJob.schedule({ type: 'weekly' })
  .id('weekly-report')
  .cron('0 9 * * MON') // Every Monday at 9am
  .from(new Date('2024-01-01')) // Start date
  .to(new Date('2024-12-31')) // End date
  .limit(52) // Maximum 52 runs
  .run()

import { Schedule } from '@boringnode/queue'

// Find a schedule by ID
const schedule = await Schedule.find('health-check')

if (schedule) {
  console.log(`Status: ${schedule.status}`) // 'active' or 'paused'
  console.log(`Run count: ${schedule.runCount}`)
  console.log(`Next run: ${schedule.nextRunAt}`)
  console.log(`Last run: ${schedule.lastRunAt}`)

  // Pause the schedule
  await schedule.pause()

  // Resume the schedule
  await schedule.resume()

  // Trigger an immediate run (outside of the normal schedule)
  await schedule.trigger()

  // Delete the schedule
  await schedule.delete()
}

import { Schedule } from '@boringnode/queue'

// List all schedules
const all = await Schedule.list()

// Filter by status
const active = await Schedule.list({ status: 'active' })
const paused = await Schedule.list({ status: 'paused' })

const config = {
  locations: ['./app/jobs/**/*.ts', './modules/**/jobs/**/*.ts'],
}

import { pino } from 'pino'

const config = {
  default: 'redis',
  adapters: {
    /* ... */
  },
  logger: pino(),
}

await QueueManager.init(config)