@igniter-js/jobs 0.1.1 → 0.1.12

package/dist/adapters/index.js

@@ -1,9 +1,14 @@
 'use strict';
 
 var adapterBullmq = require('@igniter-js/adapter-bullmq');
-var core = require('@igniter-js/core');
+var common = require('@igniter-js/common');
 
-// src/adapters/bullmq.adapter.ts
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/utils/prefix.ts
 var _IgniterJobsPrefix = class _IgniterJobsPrefix {
@@ -33,7 +38,7 @@ var _IgniterJobsPrefix = class _IgniterJobsPrefix {
 };
 _IgniterJobsPrefix.BASE_PREFIX = "igniter:jobs";
 var IgniterJobsPrefix = _IgniterJobsPrefix;
-var IgniterJobsError = class extends core.IgniterError {
+var IgniterJobsError = class extends common.IgniterError {
   constructor(options) {
     super(options);
   }
@@ -655,10 +660,16 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   async retryJob(jobId, queue) {
     const job = this.jobsById.get(jobId);
     if (!job) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+      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}".` });
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
+      });
     }
     job.status = "waiting";
     job.error = void 0;
@@ -672,15 +683,25 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     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));
+    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_NOT_FOUND", message: `Job "${jobId}" not found.` });
+      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}".` });
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
+      });
     }
     if (job.status === "delayed" || job.status === "paused") {
       job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
@@ -690,10 +711,16 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   async moveJobToFailed(jobId, reason, queue) {
     const job = this.jobsById.get(jobId);
     if (!job) {
-      throw new IgniterJobsError({ code: "JOBS_NOT_FOUND", message: `Job "${jobId}" not found.` });
+      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}".` });
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found in queue "${queue}".`
+      });
     }
     job.status = "failed";
     job.error = reason;
@@ -733,7 +760,13 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     return counts;
   }
   async listQueues() {
-    const queues = Array.from(/* @__PURE__ */ new Set([...this.jobsByQueue.keys(), ...this.registeredJobs.keys(), ...this.registeredCrons.keys()]));
+    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));
@@ -770,7 +803,10 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
         removed++;
       }
     }
-    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    this.jobsByQueue.set(
+      queue,
+      jobIds.filter((id) => this.jobsById.has(id))
+    );
     return removed;
   }
   async cleanQueue(queue, options) {
@@ -790,7 +826,10 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       this.jobsById.delete(id);
       cleaned++;
     }
-    this.jobsByQueue.set(queue, jobIds.filter((id) => this.jobsById.has(id)));
+    this.jobsByQueue.set(
+      queue,
+      jobIds.filter((id) => this.jobsById.has(id))
+    );
     return cleaned;
   }
   async obliterateQueue(queue, options) {
@@ -819,7 +858,8 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     for (const id of jobIds) {
       const job = this.jobsById.get(id);
       if (!job) continue;
-      if (job.name === jobName && job.status === "waiting") job.status = "paused";
+      if (job.name === jobName && job.status === "waiting")
+        job.status = "paused";
     }
   }
   async resumeJobType(queue, jobName) {
@@ -827,7 +867,8 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     for (const id of jobIds) {
       const job = this.jobsById.get(id);
       if (!job) continue;
-      if (job.name === jobName && job.status === "paused") job.status = "waiting";
+      if (job.name === jobName && job.status === "paused")
+        job.status = "waiting";
     }
     void this.kickWorkers(queue);
   }
@@ -836,19 +877,25 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     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());
+    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 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);
+    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));
+    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");
@@ -868,7 +915,8 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   }
   getWorkers() {
     const out = /* @__PURE__ */ new Map();
-    for (const [id, state] of this.workers) out.set(id, this.toWorkerHandle(state));
+    for (const [id, state] of this.workers)
+      out.set(id, this.toWorkerHandle(state));
     return out;
   }
   async publishEvent(channel, payload) {
@@ -943,7 +991,9 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   }
   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)));
+    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);
@@ -968,7 +1018,9 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   }
   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());
+    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) {
@@ -979,8 +1031,13 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
     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) });
+    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);
@@ -994,7 +1051,13 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
         await definition.onStart({
           input: job.input,
           context: {},
-          job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade,
+            metadata: job.metadata
+          },
           scope: job.scope,
           startedAt: job.startedAt
         });
@@ -1002,7 +1065,13 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       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 },
+        job: {
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          attemptsMade: job.attemptsMade,
+          metadata: job.metadata
+        },
         scope: job.scope
       });
       const duration = Date.now() - start;
@@ -1010,23 +1079,41 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
       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` });
