@zucker-framework/queue 1.0.0

package/dist/index.js

@@ -0,0 +1,911 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BullMqQueueEvents: () => BullMqQueueEvents,
+  BullMqQueueProvider: () => BullMqQueueProvider,
+  BullMqWorkerHost: () => BullMqWorkerHost,
+  InMemoryQueue: () => InMemoryQueue,
+  QUEUE_PROVIDER: () => QUEUE_PROVIDER,
+  QUEUE_WORKER_KEY: () => QUEUE_WORKER_KEY,
+  QueueService: () => QueueService,
+  QueueWorker: () => QueueWorker,
+  TaskLifecycleManager: () => TaskLifecycleManager,
+  ZuckerQueueModule: () => ZuckerQueueModule,
+  bullMqConnectionFromUrl: () => bullMqConnectionFromUrl
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/queue.interface.ts
+var QUEUE_PROVIDER = "QUEUE_PROVIDER";
+
+// src/in-memory-queue.ts
+var import_common = require("@nestjs/common");
+var InMemoryQueue = class _InMemoryQueue {
+  static {
+    __name(this, "InMemoryQueue");
+  }
+  logger = new import_common.Logger(_InMemoryQueue.name);
+  queues = /* @__PURE__ */ new Map();
+  paused = /* @__PURE__ */ new Set();
+  counter = 0;
+  /** timer 引用：queueName:jobId → timer */
+  delayTimers = /* @__PURE__ */ new Map();
+  getQueue(name) {
+    let q = this.queues.get(name);
+    if (!q) {
+      q = /* @__PURE__ */ new Map();
+      this.queues.set(name, q);
+    }
+    return q;
+  }
+  nextId() {
+    return String(++this.counter);
+  }
+  async add(queueName, data, options) {
+    const q = this.getQueue(queueName);
+    const id = options?.jobId ?? this.nextId();
+    const job = {
+      id,
+      data,
+      status: "waiting",
+      progress: 0,
+      attempts: 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    q.set(id, job);
+    return job;
+  }
+  async ensure(queueName, data, options) {
+    const existing = await this.getJob(queueName, options.jobId);
+    if (existing && existing.status !== "completed" && existing.status !== "failed") {
+      return existing;
+    }
+    if (existing) await this.removeJob(queueName, options.jobId);
+    return this.add(queueName, data, options);
+  }
+  async addDelayed(queueName, data, delayMs, options) {
+    const q = this.getQueue(queueName);
+    const id = options?.jobId ?? this.nextId();
+    const job = {
+      id,
+      data,
+      status: "delayed",
+      progress: 0,
+      attempts: 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    q.set(id, job);
+    const timerKey = `${queueName}:${id}`;
+    const timer = setTimeout(() => {
+      this.delayTimers.delete(timerKey);
+      const existing = q.get(id);
+      if (existing && existing.status === "delayed") {
+        existing.status = "waiting";
+      }
+    }, delayMs);
+    this.delayTimers.set(timerKey, timer);
+    return job;
+  }
+  async addRepeatable(queueName, data, pattern, options) {
+    this.logger.warn(`InMemoryQueue \u4E0D\u652F\u6301\u5B9A\u65F6\u4EFB\u52A1\u3002pattern "${pattern}" \u88AB\u5FFD\u7565\uFF0C\u4EC5\u521B\u5EFA\u4E00\u6B21\u6027\u4EFB\u52A1\u3002\u751F\u4EA7\u73AF\u5883\u8BF7\u4F7F\u7528 BullMQ\u3002`);
+    return this.add(queueName, data, options);
+  }
+  async getJob(queueName, jobId) {
+    const q = this.getQueue(queueName);
+    return q.get(jobId) ?? null;
+  }
+  async removeJob(queueName, jobId) {
+    const q = this.getQueue(queueName);
+    q.delete(jobId);
+    const timerKey = `${queueName}:${jobId}`;
+    const timer = this.delayTimers.get(timerKey);
+    if (timer) {
+      clearTimeout(timer);
+      this.delayTimers.delete(timerKey);
+    }
+  }
+  async pause(queueName) {
+    this.paused.add(queueName);
+  }
+  async resume(queueName) {
+    this.paused.delete(queueName);
+  }
+  async getStats(queueName) {
+    const q = this.getQueue(queueName);
+    const stats = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0
+    };
+    for (const job of q.values()) {
+      if (job.status !== "unknown") stats[job.status]++;
+    }
+    return stats;
+  }
+  onModuleDestroy() {
+    for (const timer of this.delayTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.delayTimers.clear();
+  }
+};
+
+// src/bullmq-queue.provider.ts
+var import_node_crypto = require("crypto");
+var import_bullmq = require("bullmq");
+var BullMqQueueProvider = class {
+  static {
+    __name(this, "BullMqQueueProvider");
+  }
+  options;
+  queues = /* @__PURE__ */ new Map();
+  defaultJobName;
+  queueFactory;
+  constructor(options) {
+    this.options = options;
+    this.defaultJobName = options.defaultJobName ?? "task";
+    this.queueFactory = options.queueFactory ?? ((name, queueOptions) => new import_bullmq.Queue(name, queueOptions));
+  }
+  async add(queueName, data, options) {
+    this.assertValidJobId(options?.jobId);
+    const job = await this.getQueue(queueName).add(options?.name ?? this.defaultJobName, data, this.toBullMqOptions(options));
+    return this.toJob(job);
+  }
+  async ensure(queueName, data, options) {
+    this.assertValidJobId(options.jobId);
+    const queue = this.getQueue(queueName);
+    const existing = await queue.getJob(options.jobId);
+    if (existing) {
+      const state = await existing.getState();
+      if (state !== "completed" && state !== "failed") {
+        return this.toJob(existing);
+      }
+      await existing.remove();
+    }
+    return this.add(queueName, data, options);
+  }
+  async addDelayed(queueName, data, delayMs, options) {
+    if (delayMs < 0) throw new RangeError("delayMs cannot be negative");
+    this.assertValidJobId(options?.jobId);
+    const job = await this.getQueue(queueName).add(options?.name ?? this.defaultJobName, data, {
+      ...this.toBullMqOptions(options),
+      delay: delayMs
+    });
+    return this.toJob(job);
+  }
+  async addRepeatable(queueName, data, pattern, options) {
+    this.assertValidJobId(options?.jobId);
+    const name = options?.name ?? this.defaultJobName;
+    const schedulerId = options?.jobId ?? `scheduler-${(0, import_node_crypto.createHash)("sha256").update(name).update("\0").update(pattern).digest("hex")}`;
+    const job = await this.getQueue(queueName).upsertJobScheduler(schedulerId, {
+      pattern
+    }, {
+      name,
+      data,
+      opts: this.toBullMqSchedulerOptions(options)
+    });
+    return this.toJob(job);
+  }
+  async getJob(queueName, jobId) {
+    const job = await this.getQueue(queueName).getJob(jobId);
+    return job ? this.toJob(job) : null;
+  }
+  async removeJob(queueName, jobId) {
+    const job = await this.getQueue(queueName).getJob(jobId);
+    if (job) await job.remove();
+  }
+  async pause(queueName) {
+    await this.getQueue(queueName).pause();
+  }
+  async resume(queueName) {
+    await this.getQueue(queueName).resume();
+  }
+  async getStats(queueName) {
+    const pausedStateForStats = "paused";
+    const counts = await this.getQueue(queueName).getJobCounts("wait", "active", "completed", "failed", "delayed", "prioritized", pausedStateForStats);
+    return {
+      waiting: (counts.wait ?? 0) + (counts.prioritized ?? 0) + (counts.paused ?? 0),
+      active: counts.active ?? 0,
+      completed: counts.completed ?? 0,
+      failed: counts.failed ?? 0,
+      delayed: counts.delayed ?? 0
+    };
+  }
+  async waitUntilReady() {
+    await Promise.all([
+      ...this.queues.values()
+    ].map((queue) => queue.waitUntilReady()));
+  }
+  async close() {
+    const queues = [
+      ...this.queues.values()
+    ];
+    this.queues.clear();
+    await Promise.all(queues.map((queue) => queue.close()));
+  }
+  async onModuleDestroy() {
+    await this.close();
+  }
+  getQueue(name) {
+    const existing = this.queues.get(name);
+    if (existing) return existing;
+    const queue = this.queueFactory(name, {
+      connection: this.options.connection,
+      prefix: this.options.prefix
+    });
+    this.queues.set(name, queue);
+    return queue;
+  }
+  toBullMqOptions(options) {
+    if (!options) return void 0;
+    return {
+      jobId: options.jobId,
+      deduplication: options.deduplicationId ? {
+        id: options.deduplicationId
+      } : void 0,
+      priority: options.priority,
+      attempts: options.attempts,
+      backoff: options.backoff,
+      removeOnComplete: options.removeOnComplete,
+      removeOnFail: options.removeOnFail
+    };
+  }
+  toBullMqSchedulerOptions(options) {
+    if (!options) return void 0;
+    return {
+      priority: options.priority,
+      attempts: options.attempts,
+      backoff: options.backoff,
+      removeOnComplete: options.removeOnComplete,
+      removeOnFail: options.removeOnFail
+    };
+  }
+  assertValidJobId(jobId) {
+    if (jobId?.includes(":")) {
+      throw new TypeError("BullMQ jobId cannot contain a colon");
+    }
+  }
+  async toJob(job) {
+    const state = await job.getState();
+    return {
+      id: String(job.id),
+      data: job.data,
+      status: this.mapState(state),
+      progress: job.progress,
+      attempts: job.attemptsMade,
+      failedReason: job.failedReason || void 0,
+      createdAt: new Date(job.timestamp),
+      processedAt: job.processedOn ? new Date(job.processedOn) : void 0,
+      completedAt: job.finishedOn ? new Date(job.finishedOn) : void 0
+    };
+  }
+  mapState(state) {
+    if (state === "active" || state === "completed" || state === "failed" || state === "delayed") {
+      return state;
+    }
+    if (state === "waiting" || state === "waiting-children" || state === "prioritized" || state === "paused") {
+      return "waiting";
+    }
+    return "unknown";
+  }
+};
+
+// src/bullmq-connection.ts
+function bullMqConnectionFromUrl(redisUrl, options = {}) {
+  const parsed = new URL(redisUrl);
+  if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+    throw new TypeError("BullMQ connection URL must use redis:// or rediss://");
+  }
+  const databasePath = parsed.pathname.replace(/^\//, "");
+  const database = databasePath === "" ? 0 : Number(databasePath);
+  if (!Number.isInteger(database) || database < 0) {
+    throw new TypeError("BullMQ Redis database must be a non-negative integer");
+  }
+  return {
+    host: parsed.hostname,
+    port: parsed.port ? Number(parsed.port) : 6379,
+    username: parsed.username ? decodeURIComponent(parsed.username) : void 0,
+    password: parsed.password ? decodeURIComponent(parsed.password) : void 0,
+    db: database,
+    tls: parsed.protocol === "rediss:" ? {} : void 0,
+    maxRetriesPerRequest: options.role === "worker" ? null : 1
+  };
+}
+__name(bullMqConnectionFromUrl, "bullMqConnectionFromUrl");
+
+// src/bullmq-worker-host.ts
+var import_bullmq2 = require("bullmq");
+var BullMqWorkerHost = class {
+  static {
+    __name(this, "BullMqWorkerHost");
+  }
+  options;
+  workers = /* @__PURE__ */ new Map();
+  readyQueues = /* @__PURE__ */ new Set();
+  workerFactory;
+  constructor(options) {
+    this.options = options;
+    this.workerFactory = options.workerFactory ?? ((queueName, processor, workerOptions) => new import_bullmq2.Worker(queueName, processor, workerOptions));
+  }
+  register(definition) {
+    if (this.workers.has(definition.queueName)) {
+      throw new Error(`Worker already registered for queue: ${definition.queueName}`);
+    }
+    if ((definition.concurrency ?? 1) < 1) throw new RangeError("concurrency must be at least 1");
+    if ((definition.lockDurationMs ?? 3e4) < 1) {
+      throw new RangeError("lockDurationMs must be at least 1");
+    }
+    const worker = this.workerFactory(definition.queueName, async (job) => definition.handler({
+      id: String(job.id),
+      name: job.name,
+      data: job.data,
+      attempt: job.attemptsMade + 1,
+      updateProgress: /* @__PURE__ */ __name((progress) => job.updateProgress(progress), "updateProgress"),
+      log: /* @__PURE__ */ __name((message) => job.log(message), "log")
+    }), {
+      connection: this.options.connection,
+      prefix: this.options.prefix,
+      concurrency: definition.concurrency ?? 1,
+      lockDuration: definition.lockDurationMs ?? 3e4,
+      autorun: definition.autorun ?? true
+    });
+    worker.on("ready", () => this.readyQueues.add(definition.queueName));
+    worker.on("error", (error) => {
+      this.readyQueues.delete(definition.queueName);
+      this.options.onError?.(definition.queueName, error);
+    });
+    this.workers.set(definition.queueName, worker);
+  }
+  async waitUntilReady() {
+    await Promise.all([
+      ...this.workers.values()
+    ].map((worker) => worker.waitUntilReady()));
+    for (const queueName of this.workers.keys()) this.readyQueues.add(queueName);
+  }
+  health() {
+    const registeredQueues = [
+      ...this.workers.keys()
+    ];
+    const runningQueues = registeredQueues.filter((queueName) => this.workers.get(queueName)?.isRunning());
+    return {
+      ready: registeredQueues.length > 0 && this.readyQueues.size === registeredQueues.length && runningQueues.length === registeredQueues.length,
+      registeredQueues,
+      runningQueues
+    };
+  }
+  /**
+  * Actively verifies the Redis connections behind every worker.
+  *
+  * BullMQ's ready/error events cannot detect a half-open connection where the
+  * TCP socket still exists but Redis no longer answers. Readiness endpoints
+  * should use this bounded probe instead of relying on lifecycle events alone.
+  */
+  async probeHealth(timeoutMs = 1e3) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+      throw new RangeError("timeoutMs must be at least 1");
+    }
+    const current = this.health();
+    if (!current.ready) return current;
+    let timer;
+    try {
+      await Promise.race([
+        Promise.all([
+          ...this.workers.values()
+        ].map(async (worker) => {
+          const client = await worker.getBackend().client;
+          await client.get(worker.toKey("health-probe"));
+        })),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Redis worker health probe timed out")), timeoutMs);
+          timer.unref?.();
+        })
+      ]);
+      return this.health();
+    } catch {
+      return {
+        ...this.health(),
+        ready: false
+      };
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  run(queueName) {
+    const worker = this.requireWorker(queueName);
+    if (worker.isRunning()) return;
+    void worker.run().catch((error) => this.options.onError?.(queueName, error));
+  }
+  async pause() {
+    await Promise.all([
+      ...this.workers.values()
+    ].map((worker) => worker.pause()));
+  }
+  async resume() {
+    await Promise.all([
+      ...this.workers.values()
+    ].map((worker) => worker.resume()));
+  }
+  async close(force = false) {
+    const workers = [
+      ...this.workers.values()
+    ];
+    this.workers.clear();
+    this.readyQueues.clear();
+    await Promise.all(workers.map((worker) => worker.close(force)));
+  }
+  async onModuleDestroy() {
+    await this.close();
+  }
+  requireWorker(queueName) {
+    const worker = this.workers.get(queueName);
+    if (!worker) throw new Error(`No worker registered for queue: ${queueName}`);
+    return worker;
+  }
+};
+
+// src/bullmq-queue-events.ts
+var import_bullmq3 = require("bullmq");
+var BullMqQueueEvents = class {
+  static {
+    __name(this, "BullMqQueueEvents");
+  }
+  options;
+  listeners = /* @__PURE__ */ new Map();
+  queueEventsFactory;
+  constructor(options) {
+    this.options = options;
+    this.queueEventsFactory = options.queueEventsFactory ?? ((queueName, queueOptions) => new import_bullmq3.QueueEvents(queueName, queueOptions));
+  }
+  listen(queueName, handlers) {
+    const queueEvents = this.getQueueEvents(queueName);
+    const subscriptions = [];
+    if (handlers.completed) {
+      const handler = /* @__PURE__ */ __name(({ jobId, returnvalue }) => handlers.completed?.({
+        queueName,
+        jobId,
+        returnvalue
+      }), "handler");
+      queueEvents.on("completed", handler);
+      subscriptions.push(() => queueEvents.off("completed", handler));
+    }
+    if (handlers.failed) {
+      const handler = /* @__PURE__ */ __name(({ jobId, failedReason }) => handlers.failed?.({
+        queueName,
+        jobId,
+        failedReason
+      }), "handler");
+      queueEvents.on("failed", handler);
+      subscriptions.push(() => queueEvents.off("failed", handler));
+    }
+    if (handlers.progress) {
+      const handler = /* @__PURE__ */ __name(({ jobId, data }) => handlers.progress?.({
+        queueName,
+        jobId,
+        data
+      }), "handler");
+      queueEvents.on("progress", handler);
+      subscriptions.push(() => queueEvents.off("progress", handler));
+    }
+    if (handlers.waiting) {
+      const handler = /* @__PURE__ */ __name(({ jobId }) => handlers.waiting?.({
+        queueName,
+        jobId
+      }), "handler");
+      queueEvents.on("waiting", handler);
+      subscriptions.push(() => queueEvents.off("waiting", handler));
+    }
+    if (handlers.active) {
+      const handler = /* @__PURE__ */ __name(({ jobId }) => handlers.active?.({
+        queueName,
+        jobId
+      }), "handler");
+      queueEvents.on("active", handler);
+      subscriptions.push(() => queueEvents.off("active", handler));
+    }
+    return () => {
+      for (const unsubscribe of subscriptions) unsubscribe();
+    };
+  }
+  async waitUntilReady() {
+    await Promise.all([
+      ...this.listeners.values()
+    ].map((listener) => listener.waitUntilReady()));
+  }
+  async close() {
+    const listeners = [
+      ...this.listeners.values()
+    ];
+    this.listeners.clear();
+    await Promise.all(listeners.map((listener) => listener.close()));
+  }
+  async onModuleDestroy() {
+    await this.close();
+  }
+  getQueueEvents(queueName) {
+    const existing = this.listeners.get(queueName);
+    if (existing) return existing;
+    const queueEvents = this.queueEventsFactory(queueName, {
+      connection: this.options.connection,
+      prefix: this.options.prefix
+    });
+    queueEvents.on("error", (error) => this.options.onError?.(queueName, error));
+    this.listeners.set(queueName, queueEvents);
+    return queueEvents;
+  }
+};
+
+// src/queue.service.ts
+var import_common2 = require("@nestjs/common");
+function _ts_decorate(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;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+function _ts_param(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+}
+__name(_ts_param, "_ts_param");
+var QueueService = class {
+  static {
+    __name(this, "QueueService");
+  }
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  /** 添加任务到队列 */
+  add(queueName, data, options) {
+    return this.provider.add(queueName, data, options);
+  }
+  /** Ensure a stable transport job exists for durable queued work. */
+  ensure(queueName, data, options) {
+    return this.provider.ensure(queueName, data, options);
+  }
+  /** 添加延迟任务 */
+  addDelayed(queueName, data, delayMs, options) {
+    return this.provider.addDelayed(queueName, data, delayMs, options);
+  }
+  /** 添加定时任务 */
+  addRepeatable(queueName, data, pattern, options) {
+    return this.provider.addRepeatable(queueName, data, pattern, options);
+  }
+  /** 获取任务状态 */
+  getJob(queueName, jobId) {
+    return this.provider.getJob(queueName, jobId);
+  }
+  /** 移除任务 */
+  removeJob(queueName, jobId) {
+    return this.provider.removeJob(queueName, jobId);
+  }
+  /** 暂停队列 */
+  pause(queueName) {
+    return this.provider.pause(queueName);
+  }
+  /** 恢复队列 */
+  resume(queueName) {
+    return this.provider.resume(queueName);
+  }
+  /** 获取队列统计 */
+  getStats(queueName) {
+    return this.provider.getStats(queueName);
+  }
+};
+QueueService = _ts_decorate([
+  (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(QUEUE_PROVIDER)),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof QueueProvider === "undefined" ? Object : QueueProvider
+  ])
+], QueueService);
+
+// src/queue.module.ts
+var import_common3 = require("@nestjs/common");
+function _ts_decorate2(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;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var QUEUE_MODULE_OPTIONS = /* @__PURE__ */ Symbol("QUEUE_MODULE_OPTIONS");
+var ZuckerQueueModule = class _ZuckerQueueModule {
+  static {
+    __name(this, "ZuckerQueueModule");
+  }
+  static forRoot(options = {}) {
+    return {
+      module: _ZuckerQueueModule,
+      global: true,
+      providers: [
+        {
+          provide: QUEUE_PROVIDER,
+          useFactory: /* @__PURE__ */ __name(() => options.provider ?? new InMemoryQueue(), "useFactory")
+        },
+        QueueService
+      ],
+      exports: [
+        QUEUE_PROVIDER,
+        QueueService
+      ]
+    };
+  }
+  static forRootAsync(options) {
+    const asyncProviders = this.createAsyncProviders(options);
+    return {
+      module: _ZuckerQueueModule,
+      global: true,
+      imports: options.imports ?? [],
+      providers: [
+        ...asyncProviders,
+        {
+          provide: QUEUE_PROVIDER,
+          useFactory: /* @__PURE__ */ __name((opts) => opts.provider ?? new InMemoryQueue(), "useFactory"),
+          inject: [
+            QUEUE_MODULE_OPTIONS
+          ]
+        },
+        QueueService
+      ],
+      exports: [
+        QUEUE_PROVIDER,
+        QueueService
+      ]
+    };
+  }
+  static createAsyncProviders(options) {
+    if (options.useFactory) {
+      return [
+        {
+          provide: QUEUE_MODULE_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject ?? []
+        }
+      ];
+    }
+    const factoryType = options.useClass ?? options.useExisting;
+    if (!factoryType) {
+      throw new Error("QueueModuleAsyncOptions requires useFactory, useClass, or useExisting");
+    }
+    const optionsProvider = {
+      provide: QUEUE_MODULE_OPTIONS,
+      useFactory: /* @__PURE__ */ __name(async (factory) => factory.createQueueOptions(), "useFactory"),
+      inject: [
+        factoryType
+      ]
+    };
+    if (options.useClass) {
+      return [
+        {
+          provide: options.useClass,
+          useClass: options.useClass
+        },
+        optionsProvider
+      ];
+    }
+    return [
+      optionsProvider
+    ];
+  }
+};
+ZuckerQueueModule = _ts_decorate2([
+  (0, import_common3.Global)(),
+  (0, import_common3.Module)({})
+], ZuckerQueueModule);
+
+// src/worker.decorator.ts
+var import_common4 = require("@nestjs/common");
+var QUEUE_WORKER_KEY = "ZUCKER_QUEUE_WORKER";
+function QueueWorker(options) {
+  const opts = typeof options === "string" ? {
+    queue: options
+  } : options;
+  return (0, import_common4.SetMetadata)(QUEUE_WORKER_KEY, opts);
+}
+__name(QueueWorker, "QueueWorker");
+
+// src/task-lifecycle.ts
+var import_common5 = require("@nestjs/common");
+var taskIdCounter = 0;
+function generateTaskId() {
+  return `task_${Date.now()}_${++taskIdCounter}`;
+}
+__name(generateTaskId, "generateTaskId");
+var TaskLifecycleManager = class _TaskLifecycleManager {
+  static {
+    __name(this, "TaskLifecycleManager");
+  }
+  logger = new import_common5.Logger(_TaskLifecycleManager.name);
+  tasks = /* @__PURE__ */ new Map();
+  cancelledTasks = /* @__PURE__ */ new Set();
+  deadLetterQueue = [];
+  maxDlqSize;
+  constructor(options) {
+    this.maxDlqSize = options?.maxDlqSize ?? 100;
+  }
+  /**
+  * 提交任务并异步执行
+  */
+  submit(definition) {
+    const id = generateTaskId();
+    const info = {
+      id,
+      name: definition.name,
+      status: "pending",
+      progress: 0,
+      createdAt: Date.now(),
+      attempts: 0,
+      metadata: definition.metadata
+    };
+    this.tasks.set(id, info);
+    this.executeTask(id, definition);
+    return id;
+  }
+  /**
+  * 获取任务状态
+  */
+  getTask(id) {
+    return this.tasks.get(id);
+  }
+  /**
+  * 列出所有任务
+  */
+  listTasks(filter) {
+    const tasks = [
+      ...this.tasks.values()
+    ];
+    if (filter?.status) {
+      return tasks.filter((t) => t.status === filter.status);
+    }
+    return tasks;
+  }
+  /**
+  * 取消任务
+  */
+  kill(id) {
+    const task = this.tasks.get(id);
+    if (!task || task.status === "completed" || task.status === "failed" || task.status === "killed") {
+      return false;
+    }
+    this.cancelledTasks.add(id);
+    task.status = "killed";
+    task.completedAt = Date.now();
+    return true;
+  }
+  /**
+  * 获取死信队列中的失败任务
+  */
+  getDeadLetterQueue() {
+    return [
+      ...this.deadLetterQueue
+    ];
+  }
+  /**
+  * 清理已完成的任务（释放内存）
+  */
+  cleanup(olderThanMs = 36e5) {
+    const cutoff = Date.now() - olderThanMs;
+    let cleaned = 0;
+    for (const [id, task] of this.tasks) {
+      if ((task.status === "completed" || task.status === "failed" || task.status === "killed") && (task.completedAt ?? task.createdAt) < cutoff) {
+        this.tasks.delete(id);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  async executeTask(id, definition) {
+    const info = this.tasks.get(id);
+    const maxRetries = definition.maxRetries ?? 0;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (this.cancelledTasks.has(id)) return;
+      info.status = "running";
+      info.startedAt = Date.now();
+      info.attempts = attempt + 1;
+      const ctx = {
+        taskId: id,
+        updateProgress: /* @__PURE__ */ __name((progress, message) => {
+          info.progress = Math.max(0, Math.min(1, progress));
+          info.progressMessage = message;
+        }, "updateProgress"),
+        isCancelled: /* @__PURE__ */ __name(() => this.cancelledTasks.has(id), "isCancelled")
+      };
+      try {
+        const resultPromise = definition.handler(ctx);
+        let result;
+        if (definition.timeoutMs) {
+          result = await Promise.race([
+            resultPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error(`Task timeout after ${definition.timeoutMs}ms`)), definition.timeoutMs))
+          ]);
+        } else {
+          result = await resultPromise;
+        }
+        if (this.cancelledTasks.has(id)) return;
+        info.status = "completed";
+        info.progress = 1;
+        info.result = result;
+        info.completedAt = Date.now();
+        return;
+      } catch (error) {
+        if (this.cancelledTasks.has(id)) return;
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (attempt < maxRetries) {
+          this.logger.warn(`Task "${info.name}" attempt ${attempt + 1} failed: ${errorMsg}. Retrying...`);
+          await new Promise((r) => setTimeout(r, 1e3 * Math.pow(2, attempt)));
+          continue;
+        }
+        info.status = "failed";
+        info.error = errorMsg;
+        info.completedAt = Date.now();
+        if (this.deadLetterQueue.length >= this.maxDlqSize) {
+          this.deadLetterQueue.shift();
+        }
+        this.deadLetterQueue.push({
+          ...info
+        });
+        this.logger.error(`Task "${info.name}" failed after ${info.attempts} attempts: ${errorMsg}`);
+      }
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BullMqQueueEvents,
+  BullMqQueueProvider,
+  BullMqWorkerHost,
+  InMemoryQueue,
+  QUEUE_PROVIDER,
+  QUEUE_WORKER_KEY,
+  QueueService,
+  QueueWorker,
+  TaskLifecycleManager,
+  ZuckerQueueModule,
+  bullMqConnectionFromUrl
+});