light-async-queue 1.1.0 → 2.0.0

package/dist/src/queue/Queue.d.ts

@@ -1,8 +1,9 @@
-import { QueueConfig, JobProcessor, JobData } from '../types.js';
+import { QueueConfig, JobProcessor, JobData, JobOptions } from "../types.js";
+import { EventEmitter } from "node:events";
 /**
  * Main Queue class - orchestrates job processing
  */
-export declare class Queue {
+export declare class Queue extends EventEmitter {
     private config;
     private storage;
     private scheduler;
@@ -10,9 +11,15 @@ export declare class Queue {
     private backoff;
     private processor;
     private workers;
+    private reservedWorkers;
     private activeJobs;
+    private completedJobIds;
+    private repeatingJobs;
     private isShuttingDown;
     private isInitialized;
+    private rateLimiter?;
+    private webhookManager?;
+    private stalledCheckInterval?;
     constructor(config: QueueConfig);
     /**
      * Initialize the queue
@@ -25,7 +32,7 @@ export declare class Queue {
     /**
      * Add a job to the queue
      */
-    add(payload: unknown): Promise<string>;
+    add(payload: unknown, options?: JobOptions): Promise<string>;
     /**
      * Handle a job that's ready to process
      */
@@ -38,6 +45,62 @@ export declare class Queue {
      * Get an available worker or create a new one
      */
     private getAvailableWorker;
+    /**
+     * Create a job with methods for use in processor
+     */
+    private createJobWithMethods;
+    /**
+     * Load completed job IDs for dependency tracking
+     */
+    private loadCompletedJobIds;
+    /**
+     * Check and update waiting jobs whose dependencies are now satisfied
+     */
+    private checkDependentJobs;
+    /**
+     * Schedule a repeating job
+     */
+    private scheduleRepeat;
+    /**
+     * Start stalled job checker
+     */
+    private startStalledChecker;
+    /**
+     * Check for stalled jobs and mark them
+     */
+    private checkStalledJobs;
+    /**
+     * Send webhook notification
+     */
+    private sendWebhook;
+    /**
+     * Get a specific job by ID
+     */
+    getJob(jobId: string): Promise<JobData | null>;
+    /**
+     * Get all jobs from the queue
+     */
+    getAllJobs(): Promise<JobData[]>;
+    /**
+     * Remove a specific job
+     */
+    removeJob(jobId: string): Promise<boolean>;
+    /**
+     * Pause the queue (stop processing new jobs)
+     */
+    pause(): void;
+    /**
+     * Resume the queue
+     */
+    resume(): void;
+    /**
+     * Drain the queue - process all pending jobs
+     */
+    drain(): Promise<void>;
+    /**
+     * Clean completed jobs older than a certain age
+     */
+    clean(maxAge?: number): Promise<number>;
     /**
      * Get all failed jobs from DLQ
      */
@@ -46,14 +109,21 @@ export declare class Queue {
      * Reprocess a failed job from DLQ
      */
     reprocessFailed(jobId: string): Promise<boolean>;
+    /**
+     * Get queue statistics
+     */
+    getConcurrency(): number;
     /**
      * Get queue statistics
      */
     getStats(): Promise<{
         active: number;
+        waiting: number;
+        delayed: number;
         pending: number;
         failed: number;
         completed: number;
+        stalled: number;
     }>;
     /**
      * Set up graceful shutdown handlers

package/dist/src/queue/Queue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../../src/queue/Queue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAoB,OAAO,EAA0B,MAAM,aAAa,CAAC;AAS3G;;GAEG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,aAAa,CAAU;gBAEnB,MAAM,EAAE,WAAW;IAkC/B;;OAEG;YACW,UAAU;IASxB;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAItC;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAoB5C;;OAEG;YACW,cAAc;IAsD5B;;OAEG;YACW,gBAAgB;IAiB9B;;OAEG;YACW,kBAAkB;IAkChC;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAOzC;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBtD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;IAgBF;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CA2BhC"}
+{"version":3,"file":"Queue.d.ts","sourceRoot":"","sources":["../../../src/queue/Queue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,YAAY,EAEZ,OAAO,EAGP,UAAU,EAGX,MAAM,aAAa,CAAC;AAWrB,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;GAEG;AACH,qBAAa,KAAM,SAAQ,YAAY;IACrC,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,GAAG,CAAkB;IAC7B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,SAAS,CAAsB;IACvC,OAAO,CAAC,OAAO,CAAW;IAC1B,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,eAAe,CAAc;IACrC,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,cAAc,CAAU;IAChC,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,WAAW,CAAC,CAAc;IAClC,OAAO,CAAC,cAAc,CAAC,CAAiB;IACxC,OAAO,CAAC,oBAAoB,CAAC,CAAiB;gBAElC,MAAM,EAAE,WAAW;IAmD/B;;OAEG;YACW,UAAU;IAexB;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI;IAItC;;OAEG;IACG,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,MAAM,CAAC;IAkCtE;;OAEG;YACW,cAAc;IAuF5B;;OAEG;YACW,gBAAgB;IAwB9B;;OAEG;YACW,kBAAkB;IAqChC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;YACW,mBAAmB;IAUjC;;OAEG;YACW,kBAAkB;IAkBhC;;OAEG;YACW,cAAc;IAmD5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;YACW,gBAAgB;IAoB9B;;OAEG;YACW,WAAW;IAazB;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAOpD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAOtC;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAsBhD;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,MAAM,IAAI,IAAI;IAMd;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0B5B;;OAEG;IACG,KAAK,CAAC,MAAM,GAAE,MAA4B,GAAG,OAAO,CAAC,MAAM,CAAC;IAqBlE;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAOzC;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiBtD;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC;QACxB,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAmBF;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAW7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAwChC"}

package/dist/src/queue/Queue.js

@@ -1,15 +1,19 @@
-import { StorageType, JobStatus } from '../types.js';
-import { Job } from './Job.js';
-import { Backoff } from './Backoff.js';
-import { Scheduler } from './Scheduler.js';
-import { Worker } from '../worker/Worker.js';
-import { DeadLetterQueue } from '../dlq/DeadLetterQueue.js';
-import { MemoryStore } from '../storage/MemoryStore.js';
-import { FileStore } from '../storage/FileStore.js';
+import { StorageType, JobStatus, QueueEventType, } from "../types.js";
+import { Job } from "./Job.js";
+import { Backoff } from "./Backoff.js";
+import { Scheduler } from "./Scheduler.js";
+import { Worker } from "../worker/Worker.js";
+import { DeadLetterQueue } from "../dlq/DeadLetterQueue.js";
+import { MemoryStore } from "../storage/MemoryStore.js";
+import { FileStore } from "../storage/FileStore.js";
+import { RateLimiter } from "../utils/RateLimiter.js";
+import { WebhookManager } from "../utils/WebhookManager.js";
+import { CronParser } from "../utils/CronParser.js";
+import { EventEmitter } from "node:events";
 /**
  * Main Queue class - orchestrates job processing
  */
-export class Queue {
+export class Queue extends EventEmitter {
     config;
     storage;
     scheduler;
@@ -17,14 +21,24 @@ export class Queue {
     backoff;
     processor;
     workers;
+    reservedWorkers;
     activeJobs;
+    completedJobIds;
+    repeatingJobs;
     isShuttingDown;
     isInitialized;
+    rateLimiter;
+    webhookManager;
+    stalledCheckInterval;
     constructor(config) {
+        super();
         this.config = config;
         this.processor = null;
         this.workers = [];
+        this.reservedWorkers = new Set();
         this.activeJobs = new Map();
+        this.completedJobIds = new Set();
+        this.repeatingJobs = new Map();
         this.isShuttingDown = false;
         this.isInitialized = false;
         // Initialize storage based on config
@@ -41,10 +55,19 @@ export class Queue {
         this.scheduler = new Scheduler(this.storage);
         this.dlq = new DeadLetterQueue(this.storage);
         this.backoff = new Backoff(config.retry.backoff);
+        // Initialize rate limiter if configured
+        if (config.rateLimiter) {
+            this.rateLimiter = new RateLimiter(config.rateLimiter);
+        }
+        // Initialize webhook manager if configured
+        if (config.webhooks && config.webhooks.length > 0) {
+            this.webhookManager = new WebhookManager(config.webhooks);
+        }
         // Set up scheduler event handler
-        this.scheduler.on('job-ready', (jobData) => {
-            this.handleJobReady(jobData).catch(error => {
-                console.error('[Queue] Error handling job:', error);
+        this.scheduler.on("job-ready", (jobData) => {
+            this.handleJobReady(jobData).catch((error) => {
+                console.error("[Queue] Error handling job:", error);
+                this.emit(QueueEventType.ERROR, error);
             });
         });
         // Set up graceful shutdown
@@ -59,6 +82,10 @@ export class Queue {
         }
         await this.storage.initialize();
         this.isInitialized = true;
+        // Start stalled job checker
+        this.startStalledChecker();
+        // Load completed job IDs for dependency tracking
+        await this.loadCompletedJobIds();
     }
     /**
      * Set the job processor function
@@ -69,15 +96,28 @@ export class Queue {
     /**
      * Add a job to the queue
      */
-    async add(payload) {
+    async add(payload, options = {}) {
         if (!this.isInitialized) {
             await this.initialize();
         }
         if (this.isShuttingDown) {
-            throw new Error('Queue is shutting down, cannot accept new jobs');
+            throw new Error("Queue is shutting down, cannot accept new jobs");
         }
-        const job = new Job(payload, this.config.retry.maxAttempts);
+        const job = new Job(payload, this.config.retry.maxAttempts, options);
         await this.storage.addJob(job.toData());
+        // Emit event based on job status
+        if (job.status === JobStatus.DELAYED) {
+            this.emit(QueueEventType.DELAYED, job.toData());
+            await this.sendWebhook(QueueEventType.DELAYED, { job: job.toData() });
+        }
+        else if (job.status === JobStatus.WAITING) {
+            this.emit(QueueEventType.WAITING, job.toData());
+            await this.sendWebhook(QueueEventType.WAITING, { job: job.toData() });
+        }
+        // Set up repeating job if configured
+        if (options.repeat) {
+            await this.scheduleRepeat(job);
+        }
         // Start scheduler if not already running
         if (!this.scheduler.getIsRunning()) {
             this.scheduler.start();
@@ -100,50 +140,85 @@ export class Queue {
             return;
         }
         if (!this.processor) {
-            console.error('[Queue] No processor function set');
+            console.error("[Queue] No processor function set");
             return;
         }
         const job = Job.fromData(jobData);
+        // Check if dependencies are satisfied
+        if (!job.areDependenciesSatisfied(this.completedJobIds)) {
+            return; // Job is still waiting for dependencies
+        }
+        // Apply rate limiting if configured
+        if (this.rateLimiter) {
+            const allowed = await this.rateLimiter.consume();
+            if (!allowed) {
+                return; // Rate limit reached, will retry on next tick
+            }
+        }
         // Mark job as processing
         job.markProcessing();
         this.activeJobs.set(job.id, job);
         await this.storage.updateJob(job.toData());
+        // Emit active event
+        this.emit(QueueEventType.ACTIVE, job.toData());
+        await this.sendWebhook(QueueEventType.ACTIVE, { job: job.toData() });
         // Get or create a worker
         const worker = await this.getAvailableWorker();
         try {
+            // Create job with methods for processor
+            const jobWithMethods = this.createJobWithMethods(job);
             // Execute job in worker
-            const result = await worker.execute(job.toData());
+            const result = await worker.execute(job.toData(), jobWithMethods);
             if (result.success) {
                 // Job succeeded
-                job.markCompleted();
+                job.markCompleted(result.result);
                 await this.storage.updateJob(job.toData());
+                // Track completed job for dependency resolution
+                this.completedJobIds.add(job.id);
+                // Check for dependent jobs
+                await this.checkDependentJobs(job.id);
+                // Emit completed event
+                this.emit(QueueEventType.COMPLETED, job.toData(), result.result);
+                await this.sendWebhook(QueueEventType.COMPLETED, {
+                    job: job.toData(),
+                    result: result.result,
+                });
             }
             else {
                 // Job failed
-                await this.handleJobFailure(job, result.error || 'Unknown error');
+                const error = new Error(result.error || "Unknown error");
+                await this.handleJobFailure(job, error);
             }
         }
         catch (error) {
             // Worker execution error
-            await this.handleJobFailure(job, error instanceof Error ? error.message : String(error));
+            const err = error instanceof Error ? error : new Error(String(error));
+            await this.handleJobFailure(job, err);
         }
         finally {
             // Remove from active jobs
             this.activeJobs.delete(job.id);
+            this.reservedWorkers.delete(worker);
         }
     }
     /**
      * Handle job failure with retry logic
      */
     async handleJobFailure(job, error) {
-        console.error(`[Queue] Job ${job.id} failed:`, error);
+        console.error(`[Queue] Job ${job.id} failed:`, error.message);
         // Calculate next run time with backoff
         const nextRunAt = this.backoff.getNextRunAt(job.attempts + 1);
-        job.markFailed(nextRunAt);
+        job.markFailed(error.message, nextRunAt);
         if (job.hasExceededMaxAttempts()) {
             // Move to dead letter queue
             console.log(`[Queue] Job ${job.id} exceeded max attempts, moving to DLQ`);
             await this.dlq.add(job);
+            // Emit failed event
+            this.emit(QueueEventType.FAILED, job.toData(), error);
+            await this.sendWebhook(QueueEventType.FAILED, {
+                job: job.toData(),
+                error,
+            });
         }
         else {
             // Update job for retry
@@ -156,26 +231,29 @@ export class Queue {
     async getAvailableWorker() {
         // Find an idle worker
         for (const worker of this.workers) {
-            if (!worker.isBusy()) {
+            if (!worker.isBusy() && !this.reservedWorkers.has(worker)) {
+                this.reservedWorkers.add(worker);
                 return worker;
             }
         }
         // Create a new worker if under concurrency limit
         if (this.workers.length < this.config.concurrency) {
             if (!this.processor) {
-                throw new Error('Processor function not set');
+                throw new Error("Processor function not set");
             }
             const worker = new Worker(this.processor);
             await worker.initialize();
             this.workers.push(worker);
+            this.reservedWorkers.add(worker);
             return worker;
         }
         // Wait for a worker to become available
         return new Promise((resolve) => {
             const checkInterval = setInterval(() => {
                 for (const worker of this.workers) {
-                    if (!worker.isBusy()) {
+                    if (!worker.isBusy() && !this.reservedWorkers.has(worker)) {
                         clearInterval(checkInterval);
+                        this.reservedWorkers.add(worker);
                         resolve(worker);
                         return;
                     }
@@ -183,6 +261,232 @@ export class Queue {
             }, 100);
         });
     }
+    /**
+     * Create a job with methods for use in processor
+     */
+    createJobWithMethods(job) {
+        return {
+            ...job.toData(),
+            updateProgress: async (progress) => {
+                job.updateProgress(progress);
+                await this.storage.updateJob(job.toData());
+                this.emit(QueueEventType.PROGRESS, job.toData(), progress);
+                await this.sendWebhook(QueueEventType.PROGRESS, { job: job.toData() });
+            },
+            log: (message) => {
+                console.log(`[Job ${job.id}] ${message}`);
+            },
+        };
+    }
+    /**
+     * Load completed job IDs for dependency tracking
+     */
+    async loadCompletedJobIds() {
+        const allJobs = await this.storage.getAllJobs();
+        this.completedJobIds.clear();
+        for (const job of allJobs) {
+            if (job.status === JobStatus.COMPLETED) {
+                this.completedJobIds.add(job.id);
+            }
+        }
+    }
+    /**
+     * Check and update waiting jobs whose dependencies are now satisfied
+     */
+    async checkDependentJobs(completedJobId) {
+        const allJobs = await this.storage.getAllJobs();
+        for (const jobData of allJobs) {
+            if (jobData.status === JobStatus.WAITING &&
+                jobData.dependsOn?.includes(completedJobId)) {
+                const job = Job.fromData(jobData);
+                if (job.areDependenciesSatisfied(this.completedJobIds)) {
+                    // All dependencies satisfied, move to pending
+                    job.status = JobStatus.PENDING;
+                    await this.storage.updateJob(job.toData());
+                }
+            }
+        }
+    }
+    /**
+     * Schedule a repeating job
+     */
+    async scheduleRepeat(job) {
+        if (!job.repeatConfig) {
+            return;
+        }
+        const repeatConfig = job.repeatConfig;
+        // Check if we've hit the repeat limit
+        if (repeatConfig.limit && job.repeatCount >= repeatConfig.limit) {
+            return;
+        }
+        // Calculate next run time
+        let nextRunAt;
+        if (repeatConfig.pattern) {
+            // Cron pattern
+            const cronParser = new CronParser(repeatConfig.pattern);
+            nextRunAt = cronParser.getNextRunTime(Date.now());
+        }
+        else if (repeatConfig.every) {
+            // Repeat every X ms
+            nextRunAt = Date.now() + repeatConfig.every;
+        }
+        else {
+            return;
+        }
+        // Check date constraints
+        if (repeatConfig.startDate &&
+            nextRunAt < repeatConfig.startDate.getTime()) {
+            nextRunAt = repeatConfig.startDate.getTime();
+        }
+        if (repeatConfig.endDate && nextRunAt > repeatConfig.endDate.getTime()) {
+            return;
+        }
+        // Schedule the next instance
+        const delay = nextRunAt - Date.now();
+        const timeout = setTimeout(async () => {
+            const nextJob = job.createRepeatInstance();
+            nextJob.nextRunAt = nextRunAt;
+            await this.storage.addJob(nextJob.toData());
+            // Schedule the next repeat
+            await this.scheduleRepeat(nextJob);
+        }, delay);
+        this.repeatingJobs.set(job.id, timeout);
+    }
+    /**
+     * Start stalled job checker
+     */
+    startStalledChecker() {
+        const interval = this.config.stalledInterval || 30000;
+        this.stalledCheckInterval = setInterval(async () => {
+            await this.checkStalledJobs();
+        }, interval);
+    }
+    /**
+     * Check for stalled jobs and mark them
+     */
+    async checkStalledJobs() {
+        const stalledThreshold = this.config.stalledInterval || 30000;
+        const allJobs = await this.storage.getAllJobs();
+        for (const jobData of allJobs) {
+            if (jobData.status === JobStatus.PROCESSING) {
+                const job = Job.fromData(jobData);
+                if (job.isStalled(stalledThreshold)) {
+                    console.warn(`[Queue] Job ${job.id} appears stalled`);
+                    job.markStalled();
+                    await this.storage.updateJob(job.toData());
+                    // Emit stalled event
+                    this.emit(QueueEventType.STALLED, job.toData());
+                    await this.sendWebhook(QueueEventType.STALLED, { job: job.toData() });
+                }
+            }
+        }
+    }
+    /**
+     * Send webhook notification
+     */
+    async sendWebhook(event, data) {
+        if (this.webhookManager) {
+            try {
+                await this.webhookManager.sendEvent(event, data);
+            }
+            catch (error) {
+                console.error("[Queue] Webhook error:", error);
+            }
+        }
+    }
+    /**
+     * Get a specific job by ID
+     */
+    async getJob(jobId) {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        return this.storage.getJob(jobId);
+    }
+    /**
+     * Get all jobs from the queue
+     */
+    async getAllJobs() {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        return this.storage.getAllJobs();
+    }
+    /**
+     * Remove a specific job
+     */
+    async removeJob(jobId) {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        // Check if job is active
+        if (this.activeJobs.has(jobId)) {
+            return false; // Cannot remove active job
+        }
+        const job = await this.storage.getJob(jobId);
+        if (!job) {
+            return false;
+        }
+        // Remove from storage by updating status
+        job.status = JobStatus.FAILED;
+        await this.storage.updateJob(job);
+        return true;
+    }
+    /**
+     * Pause the queue (stop processing new jobs)
+     */
+    pause() {
+        this.scheduler.stop();
+    }
+    /**
+     * Resume the queue
+     */
+    resume() {
+        if (!this.isShuttingDown) {
+            this.scheduler.start();
+        }
+    }
+    /**
+     * Drain the queue - process all pending jobs
+     */
+    async drain() {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        // Wait for all pending jobs to be processed
+        while (true) {
+            const allJobs = await this.storage.getAllJobs();
+            const pendingJobs = allJobs.filter((j) => j.status === JobStatus.PENDING ||
+                j.status === JobStatus.WAITING ||
+                j.status === JobStatus.DELAYED);
+            if (pendingJobs.length === 0 && this.activeJobs.size === 0) {
+                break;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        this.emit(QueueEventType.DRAINED);
+        await this.sendWebhook(QueueEventType.DRAINED, {});
+    }
+    /**
+     * Clean completed jobs older than a certain age
+     */
+    async clean(maxAge = 24 * 60 * 60 * 1000) {
+        if (!this.isInitialized) {
+            await this.initialize();
+        }
+        const allJobs = await this.storage.getAllJobs();
+        const now = Date.now();
+        let cleaned = 0;
+        for (const job of allJobs) {
+            if (job.status === JobStatus.COMPLETED && now - job.updatedAt > maxAge) {
+                job.status = JobStatus.FAILED; // Mark for removal
+                await this.storage.updateJob(job);
+                this.completedJobIds.delete(job.id);
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
     /**
      * Get all failed jobs from DLQ
      */
@@ -207,6 +511,12 @@ export class Queue {
         await this.storage.addJob(job.toData());
         return true;
     }
+    /**
+     * Get queue statistics
+     */
+    getConcurrency() {
+        return this.config.concurrency;
+    }
     /**
      * Get queue statistics
      */
@@ -218,9 +528,12 @@ export class Queue {
         const failedJobs = await this.dlq.getAll();
         return {
             active: this.activeJobs.size,
-            pending: allJobs.filter(j => j.status === JobStatus.PENDING).length,
+            waiting: allJobs.filter((j) => j.status === JobStatus.WAITING).length,
+            delayed: allJobs.filter((j) => j.status === JobStatus.DELAYED).length,
+            pending: allJobs.filter((j) => j.status === JobStatus.PENDING).length,
             failed: failedJobs.length,
-            completed: allJobs.filter(j => j.status === JobStatus.COMPLETED).length,
+            completed: allJobs.filter((j) => j.status === JobStatus.COMPLETED).length,
+            stalled: allJobs.filter((j) => j.status === JobStatus.STALLED).length,
         };
     }
     /**
@@ -228,12 +541,12 @@ export class Queue {
      */
     setupGracefulShutdown() {
         const shutdown = async () => {
-            console.log('[Queue] Graceful shutdown initiated...');
+            console.log("[Queue] Graceful shutdown initiated...");
             await this.shutdown();
             process.exit(0);
         };
-        process.on('SIGINT', shutdown);
-        process.on('SIGTERM', shutdown);
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
     }
     /**
      * Gracefully shutdown the queue
@@ -245,18 +558,27 @@ export class Queue {
         this.isShuttingDown = true;
         // Stop accepting new jobs
         this.scheduler.stop();
+        // Stop stalled checker
+        if (this.stalledCheckInterval) {
+            clearInterval(this.stalledCheckInterval);
+        }
+        // Cancel all repeating jobs
+        for (const timeout of this.repeatingJobs.values()) {
+            clearTimeout(timeout);
+        }
+        this.repeatingJobs.clear();
         // Wait for active jobs to complete
         console.log(`[Queue] Waiting for ${this.activeJobs.size} active jobs to complete...`);
         while (this.activeJobs.size > 0) {
-            await new Promise(resolve => setTimeout(resolve, 100));
+            await new Promise((resolve) => setTimeout(resolve, 100));
         }
         // Terminate all workers
-        console.log('[Queue] Terminating workers...');
-        await Promise.all(this.workers.map(worker => worker.terminate()));
+        console.log("[Queue] Terminating workers...");
+        await Promise.all(this.workers.map((worker) => worker.terminate()));
         // Close storage
-        console.log('[Queue] Closing storage...');
+        console.log("[Queue] Closing storage...");
         await this.storage.close();
-        console.log('[Queue] Shutdown complete');
+        console.log("[Queue] Shutdown complete");
     }
 }
 //# sourceMappingURL=Queue.js.map