How do you implement a custom request queue with persistence?

Question

Accepted Answer

**Persistent request queue** — store requests for later processing.

```javascript
const fs = require("fs").promises;

class PersistentQueue {
    constructor(filePath) {
        this.filePath = filePath;
        this.queue = [];
        this.processing = false;
        this.load();
    }

async load() {
        try {
            const data = await fs.readFile(this.filePath, "utf8");
            this.queue = JSON.parse(data);
        } catch {
            this.queue = [];
        }
    }

async save() {
        await fs.writeFile(this.filePath, JSON.stringify(this.queue, null, 2));
    }

async enqueue(item) {
        this.queue.push({
            ...item,
            id: Date.now() + Math.random(),
            createdAt: Date.now(),
            status: "pending",
        });
        await this.save();
    }

async dequeue() {
        const item = this.queue.find(i => i.status === "pending");
        if (item) {
            item.status = "processing";
            await this.save();
            return item;
        }
        return null;
    }

async complete(id) {
        const item = this.queue.find(i => i.id === id);
        if (item) {
            item.status = "completed";
            await this.save();
        }
    }

async process(handler) {
        while (true) {
            const item = await this.dequeue();
            if (!item) break;

try {
                await handler(item);
                await this.complete(item.id);
            } catch (err) {
                console.error("Processing failed:", err);
                item.status = "pending";
                await this.save();
            }
        }
    }
}

// Usage
const queue = new PersistentQueue("queue.json");

app.post("/tasks", async (req, res) => {
    await queue.enqueue(req.body);
    res.json({ queued: true });
});

// Process in background
queue.process(async (item) => {
    await processTask(item);
});
```

Node.js: How do you implement a custom request queue with persistence?