@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/queue/index.js

@@ -0,0 +1,958 @@
+// src/queue/Job.ts
+import { randomBytes } from "crypto";
+
+// src/container/Container.ts
+var globalContainer = null;
+function getContainer() {
+  if (!globalContainer) {
+    throw new Error("Container not initialized. Call setContainer() first.");
+  }
+  return globalContainer;
+}
+
+// src/queue/Job.ts
+var globalDriver = null;
+function setQueueDriver(driver) {
+  globalDriver = driver;
+}
+function getQueueDriver() {
+  return globalDriver;
+}
+function generateJobId() {
+  return randomBytes(16).toString("hex");
+}
+var Job = class {
+  /**
+   * The queue this job should be dispatched to.
+   * @default 'default'
+   */
+  static queue = "default";
+  /**
+   * Maximum number of times the job should be attempted.
+   * @default 3
+   */
+  static maxAttempts = 3;
+  /**
+   * Backoff strategy for retries.
+   * - 'exponential': 2^attempt * 1000ms (1s, 2s, 4s, 8s, ...)
+   * - 'linear': attempt * 1000ms (1s, 2s, 3s, 4s, ...)
+   * - number: fixed delay in milliseconds
+   * @default 'exponential'
+   */
+  static backoff = "exponential";
+  make(key) {
+    return getContainer().make(key);
+  }
+  /**
+   * Dispatch the job to the queue.
+   *
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options
+   */
+  static async dispatch(payload, options = {}) {
+    const driver = globalDriver;
+    if (!driver) {
+      throw new Error("Queue driver not configured. Call setQueueDriver() first.");
+    }
+    const jobId = generateJobId();
+    const now = /* @__PURE__ */ new Date();
+    const delay = options.delay ?? 0;
+    const job = {
+      id: jobId,
+      name: this.name,
+      payload,
+      queue: options.queue ?? this.queue,
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? this.maxAttempts,
+      availableAt: new Date(now.getTime() + delay),
+      createdAt: now,
+      reservedAt: null
+    };
+    await driver.push(job);
+    return jobId;
+  }
+  /**
+   * Dispatch the job after a delay.
+   *
+   * @param delayMs - Delay in milliseconds
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options (delay is overridden)
+   */
+  static async dispatchAfter(delayMs, payload, options = {}) {
+    return this.dispatch(payload, { ...options, delay: delayMs });
+  }
+  /**
+   * Calculate the retry delay based on backoff strategy.
+   */
+  static calculateRetryDelay(attempts) {
+    if (typeof this.backoff === "number") {
+      return this.backoff;
+    }
+    if (this.backoff === "linear") {
+      return attempts * 1e3;
+    }
+    return Math.pow(2, attempts) * 1e3;
+  }
+};
+var jobRegistry = /* @__PURE__ */ new Map();
+function registerJob(jobClass) {
+  jobRegistry.set(jobClass.name, jobClass);
+}
+function getJob(name) {
+  return jobRegistry.get(name);
+}
+function getRegisteredJobs() {
+  return new Map(jobRegistry);
+}
+function clearJobRegistry() {
+  jobRegistry.clear();
+}
+
+// src/queue/drivers/MemoryDriver.ts
+var MemoryDriver = class {
+  jobs = /* @__PURE__ */ new Map();
+  failedJobs = /* @__PURE__ */ new Map();
+  /**
+   * Push a job onto the queue.
+   */
+  async push(job) {
+    this.jobs.set(job.id, { ...job });
+  }
+  /**
+   * Pop the next available job from the queue.
+   */
+  async pop(queue) {
+    const now = /* @__PURE__ */ new Date();
+    for (const [id, job] of this.jobs) {
+      if (job.queue === queue && job.availableAt <= now && job.reservedAt === null) {
+        job.reservedAt = now;
+        return { ...job };
+      }
+    }
+    return null;
+  }
+  /**
+   * Release a job back onto the queue.
+   */
+  async release(job, delayMs = 0) {
+    const existing = this.jobs.get(job.id);
+    if (existing) {
+      existing.reservedAt = null;
+      existing.availableAt = new Date(Date.now() + delayMs);
+      existing.attempts = job.attempts;
+      if (job.lastError) {
+        existing.lastError = job.lastError;
+      }
+    }
+  }
+  /**
+   * Delete a job from the queue.
+   */
+  async delete(jobId) {
+    this.jobs.delete(jobId);
+  }
+  /**
+   * Mark a job as failed.
+   */
+  async fail(job, error) {
+    const failedJob = {
+      ...job,
+      failedAt: /* @__PURE__ */ new Date(),
+      error: error.message,
+      stack: error.stack
+    };
+    this.failedJobs.set(job.id, failedJob);
+    this.jobs.delete(job.id);
+  }
+  /**
+   * Get the number of jobs in a queue.
+   */
+  async size(queue) {
+    let count = 0;
+    for (const job of this.jobs.values()) {
+      if (job.queue === queue && job.reservedAt === null) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Get failed jobs.
+   */
+  async getFailedJobs(queue) {
+    const jobs = [];
+    for (const job of this.failedJobs.values()) {
+      if (!queue || job.queue === queue) {
+        jobs.push({ ...job });
+      }
+    }
+    return jobs.sort((a, b) => b.failedAt.getTime() - a.failedAt.getTime());
+  }
+  /**
+   * Retry a failed job.
+   */
+  async retryFailedJob(jobId) {
+    const failedJob = this.failedJobs.get(jobId);
+    if (!failedJob) {
+      throw new Error(`Failed job not found: ${jobId}`);
+    }
+    const job = {
+      id: failedJob.id,
+      name: failedJob.name,
+      payload: failedJob.payload,
+      queue: failedJob.queue,
+      attempts: 0,
+      maxAttempts: failedJob.maxAttempts,
+      availableAt: /* @__PURE__ */ new Date(),
+      createdAt: /* @__PURE__ */ new Date(),
+      reservedAt: null
+    };
+    this.jobs.set(job.id, job);
+    this.failedJobs.delete(jobId);
+  }
+  /**
+   * Delete a failed job.
+   */
+  async deleteFailedJob(jobId) {
+    this.failedJobs.delete(jobId);
+  }
+  /**
+   * Clear all jobs (for testing).
+   */
+  async clear() {
+    this.jobs.clear();
+    this.failedJobs.clear();
+  }
+  /**
+   * Get all pending jobs (for testing/debugging).
+   */
+  getPendingJobs(queue) {
+    const jobs = [];
+    for (const job of this.jobs.values()) {
+      if (!queue || job.queue === queue) {
+        jobs.push({ ...job });
+      }
+    }
+    return jobs;
+  }
+};
+
+// src/queue/drivers/RedisDriver.ts
+var RedisDriver = class {
+  constructor(redis, options = {}) {
+    this.redis = redis;
+    this.prefix = options.prefix ?? "queue:";
+    this.visibilityTimeout = options.visibilityTimeout ?? 6e4;
+  }
+  prefix;
+  visibilityTimeout;
+  pendingKey(queue) {
+    return `${this.prefix}${queue}:pending`;
+  }
+  reservedKey(queue) {
+    return `${this.prefix}${queue}:reserved`;
+  }
+  failedKey(queue) {
+    return `${this.prefix}${queue}:failed`;
+  }
+  jobKey(id) {
+    return `${this.prefix}job:${id}`;
+  }
+  /**
+   * Push a job onto the queue.
+   */
+  async push(job) {
+    const jobData = {
+      id: job.id,
+      name: job.name,
+      payload: JSON.stringify(job.payload),
+      queue: job.queue,
+      attempts: String(job.attempts),
+      maxAttempts: String(job.maxAttempts),
+      availableAt: job.availableAt.toISOString(),
+      createdAt: job.createdAt.toISOString()
+    };
+    const pipeline = this.redis.pipeline();
+    pipeline.hset(this.jobKey(job.id), jobData);
+    pipeline.zadd(this.pendingKey(job.queue), job.availableAt.getTime(), job.id);
+    await pipeline.exec();
+  }
+  /**
+   * Pop the next available job from the queue.
+   */
+  async pop(queue) {
+    const now = Date.now();
+    await this.releaseTimedOutJobs(queue);
+    const jobIds = await this.redis.zrangebyscore(
+      this.pendingKey(queue),
+      "-inf",
+      now,
+      "LIMIT",
+      0,
+      1
+    );
+    if (jobIds.length === 0) {
+      return null;
+    }
+    const jobId = jobIds[0];
+    const removed = await this.redis.zrem(this.pendingKey(queue), jobId);
+    if (removed === 0) {
+      return null;
+    }
+    const timeout = now + this.visibilityTimeout;
+    await this.redis.zadd(this.reservedKey(queue), timeout, jobId);
+    await this.redis.hset(this.jobKey(jobId), "reservedAt", (/* @__PURE__ */ new Date()).toISOString());
+    const jobData = await this.redis.hgetall(this.jobKey(jobId));
+    if (!jobData || !jobData.id) {
+      await this.redis.zrem(this.reservedKey(queue), jobId);
+      return null;
+    }
+    return this.parseJobData(jobData);
+  }
+  /**
+   * Release jobs that have exceeded visibility timeout.
+   */
+  async releaseTimedOutJobs(queue) {
+    const now = Date.now();
+    const timedOutIds = await this.redis.zrangebyscore(
+      this.reservedKey(queue),
+      "-inf",
+      now
+    );
+    for (const jobId of timedOutIds) {
+      const removed = await this.redis.zrem(this.reservedKey(queue), jobId);
+      if (removed > 0) {
+        await this.redis.zadd(this.pendingKey(queue), now, jobId);
+        await this.redis.hdel(this.jobKey(jobId), "reservedAt");
+      }
+    }
+  }
+  /**
+   * Release a job back onto the queue.
+   */
+  async release(job, delayMs = 0) {
+    const availableAt = Date.now() + delayMs;
+    await this.redis.zrem(this.reservedKey(job.queue), job.id);
+    const updates = {
+      attempts: String(job.attempts),
+      availableAt: new Date(availableAt).toISOString()
+    };
+    if (job.lastError) {
+      updates.lastError = job.lastError;
+    }
+    await this.redis.hset(this.jobKey(job.id), updates);
+    await this.redis.hdel(this.jobKey(job.id), "reservedAt");
+    await this.redis.zadd(this.pendingKey(job.queue), availableAt, job.id);
+  }
+  /**
+   * Delete a job from the queue.
+   */
+  async delete(jobId) {
+    const jobData = await this.redis.hgetall(this.jobKey(jobId));
+    if (jobData && jobData.queue) {
+      const pipeline = this.redis.pipeline();
+      pipeline.zrem(this.pendingKey(jobData.queue), jobId);
+      pipeline.zrem(this.reservedKey(jobData.queue), jobId);
+      pipeline.del(this.jobKey(jobId));
+      await pipeline.exec();
+    } else {
+      await this.redis.del(this.jobKey(jobId));
+    }
+  }
+  /**
+   * Mark a job as failed.
+   */
+  async fail(job, error) {
+    const failedData = {
+      failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      error: error.message,
+      stack: error.stack ?? ""
+    };
+    await this.redis.hset(this.jobKey(job.id), failedData);
+    const pipeline = this.redis.pipeline();
+    pipeline.zrem(this.reservedKey(job.queue), job.id);
+    pipeline.lpush(this.failedKey(job.queue), job.id);
+    await pipeline.exec();
+  }
+  /**
+   * Get the number of jobs in a queue.
+   */
+  async size(queue) {
+    return this.redis.zcard(this.pendingKey(queue));
+  }
+  /**
+   * Get failed jobs.
+   */
+  async getFailedJobs(queue) {
+    const jobs = [];
+    if (queue) {
+      jobs.push(...await this.getFailedJobsForQueue(queue));
+    } else {
+      const pattern = `${this.prefix}*:failed`;
+      let cursor = "0";
+      const queueKeys = [];
+      do {
+        const [newCursor, keys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+        cursor = newCursor;
+        queueKeys.push(...keys);
+      } while (cursor !== "0");
+      for (const key of queueKeys) {
+        const queueName = key.replace(this.prefix, "").replace(":failed", "");
+        jobs.push(...await this.getFailedJobsForQueue(queueName));
+      }
+    }
+    return jobs.sort((a, b) => b.failedAt.getTime() - a.failedAt.getTime());
+  }
+  async getFailedJobsForQueue(queue) {
+    const jobIds = await this.redis.lrange(this.failedKey(queue), 0, -1);
+    const jobs = [];
+    for (const jobId of jobIds) {
+      const jobData = await this.redis.hgetall(this.jobKey(jobId));
+      if (jobData && jobData.id) {
+        const job = this.parseJobData(jobData);
+        jobs.push({
+          ...job,
+          failedAt: new Date(jobData.failedAt || Date.now()),
+          error: jobData.error || "Unknown error",
+          stack: jobData.stack
+        });
+      }
+    }
+    return jobs;
+  }
+  /**
+   * Retry a failed job.
+   */
+  async retryFailedJob(jobId) {
+    const jobData = await this.redis.hgetall(this.jobKey(jobId));
+    if (!jobData || !jobData.queue) {
+      throw new Error(`Failed job not found: ${jobId}`);
+    }
+    const queue = jobData.queue;
+    await this.redis.lrem(this.failedKey(queue), 1, jobId);
+    const now = /* @__PURE__ */ new Date();
+    await this.redis.hset(this.jobKey(jobId), {
+      attempts: "0",
+      availableAt: now.toISOString(),
+      createdAt: now.toISOString()
+    });
+    await this.redis.hdel(this.jobKey(jobId), "reservedAt", "failedAt", "error", "stack", "lastError");
+    await this.redis.zadd(this.pendingKey(queue), now.getTime(), jobId);
+  }
+  /**
+   * Delete a failed job.
+   */
+  async deleteFailedJob(jobId) {
+    const jobData = await this.redis.hgetall(this.jobKey(jobId));
+    if (jobData && jobData.queue) {
+      await this.redis.lrem(this.failedKey(jobData.queue), 1, jobId);
+    }
+    await this.redis.del(this.jobKey(jobId));
+  }
+  /**
+   * Clear all jobs (for testing).
+   */
+  async clear() {
+    const pattern = this.prefix + "*";
+    let cursor = "0";
+    const keys = [];
+    do {
+      const [newCursor, foundKeys] = await this.redis.scan(cursor, "MATCH", pattern, "COUNT", 100);
+      cursor = newCursor;
+      keys.push(...foundKeys);
+    } while (cursor !== "0");
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+  /**
+   * Parse job data from Redis hash.
+   */
+  parseJobData(data) {
+    return {
+      id: data.id,
+      name: data.name,
+      payload: JSON.parse(data.payload || "{}"),
+      queue: data.queue,
+      attempts: parseInt(data.attempts || "0", 10),
+      maxAttempts: parseInt(data.maxAttempts || "3", 10),
+      availableAt: new Date(data.availableAt),
+      createdAt: new Date(data.createdAt),
+      reservedAt: data.reservedAt ? new Date(data.reservedAt) : null,
+      lastError: data.lastError
+    };
+  }
+};
+
+// src/queue/drivers/SqsDriver.ts
+function createSqsAdapter(client) {
+  return {
+    async sendMessage(params) {
+      const { SendMessageCommand } = await importSqs();
+      const input = {
+        QueueUrl: params.queueUrl,
+        MessageBody: params.messageBody,
+        DelaySeconds: params.delaySeconds
+      };
+      if (params.messageGroupId) {
+        input.MessageGroupId = params.messageGroupId;
+        input.MessageDeduplicationId = params.messageDeduplicationId;
+      }
+      await client.send(new SendMessageCommand(input));
+    },
+    async receiveMessage(params) {
+      const { ReceiveMessageCommand } = await importSqs();
+      const result = await client.send(
+        new ReceiveMessageCommand({
+          QueueUrl: params.queueUrl,
+          MaxNumberOfMessages: 1,
+          WaitTimeSeconds: params.waitTimeSeconds ?? 5
+        })
+      );
+      const msg = result.Messages?.[0];
+      if (!msg?.Body || !msg.ReceiptHandle) return null;
+      return { body: msg.Body, receiptHandle: msg.ReceiptHandle };
+    },
+    async changeMessageVisibility(params) {
+      const { ChangeMessageVisibilityCommand } = await importSqs();
+      await client.send(
+        new ChangeMessageVisibilityCommand({
+          QueueUrl: params.queueUrl,
+          ReceiptHandle: params.receiptHandle,
+          VisibilityTimeout: params.visibilityTimeout
+        })
+      );
+    },
+    async getApproximateMessageCount(queueUrl) {
+      const { GetQueueAttributesCommand } = await importSqs();
+      const result = await client.send(
+        new GetQueueAttributesCommand({
+          QueueUrl: queueUrl,
+          AttributeNames: ["ApproximateNumberOfMessages"]
+        })
+      );
+      return parseInt(result.Attributes?.ApproximateNumberOfMessages ?? "0", 10);
+    }
+  };
+}
+var SQS_MODULE = "@aws-sdk/client-sqs";
+async function importSqs() {
+  try {
+    return await import(SQS_MODULE);
+  } catch {
+    throw new Error(
+      `Missing optional dependency "${SQS_MODULE}". Install @aws-sdk/client-sqs to use the SQS driver or createSqsAdapter.`
+    );
+  }
+}
+var SqsDriver = class {
+  adapter;
+  options;
+  failedJobs = /* @__PURE__ */ new Map();
+  receiptHandles = /* @__PURE__ */ new Map();
+  constructor(adapter, options) {
+    this.adapter = adapter;
+    this.options = options;
+  }
+  async push(job) {
+    const delaySeconds = Math.min(
+      900,
+      Math.max(0, Math.floor((job.availableAt.getTime() - Date.now()) / 1e3))
+    );
+    await this.adapter.sendMessage({
+      queueUrl: this.resolveQueueUrl(job.queue),
+      messageBody: JSON.stringify(job),
+      delaySeconds,
+      messageGroupId: this.options.messageGroupId,
+      messageDeduplicationId: this.options.messageGroupId ? job.id : void 0
+    });
+  }
+  async pop(queue) {
+    const result = await this.adapter.receiveMessage({
+      queueUrl: this.resolveQueueUrl(queue)
+    });
+    if (!result) return null;
+    const job = deserializeJob(result.body);
+    this.receiptHandles.set(job.id, result.receiptHandle);
+    job.reservedAt = /* @__PURE__ */ new Date();
+    return job;
+  }
+  async release(job, delayMs = 0) {
+    const receiptHandle = this.receiptHandles.get(job.id);
+    if (receiptHandle) {
+      await this.adapter.changeMessageVisibility({
+        queueUrl: this.resolveQueueUrl(job.queue),
+        receiptHandle,
+        visibilityTimeout: Math.ceil(delayMs / 1e3)
+      });
+      this.receiptHandles.delete(job.id);
+    } else {
+      job.reservedAt = null;
+      job.availableAt = new Date(Date.now() + delayMs);
+      await this.push(job);
+    }
+  }
+  async delete(jobId) {
+    this.receiptHandles.delete(jobId);
+  }
+  async fail(job, error) {
+    const failedJob = {
+      ...job,
+      failedAt: /* @__PURE__ */ new Date(),
+      error: error.message,
+      stack: error.stack
+    };
+    this.failedJobs.set(job.id, failedJob);
+    this.receiptHandles.delete(job.id);
+  }
+  async size(queue) {
+    return this.adapter.getApproximateMessageCount(this.resolveQueueUrl(queue));
+  }
+  async getFailedJobs(queue) {
+    const jobs = [];
+    for (const job of this.failedJobs.values()) {
+      if (!queue || job.queue === queue) {
+        jobs.push({ ...job });
+      }
+    }
+    return jobs.sort((a, b) => b.failedAt.getTime() - a.failedAt.getTime());
+  }
+  async retryFailedJob(jobId) {
+    const failedJob = this.failedJobs.get(jobId);
+    if (!failedJob) {
+      throw new Error(`Failed job not found: ${jobId}`);
+    }
+    const job = {
+      id: failedJob.id,
+      name: failedJob.name,
+      payload: failedJob.payload,
+      queue: failedJob.queue,
+      attempts: 0,
+      maxAttempts: failedJob.maxAttempts,
+      availableAt: /* @__PURE__ */ new Date(),
+      createdAt: /* @__PURE__ */ new Date(),
+      reservedAt: null
+    };
+    await this.push(job);
+    this.failedJobs.delete(jobId);
+  }
+  async deleteFailedJob(jobId) {
+    this.failedJobs.delete(jobId);
+  }
+  async clear() {
+    this.failedJobs.clear();
+    this.receiptHandles.clear();
+  }
+  resolveQueueUrl(queue) {
+    return this.options.queueUrls?.[queue] ?? this.options.queueUrl;
+  }
+};
+function deserializeJob(body) {
+  const raw = JSON.parse(body);
+  return {
+    ...raw,
+    availableAt: new Date(raw.availableAt),
+    createdAt: new Date(raw.createdAt),
+    reservedAt: raw.reservedAt ? new Date(raw.reservedAt) : null
+  };
+}
+
+// src/queue/Worker.ts
+var Worker = class {
+  constructor(driver, options = {}, events = {}) {
+    this.driver = driver;
+    this.options = options;
+    this.events = events;
+    this.queues = options.queues ?? ["default"];
+    this.sleep = options.sleep ?? 1e3;
+    this.maxJobs = options.maxJobs ?? 0;
+    this.timeout = options.timeout ?? 6e4;
+    this.stopWhenEmpty = options.stopWhenEmpty ?? false;
+  }
+  running = false;
+  shouldStop = false;
+  processedJobs = 0;
+  queues;
+  sleep;
+  maxJobs;
+  timeout;
+  stopWhenEmpty;
+  currentJob = null;
+  /**
+   * Start the worker.
+   */
+  async start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.shouldStop = false;
+    this.processedJobs = 0;
+    this.events.workerStarted?.();
+    while (!this.shouldStop) {
+      if (this.maxJobs > 0 && this.processedJobs >= this.maxJobs) {
+        break;
+      }
+      const job = await this.getNextJob();
+      if (job) {
+        await this.processJob(job);
+        this.processedJobs++;
+      } else {
+        if (this.stopWhenEmpty) {
+          break;
+        }
+        await this.sleepMs(this.sleep);
+      }
+    }
+    this.running = false;
+    this.events.workerStopped?.();
+  }
+  /**
+   * Stop the worker gracefully.
+   */
+  async stop() {
+    this.shouldStop = true;
+    const startWait = Date.now();
+    while (this.running && this.currentJob && Date.now() - startWait < this.timeout) {
+      await this.sleepMs(100);
+    }
+  }
+  /**
+   * Check if the worker is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Get the number of processed jobs.
+   */
+  getProcessedJobsCount() {
+    return this.processedJobs;
+  }
+  /**
+   * Get the next available job from the queues.
+   */
+  async getNextJob() {
+    for (const queue of this.queues) {
+      const job = await this.driver.pop(queue);
+      if (job) {
+        return job;
+      }
+    }
+    return null;
+  }
+  /**
+   * Process a single job.
+   */
+  async processJob(job) {
+    this.currentJob = job;
+    job.attempts++;
+    const JobClass = getJob(job.name);
+    if (!JobClass) {
+      console.error(`Job class not found: ${job.name}`);
+      await this.driver.fail(job, new Error(`Job class not found: ${job.name}`));
+      this.currentJob = null;
+      return;
+    }
+    try {
+      const instance = new JobClass();
+      await this.executeWithTimeout(
+        async () => instance.handle(job.payload),
+        this.timeout
+      );
+      await this.driver.delete(job.id);
+      this.events.jobProcessed?.(job);
+    } catch (error) {
+      await this.handleFailedJob(job, error, JobClass);
+    } finally {
+      this.currentJob = null;
+    }
+  }
+  /**
+   * Handle a failed job.
+   */
+  async handleFailedJob(job, error, JobClass) {
+    const willRetry = job.attempts < job.maxAttempts;
+    if (willRetry) {
+      const delay = JobClass.calculateRetryDelay(job.attempts);
+      job.lastError = error.message;
+      await this.driver.release(job, delay);
+    } else {
+      await this.driver.fail(job, error);
+      try {
+        const instance = new JobClass();
+        if (instance.failed) {
+          await instance.failed(job.payload, error);
+        }
+      } catch (failedError) {
+        console.error(`Error in job.failed() handler:`, failedError);
+      }
+    }
+    console.error(JSON.stringify({
+      level: "error",
+      msg: `Job failed: ${job.name}`,
+      job: job.name,
+      queue: job.queue ?? "default",
+      attempt: job.attempts,
+      maxAttempts: job.maxAttempts,
+      willRetry,
+      error: error.message
+    }));
+    this.events.jobFailed?.(job, error, willRetry);
+  }
+  /**
+   * Execute a function with a timeout.
+   */
+  async executeWithTimeout(fn, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Job timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      fn().then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Sleep for a given number of milliseconds.
+   */
+  sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+async function processJob(driver, queue = "default") {
+  const worker = new Worker(driver, { queues: [queue], maxJobs: 1, stopWhenEmpty: true });
+  await worker.start();
+  return worker.getProcessedJobsCount() > 0;
+}
+
+// src/queue/FailedJobReporter.ts
+function defaultLogHandler(info) {
+  console.error(JSON.stringify({
+    level: "error",
+    msg: `Job failed: ${info.jobName}`,
+    job: info.jobName,
+    queue: info.queue,
+    attempt: info.attempt,
+    maxAttempts: info.maxAttempts,
+    willRetry: info.willRetry,
+    error: info.error.message,
+    failedAt: info.failedAt.toISOString()
+  }));
+}
+var FailedJobReporter = class {
+  handlers = [];
+  constructor() {
+    this.handlers.push(defaultLogHandler);
+  }
+  /** Add a custom handler for failed jobs. */
+  onFailure(handler) {
+    this.handlers.push(handler);
+    return this;
+  }
+  /** Report a job failure to all registered handlers. */
+  async report(info) {
+    for (const handler of this.handlers) {
+      try {
+        await handler(info);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/queue/QueueManager.ts
+var QueueManager = class {
+  defaultDriver;
+  driverFactories = /* @__PURE__ */ new Map();
+  resolvedDrivers = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.defaultDriver = config.default ?? "memory";
+    if (config.drivers) {
+      for (const [name, factory] of Object.entries(config.drivers)) {
+        this.driverFactories.set(name, factory);
+      }
+    }
+  }
+  /**
+   * Get a queue driver by name.
+   * Returns the default driver if no name is specified.
+   */
+  driver(name) {
+    const driverName = name ?? this.defaultDriver;
+    const cached = this.resolvedDrivers.get(driverName);
+    if (cached) {
+      return cached;
+    }
+    const factory = this.driverFactories.get(driverName);
+    if (!factory) {
+      throw new Error(`Queue driver not found: ${driverName}`);
+    }
+    const driver = factory();
+    this.resolvedDrivers.set(driverName, driver);
+    if (driverName === this.defaultDriver) {
+      setQueueDriver(driver);
+    }
+    return driver;
+  }
+  /**
+   * Register a custom driver factory.
+   */
+  registerDriver(name, factory) {
+    this.driverFactories.set(name, factory);
+    this.resolvedDrivers.delete(name);
+  }
+  /**
+   * Check if a driver is registered.
+   */
+  hasDriver(name) {
+    return this.driverFactories.has(name);
+  }
+  /**
+   * Get the default driver name.
+   */
+  getDefaultDriverName() {
+    return this.defaultDriver;
+  }
+  /**
+   * Get all registered driver names.
+   */
+  getDriverNames() {
+    return Array.from(this.driverFactories.keys());
+  }
+  /**
+   * Set the default driver and update global driver.
+   */
+  setDefaultDriver(name) {
+    if (!this.driverFactories.has(name)) {
+      throw new Error(`Queue driver not found: ${name}`);
+    }
+    const driver = this.driver(name);
+    setQueueDriver(driver);
+  }
+};
+function createQueueManager(config) {
+  return new QueueManager(config);
+}
+export {
+  FailedJobReporter,
+  Job,
+  MemoryDriver,
+  QueueManager,
+  RedisDriver,
+  SqsDriver,
+  Worker,
+  clearJobRegistry,
+  createQueueManager,
+  createSqsAdapter,
+  getJob,
+  getQueueDriver,
+  getRegisteredJobs,
+  processJob,
+  registerJob,
+  setQueueDriver
+};