light-async-queue 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akshay Gaikwad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,385 @@
+# 🚀 light-async-queue
+
+[![npm version](https://img.shields.io/npm/v/light-async-queue.svg)](https://www.npmjs.com/package/light-async-queue)
+[![npm downloads](https://img.shields.io/npm/dm/light-async-queue.svg)](https://www.npmjs.com/package/light-async-queue)
+[![CI](https://github.com/gaikwadakshay79/light-async-queue/actions/workflows/ci.yml/badge.svg)](https://github.com/gaikwadakshay79/light-async-queue/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Node.js Version](https://img.shields.io/node/v/light-async-queue.svg)](https://nodejs.org)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.3-blue.svg)](https://www.typescriptlang.org/)
+
+A production-ready, Redis-free async job queue for Node.js with TypeScript. Designed for single-node reliability with file-based persistence, worker process isolation, and crash recovery.
+
+## ✨ Features
+
+- **🔄 Reliable Job Processing** - File-based persistence with crash recovery
+- **👷 Worker Isolation** - Jobs execute in separate child processes using `child_process.fork()`
+- **🔁 Smart Retry Logic** - Exponential backoff with configurable attempts
+- **💀 Dead Letter Queue** - Failed jobs are preserved and can be reprocessed
+- **⚡ Concurrency Control** - Configurable parallel job execution
+- **🛡️ Graceful Shutdown** - Waits for active jobs before exiting
+- **📊 Queue Statistics** - Monitor active, pending, completed, and failed jobs
+- **🎯 TypeScript First** - Full type safety with no `any` types
+- **🪶 Zero Dependencies** - Uses only Node.js built-in modules
+
+## 📦 Installation
+
+```bash
+npm install light-async-queue
+```
+
+## 🏗️ Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                         Queue API                            │
+│  (add jobs, process, getStats, shutdown)                    │
+└────────────────┬────────────────────────────────────────────┘
+                 │
+    ┌────────────┴────────────┐
+    │                         │
+┌───▼────────┐        ┌──────▼──────┐
+│ Scheduler  │        │   Storage   │
+│ (200ms)    │◄───────┤  (Memory/   │
+│            │        │   File)     │
+└─────┬──────┘        └──────┬──────┘
+      │                      │
+      │ job-ready            │ persist
+      │                      │
+┌─────▼──────────────────────▼──────┐
+│         Worker Pool                │
+│  ┌──────┐  ┌──────┐  ┌──────┐    │
+│  │Worker│  │Worker│  │Worker│    │
+│  │ (CP) │  │ (CP) │  │ (CP) │    │
+│  └──────┘  └──────┘  └──────┘    │
+└────────────────┬───────────────────┘
+                 │
+                 │ on failure
+                 │
+         ┌───────▼────────┐
+         │ Dead Letter    │
+         │ Queue (DLQ)    │
+         └────────────────┘
+
+CP = Child Process (isolated execution)
+```
+
+## 🚀 Quick Start
+
+```typescript
+import { Queue } from "light-async-queue";
+
+// Create a queue
+const queue = new Queue({
+  storage: "file",
+  filePath: "./jobs.log",
+  concurrency: 3,
+  retry: {
+    maxAttempts: 5,
+    backoff: {
+      type: "exponential",
+      delay: 1000, // 1 second base delay
+    },
+  },
+});
+
+// Define job processor
+queue.process(async (job) => {
+  console.log("Processing:", job.payload);
+
+  // Your job logic here
+  await sendEmail(job.payload.email);
+
+  return { success: true };
+});
+
+// Add jobs
+await queue.add({
+  email: "user@example.com",
+  template: "welcome",
+});
+```
+
+## 📖 API Reference
+
+### `new Queue(config)`
+
+Create a new queue instance.
+
+**Config Options:**
+
+```typescript
+interface QueueConfig {
+  storage: "memory" | "file";
+  filePath?: string; // Required if storage is 'file'
+  concurrency: number; // Max parallel jobs
+  retry: {
+    maxAttempts: number;
+    backoff: {
+      type: "exponential";
+      delay: number; // Base delay in ms
+    };
+  };
+}
+```
+
+### `queue.process(processor)`
+
+Set the job processor function.
+
+```typescript
+queue.process(async (job: JobData) => {
+  // Process job
+  return result;
+});
+```
+
+### `queue.add(payload)`
+
+Add a job to the queue.
+
+```typescript
+const jobId = await queue.add({
+  userId: 123,
+  action: "send-email",
+});
+```
+
+### `queue.getFailedJobs()`
+
+Get all jobs in the Dead Letter Queue.
+
+```typescript
+const failedJobs = await queue.getFailedJobs();
+```
+
+### `queue.reprocessFailed(jobId)`
+
+Reprocess a failed job from the DLQ.
+
+```typescript
+await queue.reprocessFailed("job-id-here");
+```
+
+### `queue.getStats()`
+
+Get queue statistics.
+
+```typescript
+const stats = await queue.getStats();
+// {
+//   active: 2,
+//   pending: 5,
+//   completed: 100,
+//   failed: 3
+// }
+```
+
+### `queue.shutdown()`
+
+Gracefully shutdown the queue.
+
+```typescript
+await queue.shutdown();
+```
+
+## 🔄 Retry & Backoff
+
+Jobs are retried with exponential backoff:
+
+```
+delay = baseDelay * (2 ^ (attempt - 1))
+```
+
+**Example with 1000ms base delay:**
+
+- Attempt 1: Immediate
+- Attempt 2: 1 second delay
+- Attempt 3: 2 seconds delay
+- Attempt 4: 4 seconds delay
+- Attempt 5: 8 seconds delay
+
+After `maxAttempts`, jobs move to the Dead Letter Queue.
+
+## 💾 Storage Options
+
+### Memory Storage
+
+Fast, in-memory storage for development:
+
+```typescript
+const queue = new Queue({
+  storage: "memory",
+  concurrency: 5,
+  retry: {
+    /* ... */
+  },
+});
+```
+
+### File Storage
+
+Persistent, crash-recoverable storage for production:
+
+```typescript
+const queue = new Queue({
+  storage: "file",
+  filePath: "./jobs.log",
+  concurrency: 5,
+  retry: {
+    /* ... */
+  },
+});
+```
+
+**File Format:**
+
+- Append-only log
+- One JSON object per line
+- Atomic writes
+- Separate `dead-letter.log` for failed jobs
+
+## 🛡️ Crash Recovery
+
+When using file storage, the queue automatically recovers from crashes:
+
+1. **On startup**, the queue reads the job log
+2. Any job with status `"processing"` is marked as `"pending"`
+3. The job's `attempts` counter is incremented
+4. The job is scheduled for immediate retry
+
+This ensures no jobs are lost during unexpected shutdowns.
+
+## 👷 Worker Isolation
+
+Jobs execute in isolated child processes:
+
+- **Process Isolation**: Each job runs in a separate Node.js process
+- **Crash Detection**: Parent detects worker crashes and retries the job
+- **IPC Communication**: Results are sent back via inter-process communication
+- **Resource Cleanup**: Workers are properly terminated on shutdown
+
+## 🔒 Graceful Shutdown
+
+The queue handles `SIGINT` and `SIGTERM` signals:
+
+1. Stop accepting new jobs
+2. Wait for active jobs to complete
+3. Terminate all worker processes
+4. Persist final state to disk
+5. Exit cleanly
+
+```typescript
+// Automatic on SIGINT/SIGTERM
+// Or manual:
+await queue.shutdown();
+```
+
+## 📊 Comparison with Bull
+
+| Feature          | light-queue      | Bull                |
+| ---------------- | ---------------- | ------------------- |
+| Redis Required   | ❌ No            | ✅ Yes              |
+| File Persistence | ✅ Yes           | ❌ No               |
+| Worker Isolation | ✅ Child Process | ⚠️ Same Process     |
+| Crash Recovery   | ✅ Built-in      | ⚠️ Requires Redis   |
+| Setup Complexity | 🟢 Low           | 🟡 Medium           |
+| Best For         | Single-node apps | Distributed systems |
+
+## 🎯 Use Cases
+
+Perfect for:
+
+- **Single-server applications** that don't need Redis
+- **Background job processing** (emails, reports, etc.)
+- **Reliable task queues** with crash recovery
+- **Development environments** without external dependencies
+- **Edge deployments** where Redis isn't available
+
+## 🔧 Advanced Example
+
+```typescript
+import { Queue } from "light-async-queue";
+
+const queue = new Queue({
+  storage: "file",
+  filePath: "./production-jobs.log",
+  concurrency: 10,
+  retry: {
+    maxAttempts: 3,
+    backoff: {
+      type: "exponential",
+      delay: 2000,
+    },
+  },
+});
+
+// Email sending processor
+queue.process(async (job) => {
+  const { email, template, data } = job.payload;
+
+  try {
+    await emailService.send({
+      to: email,
+      template,
+      data,
+    });
+
+    return { sent: true, timestamp: Date.now() };
+  } catch (error) {
+    // Will retry with exponential backoff
+    throw error;
+  }
+});
+
+// Add jobs
+await queue.add({
+  email: "user@example.com",
+  template: "welcome",
+  data: { name: "John" },
+});
+
+// Monitor failed jobs
+setInterval(async () => {
+  const stats = await queue.getStats();
+  console.log("Queue stats:", stats);
+
+  if (stats.failed > 0) {
+    const failed = await queue.getFailedJobs();
+    console.log("Failed jobs:", failed);
+  }
+}, 60000);
+```
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+npm test
+
+# Run tests in watch mode
+npm run test:watch
+
+# Run tests with coverage
+npm run test:coverage
+
+# Run examples
+npm install
+npm run build
+npm run example
+```
+
+**Test Results:** ✅ 25 tests passing across 4 test suites (powered by Vitest)
+
+See [TEST_SUITE.md](./TEST_SUITE.md) for detailed test documentation.
+
+## 📝 License
+
+MIT
+
+## 🤝 Contributing
+
+Contributions welcome! This is a production-ready implementation focused on reliability and simplicity.
+
+---
+
+Built with ❤️ for Node.js developers who need reliable job queues without Redis.

package/dist/src/dlq/DeadLetterQueue.d.ts

@@ -0,0 +1,34 @@
+import { StorageInterface, JobData } from '../types.js';
+import { Job } from '../queue/Job.js';
+/**
+ * Dead Letter Queue for managing failed jobs
+ */
+export declare class DeadLetterQueue {
+    private storage;
+    constructor(storage: StorageInterface);
+    /**
+     * Move a job to the dead letter queue
+     */
+    add(job: Job): Promise<void>;
+    /**
+     * Get all failed jobs
+     */
+    getAll(): Promise<JobData[]>;
+    /**
+     * Get a specific failed job by ID
+     */
+    get(jobId: string): Promise<JobData | null>;
+    /**
+     * Remove a job from DLQ and return it for reprocessing
+     */
+    remove(jobId: string): Promise<Job | null>;
+    /**
+     * Get count of failed jobs
+     */
+    count(): Promise<number>;
+    /**
+     * Clear all failed jobs (use with caution)
+     */
+    clear(): Promise<void>;
+}
+//# sourceMappingURL=DeadLetterQueue.d.ts.map

package/dist/src/dlq/DeadLetterQueue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeadLetterQueue.d.ts","sourceRoot":"","sources":["../../../src/dlq/DeadLetterQueue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEtC;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAmB;gBAEtB,OAAO,EAAE,gBAAgB;IAIrC;;OAEG;IACG,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAIlC;;OAEG;IACG,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAKjD;;OAEG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAAC;IAgBhD;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAK9B;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7B"}

package/dist/src/dlq/DeadLetterQueue.js

@@ -0,0 +1,60 @@
+import { Job } from '../queue/Job.js';
+/**
+ * Dead Letter Queue for managing failed jobs
+ */
+export class DeadLetterQueue {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Move a job to the dead letter queue
+     */
+    async add(job) {
+        await this.storage.moveToDeadLetter(job.toData());
+    }
+    /**
+     * Get all failed jobs
+     */
+    async getAll() {
+        return this.storage.getFailedJobs();
+    }
+    /**
+     * Get a specific failed job by ID
+     */
+    async get(jobId) {
+        const failedJobs = await this.storage.getFailedJobs();
+        return failedJobs.find(job => job.id === jobId) || null;
+    }
+    /**
+     * Remove a job from DLQ and return it for reprocessing
+     */
+    async remove(jobId) {
+        const jobData = await this.get(jobId);
+        if (!jobData) {
+            return null;
+        }
+        await this.storage.removeFromDeadLetter(jobId);
+        // Create a Job instance and reset it for reprocessing
+        const job = Job.fromData(jobData);
+        job.reset();
+        return job;
+    }
+    /**
+     * Get count of failed jobs
+     */
+    async count() {
+        const jobs = await this.storage.getFailedJobs();
+        return jobs.length;
+    }
+    /**
+     * Clear all failed jobs (use with caution)
+     */
+    async clear() {
+        const jobs = await this.storage.getFailedJobs();
+        for (const job of jobs) {
+            await this.storage.removeFromDeadLetter(job.id);
+        }
+    }
+}
+//# sourceMappingURL=DeadLetterQueue.js.map

package/dist/src/dlq/DeadLetterQueue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeadLetterQueue.js","sourceRoot":"","sources":["../../../src/dlq/DeadLetterQueue.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAEtC;;GAEG;AACH,MAAM,OAAO,eAAe;IAClB,OAAO,CAAmB;IAElC,YAAY,OAAyB;QACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,GAAQ;QAChB,MAAM,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,GAAG,CAAC,KAAa;QACrB,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QACtD,OAAO,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,KAAK,CAAC,IAAI,IAAI,CAAC;IAC1D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAM,CAAC,KAAa;QACxB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAEtC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAI,CAAC;QACd,CAAC;QAED,MAAM,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;QAE/C,sDAAsD;QACtD,MAAM,GAAG,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,GAAG,CAAC,KAAK,EAAE,CAAC;QAEZ,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,CAAC;QAChD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,IAAI,CAAC,OAAO,CAAC,oBAAoB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;CACF"}

package/dist/src/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * light-queue - Production-ready Redis-free async job queue
+ *
+ * A reliable job queue for single-node applications with:
+ * - File-based persistence with crash recovery
+ * - Worker process isolation
+ * - Retry with exponential backoff
+ * - Dead letter queue for failed jobs
+ * - Graceful shutdown handling
+ */
+export { Queue } from './queue/Queue.js';
+export { Job } from './queue/Job.js';
+export type { QueueConfig, JobData, JobStatus, JobProcessor, RetryConfig, BackoffConfig, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACrC,YAAY,EACV,WAAW,EACX,OAAO,EACP,SAAS,EACT,YAAY,EACZ,WAAW,EACX,aAAa,GACd,MAAM,YAAY,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * light-queue - Production-ready Redis-free async job queue
+ *
+ * A reliable job queue for single-node applications with:
+ * - File-based persistence with crash recovery
+ * - Worker process isolation
+ * - Retry with exponential backoff
+ * - Dead letter queue for failed jobs
+ * - Graceful shutdown handling
+ */
+export { Queue } from './queue/Queue.js';
+export { Job } from './queue/Job.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC"}

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

@@ -0,0 +1,24 @@
+import { BackoffConfig } from '../types.js';
+/**
+ * Backoff calculator for retry delays
+ */
+export declare class Backoff {
+    private config;
+    constructor(config: BackoffConfig);
+    /**
+     * Calculate the next retry delay based on attempt number
+     * Formula: delay = baseDelay * (2 ^ (attempt - 1))
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Delay in milliseconds
+     */
+    calculateDelay(attempt: number): number;
+    /**
+     * Calculate the next run timestamp for a job
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Unix timestamp in milliseconds
+     */
+    getNextRunAt(attempt: number): number;
+}
+//# sourceMappingURL=Backoff.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Backoff.d.ts","sourceRoot":"","sources":["../../../src/queue/Backoff.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,aAAa;IAIjC;;;;;;OAMG;IACH,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAavC;;;;;OAKG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;CAItC"}

package/dist/src/queue/Backoff.js

@@ -0,0 +1,37 @@
+/**
+ * Backoff calculator for retry delays
+ */
+export class Backoff {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Calculate the next retry delay based on attempt number
+     * Formula: delay = baseDelay * (2 ^ (attempt - 1))
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Delay in milliseconds
+     */
+    calculateDelay(attempt) {
+        if (this.config.type === 'exponential') {
+            // Exponential backoff: delay * 2^(attempt-1)
+            const exponentialDelay = this.config.delay * Math.pow(2, attempt - 1);
+            // Cap at 1 hour to prevent extremely long delays
+            const maxDelay = 60 * 60 * 1000; // 1 hour
+            return Math.min(exponentialDelay, maxDelay);
+        }
+        return this.config.delay;
+    }
+    /**
+     * Calculate the next run timestamp for a job
+     *
+     * @param attempt - Current attempt number (1-based)
+     * @returns Unix timestamp in milliseconds
+     */
+    getNextRunAt(attempt) {
+        const delay = this.calculateDelay(attempt);
+        return Date.now() + delay;
+    }
+}
+//# sourceMappingURL=Backoff.js.map

package/dist/src/queue/Backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Backoff.js","sourceRoot":"","sources":["../../../src/queue/Backoff.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAO,OAAO;IACV,MAAM,CAAgB;IAE9B,YAAY,MAAqB;QAC/B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CAAC,OAAe;QAC5B,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;YACvC,6CAA6C;YAC7C,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YAEtE,iDAAiD;YACjD,MAAM,QAAQ,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,SAAS;YAC1C,OAAO,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,QAAQ,CAAC,CAAC;QAC9C,CAAC;QAED,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,OAAe;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC;IAC5B,CAAC;CACF"}

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

@@ -0,0 +1,44 @@
+import { JobData, JobStatus } from '../types.js';
+/**
+ * Job class representing a single unit of work in the queue
+ */
+export declare class Job {
+    readonly id: string;
+    payload: unknown;
+    attempts: number;
+    maxAttempts: number;
+    status: JobStatus;
+    nextRunAt: number;
+    readonly createdAt: number;
+    updatedAt: number;
+    constructor(payload: unknown, maxAttempts: number, nextRunAt?: number);
+    /**
+     * Create a Job instance from stored data
+     */
+    static fromData(data: JobData): Job;
+    /**
+     * Convert job to plain data object for storage
+     */
+    toData(): JobData;
+    /**
+     * Mark job as processing
+     */
+    markProcessing(): void;
+    /**
+     * Mark job as completed
+     */
+    markCompleted(): void;
+    /**
+     * Mark job as failed and increment attempts
+     */
+    markFailed(nextRunAt?: number): void;
+    /**
+     * Check if job has exceeded max attempts
+     */
+    hasExceededMaxAttempts(): boolean;
+    /**
+     * Reset job for reprocessing (used when recovering from DLQ)
+     */
+    reset(): void;
+}
+//# sourceMappingURL=Job.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Job.d.ts","sourceRoot":"","sources":["../../../src/queue/Job.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGjD;;GAEG;AACH,qBAAa,GAAG;IACd,SAAgB,EAAE,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IACzB,SAAgB,SAAS,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;IAYrE;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,GAAG;IAMnC;;OAEG;IACH,MAAM,IAAI,OAAO;IAajB;;OAEG;IACH,cAAc,IAAI,IAAI;IAKtB;;OAEG;IACH,aAAa,IAAI,IAAI;IAKrB;;OAEG;IACH,UAAU,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IASpC;;OAEG;IACH,sBAAsB,IAAI,OAAO;IAIjC;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}