@igniter-js/jobs 0.1.0 → 0.1.1

package/dist/adapters/memory.adapter.js

@@ -2,570 +2,568 @@
 
 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);
-    }
-  }
+// src/utils/id-generator.ts
+var IgniterJobsIdGenerator = class {
   /**
-   * Convert error to a plain object for serialization.
+   * Generates a unique identifier with a prefix.
+   *
+   * @example
+   * ```typescript
+   * const jobId = IgniterJobsIdGenerator.generate('job')
+   * ```
    */
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      stack: this.stack
-    };
+  static generate(prefix) {
+    const now = Date.now().toString(36);
+    const random = Math.random().toString(36).slice(2, 8);
+    return `${prefix}_${now}_${random}`;
+  }
+};
+var IgniterJobsError = class extends core.IgniterError {
+  constructor(options) {
+    super(options);
   }
 };
 
 // src/adapters/memory.adapter.ts
-var MemoryAdapter = class _MemoryAdapter {
+var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   constructor() {
-    this.queues = /* @__PURE__ */ new Map();
-    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.client = {
+      type: "memory"
+    };
+    this.jobsById = /* @__PURE__ */ new Map();
+    this.jobsByQueue = /* @__PURE__ */ new Map();
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.registeredCrons = /* @__PURE__ */ new Map();
     this.workers = /* @__PURE__ */ new Map();
-    this.processingInterval = null;
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => {
+        const statuses = filter?.status;
+        const limit = filter?.limit ?? 100;
+        const offset = filter?.offset ?? 0;
+        const results = await this.searchJobs({
+          queue: name,
+          status: statuses,
+          limit,
+          offset
+        });
+        return results;
+      },
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => {
+        const info = await this.getQueueInfo(name);
+        return info?.isPaused ?? false;
+      },
+      drain: async (name) => this.drainQueue(name),
+      clean: async (name, options) => this.cleanQueue(name, options),
+      obliterate: async (name, options) => this.obliterateQueue(name, options)
+    };
+    this.pausedQueues = /* @__PURE__ */ new Set();
   }
-  /**
-   * Create a new memory adapter.
-   */
   static create() {
-    return new _MemoryAdapter();
+    return new _IgniterJobsMemoryAdapter();
   }
-  /**
-   * 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()
+  registerJob(queueName, jobName, definition) {
+    const queueJobs = this.registeredJobs.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueJobs.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" already registered for queue "${queueName}".`
       });
     }
-    return this.queues.get(name);
-  }
-  /**
-   * Generate a unique job ID.
-   */
-  generateJobId() {
-    return `job-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    queueJobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, queueJobs);
   }
-  /**
-   * 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 {
-          }
-        }
-      }
+  registerCron(queueName, cronName, definition) {
+    const queueCrons = this.registeredCrons.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (queueCrons.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" already registered for queue "${queueName}".`
+      });
     }
+    queueCrons.set(cronName, definition);
+    this.registeredCrons.set(queueName, queueCrons);
   }
