@igniter-js/jobs 0.1.0 → 0.1.1

package/dist/adapters/bullmq.adapter.mjs

@@ -1,596 +1,498 @@
+import { createBullMQAdapter } from '@igniter-js/adapter-bullmq';
 import { IgniterError } from '@igniter-js/core';
 
-// src/errors/igniter-jobs.error.ts
-var IgniterJobsError = class _IgniterJobsError extends 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);
-    }
+// src/adapters/bullmq.adapter.ts
+
+// src/utils/prefix.ts
+var _IgniterJobsPrefix = class _IgniterJobsPrefix {
+  /**
+   * Builds a normalized queue name using the global prefix and queue id.
+   *
+   * @example
+   * ```typescript
+   * const name = IgniterJobsPrefix.buildQueueName('email')
+   * // -> igniter:jobs:email
+   * ```
+   */
+  static buildQueueName(queue) {
+    return `${_IgniterJobsPrefix.BASE_PREFIX}:${queue}`;
   }
   /**
-   * Convert error to a plain object for serialization.
+   * Builds the event channel used for pub/sub.
+   *
+   * Unscoped events are published to a global channel per service/environment.
+   * Scoped events are also published to an additional channel for that scope.
    */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      stack: this.stack
-    };
+  static buildEventsChannel(params) {
+    const base = `${_IgniterJobsPrefix.BASE_PREFIX}:events:${params.environment}:${params.service}`;
+    if (!params.scope) return base;
+    return `${base}:scope:${params.scope.type}:${params.scope.id}`;
+  }
+};
+_IgniterJobsPrefix.BASE_PREFIX = "igniter:jobs";
+var IgniterJobsPrefix = _IgniterJobsPrefix;
+var IgniterJobsError = class extends IgniterError {
+  constructor(options) {
+    super(options);
   }
 };
 
 // src/adapters/bullmq.adapter.ts
-var BullMQAdapter = class _BullMQAdapter {
+function toDateArray(values) {
+  if (!values) return void 0;
+  return values.map((v) => v instanceof Date ? v : new Date(v));
+}
+var IgniterJobsBullMQAdapter = class _IgniterJobsBullMQAdapter {
   constructor(options) {
-    this.queues = /* @__PURE__ */ new Map();
-    this.workers = /* @__PURE__ */ new Map();
-    this.queueEvents = /* @__PURE__ */ new Map();
-    this.BullMQ = null;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.coreAdapter = null;
+    this.coreExecutor = null;
+    this.executorDirty = true;
+    this.jobsByQueue = /* @__PURE__ */ new Map();
+    this.cronsByQueue = /* @__PURE__ */ new Map();
     this.redis = options.redis;
+    this.publisher = this.redis;
+    this.subscriber = this.redis.duplicate();
+    this.client = { redis: this.redis };
+    this.subscriber.on("message", (channel, message) => {
+      const set = this.subscribers.get(channel);
+      if (!set || set.size === 0) return;
+      let payload = message;
+      try {
+        payload = JSON.parse(message);
+      } catch {
+      }
+      for (const handler of set) handler(payload);
+    });
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const full = this.toCoreQueueName(name);
+        return this.core().queues.getJobs(full, filter);
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const full = this.toCoreQueueName(name);
+        return this.core().queues.isPaused(full);
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options2) => this.cleanQueue(name, options2),
+      obliterate: async (name, options2) => this.obliterateQueue(name, options2)
+    };
   }
