@igniter-js/jobs 0.1.13 → 0.1.14

package/dist/adapters/index.mjs

@@ -1,1887 +0,0 @@
-import { createBullMQAdapter } from '@igniter-js/adapter-bullmq';
-import { IgniterError } from '@igniter-js/common';
-
-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 {
-  /**
-   * 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}`;
-  }
-  /**
-   * 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.
-   */
-  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
-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.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)
-    };
-  }
-  static create(options) {
-    return new _IgniterJobsBullMQAdapter(options);
-  }
-  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}".`
-      });
-    }
-    map.set(jobName, definition);
-    this.jobsByQueue.set(queueName, map);
-    this.executorDirty = true;
-  }
-  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}".`
-      });
-    }
-    map.set(cronName, definition);
-    this.cronsByQueue.set(queueName, map);
-    this.executorDirty = true;
-  }
-  async dispatch(params) {
-    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,
-      metadata: params.metadata,
-      removeOnComplete: params.removeOnComplete,
-      removeOnFail: params.removeOnFail,
-      limiter: params.limiter
-    });
-  }
-  async schedule(params) {
-    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.delay,
-      priority: params.priority,
-      attempts: params.attempts,
-      metadata: params.metadata,
-      removeOnComplete: params.removeOnComplete,
-      removeOnFail: params.removeOnFail,
-      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
-    };
-    return namespace.schedule({
-      task: params.jobName,
-      input: params.input,
-      ...schedule
-    });
-  }
-  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 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) {
-    await this.core().queues.pause(this.toCoreQueueName(queue));
-  }
-  async resumeQueue(queue) {
-    await this.core().queues.resume(this.toCoreQueueName(queue));
-  }
-  async drainQueue(queue) {
-    return this.core().queues.drain(this.toCoreQueueName(queue));
-  }
-  async cleanQueue(queue, options) {
-    return this.core().queues.clean(this.toCoreQueueName(queue), options);
-  }
-  async obliterateQueue(queue, options) {
-    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 pauseJobType(queue, jobName) {
-    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) {
-    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 () => {
-      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);
-      }
-    };
-  }
-  async shutdown() {
-    await this.subscriber.quit();
-  }
-  core() {
-    if (!this.coreAdapter) {
-      this.coreAdapter = createBullMQAdapter({
-        store: { client: this.redis }
-      });
-    }
-    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);
-        }
-      }
-      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;
-      }
-    }
-    await this.core().bulkRegister(flattened);
-    this.coreExecutor = this.core().merge(routers);
-    this.executorDirty = false;
-    return this.coreExecutor;
-  }
-  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 {
-      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
-    };
-  }
-  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
-    };
-  }
-};
-
-// src/utils/id-generator.ts
-var IgniterJobsIdGenerator = class {
-  /**
-   * Generates a unique identifier with a prefix.
-   *
-   * @example
-   * ```typescript
-   * const jobId = IgniterJobsIdGenerator.generate('job')
-   * ```
-   */
-  static generate(prefix) {
-    const now = Date.now().toString(36);
-    const random = Math.random().toString(36).slice(2, 8);
-    return `${prefix}_${now}_${random}`;
-  }
-};
-
-// src/adapters/memory.adapter.ts
-var IgniterJobsMemoryAdapter = class _IgniterJobsMemoryAdapter {
-  constructor() {
-    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.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();
-  }
-  static create() {
-    return new _IgniterJobsMemoryAdapter();
-  }
-  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 metadata = params.metadata ?? {};
-    const job = {
-      id: jobId,
-      name: params.jobName,
-      queue: params.queue,
-      input: params.input,
-      status: this.pausedQueues.has(params.queue) ? "paused" : params.delay && params.delay > 0 ? "delayed" : "waiting",
-      progress: 0,
-      attemptsMade: 0,
-      maxAttempts,
-      priority: params.priority ?? 0,
-      createdAt: /* @__PURE__ */ new Date(),
-      metadata,
-      scope: params.scope,
-      logs: []
-    };
-    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) {
-    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) {
-    const job = this.jobsById.get(jobId);
-    if (!job) return null;
-    if (queue && job.queue !== queue) return null;
-    return this.toSearchResult(job);
-  }
-  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_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.status = "waiting";
-    job.error = void 0;
-    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_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.status === "delayed" || job.status === "paused") {
-      job.status = this.pausedQueues.has(job.queue) ? "paused" : "waiting";
-      void this.kickWorkers(job.queue);
-    }
-  }
-  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.`
-      });
-    }
-    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 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 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) {
-    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) {
-    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 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++;
-      }
-    }
-    this.jobsByQueue.set(
-      queue,
-      jobIds.filter((id) => this.jobsById.has(id))
-    );
-    return removed;
-  }
-  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 jobIds = this.jobsByQueue.get(queue) ?? [];
-    const now = Date.now();
-    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++;
-    }
-    this.jobsByQueue.set(
-      queue,
-      jobIds.filter((id) => this.jobsById.has(id))
-    );
-    return cleaned;
-  }
-  async obliterateQueue(queue, options) {
-    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 retried;
-  }
-  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";
-    }
-  }
-  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";
-    }
-    void this.kickWorkers(queue);
-  }
-  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 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 () => {
-      const current = this.subscribers.get(channel);
-      if (!current) return;
-      current.delete(handler);
-      if (current.size === 0) this.subscribers.delete(channel);
-    };
-  }
-  async shutdown() {
-    this.workers.clear();
-    this.subscribers.clear();
-  }
-  toSearchResult(job) {
-    return {
-      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 () => {
-        worker.paused = true;
-      },
-      resume: async () => {
-        worker.paused = false;
-        for (const q of worker.queues) void this.kickWorkers(q);
-      },
-      close: async () => {
-        worker.closed = true;
-      },
-      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
-    };
-  }
-  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);
-    }
-  }
-  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,
-          startedAt: job.startedAt
-        });
-      }
-      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);
-      }
-    }
-  }
-};
-
-// 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);
-  }
-};
-
-export { IgniterJobsBullMQAdapter, IgniterJobsMemoryAdapter, IgniterJobsSQLiteAdapter };
-//# sourceMappingURL=index.mjs.map
-//# sourceMappingURL=index.mjs.map