-  /**
-   * 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 jobId = params.jobId ?? IgniterJobsIdGenerator.generate("job");
+    const maxAttempts = params.attempts ?? 1;
+    const metadata = params.metadata ?? {};
     const job = {
       id: jobId,
-      name: params.name,
+      name: params.jobName,
       queue: params.queue,
-      data: params.data,
-      state: params.delay ? "delayed" : "waiting",
+      input: params.input,
+      status: this.pausedQueues.has(params.queue) ? "paused" : params.delay && params.delay > 0 ? "delayed" : "waiting",
       progress: 0,
-      attempts: 0,
-      maxAttempts: params.attempts ?? 3,
-      timestamp: Date.now(),
-      delay: params.delay,
+      attemptsMade: 0,
+      maxAttempts,
       priority: params.priority ?? 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata,
       scope: params.scope,
-      actor: params.actor,
-      logs: [],
-      scheduledAt: params.delay ? Date.now() + params.delay : void 0
+      logs: []
     };
-    queue.jobs.set(jobId, job);
-    await this.emitEvent(`${params.queue}:${params.name}:enqueued`, {
-      jobId,
-      name: params.name,
-      queue: params.queue
-    });
-    this.startProcessing();
+    this.jobsById.set(jobId, job);
+    const queueList = this.jobsByQueue.get(params.queue) ?? [];
+    queueList.push(jobId);
+    this.jobsByQueue.set(params.queue, queueList);
+    if (params.delay && params.delay > 0) {
+      setTimeout(() => {
+        const stored = this.jobsById.get(jobId);
+        if (!stored) return;
+        if (!this.pausedQueues.has(params.queue)) stored.status = "waiting";
+        void this.kickWorkers(params.queue);
+      }, params.delay);
+      return jobId;
+    }
+    void this.kickWorkers(params.queue);
     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;
+    if (params.at) {
+      const delay = params.at.getTime() - Date.now();
+      if (delay <= 0) {
+        throw new IgniterJobsError({
+          code: "JOBS_INVALID_SCHEDULE",
+          message: "Scheduled time must be in the future."
+        });
+      }
+      return this.dispatch({ ...params, delay });
+    }
+    if (params.cron || params.every) {
+      return this.dispatch({ ...params, delay: params.delay ?? 0 });
+    }
+    return this.dispatch(params);
   }
-  async getJobLogs(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
-    return job?.logs ?? [];
+  async getJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return null;
+    if (queue && job.queue !== queue) return null;
+    return this.toSearchResult(job);
   }
-  async retryJob(queue, jobId) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async getJobState(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return null;
+    if (queue && job.queue !== queue) return null;
+    return job.status;
+  }
+  async getJobLogs(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return [];
+    if (queue && job.queue !== queue) return [];
+    return job.logs;
+  }
+  async getJobProgress(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return 0;
+    if (queue && job.queue !== queue) return 0;
+    return job.progress;
+  }
+  async retryJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
-      });
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+    }
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${queue}".` });
     }
-    job.state = "waiting";
+    job.status = "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);
+    job.completedAt = void 0;
+    job.progress = 0;
+    void this.kickWorkers(job.queue);
+  }
+  async removeJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
+    if (!job) return;
+    if (queue && job.queue !== queue) return;
+    this.jobsById.delete(jobId);
+    const list = this.jobsByQueue.get(job.queue);
+    if (list) this.jobsByQueue.set(job.queue, list.filter((id) => id !== jobId));
+  }
+  async promoteJob(jobId, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
-      });
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+    }
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${queue}".` });
     }
-    if (job.state === "delayed") {
-      job.state = "waiting";
-      job.scheduledAt = void 0;
-      job.delay = void 0;
+    if (job.status === "delayed" || job.status === "paused") {
+      job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
+      void this.kickWorkers(job.queue);
     }
   }
-  async moveJob(queue, jobId, state, reason) {
-    const q = this.getOrCreateQueue(queue);
-    const job = q.jobs.get(jobId);
+  async moveJobToFailed(jobId, reason, queue) {
+    const job = this.jobsById.get(jobId);
     if (!job) {
-      throw new IgniterJobsError({
-        code: "JOBS_JOB_NOT_FOUND",
-        message: `Job "${jobId}" not found`,
-        statusCode: 404
-      });
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
     }
-    job.state = state;
-    job.finishedOn = Date.now();
-    if (state === "failed") {
-      job.error = reason;
-    } else {
-      job.result = reason;
+    if (queue && job.queue !== queue) {
+      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found in queue "${queue}".` });
     }
+    job.status = "failed";
+    job.error = reason;
+    job.completedAt = /* @__PURE__ */ new Date();
   }
-  async retryJobs(queue, jobIds) {
-    await Promise.all(jobIds.map((id) => this.retryJob(queue, id)));
+  async retryManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.retryJob(id, queue)));
   }
-  async removeJobs(queue, jobIds) {
-    await Promise.all(jobIds.map((id) => this.removeJob(queue, id)));
+  async removeManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.removeJob(id, queue)));
   }
