@igniter-js/jobs 0.1.13 → 0.1.15

package/dist/adapters/bun.js

@@ -0,0 +1,1048 @@
+'use strict';
+
+var promises = require('fs/promises');
+var path = require('path');
+var common = require('@igniter-js/common');
+
+// src/adapters/bun-sqlite.adapter.ts
+
+// 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}`;
+  }
+};
+var IgniterJobsError = class extends common.IgniterError {
+  constructor(options) {
+    super(options);
+  }
+};
+
+// src/adapters/bun-sqlite.adapter.ts
+var IgniterJobsBunSQLiteAdapter = class _IgniterJobsBunSQLiteAdapter {
+  constructor(options) {
+    this.queues = {
+      list: async () => this.listQueues(),
+      get: async (name) => this.getQueueInfo(name),
+      getJobCounts: async (name) => this.getQueueJobCounts(name),
+      getJobs: async (name, filter) => this.searchJobs({
+        queue: name,
+        status: filter?.status,
+        limit: filter?.limit,
+        offset: filter?.offset
+      }),
+      pause: async (name) => this.pauseQueue(name),
+      resume: async (name) => this.resumeQueue(name),
+      isPaused: async (name) => (await this.getQueueInfo(name))?.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.bunqueueModulePromise = null;
+    this.queueRuntimes = /* @__PURE__ */ new Map();
+    this.workers = /* @__PURE__ */ new Map();
+    this.subscribers = /* @__PURE__ */ new Map();
+    this.streamSubscribers = /* @__PURE__ */ new Map();
+    this.registeredJobs = /* @__PURE__ */ new Map();
+    this.streamDatabasePromise = null;
+    this.registeredCrons = /* @__PURE__ */ new Map();
+    this.options = {
+      path: options.path,
+      durable: options.durable ?? false,
+      heartbeatInterval: options.heartbeatInterval ?? 1e4,
+      pollTimeout: options.pollTimeout ?? 0,
+      batchSize: options.batchSize ?? 10,
+      lockDuration: options.lockDuration ?? 3e4,
+      maxStalledCount: options.maxStalledCount ?? 1
+    };
+    this.client = {
+      type: "bun-sqlite",
+      path: this.options.path
+    };
+  }
+  static create(options) {
+    return new _IgniterJobsBunSQLiteAdapter(options);
+  }
+  registerJob(queueName, jobName, definition) {
+    const jobs = this.registeredJobs.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (jobs.has(jobName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_DUPLICATE_JOB",
+        message: `Job "${jobName}" already registered for queue "${queueName}".`
+      });
+    }
+    jobs.set(jobName, definition);
+    this.registeredJobs.set(queueName, jobs);
+    this.markQueueCronsDirty(queueName);
+  }
+  registerCron(queueName, cronName, definition) {
+    const crons = this.registeredCrons.get(queueName) ?? /* @__PURE__ */ new Map();
+    if (crons.has(cronName)) {
+      throw new IgniterJobsError({
+        code: "JOBS_INVALID_CRON",
+        message: `Cron "${cronName}" already registered for queue "${queueName}".`
+      });
+    }
+    crons.set(cronName, definition);
+    this.registeredCrons.set(queueName, crons);
+    this.markQueueCronsDirty(queueName);
+  }
+  async dispatch(params) {
+    const queue = await this.getQueue(params.queue);
+    const job = await queue.add(
+      params.jobName,
+      this.createEnvelope(params.input, params.metadata, params.scope),
+      this.toJobOptions(params)
+    );
+    return job.id;
+  }
+  async schedule(params) {
+    const queue = await this.getQueue(params.queue);
+    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."
+        });
+      }
+      const job2 = await queue.add(
+        params.jobName,
+        this.createEnvelope(params.input, params.metadata, params.scope),
+        this.toJobOptions({ ...params, delay })
+      );
+      return job2.id;
+    }
+    const scheduleEnvelope = this.createEnvelope(
+      params.input,
+      params.metadata,
+      params.scope,
+      params
+    );
+    if (params.cron || params.every) {
+      const job2 = await queue.add(
+        params.jobName,
+        scheduleEnvelope,
+        this.toJobOptions(params, {
+          repeat: {
+            pattern: params.cron,
+            every: params.every,
+            limit: params.maxExecutions,
+            tz: params.tz
+          }
+        })
+      );
+      return job2.id;
+    }
+    const job = await queue.add(
+      params.jobName,
+      scheduleEnvelope,
+      this.toJobOptions(params)
+    );
+    return job.id;
+  }
+  async getJob(jobId, queue) {
+    if (queue) {
+      const job = await this.getQueue(queue).then((q) => q.getJob(jobId));
+      return job ? this.mapJob(job, queue) : null;
+    }
+    for (const queueName of await this.getAllQueueNames()) {
+      const job = await this.getQueue(queueName).then((q) => q.getJob(jobId));
+      if (job) return this.mapJob(job, queueName);
+    }
+    return null;
+  }
+  async getJobState(jobId, queue) {
+    const job = await this.getJob(jobId, queue);
+    return job?.status ?? null;
+  }
+  async getJobLogs(jobId, queue) {
+    const queueName = queue ?? await this.findQueueByJobId(jobId);
+    if (!queueName) return [];
+    const logs = await this.getQueue(queueName).then(
+      (q) => q.getJobLogs(jobId)
+    );
+    return logs.logs.map((entry) => this.parseLogEntry(entry));
+  }
+  async getJobProgress(jobId, queue) {
+    const job = await this.getJob(jobId, queue);
+    return job?.progress ?? 0;
+  }
+  async retryJob(jobId, queue) {
+    const job = await this.requireJob(jobId, queue);
+    await job.retry();
+  }
+  async removeJob(jobId, queue) {
+    const job = await this.requireJob(jobId, queue);
+    await job.remove();
+  }
+  async promoteJob(jobId, queue) {
+    const job = await this.requireJob(jobId, queue);
+    await job.promote();
+  }
+  async moveJobToFailed(jobId, reason, queue) {
+    const queueName = queue ?? await this.findQueueByJobId(jobId);
+    if (!queueName) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found.`
+      });
+    }
+    await this.getQueue(queueName).then(
+      (q) => q.moveJobToFailed(jobId, new Error(reason))
+    );
+  }
+  async retryManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((jobId) => this.retryJob(jobId, queue)));
+  }
+  async removeManyJobs(jobIds, queue) {
+    await Promise.all(jobIds.map((jobId) => this.removeJob(jobId, queue)));
+  }
+  async getQueueInfo(queue) {
+    const counts = await this.getQueueJobCounts(queue);
+    return {
+      name: queue,
+      isPaused: await this.getQueue(queue).then((q) => q.isPausedAsync()),
+      jobCounts: counts
+    };
+  }
+  async getQueueJobCounts(queue) {
+    const counts = await this.getQueue(queue).then(
+      (q) => q.getJobCountsAsync()
+    );
+    return {
+      waiting: counts.waiting + counts.prioritized,
+      active: counts.active,
+      completed: counts.completed,
+      failed: counts.failed,
+      delayed: counts.delayed,
+      paused: counts.paused
+    };
+  }
+  async listQueues() {
+    const queueNames = await this.getAllQueueNames();
+    return Promise.all(
+      queueNames.map((queueName) => this.getQueueInfo(queueName))
+    ).then((queues) => queues.filter(Boolean));
+  }
+  async pauseQueue(queue) {
+    const queueClient = await this.getQueue(queue);
+    queueClient.pause();
+    for (const worker of this.workers.values()) {
+      if (worker.workers.has(queue)) {
+        worker.paused = true;
+        worker.workers.get(queue)?.pause();
+      }
+    }
+  }
+  async resumeQueue(queue) {
+    const queueClient = await this.getQueue(queue);
+    queueClient.resume();
+    for (const worker of this.workers.values()) {
+      if (worker.workers.has(queue)) {
+        worker.paused = false;
+        worker.workers.get(queue)?.resume();
+      }
+    }
+  }
+  async drainQueue(queue) {
+    const queueClient = await this.getQueue(queue);
+    const before = await this.getQueueJobCounts(queue);
+    queueClient.drain();
+    const after = await this.getQueueJobCounts(queue);
+    return Math.max(
+      0,
+      before.waiting + before.delayed + before.paused - after.waiting - after.delayed - after.paused
+    );
+  }
+  async cleanQueue(queue, options) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    let cleaned = 0;
+    const queueClient = await this.getQueue(queue);
+    for (const status of statuses) {
+      const removed = await queueClient.cleanAsync(
+        options.olderThan ?? 0,
+        options.limit ?? 1e3,
+        this.toBunqueueStatus(status)
+      );
+      cleaned += removed.length;
+    }
+    return cleaned;
+  }
+  async obliterateQueue(queue, _options) {
+    const queueClient = await this.getQueue(queue);
+    queueClient.obliterate();
+    this.registeredJobs.delete(queue);
+    this.registeredCrons.delete(queue);
+    this.queueRuntimes.delete(queue);
+  }
+  async retryAllInQueue(queue) {
+    const queueClient = await this.getQueue(queue);
+    const failedJobs = await queueClient.getFailedAsync(0, 1e4);
+    await queueClient.retryJobs({
+      state: "failed",
+      count: failedJobs.length || 1e4
+    });
+    return failedJobs.length;
+  }
+  async searchJobs(filter) {
+    const queueName = filter.queue;
+    const statuses = filter.status;
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    const queueNames = queueName ? [queueName] : await this.getAllQueueNames();
+    const mappedStates = statuses?.flatMap(
+      (status) => this.toBunqueueStates(status)
+    );
+    const results = [];
+    for (const currentQueue of queueNames) {
+      const queueClient = await this.getQueue(currentQueue);
+      const jobs = await queueClient.getJobsAsync({
+        state: mappedStates,
+        start: 0,
+        end: offset + limit - 1
+      });
+      for (const job of jobs) {
+        results.push(
+          await this.mapJob(job, currentQueue)
+        );
+      }
+    }
+    return results.slice(offset, offset + limit);
+  }
+  async searchQueues(filter) {
+    const queues = await this.listQueues();
+    const name = filter.name;
+    const isPaused = filter.isPaused;
+    return queues.filter((queue) => name ? queue.name.includes(name) : true).filter(
+      (queue) => typeof isPaused === "boolean" ? queue.isPaused === isPaused : true
+    );
+  }
+  async searchWorkers(filter) {
+    const queue = filter.queue;
+    const isRunning = filter.isRunning;
+    return Array.from(this.workers.values()).filter((worker) => queue ? worker.queues.includes(queue) : true).filter(
+      (worker) => typeof isRunning === "boolean" ? isRunning ? !worker.closed && !worker.paused : worker.closed || worker.paused : true
+    ).map((worker) => this.toWorkerHandle(worker));
+  }
+  async createWorker(config) {
+    const bunqueue = await this.loadBunqueue();
+    const queueNames = config.queues.length ? config.queues : await this.getAllQueueNames();
+    const workerId = IgniterJobsIdGenerator.generate("worker");
+    const workerState = {
+      id: workerId,
+      queues: [...queueNames],
+      concurrency: config.concurrency ?? 1,
+      paused: false,
+      closed: false,
+      startedAt: /* @__PURE__ */ new Date(),
+      activeJobs: /* @__PURE__ */ new Set(),
+      metrics: { processed: 0, failed: 0, totalDuration: 0 },
+      workers: /* @__PURE__ */ new Map(),
+      handlers: config.handlers
+    };
+    const perQueueConcurrency = this.distributeConcurrency(
+      workerState.concurrency,
+      queueNames
+    );
+    for (const queueName of queueNames) {
+      await this.getQueue(queueName);
+      await this.syncCronSchedulers(queueName);
+      const worker = new bunqueue.Worker(
+        queueName,
+        async (job) => this.processJob(workerState, queueName, job),
+        {
+          embedded: true,
+          dataPath: this.options.path,
+          autorun: false,
+          concurrency: perQueueConcurrency.get(queueName) ?? 1,
+          heartbeatInterval: this.options.heartbeatInterval,
+          batchSize: this.options.batchSize,
+          pollTimeout: this.options.pollTimeout,
+          lockDuration: this.options.lockDuration,
+          maxStalledCount: this.options.maxStalledCount,
+          limiter: config.limiter ? { max: config.limiter.max, duration: config.limiter.duration } : void 0
+        }
+      );
+      this.attachWorkerEvents(workerState, queueName, worker);
+      worker.run();
+      workerState.workers.set(queueName, worker);
+    }
+    this.workers.set(workerId, workerState);
+    return this.toWorkerHandle(workerState);
+  }
+  getWorkers() {
+    return new Map(
+      Array.from(this.workers.entries()).map(([id, worker]) => [
+        id,
+        this.toWorkerHandle(worker)
+      ])
+    );
+  }
+  async publishEvent(channel, payload) {
+    const handlers = this.subscribers.get(channel);
+    if (!handlers) return;
+    await Promise.all(
+      Array.from(handlers).map(async (handler) => handler(payload))
+    );
+  }
+  async subscribeEvent(channel, handler) {
+    const handlers = this.subscribers.get(channel) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.subscribers.set(channel, handlers);
+    return async () => {
+      const current = this.subscribers.get(channel);
+      if (!current) return;
+      current.delete(handler);
+      if (current.size === 0) this.subscribers.delete(channel);
+    };
+  }
+  async writeJobStreamEvent(params) {
+    const key = this.getStreamKey(params.queue, params.jobId);
+    let eventId = String(Date.now());
+    if (params.persistence?.enabled) {
+      const db = await this.getStreamDatabase();
+      const result = db.prepare(
+        `
+          INSERT INTO igniter_jobs_stream_events (
+            queue, job_id, job_name, type, data, timestamp, scope
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `
+      ).run(
+        params.queue,
+        params.jobId,
+        params.jobName,
+        params.event.type,
+        JSON.stringify(params.event.data),
+        params.event.timestamp.toISOString(),
+        params.scope ? JSON.stringify(params.scope) : null
+      );
+      eventId = String(result.lastInsertRowid);
+      const maxEvents = params.persistence.maxEvents;
+      if (typeof maxEvents === "number" && maxEvents > 0) {
+        db.prepare(
+          `
+          DELETE FROM igniter_jobs_stream_events
+          WHERE id IN (
+            SELECT id FROM igniter_jobs_stream_events
+            WHERE queue = ? AND job_id = ?
+            ORDER BY id DESC
+            LIMIT -1 OFFSET ?
+          )
+        `
+        ).run(params.queue, params.jobId, maxEvents);
+      }
+    }
+    const event = {
+      ...params.event,
+      id: eventId
+    };
+    const handlers = this.streamSubscribers.get(key);
+    if (handlers?.size) {
+      await Promise.all(
+        Array.from(handlers).map(async (handler) => handler(event))
+      );
+    }
+    return eventId;
+  }
+  async readJobStream(params) {
+    const db = await this.getStreamDatabase();
+    const after = params.after ? Number(params.after) : 0;
+    const limit = params.limit ?? 100;
+    const rows = db.prepare(
+      `
+      SELECT id, type, data, timestamp, job_id, job_name, queue, scope
+      FROM igniter_jobs_stream_events
+      WHERE queue = ? AND job_id = ? AND id > ?
+      ORDER BY id ASC
+      LIMIT ?
+    `
+    ).all(params.queue, params.jobId, after, limit + 1);
+    const hasMore = rows.length > limit;
+    const items = rows.slice(0, limit).map((row) => this.mapStreamRow(row));
+    return {
+      items,
+      nextCursor: items.at(-1)?.id,
+      hasMore
+    };
+  }
+  async subscribeJobStream(params) {
+    const key = this.getStreamKey(params.queue, params.jobId);
+    const set = this.streamSubscribers.get(key) ?? /* @__PURE__ */ new Set();
+    set.add(params.handler);
+    this.streamSubscribers.set(key, set);
+    return async () => {
+      const current = this.streamSubscribers.get(key);
+      if (!current) return;
+      current.delete(params.handler);
+      if (current.size === 0) this.streamSubscribers.delete(key);
+    };
+  }
+  async shutdown() {
+    for (const worker of this.workers.values()) {
+      await this.closeWorkerState(worker);
+    }
+    this.workers.clear();
+    for (const runtime of this.queueRuntimes.values()) {
+      runtime.queue.close();
+    }
+    this.queueRuntimes.clear();
+    this.subscribers.clear();
+    this.streamSubscribers.clear();
+    if (this.streamDatabasePromise) {
+      const db = await this.streamDatabasePromise;
+      db.close();
+      this.streamDatabasePromise = null;
+    }
+    if (this.bunqueueModulePromise) {
+      const bunqueue = await this.bunqueueModulePromise;
+      bunqueue.shutdownManager();
+    }
+  }
+  async loadBunqueue() {
+    if (typeof globalThis.Bun === "undefined") {
+      throw new IgniterJobsError({
+        code: "JOBS_ADAPTER_ERROR",
+        message: "The Bun SQLite adapter can only run inside Bun. Use the BullMQ adapter in Node.js runtimes."
+      });
+    }
+    this.bunqueueModulePromise ?? (this.bunqueueModulePromise = import('bunqueue/client'));
+    return this.bunqueueModulePromise;
+  }
+  async getStreamDatabase() {
+    this.streamDatabasePromise ?? (this.streamDatabasePromise = (async () => {
+      await promises.mkdir(path.dirname(this.options.path), { recursive: true });
+      const sqlite = await import('bun:sqlite');
+      const db = new sqlite.Database(this.options.path, {
+        create: true
+      });
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS igniter_jobs_stream_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          queue TEXT NOT NULL,
+          job_id TEXT NOT NULL,
+          job_name TEXT NOT NULL,
+          type TEXT NOT NULL,
+          data TEXT NOT NULL,
+          timestamp TEXT NOT NULL,
+          scope TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_igniter_jobs_stream_events_job
+        ON igniter_jobs_stream_events(queue, job_id, id);
+      `);
+      return db;
+    })());
+    return this.streamDatabasePromise;
+  }
+  async getQueue(queueName) {
+    const existing = this.queueRuntimes.get(queueName);
+    if (existing) return existing.queue;
+    const bunqueue = await this.loadBunqueue();
+    await promises.mkdir(path.dirname(this.options.path), { recursive: true });
+    const queue = new bunqueue.Queue(queueName, {
+      embedded: true,
+      dataPath: this.options.path,
+      defaultJobOptions: {
+        durable: this.options.durable
+      }
+    });
+    await queue.waitUntilReady();
+    this.queueRuntimes.set(queueName, { queue, cronsSynced: false });
+    return queue;
+  }
+  async getAllQueueNames() {
+    return Array.from(
+      /* @__PURE__ */ new Set([
+        ...this.registeredJobs.keys(),
+        ...this.registeredCrons.keys(),
+        ...this.queueRuntimes.keys()
+      ])
+    );
+  }
+  markQueueCronsDirty(queueName) {
+    const runtime = this.queueRuntimes.get(queueName);
+    if (runtime) runtime.cronsSynced = false;
+  }
+  async syncCronSchedulers(queueName) {
+    const runtime = this.queueRuntimes.get(queueName);
+    if (!runtime || runtime.cronsSynced) return;
+    const cronDefinitions = this.registeredCrons.get(queueName) ?? /* @__PURE__ */ new Map();
+    const existing = await runtime.queue.getJobSchedulers(0, 1e4);
+    const existingIds = new Set(existing.map((scheduler) => scheduler.id));
+    for (const [cronName, definition] of cronDefinitions.entries()) {
+      await runtime.queue.upsertJobScheduler(
+        cronName,
+        {
+          pattern: definition.cron,
+          limit: definition.maxExecutions,
+          timezone: definition.tz
+        },
+        {
+          name: cronName,
+          data: this.createEnvelope(
+            void 0,
+            void 0,
+            void 0,
+            definition
+          ),
+          opts: { durable: this.options.durable }
+        }
+      );
+      existingIds.delete(cronName);
+    }
+    for (const schedulerId of existingIds) {
+      await runtime.queue.removeJobScheduler(schedulerId);
+    }
+    runtime.cronsSynced = true;
+  }
+  createEnvelope(input, metadata, scope, scheduleSource) {
+    return {
+      __igniterJobs: true,
+      input,
+      metadata,
+      scope,
+      schedule: scheduleSource ? {
+        skipWeekends: scheduleSource.skipWeekends,
+        onlyBusinessHours: scheduleSource.onlyBusinessHours,
+        businessHours: scheduleSource.businessHours,
+        onlyWeekdays: scheduleSource.onlyWeekdays,
+        skipDates: scheduleSource.skipDates?.map(
+          (value) => value instanceof Date ? value.toISOString() : value
+        )
+      } : void 0
+    };
+  }
+  toJobOptions(params, overrides) {
+    return {
+      jobId: params.jobId,
+      priority: params.priority,
+      delay: params.delay,
+      attempts: params.attempts,
+      removeOnComplete: params.removeOnComplete,
+      removeOnFail: params.removeOnFail,
+      durable: this.options.durable,
+      ...overrides
+    };
+  }
+  async processJob(workerState, queueName, job) {
+    const envelope = this.normalizeEnvelope(job.data);
+    if (!this.shouldExecuteScheduledJob(envelope.schedule, /* @__PURE__ */ new Date())) {
+      await this.writeLog(
+        queueName,
+        job.id,
+        "info",
+        "Scheduled run skipped by adapter rules."
+      );
+      return { skipped: true };
+    }
+    const registeredJob = this.registeredJobs.get(queueName)?.get(job.name);
+    if (registeredJob) {
+      return this.processRegisteredDefinition(
+        workerState,
+        queueName,
+        job,
+        envelope,
+        registeredJob
+      );
+    }
+    const registeredCron = this.registeredCrons.get(queueName)?.get(job.name);
+    if (registeredCron) {
+      return this.processRegisteredCron(
+        queueName,
+        job,
+        envelope,
+        registeredCron
+      );
+    }
+    throw new IgniterJobsError({
+      code: "JOBS_NOT_REGISTERED",
+      message: `Job "${job.name}" is not registered for queue "${queueName}".`
+    });
+  }
+  async processRegisteredDefinition(workerState, queueName, job, envelope, definition) {
+    const baseContext = this.createExecutionContext(
+      queueName,
+      job,
+      envelope,
+      definition
+    );
+    const startedAt = /* @__PURE__ */ new Date();
+    await this.writeLog(queueName, job.id, "info", "Job started.");
+    await this.invokeHook(
+      () => definition.onStart?.({ ...baseContext, startedAt })
+    );
+    try {
+      const result = await definition.handler(baseContext);
+      const duration = Date.now() - startedAt.getTime();
+      workerState.metrics.processed += 1;
+      workerState.metrics.totalDuration += duration;
+      await this.writeLog(
+        queueName,
+        job.id,
+        "info",
+        `Job completed in ${duration}ms.`
+      );
+      await this.invokeHook(
+        () => definition.onSuccess?.({
+          ...baseContext,
+          startedAt,
+          duration,
+          result
+        })
+      );
+      return result;
+    } catch (error) {
+      const runtimeError = error instanceof Error ? error : new Error(String(error));
+      const duration = Date.now() - startedAt.getTime();
+      const maxAttempts = definition.attempts ?? job.opts.attempts ?? 1;
+      const isFinalAttempt = job.attemptsMade >= maxAttempts;
+      workerState.metrics.failed += 1;
+      await this.writeLog(queueName, job.id, "error", runtimeError.message);
+      await this.invokeHook(
+        () => definition.onFailure?.({
+          ...baseContext,
+          startedAt,
+          duration,
+          error: runtimeError,
+          isFinalAttempt
+        })
+      );
+      throw runtimeError;
+    }
+  }
+  async processRegisteredCron(queueName, job, envelope, definition) {
+    await this.writeLog(queueName, job.id, "info", "Cron execution started.");
+    try {
+      const result = await definition.handler({
+        context: {},
+        job: {
+          id: job.id,
+          name: job.name,
+          queue: queueName,
+          attemptsMade: job.attemptsMade,
+          createdAt: new Date(job.timestamp),
+          metadata: envelope.metadata
+        },
+        scope: envelope.scope
+      });
+      await this.writeLog(
+        queueName,
+        job.id,
+        "info",
+        "Cron execution completed."
+      );
+      return result;
+    } catch (error) {
+      const runtimeError = error instanceof Error ? error : new Error(String(error));
+      await this.writeLog(queueName, job.id, "error", runtimeError.message);
+      throw runtimeError;
+    }
+  }
+  createExecutionContext(queueName, job, envelope, definition) {
+    const baseContext = {
+      input: envelope.input,
+      context: {},
+      job: {
+        id: job.id,
+        name: job.name,
+        queue: queueName,
+        attemptsMade: job.attemptsMade,
+        createdAt: new Date(job.timestamp),
+        metadata: envelope.metadata,
+        updateProgress: async (progress, message) => {
+          await job.updateProgress(progress, message);
+          await this.writeLog(
+            queueName,
+            job.id,
+            "info",
+            `Progress updated to ${progress}%.`
+          );
+          await this.invokeHook(
+            () => definition.onProgress?.({
+              ...baseContext,
+              progress,
+              message
+            })
+          );
+        }
+      },
+      scope: envelope.scope
+    };
+    return baseContext;
+  }
+  attachWorkerEvents(workerState, queueName, worker) {
+    worker.on("active", async (job) => {
+      workerState.activeJobs.add(job.id);
+      await this.invokeHandler(
+        () => workerState.handlers?.onActive?.({
+          job: this.mapJobSync(job, queueName)
+        })
+      );
+    });
+    worker.on("completed", async (job, result) => {
+      workerState.activeJobs.delete(job.id);
+      await this.invokeHandler(
+        () => workerState.handlers?.onSuccess?.({
+          job: this.mapJobSync(job, queueName, "completed"),
+          result
+        })
+      );
+    });
+    worker.on("failed", async (job, error) => {
+      workerState.activeJobs.delete(job.id);
+      await this.invokeHandler(
+        () => workerState.handlers?.onFailure?.({
+          job: this.mapJobSync(job, queueName, "failed"),
+          error
+        })
+      );
+    });
+    worker.on("drained", async () => {
+      if (workerState.activeJobs.size === 0) {
+        await this.invokeHandler(() => workerState.handlers?.onIdle?.());
+      }
+    });
+    worker.on("error", async (error) => {
+      await this.writeQueueLog(
+        queueName,
+        "error",
+        `Worker error: ${error.message}`
+      );
+    });
+  }
+  toWorkerHandle(worker) {
+    return {
+      id: worker.id,
+      queues: [...worker.queues],
+      pause: async () => {
+        worker.paused = true;
+        for (const runtime of worker.workers.values()) runtime.pause();
+      },
+      resume: async () => {
+        worker.paused = false;
+        for (const runtime of worker.workers.values()) runtime.resume();
+      },
+      close: async () => {
+        await this.closeWorkerState(worker);
+      },
+      isRunning: () => !worker.closed && !worker.paused,
+      isPaused: () => worker.paused,
+      isClosed: () => worker.closed,
+      getMetrics: async () => this.buildWorkerMetrics(worker)
+    };
+  }
+  buildWorkerMetrics(worker) {
+    return {
+      processed: worker.metrics.processed,
+      failed: worker.metrics.failed,
+      avgDuration: worker.metrics.processed > 0 ? worker.metrics.totalDuration / worker.metrics.processed : 0,
+      concurrency: worker.concurrency,
+      uptime: Date.now() - worker.startedAt.getTime()
+    };
+  }
+  async closeWorkerState(worker) {
+    worker.closed = true;
+    await Promise.all(
+      Array.from(worker.workers.values()).map((runtime) => runtime.close())
+    );
+    worker.workers.clear();
+  }
+  async requireJob(jobId, queue) {
+    const queueName = queue ?? await this.findQueueByJobId(jobId);
+    if (!queueName) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found.`
+      });
+    }
+    const job = await this.getQueue(queueName).then(
+      (queueClient) => queueClient.getJob(jobId)
+    );
+    if (!job) {
+      throw new IgniterJobsError({
+        code: "JOBS_NOT_FOUND",
+        message: `Job "${jobId}" not found${queue ? ` in queue "${queue}"` : ""}.`
+      });
+    }
+    return job;
+  }
+  async findQueueByJobId(jobId) {
+    for (const queueName of await this.getAllQueueNames()) {
+      const job = await this.getQueue(queueName).then(
+        (queueClient) => queueClient.getJob(jobId)
+      );
+      if (job) return queueName;
+    }
+    return null;
+  }
+  getStreamKey(queue, jobId) {
+    return `${queue}:${jobId}`;
+  }
+  mapStreamRow(row) {
+    return {
+      id: String(row.id),
+      type: row.type,
+      data: JSON.parse(row.data),
+      timestamp: new Date(row.timestamp),
+      jobId: row.job_id,
+      jobName: row.job_name,
+      queue: row.queue,
+      scope: row.scope ? JSON.parse(row.scope) : void 0
+    };
+  }
+  async mapJob(job, queueName, forcedState) {
+    const queue = await this.getQueue(queueName);
+    const rawState = await job.getState();
+    return this.mapJobSync(
+      job,
+      queueName,
+      forcedState ?? this.toPublicStatus(rawState, queue.isPaused())
+    );
+  }
+  mapJobSync(job, queueName, status) {
+    const envelope = this.normalizeEnvelope(job.data);
+    return {
+      id: job.id,
+      name: job.name,
+      queue: queueName,
+      status: status ?? this.toPublicStatus("waiting", false),
+      input: envelope.input,
+      result: job.returnvalue,
+      error: job.failedReason ?? void 0,
+      progress: typeof job.progress === "number" ? job.progress : 0,
+      attemptsMade: job.attemptsMade,
+      priority: job.priority ?? 0,
+      createdAt: new Date(job.timestamp),
+      startedAt: job.processedOn ? new Date(job.processedOn) : void 0,
+      completedAt: job.finishedOn ? new Date(job.finishedOn) : void 0,
+      metadata: envelope.metadata,
+      scope: envelope.scope
+    };
+  }
+  normalizeEnvelope(data) {
+    if (data && typeof data === "object" && data.__igniterJobs === true) {
+      return data;
+    }
+    return {
+      __igniterJobs: true,
+      input: data
+    };
+  }
+  toPublicStatus(rawState, isQueuePaused) {
+    if ((rawState === "waiting" || rawState === "prioritized") && isQueuePaused) {
+      return "paused";
+    }
+    switch (rawState) {
+      case "prioritized":
+      case "waiting-children":
+        return "waiting";
+      case "waiting":
+      case "active":
+      case "completed":
+      case "failed":
+      case "delayed":
+      case "paused":
+        return rawState;
+      default:
+        return "waiting";
+    }
+  }
+  toBunqueueStatus(status) {
+    switch (status) {
+      case "waiting":
+        return "waiting";
+      default:
+        return status;
+    }
+  }
+  toBunqueueStates(status) {
+    switch (status) {
+      case "waiting":
+        return ["waiting", "prioritized"];
+      case "paused":
+        return ["paused"];
+      default:
+        return [status];
+    }
+  }
+  distributeConcurrency(total, queues) {
+    const result = /* @__PURE__ */ new Map();
+    if (queues.length === 0) return result;
+    const base = Math.max(1, Math.floor(total / queues.length));
+    let remainder = Math.max(0, total - base * queues.length);
+    for (const queue of queues) {
+      const value = base + (remainder > 0 ? 1 : 0);
+      result.set(queue, value);
+      remainder = Math.max(0, remainder - 1);
+    }
+    return result;
+  }
+  shouldExecuteScheduledJob(schedule, now) {
+    if (!schedule) return true;
+    const day = now.getDay();
+    const isoDate = now.toISOString().slice(0, 10);
+    if (schedule.skipWeekends && (day === 0 || day === 6)) return false;
+    if (schedule.onlyWeekdays?.length && !schedule.onlyWeekdays.includes(day))
+      return false;
+    if (schedule.skipDates?.some((value) => value.slice(0, 10) === isoDate))
+      return false;
+    if (schedule.onlyBusinessHours && schedule.businessHours) {
+      const hour = now.getHours();
+      return hour >= schedule.businessHours.start && hour < schedule.businessHours.end;
+    }
+    return true;
+  }
+  parseLogEntry(entry) {
+    try {
+      const parsed = JSON.parse(entry);
+      if (parsed && typeof parsed.message === "string" && typeof parsed.timestamp === "string" && (parsed.level === "info" || parsed.level === "warn" || parsed.level === "error")) {
+        return {
+          timestamp: new Date(parsed.timestamp),
+          level: parsed.level,
+          message: parsed.message
+        };
+      }
+    } catch {
+    }
+    return {
+      timestamp: /* @__PURE__ */ new Date(),
+      level: "info",
+      message: entry
+    };
+  }
+  async writeLog(queueName, jobId, level, message) {
+    const queue = await this.getQueue(queueName);
+    await queue.addJobLog(
+      jobId,
+      JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString(), level, message })
+    );
+  }
+  async writeQueueLog(queueName, level, message) {
+  }
+  async invokeHook(fn) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+  async invokeHandler(fn) {
+    try {
+      await fn();
+    } catch {
+    }
+  }
+};
+
+exports.IgniterJobsBunSQLiteAdapter = IgniterJobsBunSQLiteAdapter;
+//# sourceMappingURL=bun.js.map
+//# sourceMappingURL=bun.js.map