@igniter-js/jobs 0.1.0

package/dist/adapters/bullmq.adapter.js

@@ -0,0 +1,598 @@
+'use strict';
+
+var core = require('@igniter-js/core');
+
+// src/errors/igniter-jobs.error.ts
+var IgniterJobsError = class _IgniterJobsError extends core.IgniterError {
+  constructor(options) {
+    super({
+      code: options.code,
+      message: options.message,
+      statusCode: options.statusCode ?? 500,
+      causer: "@igniter-js/jobs",
+      cause: options.cause,
+      details: options.details,
+      logger: options.logger
+    });
+    this.code = options.code;
+    this.details = options.details;
+    this.name = "IgniterJobsError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _IgniterJobsError);
+    }
+  }
+  /**
+   * Convert error to a plain object for serialization.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details,
+      stack: this.stack
+    };
+  }
+};
+
+// src/adapters/bullmq.adapter.ts
+var BullMQAdapter = class _BullMQAdapter {
+  constructor(options) {
+    this.queues = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.queueEvents = /* @__PURE__ */ new Map();
+    this.BullMQ = null;
+    this.redis = options.redis;
+  }
+  /**
+   * Create a new BullMQ adapter.
+   *
+   * @param options - Adapter options with Redis connection
+   * @returns A new BullMQAdapter instance
+   */
+  static create(options) {
+    return new _BullMQAdapter(options);
+  }
+  /**
+   * Get the underlying Redis client.
+   */
+  get client() {
+    return this.redis;
+  }
+  /**
+   * Lazily load BullMQ module.
+   */
+  async getBullMQ() {
+    if (!this.BullMQ) {
+      this.BullMQ = await import('bullmq');
+    }
+    return this.BullMQ;
+  }
+  /**
+   * Get or create a queue instance.
+   */
+  async getOrCreateQueue(name) {
+    if (!this.queues.has(name)) {
+      const { Queue } = await this.getBullMQ();
+      const queue = new Queue(name, {
+        connection: this.redis
+      });
+      this.queues.set(name, queue);
+    }
+    return this.queues.get(name);
+  }
+  /**
+   * Get or create queue events instance.
+   */
+  async getQueueEvents(name) {
+    if (!this.queueEvents.has(name)) {
+      const { QueueEvents } = await this.getBullMQ();
+      const events = new QueueEvents(name, {
+        connection: this.redis
+      });
+      this.queueEvents.set(name, events);
+    }
+    return this.queueEvents.get(name);
+  }
+  /**
+   * Convert BullMQ job state to IgniterJobStatus.
+   */
+  mapJobState(state) {
+    const stateMap = {
+      waiting: "waiting",
+      active: "active",
+      completed: "completed",
+      failed: "failed",
+      delayed: "delayed",
+      paused: "paused",
+      "waiting-children": "waiting"
+    };
+    return stateMap[state] || "waiting";
+  }
+  /**
+   * Convert BullMQ job to IgniterJobInfo.
+   */
+  async mapJobToInfo(job) {
+    const data = job.data;
+    const state = await job.getState();
+    return {
+      id: job.id,
+      name: job.name,
+      queue: job.queueName,
+      state: this.mapJobState(state || "waiting"),
+      data: data.input ?? data,
+      result: job.returnvalue,
+      error: job.failedReason,
+      progress: typeof job.progress === "number" ? job.progress : 0,
+      attempts: job.attemptsMade,
+      timestamp: job.timestamp,
+      processedOn: job.processedOn,
+      finishedOn: job.finishedOn,
+      delay: job.delay,
+      priority: job.opts?.priority,
+      scope: data.scope,
+      actor: data.actor,
+      metadata: data.metadata
+    };
+  }
+  // ==========================================
+  // JOB OPERATIONS
+  // ==========================================
+  async dispatch(params) {
+    const queue = await this.getOrCreateQueue(params.queue);
+    const jobOptions = {
+      jobId: params.jobId,
+      delay: params.delay,
+      priority: params.priority,
+      attempts: params.attempts ?? 3,
+      backoff: params.backoff ? {
+        type: params.backoff.type === "custom" ? "fixed" : params.backoff.type,
+        delay: params.backoff.type === "custom" ? params.backoff.delays[0] : params.backoff.delay
+      } : void 0,
+      removeOnComplete: params.removeOnComplete,
+      removeOnFail: params.removeOnFail
+    };
+    const jobData = {
+      input: params.data,
+      scope: params.scope,
+      actor: params.actor
+    };
+    const job = await queue.add(params.name, jobData, jobOptions);
+    return job.id;
+  }
+  async schedule(params) {
+    const queue = await this.getOrCreateQueue(params.queue);
+    const jobOptions = {
+      jobId: params.jobId,
+      delay: params.at ? params.at.getTime() - Date.now() : params.delay,
+      priority: params.priority,
+      attempts: params.attempts ?? 3,
+      backoff: params.backoff ? {
+        type: params.backoff.type === "custom" ? "fixed" : params.backoff.type,
+        delay: params.backoff.type === "custom" ? params.backoff.delays[0] : params.backoff.delay
+      } : void 0,
+      removeOnComplete: params.removeOnComplete,
+      removeOnFail: params.removeOnFail,
+      repeat: params.cron ? {
+        pattern: params.cron,
+        tz: params.timezone
+      } : params.every ? {
+        every: params.every
+      } : void 0
+    };
+    const jobData = {
+      input: params.data,
+      scope: params.scope,
+      actor: params.actor
+    };
+    const job = await queue.add(params.name, jobData, jobOptions);
+    return job.id;
+  }
+  async getJob(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) return null;
+    return await this.mapJobToInfo(job);
+  }
+  async getJobState(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) return null;
+    const state = await job.getState();
+    return this.mapJobState(state);
+  }
+  async getJobProgress(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) return 0;
+    return typeof job.progress === "number" ? job.progress : 0;
+  }
+  async getJobLogs(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) return [];
+    const { logs } = await q.getJobLogs(jobId);
+    return logs.map((log, index) => ({
+      timestamp: /* @__PURE__ */ new Date(),
+      message: log,
+      level: "info"
+    }));
+  }
+  async retryJob(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}"`,
+        statusCode: 404
+      });
+    }
+    await job.retry();
+  }
+  async removeJob(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) return;
+    await job.remove();
+  }
+  async promoteJob(queue, jobId) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}"`,
+        statusCode: 404
+      });
+    }
+    await job.promote();
+  }
+  async moveJob(queue, jobId, state, reason) {
+    const q = await this.getOrCreateQueue(queue);
+    const job = await q.getJob(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}"`,
+        statusCode: 404
+      });
+    }
+    if (state === "failed") {
+      await job.moveToFailed(new Error(reason || "Manually moved to failed"), "manual");
+    } else {
+      await job.moveToCompleted(reason || "Manually completed", "manual");
+    }
+  }
+  async retryJobs(queue, jobIds) {
+    const q = await this.getOrCreateQueue(queue);
+    await Promise.all(
+      jobIds.map(async (jobId) => {
+        const job = await q.getJob(jobId);
+        if (job) await job.retry();
+      })
+    );
+  }
+  async removeJobs(queue, jobIds) {
+    const q = await this.getOrCreateQueue(queue);
+    await Promise.all(
+      jobIds.map(async (jobId) => {
+        const job = await q.getJob(jobId);
+        if (job) await job.remove();
+      })
+    );
+  }
+  // ==========================================
+  // QUEUE OPERATIONS
+  // ==========================================
+  async getQueue(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    const isPaused = await q.isPaused();
+    const counts = await q.getJobCounts();
+    return {
+      name: queue,
+      isPaused,
+      jobCounts: {
+        waiting: counts.waiting || 0,
+        active: counts.active || 0,
+        completed: counts.completed || 0,
+        failed: counts.failed || 0,
+        delayed: counts.delayed || 0,
+        paused: counts.paused || 0
+      }
+    };
+  }
+  async pauseQueue(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    await q.pause();
+  }
+  async resumeQueue(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    await q.resume();
+  }
+  async drainQueue(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    await q.drain();
+    return 0;
+  }
+  async cleanQueue(queue, options) {
+    const q = await this.getOrCreateQueue(queue);
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    let total = 0;
+    for (const status of statuses) {
+      const cleaned = await q.clean(
+        options.olderThan ?? 0,
+        options.limit ?? 1e3,
+        status
+      );
+      total += cleaned.length;
+    }
+    return total;
+  }
+  async obliterateQueue(queue, options) {
+    const q = await this.getOrCreateQueue(queue);
+    await q.obliterate({ force: options?.force });
+  }
+  async retryAllFailed(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    const failed = await q.getFailed();
+    await Promise.all(failed.map((job) => job.retry()));
+    return failed.length;
+  }
+  async getJobCounts(queue) {
+    const q = await this.getOrCreateQueue(queue);
+    const counts = await q.getJobCounts();
+    return {
+      waiting: counts.waiting || 0,
+      active: counts.active || 0,
+      completed: counts.completed || 0,
+      failed: counts.failed || 0,
+      delayed: counts.delayed || 0,
+      paused: counts.paused || 0
+    };
+  }
+  async listJobs(queue, options) {
+    const q = await this.getOrCreateQueue(queue);
+    const statuses = options?.status || ["waiting", "active", "completed", "failed", "delayed"];
+    const jobs = [];
+    for (const status of statuses) {
+      const statusJobs = await q.getJobs([status], options?.start, options?.end);
+      jobs.push(...statusJobs);
+    }
+    return Promise.all(jobs.map(async (job) => {
+      const data = job.data;
+      const state = await job.getState();
+      return {
+        id: job.id,
+        name: job.name,
+        queue: job.queueName,
+        state: this.mapJobState(state || "waiting"),
+        data: data.input ?? data,
+        result: job.returnvalue,
+        error: job.failedReason,
+        progress: typeof job.progress === "number" ? job.progress : 0,
+        attempts: job.attemptsMade,
+        timestamp: job.timestamp,
+        processedOn: job.processedOn,
+        finishedOn: job.finishedOn,
+        scope: data.scope,
+        actor: data.actor
+      };
+    }));
+  }
+  // ==========================================
+  // PAUSE/RESUME JOB TYPES
+  // ==========================================
+  async pauseJobType(queue, jobName) {
+    this.config?.logger?.warn?.(`pauseJobType is not fully supported in BullMQ adapter`);
+  }
+  async resumeJobType(queue, jobName) {
+    this.config?.logger?.warn?.(`resumeJobType is not fully supported in BullMQ adapter`);
+  }
+  // ==========================================
+  // EVENTS
+  // ==========================================
+  async subscribe(pattern, handler) {
+    const subscriptions = [];
+    for (const [queueName] of this.queues) {
+      const events = await this.getQueueEvents(queueName);
+      const completedHandler = async (args) => {
+        if (this.matchesPattern(pattern, `${queueName}:${args.jobId}:completed`)) {
+          await handler({
+            type: "completed",
+            data: args,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      };
+      const failedHandler = async (args) => {
+        if (this.matchesPattern(pattern, `${queueName}:${args.jobId}:failed`)) {
+          await handler({
+            type: "failed",
+            data: args,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      };
+      events.on("completed", completedHandler);
+      events.on("failed", failedHandler);
+      subscriptions.push(async () => {
+        events.off("completed", completedHandler);
+        events.off("failed", failedHandler);
+      });
+    }
+    return async () => {
+      await Promise.all(subscriptions.map((unsub) => unsub()));
+    };
+  }
+  matchesPattern(pattern, eventType) {
+    if (pattern === "*") return true;
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    return regex.test(eventType);
+  }
+  // ==========================================
+  // WORKERS
+  // ==========================================
+  async createWorker(config, handler) {
+    const { Worker } = await this.getBullMQ();
+    const workerId = `worker-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const workers = [];
+    for (const queueName of config.queues) {
+      const workerOptions = {
+        connection: this.redis,
+        concurrency: config.concurrency,
+        lockDuration: config.lockDuration,
+        limiter: config.limiter
+      };
+      const worker = new Worker(
+        queueName,
+        async (job) => {
+          const data = job.data;
+          return handler({
+            id: job.id,
+            name: job.name,
+            queue: job.queueName,
+            data: data.input ?? data,
+            attempt: job.attemptsMade + 1,
+            timestamp: job.timestamp,
+            scope: data.scope,
+            actor: data.actor,
+            log: async (level, message) => {
+              await job.log(`[${level.toUpperCase()}] ${message}`);
+            },
+            updateProgress: async (progress) => {
+              await job.updateProgress(progress);
+            }
+          });
+        },
+        workerOptions
+      );
+      if (config.onIdle) {
+        worker.on("drained", config.onIdle);
+      }
+      workers.push(worker);
+      this.workers.set(`${workerId}-${queueName}`, worker);
+    }
+    let isPaused = false;
+    const startTime = Date.now();
+    let processed = 0;
+    let failed = 0;
+    let completed = 0;
+    for (const worker of workers) {
+      worker.on("completed", () => {
+        processed++;
+        completed++;
+      });
+      worker.on("failed", () => {
+        processed++;
+        failed++;
+      });
+    }
+    return {
+      id: workerId,
+      pause: async () => {
+        await Promise.all(workers.map((w) => w.pause()));
+        isPaused = true;
+      },
+      resume: async () => {
+        await Promise.all(workers.map((w) => w.resume()));
+        isPaused = false;
+      },
+      close: async () => {
+        await Promise.all(workers.map((w) => w.close()));
+        for (const worker of workers) {
+          const key = Array.from(this.workers.entries()).find(
+            ([_, w]) => w === worker
+          )?.[0];
+          if (key) this.workers.delete(key);
+        }
+      },
+      isRunning: () => !isPaused && workers.every((w) => w.isRunning()),
+      isPaused: () => isPaused,
+      getMetrics: async () => ({
+        processed,
+        failed,
+        completed,
+        active: workers.reduce((sum, w) => sum + (w.isRunning() ? 1 : 0), 0),
+        uptime: Date.now() - startTime
+      })
+    };
+  }
+  // ==========================================
+  // SEARCH
+  // ==========================================
+  async searchJobs(filter) {
+    const results = [];
+    const queuesToSearch = filter.queue ? [filter.queue] : Array.from(this.queues.keys());
+    for (const queueName of queuesToSearch) {
+      const jobs = await this.listJobs(queueName, {
+        status: filter.status,
+        start: filter.offset,
+        end: filter.limit ? (filter.offset || 0) + filter.limit : void 0
+      });
+      for (const job of jobs) {
+        if (filter.jobName && job.name !== filter.jobName) continue;
+        if (filter.scopeId && job.scope?.id !== filter.scopeId) continue;
+        if (filter.actorId && job.actor?.id !== filter.actorId) continue;
+        if (filter.dateRange?.from && job.timestamp < filter.dateRange.from.getTime()) continue;
+        if (filter.dateRange?.to && job.timestamp > filter.dateRange.to.getTime()) continue;
+        results.push(job);
+      }
+    }
+    if (filter.orderBy) {
+      const [field, direction] = filter.orderBy.split(":");
+      results.sort((a, b) => {
+        const aVal = field === "createdAt" ? a.timestamp : a[field];
+        const bVal = field === "createdAt" ? b.timestamp : b[field];
+        return direction === "asc" ? aVal - bVal : bVal - aVal;
+      });
+    }
+    return results.slice(0, filter.limit || 100);
+  }
+  async searchQueues(filter) {
+    const results = [];
+    for (const [queueName, queue] of this.queues) {
+      if (filter.name && !queueName.includes(filter.name)) continue;
+      const isPaused = await queue.isPaused();
+      if (filter.isPaused !== void 0 && isPaused !== filter.isPaused) continue;
+      const counts = await queue.getJobCounts();
+      results.push({
+        name: queueName,
+        isPaused,
+        jobCounts: {
+          waiting: counts.waiting || 0,
+          active: counts.active || 0,
+          completed: counts.completed || 0,
+          failed: counts.failed || 0,
+          delayed: counts.delayed || 0,
+          paused: counts.paused || 0
+        }
+      });
+    }
+    return results;
+  }
+  // ==========================================
+  // LIFECYCLE
+  // ==========================================
+  async shutdown() {
+    for (const [_, worker] of this.workers) {
+      await worker.close();
+    }
+    this.workers.clear();
+    for (const [_, events] of this.queueEvents) {
+      await events.close();
+    }
+    this.queueEvents.clear();
+    for (const [_, queue] of this.queues) {
+      await queue.close();
+    }
+    this.queues.clear();
+  }
+};
+
+exports.BullMQAdapter = BullMQAdapter;
+//# sourceMappingURL=bullmq.adapter.js.map
+//# sourceMappingURL=bullmq.adapter.js.map