-  // ==========================================
-  // QUEUE OPERATIONS
-  // ==========================================
-  async getQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    const counts = await this.getJobCounts(queue);
+  async getQueueInfo(queue) {
+    const counts = await this.getQueueJobCounts(queue);
     return {
       name: queue,
-      isPaused: q.isPaused,
+      isPaused: this.pausedQueues.has(queue),
       jobCounts: counts
     };
   }
+  async getQueueJobCounts(queue) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    const counts = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status in counts) {
+        counts[job.status]++;
+      }
+    }
+    return counts;
+  }
+  async listQueues() {
+    const queues = Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.registeredJobs.keys(), ...this.registeredCrons.keys()]));
+    const result = [];
+    for (const q of queues) {
+      result.push(await this.getQueueInfo(q));
+    }
+    return result;
+  }
   async pauseQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = true;
+    this.pausedQueues.add(queue);
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "waiting") job.status = "paused";
+    }
   }
   async resumeQueue(queue) {
-    const q = this.getOrCreateQueue(queue);
-    q.isPaused = false;
+    this.pausedQueues.delete(queue);
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "paused") job.status = "waiting";
+    }
+    void this.kickWorkers(queue);
   }
   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++;
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    let removed = 0;
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "waiting" || job.status === "paused") {
+        this.jobsById.delete(id);
+        removed++;
       }
     }
-    return count;
+    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    return removed;
   }
   async cleanQueue(queue, options) {
-    const q = this.getOrCreateQueue(queue);
     const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    const olderThan = options.olderThan ?? 0;
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
     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++;
-        }
-      }
+    let cleaned = 0;
+    for (const id of [...jobIds]) {
+      if (cleaned >= limit) break;
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (!statuses.includes(job.status)) continue;
+      const ageMs = now - job.createdAt.getTime();
+      if (ageMs < olderThan) continue;
+      this.jobsById.delete(id);
+      cleaned++;
     }
-    return count;
+    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    return cleaned;
   }
   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++;
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) this.jobsById.delete(id);
+    this.jobsByQueue.delete(queue);
+    this.registeredJobs.delete(queue);
+    this.registeredCrons.delete(queue);
+    this.pausedQueues.delete(queue);
+  }
+  async retryAllInQueue(queue) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    let retried = 0;
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.status === "failed") {
+        await this.retryJob(id, queue);
+        retried++;
       }
     }
-    return count;
+    return retried;
   }
-  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]++;
+  async pauseJobType(queue, jobName) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.name === jobName && job.status === "waiting") job.status = "paused";
     }
-    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
-        });
-      }
+  async resumeJobType(queue, jobName) {
+    const jobIds = this.jobsByQueue.get(queue) ?? [];
+    for (const id of jobIds) {
+      const job = this.jobsById.get(id);
+      if (!job) continue;
+      if (job.name === jobName && job.status === "paused") job.status = "waiting";
     }
-    const start = options?.start ?? 0;
-    const end = options?.end ?? results.length;
-    return results.slice(start, end);
+    void this.kickWorkers(queue);
   }
-  // ==========================================
-  // PAUSE/RESUME JOB TYPES
-  // ==========================================
-  async pauseJobType(queue, jobName) {
-    const q = this.getOrCreateQueue(queue);
-    q.pausedJobTypes.add(jobName);
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const statuses = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    const all = Array.from(this.jobsById.values()).filter((j) => queue ? j.queue === queue : true).filter((j) => statuses ? statuses.includes(j.status) : true).sort((a, b) => b.priority - a.priority || a.createdAt.getTime() - b.createdAt.getTime());
+    return all.slice(offset, offset + limit).map((j) => this.toSearchResult(j));
   }
