@buenojs/bueno 0.8.4 → 0.8.6

package/dist/jobs/index.js

@@ -0,0 +1,819 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/jobs/drivers/memory.ts
+class MemoryJobQueueDriver {
+  config;
+  jobStore = new Map;
+  pendingQueue = [];
+  processingSet = new Set;
+  failedQueue = [];
+  cleanupInterval = null;
+  jobCounter = 0;
+  metrics = {
+    enqueued: 0,
+    processed: 0,
+    failed: 0,
+    pending: 0,
+    processing: 0,
+    avgLatency: 0,
+    totalLatency: 0,
+    retried: 0,
+    successRate: 0,
+    avgAttempts: 0
+  };
+  constructor(config = {}) {
+    this.config = config;
+    this._startCleanup();
+  }
+  generateJobId() {
+    this.jobCounter++;
+    return `job:memory:${Date.now()}:${this.jobCounter}`;
+  }
+  _startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [jobId, stored] of this.jobStore.entries()) {
+        if (now > stored.expiresAt) {
+          this.jobStore.delete(jobId);
+        }
+      }
+    }, 30000);
+  }
+  async connect() {}
+  async disconnect() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.jobStore.clear();
+    this.pendingQueue = [];
+    this.processingSet.clear();
+    this.failedQueue = [];
+  }
+  async isConnected() {
+    return true;
+  }
+  async enqueue(name, data, options) {
+    const jobId = this.generateJobId();
+    const now = new Date;
+    const job = {
+      id: jobId,
+      name,
+      data,
+      status: "pending",
+      attempts: 0,
+      maxRetries: options?.maxRetries ?? this.config.maxRetries ?? 3,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      priority: options?.priority ?? 0,
+      metadata: options?.metadata
+    };
+    if (options?.delay) {
+      const delayMs = options.delay instanceof Date ? options.delay.getTime() - Date.now() : options.delay;
+      if (delayMs > 0) {
+        job.status = "delayed";
+        job.scheduledFor = new Date(Date.now() + delayMs).toISOString();
+      }
+    }
+    const expiryMs = 7 * 24 * 60 * 60 * 1000;
+    this.jobStore.set(jobId, {
+      job,
+      expiresAt: Date.now() + expiryMs
+    });
+    if (job.status === "pending") {
+      this.pendingQueue.push(jobId);
+    }
+    this.metrics.enqueued++;
+    this.metrics.pending = this.pendingQueue.length;
+    return jobId;
+  }
+  async claim(count, timeout) {
+    const now = Date.now();
+    const claimed = [];
+    const toRemove = [];
+    this.jobStore.forEach((stored, jobId) => {
+      if (stored.job.status === "delayed" && stored.job.scheduledFor && new Date(stored.job.scheduledFor).getTime() <= now) {
+        stored.job.status = "pending";
+        if (!this.pendingQueue.includes(jobId)) {
+          this.pendingQueue.push(jobId);
+        }
+      }
+    });
+    while (claimed.length < count && this.pendingQueue.length > 0) {
+      const jobId = this.pendingQueue.shift();
+      if (!jobId)
+        break;
+      const stored = this.jobStore.get(jobId);
+      if (!stored)
+        continue;
+      const job = stored.job;
+      job.status = "processing";
+      job.attempts++;
+      job.startedAt = new Date().toISOString();
+      job.claimExpiresAt = new Date(now + timeout).toISOString();
+      job.updatedAt = new Date().toISOString();
+      this.processingSet.add(jobId);
+      claimed.push(job);
+    }
+    this.metrics.processing = this.processingSet.size;
+    this.metrics.pending = this.pendingQueue.length;
+    return claimed;
+  }
+  async complete(jobId) {
+    const stored = this.jobStore.get(jobId);
+    if (!stored)
+      return;
+    const job = stored.job;
+    const now = new Date;
+    job.status = "completed";
+    job.completedAt = now.toISOString();
+    job.updatedAt = now.toISOString();
+    if (job.startedAt) {
+      job.duration = new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime();
+      this.metrics.totalLatency += job.duration;
+    }
+    this.processingSet.delete(jobId);
+    this.metrics.processed++;
+    this.metrics.processing = this.processingSet.size;
+    if (this.metrics.processed > 0) {
+      this.metrics.avgLatency = this.metrics.totalLatency / this.metrics.processed;
+    }
+    const total = this.metrics.processed + this.metrics.failed + this.metrics.pending;
+    if (total > 0) {
+      this.metrics.successRate = this.metrics.processed / total;
+    }
+    const allJobs = Array.from(this.jobStore.values()).map((s) => s.job).filter((j) => j.status === "completed" || j.status === "failed");
+    if (allJobs.length > 0) {
+      const totalAttempts = allJobs.reduce((sum, j) => sum + (j.attempts || 1), 0);
+      this.metrics.avgAttempts = totalAttempts / allJobs.length;
+    }
+  }
+  async fail(jobId, error, stackTrace) {
+    const stored = this.jobStore.get(jobId);
+    if (!stored)
+      return;
+    const job = stored.job;
+    const now = new Date;
+    job.error = error;
+    job.stackTrace = stackTrace;
+    job.status = "failed";
+    job.updatedAt = now.toISOString();
+    this.processingSet.delete(jobId);
+    this.failedQueue.push(jobId);
+    this.metrics.failed++;
+    this.metrics.processing = this.processingSet.size;
+    const total = this.metrics.processed + this.metrics.failed + this.metrics.pending;
+    if (total > 0) {
+      this.metrics.successRate = this.metrics.processed / total;
+    }
+  }
+  async scheduleRetry(jobId, delayMs, error) {
+    const stored = this.jobStore.get(jobId);
+    if (!stored)
+      return;
+    const job = stored.job;
+    const now = new Date;
+    job.error = error;
+    job.status = "delayed";
+    job.scheduledFor = new Date(now.getTime() + delayMs).toISOString();
+    job.updatedAt = now.toISOString();
+    this.processingSet.delete(jobId);
+    const failedIndex = this.failedQueue.indexOf(jobId);
+    if (failedIndex >= 0) {
+      this.failedQueue.splice(failedIndex, 1);
+    }
+    this.metrics.retried++;
+    this.metrics.processing = this.processingSet.size;
+  }
+  async getJob(jobId) {
+    const stored = this.jobStore.get(jobId);
+    return stored ? stored.job : null;
+  }
+  async getMetrics() {
+    return { ...this.metrics };
+  }
+  async clear() {
+    this.jobStore.clear();
+    this.pendingQueue = [];
+    this.processingSet.clear();
+    this.failedQueue = [];
+    this.metrics = {
+      enqueued: 0,
+      processed: 0,
+      failed: 0,
+      pending: 0,
+      processing: 0,
+      avgLatency: 0,
+      totalLatency: 0,
+      retried: 0,
+      successRate: 0,
+      avgAttempts: 0
+    };
+  }
+}
+
+// src/jobs/drivers/redis.ts
+class RedisJobQueueDriver {
+  config;
+  client = null;
+  _isConnected = false;
+  keyPrefix;
+  constructor(config = {}) {
+    this.config = config;
+    this.keyPrefix = config.keyPrefix ?? "jobs:";
+  }
+  key(suffix) {
+    return `${this.keyPrefix}${suffix}`;
+  }
+  getClient() {
+    return this.client;
+  }
+  async connect() {
+    try {
+      const { RedisClient } = await Promise.resolve(globalThis.Bun);
+      if (!this.config.url) {
+        throw new Error("Redis URL is required for RedisJobQueueDriver");
+      }
+      this.client = new RedisClient(this.config.url);
+      this._isConnected = true;
+    } catch (error) {
+      throw new Error(`Failed to connect to Redis: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async disconnect() {
+    this._isConnected = false;
+    this.client = null;
+  }
+  async isConnected() {
+    return this._isConnected;
+  }
+  async enqueue(name, data, options) {
+    const client = this.getClient();
+    const jobId = `${name}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+    const now = new Date;
+    const job = {
+      id: jobId,
+      name,
+      data,
+      status: "pending",
+      attempts: 0,
+      maxRetries: options?.maxRetries ?? this.config.maxRetries ?? 3,
+      createdAt: now.toISOString(),
+      updatedAt: now.toISOString(),
+      priority: options?.priority ?? 0,
+      metadata: options?.metadata
+    };
+    let scheduledScore = now.getTime();
+    if (options?.delay) {
+      const delayMs = options.delay instanceof Date ? options.delay.getTime() - Date.now() : options.delay;
+      if (delayMs > 0) {
+        job.status = "delayed";
+        job.scheduledFor = new Date(now.getTime() + delayMs).toISOString();
+        scheduledScore = now.getTime() + delayMs;
+      }
+    }
+    await client.set(this.key(`job:${jobId}`), JSON.stringify(job));
+    await client.zadd(this.key("queue:pending"), scheduledScore, jobId);
+    await client.hincrby(this.key("metrics"), "enqueued", 1);
+    return jobId;
+  }
+  async claim(count, timeout) {
+    const client = this.getClient();
+    const now = Date.now();
+    const claimed = [];
+    try {
+      const jobIds = await client.zrange(this.key("queue:pending"), 0, count - 1);
+      for (const jobId of jobIds) {
+        if (claimed.length >= count)
+          break;
+        const jobKey = this.key(`job:${jobId}`);
+        const jobData = await client.get(jobKey);
+        if (!jobData)
+          continue;
+        const job = JSON.parse(jobData);
+        job.status = "processing";
+        job.attempts = (job.attempts || 0) + 1;
+        job.startedAt = new Date().toISOString();
+        job.claimExpiresAt = new Date(now + timeout).toISOString();
+        job.updatedAt = new Date().toISOString();
+        await client.set(jobKey, JSON.stringify(job));
+        await client.zadd(this.key("queue:processing"), now + timeout, jobId);
+        await client.zrem(this.key("queue:pending"), jobId);
+        claimed.push(job);
+      }
+      return claimed;
+    } catch (error) {
+      console.error("Error claiming jobs:", error);
+      return [];
+    }
+  }
+  async complete(jobId) {
+    const client = this.getClient();
+    const jobKey = this.key(`job:${jobId}`);
+    const jobData = await client.get(jobKey);
+    if (!jobData)
+      return;
+    const job = JSON.parse(jobData);
+    const now = new Date;
+    job.status = "completed";
+    job.completedAt = now.toISOString();
+    job.updatedAt = now.toISOString();
+    if (job.startedAt) {
+      job.duration = new Date(job.completedAt).getTime() - new Date(job.startedAt).getTime();
+    }
+    await client.set(jobKey, JSON.stringify(job));
+    await client.zrem(this.key("queue:processing"), jobId);
+    await client.hincrby(this.key("metrics"), "processed", 1);
+    if (job.duration) {
+      await client.hincrby(this.key("metrics"), "totalLatency", Math.floor(job.duration));
+    }
+  }
+  async fail(jobId, error, stackTrace) {
+    const client = this.getClient();
+    const jobKey = this.key(`job:${jobId}`);
+    const jobData = await client.get(jobKey);
+    if (!jobData)
+      return;
+    const job = JSON.parse(jobData);
+    job.error = error;
+    job.stackTrace = stackTrace;
+    job.status = "failed";
+    job.updatedAt = new Date().toISOString();
+    await client.set(jobKey, JSON.stringify(job));
+    await client.zrem(this.key("queue:processing"), jobId);
+    await client.zadd(this.key("queue:failed"), Date.now(), jobId);
+    await client.hincrby(this.key("metrics"), "failed", 1);
+  }
+  async scheduleRetry(jobId, delayMs, error) {
+    const client = this.getClient();
+    const jobKey = this.key(`job:${jobId}`);
+    const jobData = await client.get(jobKey);
+    if (!jobData)
+      return;
+    const job = JSON.parse(jobData);
+    job.status = "delayed";
+    job.error = error;
+    job.scheduledFor = new Date(Date.now() + delayMs).toISOString();
+    job.updatedAt = new Date().toISOString();
+    await client.set(jobKey, JSON.stringify(job));
+    await client.zrem(this.key("queue:processing"), jobId);
+    await client.zadd(this.key("queue:pending"), Date.now() + delayMs, jobId);
+    await client.hincrby(this.key("metrics"), "retried", 1);
+  }
+  async getJob(jobId) {
+    const client = this.getClient();
+    const jobData = await client.get(this.key(`job:${jobId}`));
+    if (!jobData)
+      return null;
+    return JSON.parse(jobData);
+  }
+  async getMetrics() {
+    const client = this.getClient();
+    const metricsData = await client.hgetall(this.key("metrics"));
+    const pendingCount = await client.zcard(this.key("queue:pending"));
+    const processingCount = await client.zcard(this.key("queue:processing"));
+    const enqueued = Number.parseInt(metricsData.enqueued || "0");
+    const processed = Number.parseInt(metricsData.processed || "0");
+    const failed = Number.parseInt(metricsData.failed || "0");
+    const totalLatency = Number.parseInt(metricsData.totalLatency || "0");
+    const retried = Number.parseInt(metricsData.retried || "0");
+    const total = enqueued;
+    const successRate = total > 0 ? processed / total : 0;
+    const avgLatency = processed > 0 ? totalLatency / processed : 0;
+    return {
+      enqueued,
+      processed,
+      failed,
+      pending: pendingCount,
+      processing: processingCount,
+      avgLatency,
+      totalLatency,
+      retried,
+      successRate,
+      avgAttempts: enqueued > 0 ? (processed + failed) / enqueued : 0
+    };
+  }
+  async clear() {
+    const client = this.getClient();
+    const keys = [
+      this.key("queue:pending"),
+      this.key("queue:processing"),
+      this.key("queue:failed"),
+      this.key("metrics")
+    ];
+    const pendingJobs = await client.zrange(this.key("queue:pending"), 0, -1);
+    for (const jobId of pendingJobs) {
+      keys.push(this.key(`job:${jobId}`));
+    }
+    const processingJobs = await client.zrange(this.key("queue:processing"), 0, -1);
+    for (const jobId of processingJobs) {
+      keys.push(this.key(`job:${jobId}`));
+    }
+    const failedJobs = await client.zrange(this.key("queue:failed"), 0, -1);
+    for (const jobId of failedJobs) {
+      keys.push(this.key(`job:${jobId}`));
+    }
+    if (keys.length > 0) {
+      await client.del(...keys);
+    }
+  }
+}
+
+// src/jobs/queue.ts
+class JobQueue {
+  driver;
+  handlers = new Map;
+  handlerRegistry = [];
+  eventListeners = new Map;
+  isRunning = false;
+  constructor(config = {}) {
+    const driver = config.driver ?? "memory";
+    if (driver === "redis") {
+      if (!config.url) {
+        throw new Error("Redis URL is required for Redis driver");
+      }
+      this.driver = new RedisJobQueueDriver(config);
+    } else {
+      this.driver = new MemoryJobQueueDriver(config);
+    }
+  }
+  async init() {
+    await this.driver.connect();
+  }
+  async shutdown() {
+    this.isRunning = false;
+    await this.driver.disconnect();
+  }
+  async enqueue(name, data, options) {
+    const jobId = await this.driver.enqueue(name, data, options);
+    this._emitEvent("enqueued", { id: jobId, name });
+    return jobId;
+  }
+  on(pattern, handler) {
+    this.handlers.set(pattern, handler);
+    const specificity = pattern.split(".").length;
+    const entry = { pattern, handler, specificity };
+    const index = this.handlerRegistry.findIndex((e) => e.specificity < specificity);
+    if (index >= 0) {
+      this.handlerRegistry.splice(index, 0, entry);
+    } else {
+      this.handlerRegistry.push(entry);
+    }
+  }
+  off(pattern) {
+    this.handlers.delete(pattern);
+    const index = this.handlerRegistry.findIndex((e) => e.pattern === pattern);
+    if (index >= 0) {
+      this.handlerRegistry.splice(index, 1);
+    }
+  }
+  findHandler(jobName) {
+    for (const entry of this.handlerRegistry) {
+      if (this._patternMatches(entry.pattern, jobName)) {
+        return entry.handler;
+      }
+    }
+    return null;
+  }
+  _patternMatches(pattern, jobName) {
+    if (pattern === jobName)
+      return true;
+    if (pattern.endsWith(".*")) {
+      const prefix = pattern.slice(0, -2);
+      return jobName.startsWith(prefix + ".");
+    }
+    return false;
+  }
+  onEvent(event, listener) {
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, new Set);
+    }
+    this.eventListeners.get(event).add(listener);
+  }
+  offEvent(event, listener) {
+    this.eventListeners.get(event)?.delete(listener);
+  }
+  _emitEvent(eventType, job) {
+    const listeners = this.eventListeners.get(eventType);
+    if (!listeners)
+      return;
+    const event = {
+      type: eventType,
+      job,
+      timestamp: new Date
+    };
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error(`Error in ${eventType} listener:`, error);
+      }
+    }
+  }
+  async start(options = {}) {
+    this.isRunning = true;
+    const pollInterval = options.pollInterval ?? 1000;
+    const concurrency = options.concurrency ?? 10;
+    while (this.isRunning) {
+      try {
+        const jobs = await this.driver.claim(concurrency, 30000);
+        for (const job of jobs) {
+          if (!this.isRunning)
+            break;
+          try {
+            const handler = this.findHandler(job.name);
+            if (!handler) {
+              console.warn(`No handler found for job type: ${job.name}`);
+              await this.driver.complete(job.id);
+              continue;
+            }
+            this._emitEvent("started", job);
+            await handler(job);
+            this._emitEvent("completed", job);
+            await this.driver.complete(job.id);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            const stackTrace = error instanceof Error ? error.stack : undefined;
+            if (job.attempts < job.maxRetries) {
+              const backoffMs = Math.pow(2, job.attempts) * 1000;
+              this._emitEvent("retried", job);
+              await this.driver.scheduleRetry(job.id, backoffMs, errorMsg);
+            } else {
+              this._emitEvent("failed", job);
+              await this.driver.fail(job.id, errorMsg, stackTrace);
+            }
+          }
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      } catch (error) {
+        console.error("Error in job queue polling loop:", error);
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    }
+  }
+  async stop() {
+    this.isRunning = false;
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  async getJob(jobId) {
+    return this.driver.getJob(jobId);
+  }
+  async getMetrics() {
+    return this.driver.getMetrics();
+  }
+  async clear() {
+    return this.driver.clear();
+  }
+  async isConnected() {
+    return this.driver.isConnected();
+  }
+}
+function createJobQueue(config) {
+  return new JobQueue(config);
+}
+// src/jobs/worker.ts
+class JobWorker {
+  driver;
+  handlers = new Map;
+  handlerRegistry = [];
+  eventListeners = new Map;
+  isRunning = false;
+  pollInterval;
+  concurrency;
+  jobTimeout;
+  maxBackoffDelay = 30000;
+  currentBackoff = 0;
+  inFlightJobs = new Set;
+  shutdownTimeout = 1e4;
+  constructor(config = {}) {
+    const driver = config.driver ?? "memory";
+    if (driver === "redis") {
+      if (!config.url) {
+        throw new Error("Redis URL is required for Redis driver");
+      }
+      this.driver = new RedisJobQueueDriver(config);
+    } else {
+      this.driver = new MemoryJobQueueDriver(config);
+    }
+    this.pollInterval = config.pollInterval ?? 1000;
+    this.concurrency = config.concurrency ?? 10;
+    this.jobTimeout = config.jobTimeout ?? 300000;
+  }
+  async init() {
+    await this.driver.connect();
+  }
+  handle(pattern, handler) {
+    this.handlers.set(pattern, handler);
+    const specificity = pattern.split(".").length;
+    const entry = { pattern, handler, specificity };
+    const index = this.handlerRegistry.findIndex((e) => e.specificity < specificity);
+    if (index >= 0) {
+      this.handlerRegistry.splice(index, 0, entry);
+    } else {
+      this.handlerRegistry.push(entry);
+    }
+  }
+  unhandle(pattern) {
+    this.handlers.delete(pattern);
+    const index = this.handlerRegistry.findIndex((e) => e.pattern === pattern);
+    if (index >= 0) {
+      this.handlerRegistry.splice(index, 1);
+    }
+  }
+  on(eventType, listener) {
+    if (!this.eventListeners.has(eventType)) {
+      this.eventListeners.set(eventType, new Set);
+    }
+    this.eventListeners.get(eventType).add(listener);
+  }
+  off(eventType, listener) {
+    this.eventListeners.get(eventType)?.delete(listener);
+  }
+  _emitEvent(eventType, job) {
+    const listeners = this.eventListeners.get(eventType);
+    if (!listeners)
+      return;
+    const event = {
+      type: eventType,
+      job,
+      timestamp: new Date
+    };
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.error(`Error in ${eventType} listener:`, error);
+      }
+    }
+  }
+  findHandler(jobName) {
+    for (const entry of this.handlerRegistry) {
+      if (this._patternMatches(entry.pattern, jobName)) {
+        return entry.handler;
+      }
+    }
+    return null;
+  }
+  _patternMatches(pattern, jobName) {
+    if (pattern === jobName)
+      return true;
+    if (pattern.endsWith(".*")) {
+      const prefix = pattern.slice(0, -2);
+      return jobName.startsWith(prefix + ".");
+    }
+    return false;
+  }
+  async start() {
+    this.isRunning = true;
+    console.log("[JobWorker] Starting worker process");
+    const handleSignal = async () => {
+      await this.stop();
+    };
+    process.on("SIGTERM", handleSignal);
+    process.on("SIGINT", handleSignal);
+    try {
+      await this._pollLoop();
+    } finally {
+      process.removeListener("SIGTERM", handleSignal);
+      process.removeListener("SIGINT", handleSignal);
+    }
+  }
+  async _pollLoop() {
+    while (this.isRunning) {
+      try {
+        const availableSlots = this.concurrency - this.inFlightJobs.size;
+        if (availableSlots > 0) {
+          const jobs = await this.driver.claim(availableSlots, this.jobTimeout);
+          if (jobs.length > 0) {
+            this.currentBackoff = 0;
+            for (const job of jobs) {
+              this._processJob(job).catch((error) => {
+                console.error(`[JobWorker] Unhandled error processing job ${job.id}:`, error);
+              });
+            }
+          } else {
+            this.currentBackoff = Math.min((this.currentBackoff || this.pollInterval) * 1.5, this.maxBackoffDelay);
+          }
+        }
+        const delay = this.currentBackoff || this.pollInterval;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      } catch (error) {
+        console.error("[JobWorker] Error in polling loop:", error);
+        this.currentBackoff = Math.min((this.currentBackoff || this.pollInterval) * 1.5, this.maxBackoffDelay);
+        await new Promise((resolve) => setTimeout(resolve, this.currentBackoff));
+      }
+    }
+  }
+  async _processJob(job) {
+    this.inFlightJobs.add(job.id);
+    try {
+      const handler = this.findHandler(job.name);
+      if (!handler) {
+        console.warn(`[JobWorker] No handler found for job type: ${job.name}`);
+        await this.driver.complete(job.id);
+        return;
+      }
+      this._emitEvent("started", job);
+      const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error(`Job timeout after ${this.jobTimeout}ms`)), this.jobTimeout));
+      const handlerPromise = handler(job);
+      await Promise.race([handlerPromise, timeoutPromise]);
+      this._emitEvent("completed", job);
+      await this.driver.complete(job.id);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      const stackTrace = error instanceof Error ? error.stack : undefined;
+      if (job.attempts < job.maxRetries) {
+        const delaySeconds = Math.min(Math.pow(2, job.attempts), 3600);
+        const delayMs = delaySeconds * 1000;
+        this._emitEvent("retried", job);
+        await this.driver.scheduleRetry(job.id, delayMs, errorMsg);
+        console.warn(`[JobWorker] Job ${job.id} failed (attempt ${job.attempts}/${job.maxRetries}): ${errorMsg}. Retrying in ${delaySeconds}s`);
+      } else {
+        this._emitEvent("failed", job);
+        await this.driver.fail(job.id, errorMsg, stackTrace);
+        console.error(`[JobWorker] Job ${job.id} failed permanently: ${errorMsg}`);
+      }
+    } finally {
+      this.inFlightJobs.delete(job.id);
+    }
+  }
+  async stop() {
+    if (!this.isRunning)
+      return;
+    console.log("[JobWorker] Shutting down gracefully...");
+    this.isRunning = false;
+    const startTime = Date.now();
+    while (this.inFlightJobs.size > 0 && Date.now() - startTime < this.shutdownTimeout) {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    if (this.inFlightJobs.size > 0) {
+      console.warn(`[JobWorker] Force shutdown with ${this.inFlightJobs.size} jobs still in flight`);
+    } else {
+      console.log("[JobWorker] All jobs completed, shutting down");
+    }
+    await this.driver.disconnect();
+  }
+  getInFlightCount() {
+    return this.inFlightJobs.size;
+  }
+  async getMetrics() {
+    return this.driver.getMetrics();
+  }
+  isActive() {
+    return this.isRunning;
+  }
+}
+async function startWorker(config) {
+  const worker = new JobWorker(config);
+  const metricsInterval = setInterval(async () => {
+    if (worker.isActive()) {
+      const metrics = await worker.getMetrics();
+      console.log("[JobWorker] Metrics:", {
+        pending: metrics.pending,
+        processing: metrics.processing,
+        processed: metrics.processed,
+        failed: metrics.failed,
+        avgLatency: `${Math.round(metrics.avgLatency)}ms`
+      });
+    }
+  }, 30000);
+  await worker.init();
+  process.on("exit", () => {
+    clearInterval(metricsInterval);
+  });
+  await worker.start();
+}
+export {
+  startWorker,
+  createJobQueue,
+  RedisJobQueueDriver,
+  MemoryJobQueueDriver,
+  JobWorker,
+  JobQueue
+};