+      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 },
+          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 });
+      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" });
+      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";
@@ -1037,13 +1124,23 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
           await definition.onFailure({
             input: job.input,
             context: {},
-            job: { id: job.id, name: job.name, queue: job.queue, attemptsMade: job.attemptsMade, metadata: job.metadata },
+            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 });
+        if (worker.handlers?.onFailure)
+          await worker.handlers.onFailure({
+            job: this.toSearchResult(job),
+            error
+          });
       } else {
         job.status = "waiting";
         void this.kickWorkers(job.queue);
@@ -1052,7 +1149,743 @@ var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
   }
 };
 
+// src/adapters/sqlite.adapter.ts
+var IgniterJobsSQLiteAdapter = class _IgniterJobsSQLiteAdapter {
+  constructor(options) {
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.registeredCrons = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.pausedQueues = /* @__PURE__ */ new Set();
+    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.options = {
+      path: options.path,
+      pollingInterval: options.pollingInterval ?? 500,
+      enableWAL: options.enableWAL ?? true
+    };
+    this.client = {
+      type: "sqlite",
+      path: this.options.path
+    };
+    const Database = __require("better-sqlite3");
+    this.db = new Database(this.options.path);
+    this.initializeSchema();
+  }
+  /**
+   * Creates a new SQLite adapter instance.
+   *
+   * @param options - Configuration options
+   * @returns A new adapter instance
+   *
+   * @example
+   * ```ts
+   * // File-based database (persistent)
+   * const adapter = IgniterJobsSQLiteAdapter.create({
+   *   path: './data/jobs.sqlite'
+   * });
+   *
+   * // In-memory database (for testing)
+   * const testAdapter = IgniterJobsSQLiteAdapter.create({
+   *   path: ':memory:'
+   * });
+   * ```
+   */
+  static create(options) {
+    return new _IgniterJobsSQLiteAdapter(options);
+  }
+  initializeSchema() {
+    if (this.options.enableWAL) {
+      this.db.exec("PRAGMA journal_mode = WAL;");
+    }
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS jobs (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        queue TEXT NOT NULL,
+        input TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'waiting',
+        progress REAL NOT NULL DEFAULT 0,
+        attempts_made INTEGER NOT NULL DEFAULT 0,
+        max_attempts INTEGER NOT NULL DEFAULT 1,
+        priority INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT NOT NULL,
+        started_at TEXT,
+        completed_at TEXT,
+        scheduled_at TEXT,
+        result TEXT,
+        error TEXT,
+        metadata TEXT,
+        scope TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_jobs_queue_status ON jobs(queue, status);
+      CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+      CREATE INDEX IF NOT EXISTS idx_jobs_scheduled_at ON jobs(scheduled_at);
+      CREATE INDEX IF NOT EXISTS idx_jobs_priority ON jobs(priority DESC, created_at ASC);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS job_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        job_id TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        FOREIGN KEY (job_id) REFERENCES jobs(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_job_logs_job_id ON job_logs(job_id);
+    `);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS paused_queues (
+        name TEXT PRIMARY KEY
+      );
+    `);
+    const pausedRows = this.db.prepare(
+      "SELECT name FROM paused_queues"
+    ).all();
+    for (const row of pausedRows) {
+      this.pausedQueues.add(row.name);
+    }
+  }
+  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}".`
+      });
+    }
+    queueJobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, queueJobs);
+  }
+  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);
+  }
+  async dispatch(params) {
+    const jobId = params.jobId ?? IgniterJobsIdGenerator.generate("job");
+    const maxAttempts = params.attempts ?? 1;
+    const now = /* @__PURE__ */ new Date();
+    let status = "waiting";
+    let scheduledAt = null;
+    if (this.pausedQueues.has(params.queue)) {
+      status = "paused";
+    } else if (params.delay && params.delay > 0) {
+      status = "delayed";
+      scheduledAt = new Date(now.getTime() + params.delay);
+    }
+    const stmt = this.db.prepare(`
+      INSERT INTO jobs (
+        id, name, queue, input, status, progress, attempts_made, max_attempts,
+        priority, created_at, scheduled_at, metadata, scope
+      ) VALUES (?, ?, ?, ?, ?, 0, 0, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(
+      jobId,
+      params.jobName,
+      params.queue,
+      JSON.stringify(params.input ?? {}),
+      status,
+      maxAttempts,
+      params.priority ?? 0,
+      now.toISOString(),
+      scheduledAt?.toISOString() ?? null,
+      params.metadata ? JSON.stringify(params.metadata) : null,
+      params.scope ? JSON.stringify(params.scope) : null
+    );
+    if (params.delay && params.delay > 0) {
+      setTimeout(() => {
+        this.promoteDelayedJob(jobId, params.queue);
+      }, params.delay);
+    }
+    return jobId;
+  }
+  promoteDelayedJob(jobId, queue) {
+    if (this.pausedQueues.has(queue)) return;
+    const stmt = this.db.prepare(`
+      UPDATE jobs SET status = 'waiting', scheduled_at = NULL
+      WHERE id = ? AND status = 'delayed'
+    `);
+    stmt.run(jobId);
+  }
+  async schedule(params) {
+    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 getJob(jobId, queue) {
+    let sql = "SELECT * FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    if (!row) return null;
+    return this.rowToSearchResult(row);
+  }
+  async getJobState(jobId, queue) {
+    let sql = "SELECT status FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row?.status ?? null;
+  }
+  async getJobLogs(jobId, queue) {
+    if (queue) {
+      const job = await this.getJob(jobId, queue);
+      if (!job) return [];
+    }
+    const rows = this.db.prepare("SELECT * FROM job_logs WHERE job_id = ? ORDER BY timestamp ASC").all(jobId);
+    return rows.map((row) => ({
+      timestamp: new Date(row.timestamp),
+      level: row.level,
+      message: row.message
+    }));
+  }
+  async getJobProgress(jobId, queue) {
+    let sql = "SELECT progress FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row?.progress ?? 0;
+  }
+  async retryJob(jobId, queue) {
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const exists = this.db.prepare(sql).get(...checkParams);
+    if (!exists) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    let updateSql = "UPDATE jobs SET status = 'waiting', error = NULL, completed_at = NULL, progress = 0 WHERE id = ?";
+    const updateParams = [jobId];
+    if (queue) {
+      updateSql = updateSql.replace("WHERE id = ?", "WHERE id = ? AND queue = ?");
+      updateParams.push(queue);
+    }
+    this.db.prepare(updateSql).run(...updateParams);
+  }
+  async removeJob(jobId, queue) {
+    let sql = "DELETE FROM jobs WHERE id = ?";
+    const params = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    this.db.prepare(sql).run(...params);
+  }
+  async promoteJob(jobId, queue) {
+    let sql = "SELECT id, status, queue FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const row = this.db.prepare(sql).get(...checkParams);
+    if (!row) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    if (row.status === "delayed" || row.status === "paused") {
+      const newStatus = this.pausedQueues.has(row.queue) ? "paused" : "waiting";
+      this.db.prepare("UPDATE jobs SET status = ?, scheduled_at = NULL WHERE id = ?").run(newStatus, jobId);
+    }
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    let sql = "SELECT id FROM jobs WHERE id = ?";
+    const checkParams = [jobId];
+    if (queue) {
+      sql += " AND queue = ?";
+      checkParams.push(queue);
+    }
+    const exists = this.db.prepare(sql).get(...checkParams);
+    if (!exists) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    this.db.prepare(`
+      UPDATE jobs SET status = 'failed', error = ?, completed_at = ?
+      WHERE id = ?
+    `).run(reason, (/* @__PURE__ */ new Date()).toISOString(), jobId);
+  }
+  async retryManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.retryJob(id, queue)));
+  }
+  async removeManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((id) => this.removeJob(id, queue)));
+  }
+  async getQueueInfo(queue) {
+    const counts = await this.getQueueJobCounts(queue);
+    return {
+      name: queue,
+      isPaused: this.pausedQueues.has(queue),
+      jobCounts: counts
+    };
+  }
+  async getQueueJobCounts(queue) {
+    const counts = {
+      waiting: 0,
+      active: 0,
+      completed: 0,
+      failed: 0,
+      delayed: 0,
+      paused: 0
+    };
+    const rows = this.db.prepare(
+      "SELECT status, COUNT(*) as count FROM jobs WHERE queue = ? GROUP BY status"
+    ).all(queue);
+    for (const row of rows) {
+      if (row.status in counts) {
+        counts[row.status] = row.count;
+      }
+    }
+    return counts;
+  }
+  async listQueues() {
+    const jobQueues = this.db.prepare("SELECT DISTINCT queue FROM jobs").all().map((r) => r.queue);
+    const allQueues = /* @__PURE__ */ new Set([
+      ...jobQueues,
+      ...this.registeredJobs.keys(),
+      ...this.registeredCrons.keys()
+    ]);
+    const result = [];
+    for (const q of allQueues) {
+      const info = await this.getQueueInfo(q);
+      if (info) result.push(info);
+    }
+    return result;
+  }
+  async pauseQueue(queue) {
+    this.pausedQueues.add(queue);
+    this.db.prepare("INSERT OR IGNORE INTO paused_queues (name) VALUES (?)").run(queue);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'paused' WHERE queue = ? AND status = 'waiting'"
+    ).run(queue);
+  }
+  async resumeQueue(queue) {
+    this.pausedQueues.delete(queue);
+    this.db.prepare("DELETE FROM paused_queues WHERE name = ?").run(queue);
+    this.db.prepare(
+      "UPDATE jobs SET status = 'waiting' WHERE queue = ? AND status = 'paused'"
+    ).run(queue);
+  }
+  async drainQueue(queue) {
+    const result = this.db.prepare(
+      "DELETE FROM jobs WHERE queue = ? AND status IN ('waiting', 'paused')"
+    ).run(queue);
+    return result.changes;
+  }
+  async cleanQueue(queue, options) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    const olderThan = options.olderThan ?? 0;
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    const cutoffTime = new Date(Date.now() - olderThan).toISOString();
+    const statusPlaceholders = statuses.map(() => "?").join(", ");
+    let sql = `
+      DELETE FROM jobs WHERE id IN (
+        SELECT id FROM jobs
+        WHERE queue = ? AND status IN (${statusPlaceholders}) AND created_at < ?
+        ORDER BY created_at ASC
+        LIMIT ?
+      )
+    `;
+    const result = this.db.prepare(sql).run(
+      queue,
+      ...statuses,
+      cutoffTime,
+      limit === Number.POSITIVE_INFINITY ? -1 : limit
+    );
+    return result.changes;
+  }
+  async obliterateQueue(queue, _options) {
+    this.db.prepare("DELETE FROM jobs WHERE queue = ?").run(queue);
+    this.registeredJobs.delete(queue);
+    this.registeredCrons.delete(queue);
+    this.pausedQueues.delete(queue);
+    this.db.prepare("DELETE FROM paused_queues WHERE name = ?").run(queue);
+  }
+  async retryAllInQueue(queue) {
+    const result = this.db.prepare(`
+      UPDATE jobs SET status = 'waiting', error = NULL, completed_at = NULL, progress = 0
+      WHERE queue = ? AND status = 'failed'
+    `).run(queue);
+    return result.changes;
+  }
+  async pauseJobType(queue, jobName) {
+    this.db.prepare(
+      "UPDATE jobs SET status = 'paused' WHERE queue = ? AND name = ? AND status = 'waiting'"
+    ).run(queue, jobName);
+  }
+  async resumeJobType(queue, jobName) {
+    this.db.prepare(
+      "UPDATE jobs SET status = 'waiting' WHERE queue = ? AND name = ? AND status = 'paused'"
+    ).run(queue, jobName);
+  }
+  async searchJobs(filter) {
+    const queue = filter?.queue;
+    const statuses = filter?.status;
+    const limit = filter?.limit ?? 100;
+    const offset = filter?.offset ?? 0;
+    let sql = "SELECT * FROM jobs WHERE 1=1";
+    const params = [];
+    if (queue) {
+      sql += " AND queue = ?";
+      params.push(queue);
+    }
+    if (statuses && statuses.length > 0) {
+      const placeholders = statuses.map(() => "?").join(", ");
+      sql += ` AND status IN (${placeholders})`;
+      params.push(...statuses);
+    }
+    sql += " ORDER BY priority DESC, created_at ASC LIMIT ? OFFSET ?";
+    params.push(limit, offset);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.rowToSearchResult(row));
+  }
+  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,
+      activeJobs: 0
+    };
+    this.workers.set(workerId, state);
+    this.startPollingLoop(state);
+    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 () => {
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(channel);
+    };
+  }
+  async shutdown() {
+    for (const worker of this.workers.values()) {
+      worker.closed = true;
+      if (worker.pollingTimer) {
+        clearInterval(worker.pollingTimer);
+      }
+    }
+    this.workers.clear();
+    this.subscribers.clear();
+    this.db.close();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  rowToSearchResult(row) {
+    return {
+      id: row.id,
+      name: row.name,
+      queue: row.queue,
+      status: row.status,
+      input: JSON.parse(row.input),
+      result: row.result ? JSON.parse(row.result) : void 0,
+      error: row.error ?? void 0,
+      progress: row.progress,
+      attemptsMade: row.attempts_made,
+      priority: row.priority,
+      createdAt: new Date(row.created_at),
+      startedAt: row.started_at ? new Date(row.started_at) : void 0,
+      completedAt: row.completed_at ? new Date(row.completed_at) : void 0,
+      metadata: row.metadata ? JSON.parse(row.metadata) : void 0,
+      scope: row.scope ? JSON.parse(row.scope) : void 0
+    };
+  }
+  toWorkerHandle(worker) {
+    return {
+      id: worker.id,
+      queues: worker.queues,
+      pause: async () => {
+        worker.paused = true;
+      },
+      resume: async () => {
+        worker.paused = false;
+      },
+      close: async () => {
+        worker.closed = true;
+        if (worker.pollingTimer) {
+          clearInterval(worker.pollingTimer);
+        }
+      },
+      isRunning: () => !worker.closed && !worker.paused,
+      isPaused: () => worker.paused,
+      isClosed: () => worker.closed,
+      getMetrics: async () => this.toWorkerMetrics(worker)
+    };
+  }
+  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
+    };
+  }
+  startPollingLoop(worker) {
+    const poll = () => {
+      if (worker.closed || worker.paused) return;
+      void this.processNextJobs(worker);
+    };
+    poll();
+    worker.pollingTimer = setInterval(poll, this.options.pollingInterval);
+  }
+  async processNextJobs(worker) {
+    if (worker.closed || worker.paused) return;
+    const availableSlots = worker.concurrency - worker.activeJobs;
+    if (availableSlots <= 0) return;
+    const queueFilter = worker.queues.length > 0 ? `queue IN (${worker.queues.map(() => "?").join(", ")})` : "1=1";
+    const params = worker.queues.length > 0 ? [...worker.queues, availableSlots] : [availableSlots];
+    const rows = this.db.prepare(`
+      SELECT * FROM jobs
+      WHERE status = 'waiting' AND ${queueFilter}
+      ORDER BY priority DESC, created_at ASC
+      LIMIT ?
+    `).all(...params);
+    for (const row of rows) {
+      if (worker.closed || worker.paused) break;
+      if (worker.activeJobs >= worker.concurrency) break;
+      const claimed = this.db.prepare(`
+        UPDATE jobs SET status = 'active', started_at = ?
+        WHERE id = ? AND status = 'waiting'
+      `).run((/* @__PURE__ */ new Date()).toISOString(), row.id);
+      if (claimed.changes === 0) continue;
+      worker.activeJobs++;
+      void this.processJob(worker, row.id).finally(() => {
+        worker.activeJobs--;
+        if (worker.handlers?.onIdle && worker.activeJobs === 0) {
+          void worker.handlers.onIdle();
+        }
+      });
+    }
+  }
+  async processJob(worker, jobId) {
+    const row = this.db.prepare("SELECT * FROM jobs WHERE id = ?").get(jobId);
+    if (!row) return;
+    const job = this.rowToSearchResult(row);
+    this.addJobLog(jobId, "info", "Job started");
+    if (worker.handlers?.onActive) {
+      await worker.handlers.onActive({ job });
+    }
+    const start = Date.now();
+    try {
+      const definition = this.registeredJobs.get(row.queue)?.get(row.name);
+      if (!definition) {
+        throw new IgniterJobsError({
+          code: "JOBS_NOT_REGISTERED",
+          message: `Job "${row.name}" is not registered for queue "${row.queue}".`
+        });
+      }
+      this.db.prepare("UPDATE jobs SET attempts_made = attempts_made + 1 WHERE id = ?").run(jobId);
+      if (definition.onStart) {
+        await definition.onStart({
+          input: job.input,
+          context: {},
+          job: {
+            id: job.id,
+            name: job.name,
+            queue: job.queue,
+            attemptsMade: job.attemptsMade + 1,
+            metadata: job.metadata
+          },
+          scope: job.scope,
+          startedAt: /* @__PURE__ */ new Date()
+        });
+      }
+      const result = await definition.handler({
+        input: job.input,
+        context: {},
+        job: {
+          id: job.id,
+          name: job.name,
+          queue: job.queue,
+          attemptsMade: job.attemptsMade + 1,
+          metadata: job.metadata
+        },
+        scope: job.scope
+      });
+      const duration = Date.now() - start;
+      this.db.prepare(`
+        UPDATE jobs SET status = 'completed', completed_at = ?, result = ?, progress = 100
+        WHERE id = ?
+      `).run((/* @__PURE__ */ new Date()).toISOString(), JSON.stringify(result), jobId);
+      this.addJobLog(jobId, "info", `Job completed in ${duration}ms`);
+      worker.metrics.processed++;
+      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 + 1,
+            metadata: job.metadata
+          },
+          scope: job.scope,
+          result,
+          duration
+        });
+      }
+      if (worker.handlers?.onSuccess) {
+        const updatedJob = await this.getJob(jobId);
+        if (updatedJob) {
+          await worker.handlers.onSuccess({ job: updatedJob, result });
+        }
+      }
+    } catch (error) {
+      const errorMessage = error?.message ?? String(error);
+      this.addJobLog(jobId, "error", errorMessage);
+      const current = this.db.prepare(
+        "SELECT attempts_made, max_attempts FROM jobs WHERE id = ?"
+      ).get(jobId);
+      const isFinalAttempt = (current?.attempts_made ?? 0) >= (current?.max_attempts ?? 1);
+      if (isFinalAttempt) {
+        this.db.prepare(`
+          UPDATE jobs SET status = 'failed', error = ?, completed_at = ?
+          WHERE id = ?
+        `).run(errorMessage, (/* @__PURE__ */ new Date()).toISOString(), jobId);
+        worker.metrics.failed++;
+        const definition = this.registeredJobs.get(row.queue)?.get(row.name);
+        if (definition?.onFailure) {
+          await definition.onFailure({
+            input: job.input,
+            context: {},
+            job: {
+              id: job.id,
+              name: job.name,
+              queue: job.queue,
+              attemptsMade: current?.attempts_made ?? 1,
+              metadata: job.metadata
+            },
+            scope: job.scope,
+            error,
+            isFinalAttempt: true
+          });
+        }
+        if (worker.handlers?.onFailure) {
+          const updatedJob = await this.getJob(jobId);
+          if (updatedJob) {
+            await worker.handlers.onFailure({ job: updatedJob, error });
+          }
+        }
+      } else {
+        this.db.prepare("UPDATE jobs SET status = 'waiting' WHERE id = ?").run(jobId);
+      }
+    }
+  }
+  addJobLog(jobId, level, message) {
+    this.db.prepare(`
+      INSERT INTO job_logs (job_id, timestamp, level, message)
+      VALUES (?, ?, ?, ?)
+    `).run(jobId, (/* @__PURE__ */ new Date()).toISOString(), level, message);
+  }
+};
+
 exports.IgniterJobsBullMQAdapter = IgniterJobsBullMQAdapter;
 exports.IgniterJobsMemoryAdapter = IgniterJobsMemoryAdapter;
+exports.IgniterJobsSQLiteAdapter = IgniterJobsSQLiteAdapter;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map