-  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);
+  async searchQueues(filter) {
+    const name = filter?.name;
+    const isPaused = filter?.isPaused;
+    const all = await this.listQueues();
+    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;
+    return Array.from(this.workers.values()).filter((w) => queue ? w.queues.includes(queue) : true).filter((w) => typeof isRunning === "boolean" ? isRunning ? !w.closed : w.closed : true).map((w) => this.toWorkerHandle(w));
+  }
+  async createWorker(config) {
+    const workerId = IgniterJobsIdGenerator.generate("worker");
+    const state = {
+      id: workerId,
+      queues: config.queues ?? [],
+      concurrency: config.concurrency ?? 1,
+      paused: false,
+      closed: false,
+      startedAt: /* @__PURE__ */ new Date(),
+      metrics: { processed: 0, failed: 0, totalDuration: 0 },
+      handlers: config.handlers
+    };
+    this.workers.set(workerId, state);
+    for (const q of state.queues) void this.kickWorkers(q);
+    return this.toWorkerHandle(state);
+  }
+  getWorkers() {
+    const out = /* @__PURE__ */ new Map();
+    for (const [id, state] of this.workers) out.set(id, this.toWorkerHandle(state));
+    return out;
+  }
+  async publishEvent(channel, payload) {
+    const handlers = this.subscribers.get(channel);
+    if (!handlers) return;
+    await Promise.all(Array.from(handlers).map(async (h) => h(payload)));
+  }
+  async subscribeEvent(channel, handler) {
+    const set = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.subscribers.set(channel, set);
     return async () => {
-      this.eventHandlers.get(pattern)?.delete(handler);
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(channel);
     };
   }
-  // ==========================================
-  // 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;
+  async shutdown() {
+    this.workers.clear();
+    this.subscribers.clear();
+  }
+  toSearchResult(job) {
     return {
-      id: workerId,
+      id: job.id,
+      name: job.name,
+      queue: job.queue,
+      status: job.status,
+      input: job.input,
+      result: job.result,
+      error: job.error,
+      progress: job.progress,
+      attemptsMade: job.attemptsMade,
+      priority: job.priority,
+      createdAt: job.createdAt,
+      startedAt: job.startedAt,
+      completedAt: job.completedAt,
+      metadata: job.metadata,
+      scope: job.scope
+    };
+  }
+  toWorkerHandle(worker) {
+    return {
+      id: worker.id,
+      queues: worker.queues,
       pause: async () => {
-        const worker = this.workers.get(workerId);
-        if (worker) worker.paused = true;
+        worker.paused = true;
       },
       resume: async () => {
-        const worker = this.workers.get(workerId);
-        if (worker) worker.paused = false;
+        worker.paused = false;
+        for (const q of worker.queues) void this.kickWorkers(q);
       },
       close: async () => {
-        this.workers.delete(workerId);
+        worker.closed = true;
       },
-      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
-      })
+      isRunning: () => !worker.closed && !worker.paused,
+      isPaused: () => worker.paused,
+      isClosed: () => worker.closed,
+      getMetrics: async () => this.toWorkerMetrics(worker)
     };
   }