-  /**
-   * 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;
+    return new _IgniterJobsBullMQAdapter(options);
   }
-  /**
-   * 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
+  registerJob(queueName, jobName, definition) {
+    const map = this.jobsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" is already registered in queue "${queueName}".`
       });
-      this.queues.set(name, queue);
     }
-    return this.queues.get(name);
+    map.set(jobName, definition);
+    this.jobsByQueue.set(queueName, map);
+    this.executorDirty = true;
   }
-  /**
-   * 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
+  registerCron(queueName, cronName, definition) {
+    const map = this.cronsByQueue.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (map.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" is already registered in queue "${queueName}".`
       });
-      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";
+    map.set(cronName, definition);
+    this.cronsByQueue.set(queueName, map);
+    this.executorDirty = true;
   }
-  /**
-   * 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 = {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    return namespace.enqueue({
+      task: params.jobName,
+      input: params.input,
       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,
+      attempts: params.attempts,
+      metadata: params.metadata,
       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;
+      removeOnFail: params.removeOnFail,
+      limiter: params.limiter
+    });
   }
   async schedule(params) {
-    const queue = await this.getOrCreateQueue(params.queue);
-    const jobOptions = {
+    const executor = await this.executor();
+    const namespace = executor[params.queue];
+    if (!namespace) {
+      throw new IgniterJobsError({
+        code: "JOBS_QUEUE_NOT_FOUND",
+        message: `Queue "${params.queue}" is not registered in the adapter.`
+      });
+    }
+    const schedule = {
       jobId: params.jobId,
-      delay: params.at ? params.at.getTime() - Date.now() : params.delay,
+      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,
+      attempts: params.attempts,
+      metadata: params.metadata,
       removeOnComplete: params.removeOnComplete,
       removeOnFail: params.removeOnFail,
-      repeat: params.cron ? {
-        pattern: params.cron,
-        tz: params.timezone
-      } : params.every ? {
-        every: params.every
+      limiter: params.limiter,
+      at: params.at,
+      repeat: params.cron || params.every || params.maxExecutions || params.skipWeekends || params.onlyBusinessHours || params.businessHours || params.onlyWeekdays || params.skipDates ? {
+        cron: params.cron,
+        every: params.every,
+        times: params.maxExecutions,
+        skipWeekends: params.skipWeekends,
+        onlyBusinessHours: params.onlyBusinessHours,
+        businessHours: params.businessHours,
+        onlyWeekdays: params.onlyWeekdays,
+        skipDates: toDateArray(params.skipDates)
       } : 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();
+    return namespace.schedule({
+      task: params.jobName,
+      input: params.input,
+      ...schedule
+    });
   }
-  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 getJob(jobId, queue) {
+    const result = await this.core().job.get(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return result ? this.mapJob(result, queue) : null;
   }
-  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 getJobState(jobId, queue) {
+    const state = await this.core().job.getState(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return state;
+  }
+  async getJobLogs(jobId, queue) {
+    const logs = await this.core().job.getLogs(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+    return logs;
+  }
+  async getJobProgress(jobId, queue) {
+    return this.core().job.getProgress(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async retryJob(jobId, queue) {
+    await this.core().job.retry(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async removeJob(jobId, queue) {
+    await this.core().job.remove(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async promoteJob(jobId, queue) {
+    await this.core().job.promote(jobId, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    await this.core().job.moveToFailed(jobId, reason, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async retryManyJobs(jobIds, queue) {
+    await this.core().job.retryMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async removeManyJobs(jobIds, queue) {
+    await this.core().job.removeMany(jobIds, queue ? this.toCoreQueueName(queue) : void 0);
+  }
+  async getQueueInfo(queue) {
+    const info = await this.core().queues.get(this.toCoreQueueName(queue));
+    if (!info) return null;
+    return this.mapQueueInfo(info);
+  }
+  async getQueueJobCounts(queue) {
+    const counts = await this.core().queues.getJobCounts(this.toCoreQueueName(queue));
+    return counts;
+  }
+  async listQueues() {
+    const list = await this.core().queues.list();
+    return list.map((q) => this.mapQueueInfo(q));
   }
   async pauseQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.pause();
+    await this.core().queues.pause(this.toCoreQueueName(queue));
   }
   async resumeQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.resume();
+    await this.core().queues.resume(this.toCoreQueueName(queue));
   }
   async drainQueue(queue) {
-    const q = await this.getOrCreateQueue(queue);
-    await q.drain();
-    return 0;
+    return this.core().queues.drain(this.toCoreQueueName(queue));
   }
   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;
+    return this.core().queues.clean(this.toCoreQueueName(queue), options);
   }
   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
-    };
+    await this.core().queues.obliterate(this.toCoreQueueName(queue), options);
+  }
+  async retryAllInQueue(queue) {
+    const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status: ["failed"], limit: 1e3 });
+    await Promise.all(jobs.map((j) => this.core().job.retry(j.id, this.toCoreQueueName(queue))));
+    return jobs.length;
   }
-  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`);
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support pausing a single job type; pause the queue or adjust worker filters."
+    });
   }
   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);
-      });
+    throw new IgniterJobsError({
+      code: "JOBS_QUEUE_OPERATION_FAILED",
+      message: "BullMQ backend does not support resuming a single job type; resume the queue or adjust worker filters."
+    });
+  }
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const status = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    if (queue) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(queue), { status, limit, offset });
+      return jobs.map((j) => this.mapJob(j, queue));
+    }
+    const queues = await this.listQueues();
+    const results = [];
+    for (const q of queues) {
+      const jobs = await this.core().queues.getJobs(this.toCoreQueueName(q.name), { status, limit, offset });
+      results.push(...jobs.map((j) => this.mapJob(j, q.name)));
+      if (results.length >= limit) break;
+    }
+    return results.slice(0, limit);
+  }
+  async searchQueues(filter) {
+    const all = await this.listQueues();
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    return all.filter((q) => name ? q.name.includes(name) : true).filter((q) => typeof isPaused === "boolean" ? q.isPaused === isPaused : true);
+  }
+  async searchWorkers(filter) {
+    const queue = filter?.queue;
+    const isRunning = filter?.isRunning;
+    const all = Array.from(this.core().getWorkers().values());
+    return all.filter((w) => {
+      if (!queue) return true;
+      const coreQueue = this.toCoreQueueName(queue);
+      const queues = w.config?.queues ?? [w.queueName];
+      return Array.isArray(queues) ? queues.includes(coreQueue) : false;
+    }).filter((w) => typeof isRunning === "boolean" ? isRunning ? w.isRunning() : !w.isRunning() : true).map((w) => this.mapWorker(w));
+  }
+  async createWorker(config) {
+    await this.executor();
+    const queuesSource = config.queues?.length ? config.queues : Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]));
+    const queues = queuesSource.map((q) => this.toCoreQueueName(q));
+    const coreConfig = {
+      queues,
+      concurrency: config.concurrency ?? 1,
+      limiter: config.limiter,
+      onActive: config.handlers?.onActive,
+      onSuccess: config.handlers?.onSuccess,
+      onFailure: config.handlers?.onFailure,
+      onIdle: config.handlers?.onIdle
+    };
+    const handle = await this.core().worker(coreConfig);
+    return this.mapWorker(handle);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, handle] of this.core().getWorkers()) out.set(id, this.mapWorker(handle));
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    await this.publisher.publish(channel, JSON.stringify(payload));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    const wrapped = (payload) => void handler(payload);
+    set.add(wrapped);
+    this.subscribers.set(channel, set);
+    if (set.size === 1) {
+      await this.subscriber.subscribe(channel);
     }
     return async () => {
-      await Promise.all(subscriptions.map((unsub) => unsub()));
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(wrapped);
+      if (current.size === 0) {
+        this.subscribers.delete(channel);
+        await this.subscriber.unsubscribe(channel);
+      }
     };
   }
-  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++;
+  async shutdown() {
+    await this.subscriber.quit();
+  }
+  core() {
+    if (!this.coreAdapter) {
+      this.coreAdapter = createBullMQAdapter({
+        store: { client: this.redis }
       });
     }
-    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);
+    return this.coreAdapter;
+  }
+  async executor() {
+    if (!this.executorDirty && this.coreExecutor) return this.coreExecutor;
+    const routers = {};
+    const flattened = {};
+    const allQueues = /* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.cronsByQueue.keys()]);
+    for (const queueName of allQueues) {
+      const coreJobs = {};
+      const jobs = this.jobsByQueue.get(queueName);
+      if (jobs) {
+        for (const [jobName, def] of jobs.entries()) {
+          const queue = def.queue ? `${queueName}.${def.queue}` : queueName;
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queue);
+          coreJobs[jobName] = this.toCoreJobDefinition(queueName, jobName, def, fullQueue);
         }
-      },
-      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;
+      const crons = this.cronsByQueue.get(queueName);
+      if (crons) {
+        for (const [cronName, def] of crons.entries()) {
+          const fullQueue = IgniterJobsPrefix.buildQueueName(queueName);
+          coreJobs[cronName] = this.toCoreCronJobDefinition(queueName, cronName, def, fullQueue);
+        }
+      }
+      if (Object.keys(coreJobs).length === 0) continue;
+      routers[queueName] = this.core().router({
+        jobs: coreJobs,
+        namespace: queueName
       });
+      for (const [jobName, def] of Object.entries(coreJobs)) {
+        flattened[`${queueName}.${jobName}`] = def;
+      }
     }
-    return results.slice(0, filter.limit || 100);
+    await this.core().bulkRegister(flattened);
+    this.coreExecutor = this.core().merge(routers);
+    this.executorDirty = false;
+    return this.coreExecutor;
   }
-  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
-        }
+  toCoreQueueName(queueName) {
+    return IgniterJobsPrefix.buildQueueName(queueName);
+  }
+  mapQueueInfo(info) {
+    return {
+      name: this.fromCoreQueueName(info.name),
+      isPaused: info.isPaused,
+      jobCounts: info.jobCounts
+    };
+  }
+  fromCoreQueueName(full) {
+    const prefix = `${IgniterJobsPrefix.BASE_PREFIX}:`;
+    return full.startsWith(prefix) ? full.slice(prefix.length) : full;
+  }
+  mapJob(job, queue) {
+    const q = queue ?? this.fromCoreQueueName(job.metadata?.queue ?? job.queueName ?? "");
+    const scope = job.metadata?.__igniter_jobs_scope;
+    return {
+      id: job.id,
+      name: job.name,
+      queue: q,
+      status: job.status,
+      input: job.payload,
+      result: job.result,
+      error: job.error,
+      progress: 0,
+      attemptsMade: job.attemptsMade ?? 0,
+      priority: job.priority ?? 0,
+      createdAt: job.createdAt,
+      startedAt: job.processedAt,
+      completedAt: job.completedAt,
+      metadata: job.metadata,
+      scope
+    };
+  }
+  mapWorker(handle) {
+    const queues = handle.config?.queues ?? [handle.queueName];
+    return {
+      id: handle.id,
+      queues: queues.map((q) => this.fromCoreQueueName(q)),
+      pause: () => handle.pause(),
+      resume: () => handle.resume(),
+      close: () => handle.close(),
+      isRunning: () => handle.isRunning(),
+      isPaused: () => handle.isPaused(),
+      isClosed: () => handle.isClosed(),
+      getMetrics: async () => handle.getMetrics()
+    };
+  }
+  toCoreJobDefinition(queueName, jobName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        input: ctx.input,
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: jobName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
       });
-    }
-    return results;
+    };
+    return {
+      name: jobName,
+      input: def.input,
+      handler,
+      queue: { name: fullQueueName },
+      attempts: def.attempts,
+      priority: def.priority,
+      delay: def.delay,
+      removeOnComplete: def.removeOnComplete,
+      removeOnFail: def.removeOnFail,
+      metadata: def.metadata,
+      limiter: def.limiter,
+      onStart: def.onStart,
+      onSuccess: def.onSuccess,
+      onFailure: def.onFailure,
+      onProgress: def.onProgress
+    };
   }
-  // ==========================================
-  // 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();
+  toCoreCronJobDefinition(queueName, cronName, def, fullQueueName) {
+    const handler = async (ctx) => {
+      return def.handler({
+        context: ctx.context,
+        job: {
+          id: ctx.job.id,
+          name: cronName,
+          queue: queueName,
+          attemptsMade: ctx.job.attemptsMade,
+          createdAt: ctx.job.createdAt,
+          metadata: ctx.job.metadata
+        },
+        scope: ctx.job.metadata?.__igniter_jobs_scope
+      });
+    };
+    return {
+      name: cronName,
+      handler,
+      queue: { name: fullQueueName },
+      repeat: {
+        cron: def.cron,
+        tz: def.tz,
+        limit: def.maxExecutions,
+        startDate: def.startDate,
+        endDate: def.endDate
+      },
+      metadata: def.onlyBusinessHours || def.skipWeekends || def.businessHours || def.onlyWeekdays || def.skipDates || def.startDate && def.endDate ? {
+        advancedScheduling: {
+          onlyBusinessHours: def.onlyBusinessHours,
+          skipWeekends: def.skipWeekends,
+          businessHours: def.businessHours,
+          skipDates: toDateArray(def.skipDates),
+          onlyWeekdays: def.onlyWeekdays,
+          between: def.startDate && def.endDate ? [def.startDate, def.endDate] : void 0
+        }
+      } : void 0
+    };
   }
 };
 
-export { BullMQAdapter };
+export { IgniterJobsBullMQAdapter };
 //# sourceMappingURL=bullmq.adapter.mjs.map
 //# sourceMappingURL=bullmq.adapter.mjs.map