@igniter-js/jobs 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,1129 @@
+'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();
+  }
+};
+
+// src/adapters/memory.adapter.ts
+var MemoryAdapter = class _MemoryAdapter {
+  constructor() {
+    this.queues = /* @__PURE__ */ new Map();
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.processingInterval = null;
+  }
+  /**
+   * Create a new memory adapter.
+   */
+  static create() {
+    return new _MemoryAdapter();
+  }
+  /**
+   * Get the underlying client (null for memory adapter).
+   */
+  get client() {
+    return null;
+  }
+  /**
+   * Get or create a queue.
+   */
+  getOrCreateQueue(name) {
+    if (!this.queues.has(name)) {
+      this.queues.set(name, {
+        name,
+        isPaused: false,
+        jobs: /* @__PURE__ */ new Map(),
+        pausedJobTypes: /* @__PURE__ */ new Set()
+      });
+    }
+    return this.queues.get(name);
+  }
+  /**
+   * Generate a unique job ID.
+   */
+  generateJobId() {
+    return `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Emit an event to subscribers.
+   */
+  async emitEvent(type, data) {
+    for (const [pattern, handlers] of this.eventHandlers) {
+      if (this.matchesPattern(pattern, type)) {
+        for (const handler of handlers) {
+          try {
+            await handler({
+              type,
+              data,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Check if a pattern matches an event type.
+   */
+  matchesPattern(pattern, eventType) {
+    if (pattern === "*") return true;
+    const regex = new RegExp(
+      "^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+    );
+    return regex.test(eventType);
+  }
+  // ==========================================
+  // JOB OPERATIONS
+  // ==========================================
+  async dispatch(params) {
+    const queue = this.getOrCreateQueue(params.queue);
+    const jobId = params.jobId || this.generateJobId();
+    const job = {
+      id: jobId,
+      name: params.name,
+      queue: params.queue,
+      data: params.data,
+      state: params.delay ? "delayed" : "waiting",
+      progress: 0,
+      attempts: 0,
+      maxAttempts: params.attempts ?? 3,
+      timestamp: Date.now(),
+      delay: params.delay,
+      priority: params.priority ?? 0,
+      scope: params.scope,
+      actor: params.actor,
+      logs: [],
+      scheduledAt: params.delay ? Date.now() + params.delay : void 0
+    };
+    queue.jobs.set(jobId, job);
+    await this.emitEvent(`${params.queue}:${params.name}:enqueued`, {
+      jobId,
+      name: params.name,
+      queue: params.queue
+    });
+    this.startProcessing();
+    return jobId;
+  }
+  async schedule(params) {
+    const delay = params.at ? params.at.getTime() - Date.now() : params.delay ?? 0;
+    return this.dispatch({
+      ...params,
+      delay
+    });
+  }
+  async getJob(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    if (!job) return null;
+    return {
+      id: job.id,
+      name: job.name,
+      queue: job.queue,
+      state: job.state,
+      data: job.data,
+      result: job.result,
+      error: job.error,
+      progress: job.progress,
+      attempts: job.attempts,
+      timestamp: job.timestamp,
+      processedOn: job.processedOn,
+      finishedOn: job.finishedOn,
+      delay: job.delay,
+      priority: job.priority,
+      scope: job.scope,
+      actor: job.actor
+    };
+  }
+  async getJobState(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    return job?.state ?? null;
+  }
+  async getJobProgress(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    return job?.progress ?? 0;
+  }
+  async getJobLogs(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    return job?.logs ?? [];
+  }
+  async retryJob(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found`,
+        statusCode: 404
+      });
+    }
+    job.state = "waiting";
+    job.error = void 0;
+    job.attempts = 0;
+  }
+  async removeJob(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    q.jobs.delete(jobId);
+  }
+  async promoteJob(queue, jobId) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found`,
+        statusCode: 404
+      });
+    }
+    if (job.state === "delayed") {
+      job.state = "waiting";
+      job.scheduledAt = void 0;
+      job.delay = void 0;
+    }
+  }
+  async moveJob(queue, jobId, state, reason) {
+    const q = this.getOrCreateQueue(queue);
+    const job = q.jobs.get(jobId);
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_JOB_NOT_FOUND",
+        message: `Job "${jobId}" not found`,
+        statusCode: 404
+      });
+    }
+    job.state = state;
+    job.finishedOn = Date.now();
+    if (state === "failed") {
+      job.error = reason;
+    } else {
+      job.result = reason;
+    }
+  }
+  async retryJobs(queue, jobIds) {
+    await Promise.all(jobIds.map((id) => this.retryJob(queue, id)));
+  }
+  async removeJobs(queue, jobIds) {
+    await Promise.all(jobIds.map((id) => this.removeJob(queue, id)));
+  }
+  // ==========================================
+  // QUEUE OPERATIONS
+  // ==========================================
+  async getQueue(queue) {
+    const q = this.getOrCreateQueue(queue);
+    const counts = await this.getJobCounts(queue);
+    return {
+      name: queue,
+      isPaused: q.isPaused,
+      jobCounts: counts
+    };
+  }
+  async pauseQueue(queue) {
+    const q = this.getOrCreateQueue(queue);
+    q.isPaused = true;
+  }
+  async resumeQueue(queue) {
+    const q = this.getOrCreateQueue(queue);
+    q.isPaused = false;
+  }
+  async drainQueue(queue) {
+    const q = this.getOrCreateQueue(queue);
+    let count = 0;
+    for (const [id, job] of q.jobs) {
+      if (job.state === "waiting" || job.state === "delayed") {
+        q.jobs.delete(id);
+        count++;
+      }
+    }
+    return count;
+  }
+  async cleanQueue(queue, options) {
+    const q = this.getOrCreateQueue(queue);
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    const now = Date.now();
+    let count = 0;
+    let removed = 0;
+    for (const [id, job] of q.jobs) {
+      if (options.limit && removed >= options.limit) break;
+      if (statuses.includes(job.state)) {
+        const age = now - job.timestamp;
+        if (!options.olderThan || age >= options.olderThan) {
+          q.jobs.delete(id);
+          removed++;
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+  async obliterateQueue(queue, options) {
+    this.queues.delete(queue);
+  }
+  async retryAllFailed(queue) {
+    const q = this.getOrCreateQueue(queue);
+    let count = 0;
+    for (const job of q.jobs.values()) {
+      if (job.state === "failed") {
+        job.state = "waiting";
+        job.error = void 0;
+        job.attempts = 0;
+        count++;
+      }
+    }
+    return count;
+  }
+  async getJobCounts(queue) {
+    const q = this.getOrCreateQueue(queue);
+    const counts = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+    for (const job of q.jobs.values()) {
+      counts[job.state]++;
+    }
+    return counts;
+  }
+  async listJobs(queue, options) {
+    const q = this.getOrCreateQueue(queue);
+    const results = [];
+    const statuses = options?.status || ["waiting", "active", "completed", "failed", "delayed", "paused"];
+    for (const job of q.jobs.values()) {
+      if (statuses.includes(job.state)) {
+        results.push({
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          state: job.state,
+          data: job.data,
+          result: job.result,
+          error: job.error,
+          progress: job.progress,
+          attempts: job.attempts,
+          timestamp: job.timestamp,
+          processedOn: job.processedOn,
+          finishedOn: job.finishedOn,
+          scope: job.scope,
+          actor: job.actor
+        });
+      }
+    }
+    const start = options?.start ?? 0;
+    const end = options?.end ?? results.length;
+    return results.slice(start, end);
+  }
+  // ==========================================
+  // PAUSE/RESUME JOB TYPES
+  // ==========================================
+  async pauseJobType(queue, jobName) {
+    const q = this.getOrCreateQueue(queue);
+    q.pausedJobTypes.add(jobName);
+  }
+  async resumeJobType(queue, jobName) {
+    const q = this.getOrCreateQueue(queue);
+    q.pausedJobTypes.delete(jobName);
+  }
+  // ==========================================
+  // EVENTS
+  // ==========================================
+  async subscribe(pattern, handler) {
+    if (!this.eventHandlers.has(pattern)) {
+      this.eventHandlers.set(pattern, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(pattern).add(handler);
+    return async () => {
+      this.eventHandlers.get(pattern)?.delete(handler);
+    };
+  }
+  // ==========================================
+  // WORKERS
+  // ==========================================
+  async createWorker(config, handler) {
+    const workerId = `worker-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    this.workers.set(workerId, {
+      handler,
+      config,
+      running: true,
+      paused: false
+    });
+    const startTime = Date.now();
+    let processed = 0;
+    let failed = 0;
+    let completed = 0;
+    return {
+      id: workerId,
+      pause: async () => {
+        const worker = this.workers.get(workerId);
+        if (worker) worker.paused = true;
+      },
+      resume: async () => {
+        const worker = this.workers.get(workerId);
+        if (worker) worker.paused = false;
+      },
+      close: async () => {
+        this.workers.delete(workerId);
+      },
+      isRunning: () => {
+        const worker = this.workers.get(workerId);
+        return worker?.running && !worker?.paused || false;
+      },
+      isPaused: () => {
+        return this.workers.get(workerId)?.paused || false;
+      },
+      getMetrics: async () => ({
+        processed,
+        failed,
+        completed,
+        active: 0,
+        uptime: Date.now() - startTime
+      })
+    };
+  }
+  /**
+   * Start the internal job processing loop.
+   */
+  startProcessing() {
+    if (this.processingInterval) return;
+    this.processingInterval = setInterval(async () => {
+      await this.processJobs();
+    }, 100);
+  }
+  /**
+   * Process pending jobs.
+   */
+  async processJobs() {
+    for (const [_, worker] of this.workers) {
+      if (!worker.running || worker.paused) continue;
+      for (const queueName of worker.config.queues) {
+        const queue = this.queues.get(queueName);
+        if (!queue || queue.isPaused) continue;
+        for (const job of queue.jobs.values()) {
+          if (job.state !== "waiting") continue;
+          if (queue.pausedJobTypes.has(job.name)) continue;
+          if (job.scheduledAt && job.scheduledAt > Date.now()) continue;
+          job.state = "active";
+          job.processedOn = Date.now();
+          job.attempts++;
+          try {
+            const result = await worker.handler({
+              id: job.id,
+              name: job.name,
+              queue: job.queue,
+              data: job.data,
+              attempt: job.attempts,
+              timestamp: job.timestamp,
+              scope: job.scope,
+              actor: job.actor,
+              log: async (level, message) => {
+                job.logs.push({
+                  timestamp: /* @__PURE__ */ new Date(),
+                  message,
+                  level
+                });
+              },
+              updateProgress: async (progress) => {
+                job.progress = progress;
+              }
+            });
+            job.state = "completed";
+            job.result = result;
+            job.finishedOn = Date.now();
+            await this.emitEvent(`${job.queue}:${job.name}:completed`, {
+              jobId: job.id,
+              result
+            });
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (job.attempts < job.maxAttempts) {
+              job.state = "waiting";
+              await this.emitEvent(`${job.queue}:${job.name}:retrying`, {
+                jobId: job.id,
+                error: errorMessage,
+                attempt: job.attempts
+              });
+            } else {
+              job.state = "failed";
+              job.error = errorMessage;
+              job.finishedOn = Date.now();
+              await this.emitEvent(`${job.queue}:${job.name}:failed`, {
+                jobId: job.id,
+                error: errorMessage
+              });
+            }
+          }
+        }
+      }
+    }
+  }
+  // ==========================================
+  // SEARCH
+  // ==========================================
+  async searchJobs(filter) {
+    const results = [];
+    const queuesToSearch = filter.queue ? [filter.queue] : Array.from(this.queues.keys());
+    for (const queueName of queuesToSearch) {
+      const queue = this.queues.get(queueName);
+      if (!queue) continue;
+      for (const job of queue.jobs.values()) {
+        if (filter.status && !filter.status.includes(job.state)) continue;
+        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({
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          state: job.state,
+          data: job.data,
+          result: job.result,
+          error: job.error,
+          progress: job.progress,
+          attempts: job.attempts,
+          timestamp: job.timestamp,
+          processedOn: job.processedOn,
+          finishedOn: job.finishedOn,
+          scope: job.scope,
+          actor: job.actor
+        });
+      }
+    }
+    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;
+      });
+    }
+    const offset = filter.offset ?? 0;
+    const limit = filter.limit ?? 100;
+    return results.slice(offset, offset + limit);
+  }
+  async searchQueues(filter) {
+    const results = [];
+    for (const [queueName, queue] of this.queues) {
+      if (filter.name && !queueName.includes(filter.name)) continue;
+      if (filter.isPaused !== void 0 && queue.isPaused !== filter.isPaused) continue;
+      const counts = await this.getJobCounts(queueName);
+      results.push({
+        name: queueName,
+        isPaused: queue.isPaused,
+        jobCounts: counts
+      });
+    }
+    return results;
+  }
+  // ==========================================
+  // LIFECYCLE
+  // ==========================================
+  async shutdown() {
+    if (this.processingInterval) {
+      clearInterval(this.processingInterval);
+      this.processingInterval = null;
+    }
+    this.workers.clear();
+    this.queues.clear();
+    this.eventHandlers.clear();
+  }
+};
+
+exports.BullMQAdapter = BullMQAdapter;
+exports.MemoryAdapter = MemoryAdapter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map