-  /**
-   * Start the internal job processing loop.
-   */
-  startProcessing() {
-    if (this.processingInterval) return;
-    this.processingInterval = setInterval(async () => {
-      await this.processJobs();
-    }, 100);
+  toWorkerMetrics(worker) {
+    const uptime = Date.now() - worker.startedAt.getTime();
+    const processed = worker.metrics.processed;
+    return {
+      processed,
+      failed: worker.metrics.failed,
+      avgDuration: processed > 0 ? worker.metrics.totalDuration / processed : 0,
+      concurrency: worker.concurrency,
+      uptime
+    };
   }
-  /**
-   * 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
-              });
-            }
-          }
-        }
-      }
+  async kickWorkers(queue) {
+    if (this.pausedQueues.has(queue)) return;
+    const relevant = Array.from(this.workers.values()).filter((w) => !w.closed && !w.paused && (w.queues.length === 0 || w.queues.includes(queue)));
+    if (relevant.length === 0) return;
+    for (const w of relevant) {
+      void this.processLoop(w, queue);
     }
   }
-  // ==========================================
-  // 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,
+  async processLoop(worker, queue) {
+    if (worker.closed || worker.paused) return;
+    const concurrency = Math.max(1, worker.concurrency);
+    const running = worker.__running;
+    const currentRunning = running ?? 0;
+    if (currentRunning >= concurrency) return;
+    worker.__running = currentRunning + 1;
+    try {
+      const next = this.nextJob(queue);
+      if (!next) return;
+      await this.processJob(worker, next);
+    } finally {
+      worker.__running = worker.__running - 1;
+      if (this.nextJob(queue)) void this.processLoop(worker, queue);
+      else if (worker.handlers?.onIdle) await worker.handlers.onIdle();
+    }
+  }
+  nextJob(queue) {
+    const ids = this.jobsByQueue.get(queue) ?? [];
+    const candidates = ids.map((id) => this.jobsById.get(id)).filter((j) => Boolean(j)).filter((j) => j.status === "waiting").sort((a, b) => b.priority - a.priority || a.createdAt.getTime() - b.createdAt.getTime());
+    return candidates[0] ?? null;
+  }
+  async processJob(worker, job) {
+    if (this.pausedQueues.has(job.queue)) {
+      job.status = "paused";
+      return;
+    }
+    job.status = "active";
+    job.startedAt = /* @__PURE__ */ new Date();
+    job.attemptsMade += 1;
+    job.logs.push({ timestamp: /* @__PURE__ */ new Date(), level: "info", message: "Job started" });
+    if (worker.handlers?.onActive) await worker.handlers.onActive({ job: this.toSearchResult(job) });
+    const start = Date.now();
+    try {
+      const definition = this.registeredJobs.get(job.queue)?.get(job.name);
+      if (!definition) {
+        throw new IgniterJobsError({
+          code: "JOBS_NOT_REGISTERED",
+          message: `Job "${job.name}" is not registered for queue "${job.queue}".`
+        });
+      }
+      if (definition.onStart) {
+        await definition.onStart({
+          input: job.input,
+          context: {},
+          job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
           scope: job.scope,
-          actor: job.actor
+          startedAt: job.startedAt
         });
       }
-    }
-    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
+      const result = await definition.handler({
+        input: job.input,
+        context: {},
+        job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
+        scope: job.scope
       });
+      const duration = Date.now() - start;
+      job.status = "completed";
+      job.completedAt = /* @__PURE__ */ new Date();
+      job.result = result;
+      job.progress = 100;
+      job.logs.push({ timestamp: /* @__PURE__ */ new Date(), level: "info", message: `Job completed in ${duration}ms` });
+      worker.metrics.processed += 1;
+      worker.metrics.totalDuration += duration;
+      if (definition.onSuccess) {
+        await definition.onSuccess({
+          input: job.input,
+          context: {},
+          job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
+          scope: job.scope,
+          result,
+          duration
+        });
+      }
+      if (worker.handlers?.onSuccess) await worker.handlers.onSuccess({ job: this.toSearchResult(job), result });
+    } catch (error) {
+      job.error = error?.message ?? String(error);
+      job.logs.push({ timestamp: /* @__PURE__ */ new Date(), level: "error", message: job.error ?? "Unknown error" });
+      const isFinalAttempt = job.attemptsMade >= job.maxAttempts;
+      if (isFinalAttempt) {
+        job.status = "failed";
+        job.completedAt = /* @__PURE__ */ new Date();
+        worker.metrics.failed += 1;
+        const definition = this.registeredJobs.get(job.queue)?.get(job.name);
+        if (definition?.onFailure) {
+          await definition.onFailure({
+            input: job.input,
+            context: {},
+            job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
+            scope: job.scope,
+            error,
+            isFinalAttempt: true
+          });
+        }
+        if (worker.handlers?.onFailure) await worker.handlers.onFailure({ job: this.toSearchResult(job), error });
+      } else {
+        job.status = "waiting";
+        void this.kickWorkers(job.queue);
+      }
     }
-    return results;
-  }
-  // ==========================================
-  // LIFECYCLE
-  // ==========================================
-  async shutdown() {
-    if (this.processingInterval) {
-      clearInterval(this.processingInterval);
-      this.processingInterval = null;
-    }
-    this.workers.clear();
-    this.queues.clear();
-    this.eventHandlers.clear();
   }
 };
 
-exports.MemoryAdapter = MemoryAdapter;
+exports.IgniterJobsMemoryAdapter = IgniterJobsMemoryAdapter;
 //# sourceMappingURL=memory.adapter.js.map
 //# sourceMappingURL=memory.adapter.js.map