import { setTimeout as sleep } from 'node:timers/promises' import { QueueManager } from '../queue_manager.js' import { createLeaseToken } from '../utils.js' import type { Adapter, AcquiredJob, JobLease, StalledJobsRecovery } from '../contracts/adapter.js' import type { JobData, JobRetention, ScheduleConfig, ScheduleData, ScheduleListOptions, } from '../types/main.js' /** * Create a sync adapter factory. */ export function sync() { return () => new SyncAdapter() } /** * Sync adapter executes jobs immediately when pushed. * Pop/complete/fail/retry are not supported as jobs are executed synchronously. */ export class SyncAdapter implements Adapter { #pendingTimeouts = new Set() setWorkerId(_workerId: string): void {} push(jobData: JobData): Promise { return this.pushOn('default', jobData) } async pushOn(queue: string, jobData: JobData): Promise { return this.#execute(JSON.stringify(jobData), queue) } pushLater(jobData: JobData, delay: number): Promise { return this.pushLaterOn('default', jobData, delay) } /** * Run the job after the delay, in this process. `destroy()` cancels the * jobs whose delay has not elapsed. */ async pushLaterOn(queue: string, jobData: JobData, delay: number): Promise { const job = JSON.stringify(jobData) const timeout = setTimeout(() => { this.#pendingTimeouts.delete(timeout) void this.#execute(job, queue).catch((error) => { QueueManager.getLogger().error( { err: error, jobId: jobData.id, jobName: jobData.name, queue }, 'Failed to execute delayed sync job' ) }) }, delay) this.#pendingTimeouts.add(timeout) } pushMany(jobs: JobData[]): Promise { return this.pushManyOn('default', jobs) } async pushManyOn(queue: string, jobs: JobData[]): Promise { if (jobs.some((j) => j.dedup)) { throw new Error('dedup is not supported in batch dispatch; use single dispatch') } // Encoded up front: a batch JSON cannot encode runs none of its jobs. for (const job of jobs.map((jobData) => JSON.stringify(jobData))) { await this.#execute(job, queue) } } size(): Promise { return this.sizeOf('default') } sizeOf(_queue: string): Promise { return Promise.resolve(0) } pop(): Promise { return this.popFrom('default') } popFrom(_queue: string): Promise { throw new Error('SyncAdapter does not support pop - jobs are executed immediately on push') } completeJob(_job: JobLease, _queue: string, _removeOnComplete?: JobRetention): Promise { return Promise.resolve(false) } failJob( _job: JobLease, _queue: string, _error?: Error, _removeOnFail?: JobRetention ): Promise { return Promise.resolve(false) } retryJob(_job: JobLease, _queue: string, _retryAt?: Date): Promise { return Promise.resolve(false) } recoverStalledJobs( _queue: string, _stalledThreshold: number, _maxStalledCount: number, _maxExceeded: number ): Promise { // SyncAdapter has no stalled jobs - jobs are executed immediately return Promise.resolve({ recovered: 0, exceeded: [] }) } renewJobs(_queue: string, _jobs: JobLease[]): Promise { // SyncAdapter executes jobs immediately - there is nothing to renew return Promise.resolve(0) } getJob(_jobId: string, _queue: string): Promise { return Promise.resolve(null) } destroy(): Promise { for (const timeout of this.#pendingTimeouts) { clearTimeout(timeout) } this.#pendingTimeouts.clear() return Promise.resolve() } migrate(): Promise { return Promise.resolve() } upsertSchedule(_config: ScheduleConfig): Promise { // No-op: schedules don't make sense for sync adapter // Return a fake ID so code doesn't break in dev return Promise.resolve(`sync-schedule-${Date.now()}`) } /** * @deprecated Use `upsertSchedule` instead. */ createSchedule(config: ScheduleConfig): Promise { return this.upsertSchedule(config) } getSchedule(_id: string): Promise { return Promise.resolve(null) } listSchedules(_options?: ScheduleListOptions): Promise { return Promise.resolve([]) } updateSchedule( _id: string, _updates: Partial> ): Promise { return Promise.resolve() } deleteSchedule(_id: string): Promise { return Promise.resolve() } claimDueSchedule(): Promise { // SyncAdapter doesn't support scheduling return Promise.resolve(null) } /** * Run a job stored as JSON, as real adapters store it: each attempt gets * its own copy, and shares no object with the caller. */ async #execute(job: string, queue: string = 'default'): Promise { const runtime = QueueManager.getJobExecutionRuntime() let attempts = (JSON.parse(job) as JobData).attempts while (true) { const now = Date.now() const acquiredJob: AcquiredJob = { ...(JSON.parse(job) as JobData), attempts, acquiredAt: now, leaseToken: createLeaseToken('sync'), } const outcome = await runtime.execute(acquiredJob, queue) // A timed out handler keeps running until it returns: wait for it, so // the caller never sees two attempts running at once. if ('timedOutExecution' in outcome) { await outcome.timedOutExecution } if (outcome.type === 'initialization-failed') { throw outcome.error } if (outcome.type === 'failed') { if (outcome.failedHookError) { throw outcome.failedHookError } return } if (outcome.type === 'completed') return attempts++ if (outcome.retryAt) { const delay = outcome.retryAt.getTime() - Date.now() if (delay > 0) { await sleep(delay) } } } } }