@workglow/job-queue 0.0.52

package/dist/browser.js

@@ -0,0 +1,1075 @@
+// src/job/IJobQueue.ts
+import { JobStatus } from "@workglow/storage";
+var QueueMode;
+((QueueMode2) => {
+  QueueMode2["CLIENT"] = "CLIENT";
+  QueueMode2["SERVER"] = "SERVER";
+  QueueMode2["BOTH"] = "BOTH";
+})(QueueMode ||= {});
+// src/job/JobError.ts
+import { BaseError } from "@workglow/util";
+
+class JobError extends BaseError {
+  message;
+  static type = "JobError";
+  retryable = false;
+  constructor(message) {
+    super(message);
+    this.message = message;
+  }
+}
+
+class JobNotFoundError extends JobError {
+  static type = "JobNotFoundError";
+  constructor(message = "Job not found") {
+    super(message);
+  }
+}
+
+class RetryableJobError extends JobError {
+  retryDate;
+  static type = "RetryableJobError";
+  constructor(message, retryDate) {
+    super(message);
+    this.retryDate = retryDate;
+    this.retryable = true;
+  }
+}
+
+class PermanentJobError extends JobError {
+  static type = "PermanentJobError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class AbortSignalJobError extends PermanentJobError {
+  static type = "AbortSignalJobError";
+  constructor(message) {
+    super(message);
+  }
+}
+
+class JobDisabledError extends PermanentJobError {
+  static type = "JobDisabledError";
+}
+
+// src/job/Job.ts
+class Job {
+  id;
+  jobRunId;
+  queueName;
+  input;
+  maxRetries;
+  createdAt;
+  fingerprint;
+  status = JobStatus.PENDING;
+  runAfter;
+  output = null;
+  runAttempts = 0;
+  lastRanAt = null;
+  completedAt = null;
+  deadlineAt = null;
+  error = null;
+  errorCode = null;
+  progress = 0;
+  progressMessage = "";
+  progressDetails = null;
+  queue;
+  constructor({
+    queueName,
+    input,
+    jobRunId,
+    id,
+    error = null,
+    errorCode = null,
+    fingerprint = undefined,
+    output = null,
+    maxRetries = 10,
+    createdAt = new Date,
+    completedAt = null,
+    status = JobStatus.PENDING,
+    deadlineAt = null,
+    runAttempts = 0,
+    lastRanAt = null,
+    runAfter = new Date,
+    progress = 0,
+    progressMessage = "",
+    progressDetails = null
+  }) {
+    this.runAfter = runAfter ?? new Date;
+    this.createdAt = createdAt ?? new Date;
+    this.lastRanAt = lastRanAt ?? null;
+    this.deadlineAt = deadlineAt ?? null;
+    this.completedAt = completedAt ?? null;
+    this.queueName = queueName;
+    this.id = id;
+    this.jobRunId = jobRunId;
+    this.status = status;
+    this.fingerprint = fingerprint;
+    this.input = input;
+    this.maxRetries = maxRetries;
+    this.runAttempts = runAttempts;
+    this.output = output;
+    this.error = error;
+    this.errorCode = errorCode;
+    this.progress = progress;
+    this.progressMessage = progressMessage;
+    this.progressDetails = progressDetails;
+  }
+  async execute(input, context) {
+    throw new JobError("Method not implemented.");
+  }
+  progressListeners = new Set;
+  async updateProgress(progress, message = "", details = null) {
+    this.progress = progress;
+    this.progressMessage = message;
+    this.progressDetails = details;
+    for (const listener of this.progressListeners) {
+      listener(progress, message, details);
+    }
+    await this.queue?.updateProgress(this.id, progress, message, details);
+  }
+  onJobProgress(listener) {
+    this.progressListeners.add(listener);
+    return () => {
+      this.progressListeners.delete(listener);
+    };
+  }
+}
+// src/job/JobQueue.ts
+import {
+  InMemoryQueueStorage,
+  QUEUE_STORAGE
+} from "@workglow/storage";
+import { EventEmitter, globalServiceRegistry, sleep } from "@workglow/util";
+
+// src/limiter/ILimiter.ts
+import { createServiceToken } from "@workglow/util";
+var JOB_LIMITER = createServiceToken("jobqueue.limiter");
+
+// src/limiter/NullLimiter.ts
+import { createServiceToken as createServiceToken2 } from "@workglow/util";
+var NULL_JOB_LIMITER = createServiceToken2("jobqueue.limiter.null");
+
+class NullLimiter {
+  async canProceed() {
+    return true;
+  }
+  async recordJobStart() {}
+  async recordJobCompletion() {}
+  async getNextAvailableTime() {
+    return new Date;
+  }
+  async setNextAvailableTime(date) {}
+  async clear() {}
+}
+
+// src/job/JobQueue.ts
+class JobQueue {
+  queueName;
+  jobClass;
+  options;
+  constructor(queueName, jobClass, options) {
+    this.queueName = queueName;
+    this.jobClass = jobClass;
+    const { limiter, storage, ...rest } = options;
+    this.options = {
+      waitDurationInMilliseconds: 100,
+      ...rest
+    };
+    if (limiter) {
+      this.limiter = limiter;
+    } else {
+      try {
+        this.limiter = globalServiceRegistry.get(JOB_LIMITER);
+      } catch (err) {
+        console.warn("Warning: did not find job limiter in global DI", err);
+        this.limiter = new NullLimiter;
+      }
+    }
+    if (storage) {
+      this.storage = storage;
+    } else {
+      try {
+        this.storage = globalServiceRegistry.get(QUEUE_STORAGE);
+      } catch (err) {
+        console.warn("Warning: did not find queue storage in global DI", err);
+        this.storage = new InMemoryQueueStorage(queueName);
+      }
+    }
+    this.stats = {
+      totalJobs: 0,
+      completedJobs: 0,
+      failedJobs: 0,
+      abortedJobs: 0,
+      retriedJobs: 0,
+      disabledJobs: 0,
+      lastUpdateTime: new Date
+    };
+  }
+  async get(id) {
+    if (!id)
+      throw new JobNotFoundError("Cannot get undefined job");
+    const job = await this.storage.get(id);
+    if (!job)
+      return;
+    return this.storageToClass(job);
+  }
+  async add(job) {
+    const jobId = await this.storage.add(this.classToStorage(job));
+    return jobId;
+  }
+  async next() {
+    const job = await this.storage.next();
+    if (!job)
+      return;
+    return this.storageToClass(job);
+  }
+  async peek(status, num) {
+    const jobs = await this.storage.peek(status, num);
+    return jobs.map((job) => this.storageToClass(job));
+  }
+  async size(status) {
+    return this.storage.size(status);
+  }
+  async delete(id) {
+    if (!id)
+      throw new JobNotFoundError("Cannot delete undefined job");
+    await this.storage.delete(id);
+  }
+  async disable(id) {
+    if (!id)
+      throw new JobNotFoundError("Cannot disable undefined job");
+    const job = await this.get(id);
+    if (!job)
+      throw new JobNotFoundError(`Job ${id} not found`);
+    await this.disableJob(job);
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  async outputForInput(input) {
+    if (!input)
+      throw new JobNotFoundError("Cannot get output for undefined input");
+    return this.storage.outputForInput(input);
+  }
+  async executeJob(job, signal) {
+    if (!job)
+      throw new JobNotFoundError("Cannot execute null or undefined job");
+    return await job.execute(job.input, {
+      signal,
+      updateProgress: this.updateProgress.bind(this, job.id)
+    });
+  }
+  async waitFor(jobId) {
+    if (!jobId)
+      throw new JobNotFoundError("Cannot wait for undefined job");
+    const { promise, resolve, reject } = Promise.withResolvers();
+    promise.catch(() => {});
+    const promises = this.activeJobPromises.get(jobId) || [];
+    promises.push({ resolve, reject });
+    this.activeJobPromises.set(jobId, promises);
+    const job = await this.get(jobId);
+    if (!job)
+      throw new JobNotFoundError(`Job ${jobId} not found`);
+    if (job.status === JobStatus.COMPLETED) {
+      return job.output;
+    }
+    if (job.status === JobStatus.DISABLED) {
+      return;
+    }
+    if (job.status === JobStatus.FAILED) {
+      throw this.buildErrorFromJob(job);
+    }
+    return promise;
+  }
+  buildErrorFromJob(job) {
+    const errorMessage = job.error || "Job failed";
+    if (job.errorCode === "PermanentJobError") {
+      return new PermanentJobError(errorMessage);
+    }
+    if (job.errorCode === "RetryableJobError") {
+      return new RetryableJobError(errorMessage);
+    }
+    if (job.errorCode === "AbortSignalJobError") {
+      return new AbortSignalJobError(errorMessage);
+    }
+    if (job.errorCode === "JobDisabledError") {
+      return new JobDisabledError(errorMessage);
+    }
+    return new JobError(errorMessage);
+  }
+  async updateProgress(jobId, progress, message = "", details = null) {
+    const job = await this.get(jobId);
+    if (!job)
+      throw new JobNotFoundError(`Job ${jobId} not found`);
+    if ([JobStatus.COMPLETED, JobStatus.FAILED, JobStatus.ABORTING, JobStatus.DISABLED].includes(job.status)) {
+      return;
+    }
+    progress = Math.max(0, Math.min(100, progress));
+    job.progress = progress;
+    job.progressMessage = message;
+    job.progressDetails = details;
+    await this.saveProgress(jobId, progress, message, details ?? null);
+    this.announceProgress(jobId, progress, message, details ?? null);
+  }
+  onJobProgress(jobId, listener) {
+    if (!this.jobProgressListeners.has(jobId)) {
+      this.jobProgressListeners.set(jobId, new Set);
+    }
+    const listeners = this.jobProgressListeners.get(jobId);
+    listeners.add(listener);
+    return () => {
+      const listeners2 = this.jobProgressListeners.get(jobId);
+      if (listeners2) {
+        listeners2.delete(listener);
+        if (listeners2.size === 0) {
+          this.jobProgressListeners.delete(jobId);
+        }
+      }
+    };
+  }
+  async start(mode = "BOTH" /* BOTH */) {
+    if (this.running) {
+      return this;
+    }
+    this.mode = mode;
+    this.running = true;
+    this.events.emit("queue_start", this.queueName);
+    if (this.mode === "SERVER" /* SERVER */ || this.mode === "BOTH" /* BOTH */) {
+      await this.fixupJobs();
+      await this.processJobs();
+    }
+    if (this.mode === "CLIENT" /* CLIENT */ || this.mode === "BOTH" /* BOTH */) {
+      await this.monitorJobs();
+    }
+    return this;
+  }
+  async stop() {
+    if (!this.running)
+      return this;
+    this.running = false;
+    const size = await this.size(JobStatus.PROCESSING);
+    const sleepTime = Math.max(100, size * 2);
+    await sleep(sleepTime);
+    for (const [jobId] of this.activeJobAbortControllers.entries()) {
+      this.abort(jobId);
+    }
+    this.activeJobPromises.forEach((promises) => promises.forEach(({ reject }) => reject(new PermanentJobError("Queue Stopped"))));
+    await sleep(sleepTime);
+    this.events.emit("queue_stop", this.queueName);
+    return this;
+  }
+  async clear() {
+    await this.storage.deleteAll();
+    this.activeJobAbortControllers.clear();
+    this.activeJobPromises.clear();
+    this.processingTimes.clear();
+    this.lastKnownProgress.clear();
+    this.jobProgressListeners.clear();
+    this.stats = {
+      totalJobs: 0,
+      completedJobs: 0,
+      failedJobs: 0,
+      abortedJobs: 0,
+      retriedJobs: 0,
+      disabledJobs: 0,
+      lastUpdateTime: new Date
+    };
+    this.emitStatsUpdate();
+    return this;
+  }
+  async restart() {
+    await this.stop();
+    await this.clear();
+    await this.start();
+    return this;
+  }
+  async abortJobRun(jobRunId) {
+    if (!jobRunId)
+      throw new JobNotFoundError("Cannot abort job run with undefined jobRunId");
+    const jobs = await this.getJobsByRunId(jobRunId);
+    await Promise.allSettled(jobs.map((job) => {
+      if ([JobStatus.PROCESSING, JobStatus.PENDING].includes(job.status)) {
+        this.abort(job.id);
+      }
+    }));
+  }
+  async getJobsByRunId(runId) {
+    if (!runId)
+      throw new JobNotFoundError("Cannot get jobs by undefined runId");
+    const jobs = await this.storage.getByRunId(runId);
+    return jobs.map((job) => this.storageToClass(job));
+  }
+  on(event, listener) {
+    this.events.on(event, listener);
+  }
+  off(event, listener) {
+    this.events.off(event, listener);
+  }
+  once(event, listener) {
+    this.events.once(event, listener);
+  }
+  waitOn(event) {
+    return this.events.waitOn(event);
+  }
+  limiter;
+  storage;
+  running = false;
+  stats = {
+    totalJobs: 0,
+    completedJobs: 0,
+    failedJobs: 0,
+    abortedJobs: 0,
+    retriedJobs: 0,
+    disabledJobs: 0,
+    lastUpdateTime: new Date
+  };
+  events = new EventEmitter;
+  activeJobAbortControllers = new Map;
+  activeJobPromises = new Map;
+  processingTimes = new Map;
+  mode = "BOTH" /* BOTH */;
+  jobProgressListeners = new Map;
+  lastKnownProgress = new Map;
+  async saveProgress(id, progress, message, details) {
+    if (!id)
+      throw new JobNotFoundError("Cannot save progress for undefined job");
+    await this.storage.saveProgress(id, progress, message, details);
+  }
+  createAbortController(jobId) {
+    if (!jobId)
+      throw new JobNotFoundError("Cannot create abort controller for undefined job");
+    if (this.activeJobAbortControllers.has(jobId)) {
+      return this.activeJobAbortControllers.get(jobId);
+    }
+    const abortController = new AbortController;
+    abortController.signal.addEventListener("abort", () => this.handleAbort(jobId));
+    this.activeJobAbortControllers.set(jobId, abortController);
+    return abortController;
+  }
+  async validateJobState(job) {
+    if (job.status === JobStatus.COMPLETED) {
+      throw new PermanentJobError(`Job ${job.id} is already completed`);
+    }
+    if (job.status === JobStatus.FAILED) {
+      throw new PermanentJobError(`Job ${job.id} has failed`);
+    }
+    if (job.status === JobStatus.ABORTING || this.activeJobAbortControllers.get(job.id)?.signal.aborted) {
+      throw new AbortSignalJobError(`Job ${job.id} is being aborted`);
+    }
+    if (job.deadlineAt && job.deadlineAt < new Date) {
+      throw new PermanentJobError(`Job ${job.id} has exceeded its deadline`);
+    }
+    if (job.status === JobStatus.DISABLED) {
+      throw new JobDisabledError(`Job ${job.id} has been disabled`);
+    }
+  }
+  normalizeError(err) {
+    if (err instanceof JobError) {
+      return err;
+    }
+    if (err instanceof Error) {
+      return err;
+    }
+    return new PermanentJobError(String(err));
+  }
+  updateAverageProcessingTime() {
+    const times = Array.from(this.processingTimes.values());
+    if (times.length > 0) {
+      this.stats.averageProcessingTime = times.reduce((a, b) => a + b, 0) / times.length;
+    }
+  }
+  emitStatsUpdate() {
+    this.stats.lastUpdateTime = new Date;
+    this.events.emit("queue_stats_update", this.queueName, { ...this.stats });
+  }
+  announceProgress(jobId, progress, message, details) {
+    this.lastKnownProgress.set(jobId, {
+      progress,
+      message,
+      details
+    });
+    this.events.emit("job_progress", this.queueName, jobId, progress, message, details);
+    const listeners = this.jobProgressListeners.get(jobId);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(progress, message, details);
+      }
+    }
+  }
+  storageToClass(details) {
+    const toDate = (date) => {
+      if (!date)
+        return null;
+      const d = new Date(date);
+      return isNaN(d.getTime()) ? null : d;
+    };
+    const job = new this.jobClass({
+      id: details.id,
+      jobRunId: details.job_run_id,
+      queueName: details.queue,
+      fingerprint: details.fingerprint,
+      input: details.input,
+      output: details.output,
+      runAfter: toDate(details.run_after),
+      createdAt: toDate(details.created_at),
+      deadlineAt: toDate(details.deadline_at),
+      lastRanAt: toDate(details.last_ran_at),
+      completedAt: toDate(details.completed_at),
+      progress: details.progress || 0,
+      progressMessage: details.progress_message || "",
+      progressDetails: details.progress_details ?? null,
+      status: details.status,
+      error: details.error ?? null,
+      errorCode: details.error_code ?? null,
+      runAttempts: details.run_attempts ?? 0,
+      maxRetries: details.max_retries ?? 10
+    });
+    job.queue = this;
+    return job;
+  }
+  classToStorage(job) {
+    const dateToISOString = (date) => {
+      if (!date)
+        return null;
+      return isNaN(date.getTime()) ? null : date.toISOString();
+    };
+    const now = new Date().toISOString();
+    return {
+      id: job.id,
+      job_run_id: job.jobRunId,
+      queue: job.queueName || this.queueName,
+      fingerprint: job.fingerprint,
+      input: job.input,
+      status: job.status,
+      output: job.output ?? null,
+      error: job.error === null ? null : String(job.error),
+      error_code: job.errorCode || null,
+      run_attempts: job.runAttempts ?? 0,
+      max_retries: job.maxRetries ?? 10,
+      run_after: dateToISOString(job.runAfter) ?? now,
+      created_at: dateToISOString(job.createdAt) ?? now,
+      deadline_at: dateToISOString(job.deadlineAt),
+      last_ran_at: dateToISOString(job.lastRanAt),
+      completed_at: dateToISOString(job.completedAt),
+      progress: job.progress ?? 0,
+      progress_message: job.progressMessage ?? "",
+      progress_details: job.progressDetails ?? null
+    };
+  }
+  async rescheduleJob(job, retryDate) {
+    try {
+      job.status = JobStatus.PENDING;
+      const nextAvailableTime = await this.limiter.getNextAvailableTime();
+      job.runAfter = retryDate instanceof Date ? retryDate : nextAvailableTime;
+      job.progress = 0;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      await this.storage.complete(this.classToStorage(job));
+      this.stats.retriedJobs++;
+      this.events.emit("job_retry", this.queueName, job.id, job.runAfter);
+    } catch (err) {
+      console.error("rescheduleJob", err);
+    }
+  }
+  async disableJob(job) {
+    try {
+      job.status = JobStatus.DISABLED;
+      job.progress = 100;
+      job.completedAt = new Date;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      await this.storage.complete(this.classToStorage(job));
+      if (this.options.deleteAfterDisabledMs === 0) {
+        await this.delete(job.id);
+      }
+      this.stats.disabledJobs++;
+      this.events.emit("job_disabled", this.queueName, job.id);
+      const promises = this.activeJobPromises.get(job.id) || [];
+      promises.forEach(({ resolve }) => resolve(undefined));
+      this.activeJobPromises.delete(job.id);
+    } catch (err) {
+      console.error("disableJob", err);
+    }
+  }
+  async failJob(job, error) {
+    try {
+      job.status = JobStatus.FAILED;
+      job.progress = 100;
+      job.completedAt = new Date;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      job.error = error.message;
+      job.errorCode = error?.constructor?.name ?? null;
+      await this.storage.complete(this.classToStorage(job));
+      if (this.options.deleteAfterFailureMs === 0) {
+        await this.delete(job.id);
+      }
+      this.stats.failedJobs++;
+      this.events.emit("job_error", this.queueName, job.id, `${error.name}: ${error.message}`);
+      const promises = this.activeJobPromises.get(job.id) || [];
+      promises.forEach(({ reject }) => reject(error));
+      this.activeJobPromises.delete(job.id);
+    } catch (err) {
+      console.error("failJob errored out?", err);
+    }
+    this.activeJobAbortControllers.delete(job.id);
+    this.lastKnownProgress.delete(job.id);
+    this.jobProgressListeners.delete(job.id);
+    this.activeJobPromises.delete(job.id);
+  }
+  async completeJob(job, output) {
+    try {
+      job.status = JobStatus.COMPLETED;
+      job.progress = 100;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      job.completedAt = new Date;
+      job.output = output ?? null;
+      job.error = null;
+      job.errorCode = null;
+      await this.storage.complete(this.classToStorage(job));
+      if (job && this.options.deleteAfterCompletionMs === 0) {
+        await this.delete(job.id);
+      }
+      this.stats.completedJobs++;
+      this.events.emit("job_complete", this.queueName, job.id, output);
+      const promises = this.activeJobPromises.get(job.id);
+      if (promises) {
+        promises.forEach(({ resolve }) => resolve(output));
+      }
+      this.activeJobPromises.delete(job.id);
+    } catch (err) {
+      console.error("completeJob errored out?", err);
+    }
+    this.activeJobAbortControllers.delete(job.id);
+    this.lastKnownProgress.delete(job.id);
+    this.jobProgressListeners.delete(job.id);
+    this.activeJobPromises.delete(job.id);
+  }
+  async abort(jobId) {
+    if (!jobId)
+      throw new JobNotFoundError("Cannot abort undefined job");
+    await this.storage.abort(jobId);
+    let controller = this.activeJobAbortControllers.get(jobId);
+    if (!controller) {
+      controller = this.createAbortController(jobId);
+    }
+    if (!controller.signal.aborted) {
+      controller.abort();
+    }
+    this.events.emit("job_aborting", this.queueName, jobId);
+  }
+  async handleAbort(jobId) {
+    const promises = this.activeJobPromises.get(jobId);
+    if (promises) {
+      const job = await this.get(jobId);
+      if (!job) {
+        console.error("handleAbort: job not found", jobId);
+        return;
+      }
+      const error = new AbortSignalJobError("Job Aborted");
+      this.failJob(job, error);
+    }
+    this.stats.abortedJobs++;
+  }
+  async processSingleJob(job) {
+    if (!job || !job.id)
+      throw new JobNotFoundError("Invalid job provided for processing");
+    const startTime = Date.now();
+    try {
+      await this.validateJobState(job);
+      await this.limiter.recordJobStart();
+      this.emitStatsUpdate();
+      const abortController = this.createAbortController(job.id);
+      this.lastKnownProgress.set(job.id, {
+        progress: 0,
+        message: "",
+        details: null
+      });
+      this.events.emit("job_start", this.queueName, job.id);
+      const output = await this.executeJob(job, abortController.signal);
+      await this.completeJob(job, output);
+      this.processingTimes.set(job.id, Date.now() - startTime);
+      this.updateAverageProcessingTime();
+    } catch (err) {
+      const error = this.normalizeError(err);
+      if (error instanceof RetryableJobError) {
+        if (job.runAttempts > job.maxRetries) {
+          await this.failJob(job, error);
+        } else {
+          await this.rescheduleJob(job, error.retryDate);
+        }
+      } else {
+        await this.failJob(job, error);
+      }
+    } finally {
+      await this.limiter.recordJobCompletion();
+      this.emitStatsUpdate();
+    }
+  }
+  async processJobs() {
+    if (!this.running) {
+      return;
+    }
+    try {
+      await this.cleanUpJobs();
+      const canProceed = await this.limiter.canProceed();
+      if (canProceed) {
+        const job = await this.next();
+        if (job) {
+          this.processSingleJob(job);
+        }
+      }
+    } finally {
+      setTimeout(() => this.processJobs(), this.options.waitDurationInMilliseconds);
+    }
+  }
+  async cleanUpJobs() {
+    const abortingJobs = await this.peek(JobStatus.ABORTING);
+    for (const job of abortingJobs) {
+      await this.handleAbort(job.id);
+    }
+    if (this.options.deleteAfterCompletionMs) {
+      await this.storage.deleteJobsByStatusAndAge(JobStatus.COMPLETED, this.options.deleteAfterCompletionMs);
+    }
+    if (this.options.deleteAfterFailureMs) {
+      await this.storage.deleteJobsByStatusAndAge(JobStatus.FAILED, this.options.deleteAfterFailureMs);
+    }
+  }
+  async monitorJobs() {
+    if (!this.running) {
+      return;
+    }
+    try {
+      const jobIds = Array.from(this.jobProgressListeners.keys());
+      for (const jobId of jobIds) {
+        const job = await this.get(jobId);
+        if (job) {
+          const currentProgress = {
+            progress: job.progress,
+            message: job.progressMessage,
+            details: job.progressDetails || null
+          };
+          const lastProgress = this.lastKnownProgress.get(jobId);
+          const hasChanged = !lastProgress || lastProgress.progress !== currentProgress.progress || lastProgress.message !== currentProgress.message;
+          if (hasChanged && currentProgress.progress !== 0 && currentProgress.message !== "") {
+            this.announceProgress(jobId, currentProgress.progress, currentProgress.message, currentProgress.details);
+          }
+        }
+      }
+      for (const jobId of this.lastKnownProgress.keys()) {
+        const job = await this.get(jobId);
+        if (!job || job.status === JobStatus.COMPLETED || job.status === JobStatus.FAILED) {
+          this.lastKnownProgress.delete(jobId);
+        }
+      }
+    } catch (error) {
+      console.error(`Error in monitorJobs: ${error}`);
+    }
+    setTimeout(() => this.monitorJobs(), this.options.waitDurationInMilliseconds);
+  }
+  async fixupJobs() {
+    const stuckProcessingJobs = await this.peek(JobStatus.PROCESSING);
+    const stuckAbortingJobs = await this.peek(JobStatus.ABORTING);
+    const stuckJobs = [...stuckProcessingJobs, ...stuckAbortingJobs];
+    for (const job of stuckJobs) {
+      job.status = JobStatus.PENDING;
+      job.runAfter = job.lastRanAt || new Date;
+      job.progress = 0;
+      job.progressMessage = "";
+      job.progressDetails = null;
+      job.error = "Restarting server";
+      await this.storage.complete(this.classToStorage(job));
+      await this.rescheduleJob(job, job.lastRanAt);
+    }
+  }
+}
+// src/limiter/CompositeLimiter.ts
+class CompositeLimiter {
+  limiters = [];
+  constructor(limiters = []) {
+    this.limiters = limiters;
+  }
+  addLimiter(limiter) {
+    this.limiters.push(limiter);
+  }
+  async canProceed() {
+    for (const limiter of this.limiters) {
+      if (!await limiter.canProceed()) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async recordJobStart() {
+    this.limiters.forEach((limiter) => limiter.recordJobStart());
+  }
+  async recordJobCompletion() {
+    this.limiters.forEach((limiter) => limiter.recordJobCompletion());
+  }
+  async getNextAvailableTime() {
+    let maxDate = new Date;
+    for (const limiter of this.limiters) {
+      const limiterNextTime = await limiter.getNextAvailableTime();
+      if (limiterNextTime > maxDate) {
+        maxDate = limiterNextTime;
+      }
+    }
+    return maxDate;
+  }
+  async setNextAvailableTime(date) {
+    for (const limiter of this.limiters) {
+      await limiter.setNextAvailableTime(date);
+    }
+  }
+  async clear() {
+    this.limiters.forEach((limiter) => limiter.clear());
+  }
+}
+// src/limiter/ConcurrencyLimiter.ts
+import { createServiceToken as createServiceToken3 } from "@workglow/util";
+var CONCURRENT_JOB_LIMITER = createServiceToken3("jobqueue.limiter.concurrent");
+
+class ConcurrencyLimiter {
+  currentRunningJobs = 0;
+  maxConcurrentJobs;
+  timeSliceInMilliseconds;
+  nextAllowedStartTime = new Date;
+  constructor(maxConcurrentJobs, timeSliceInMilliseconds = 1000) {
+    this.maxConcurrentJobs = maxConcurrentJobs;
+    this.timeSliceInMilliseconds = timeSliceInMilliseconds;
+  }
+  async canProceed() {
+    return this.currentRunningJobs < this.maxConcurrentJobs && Date.now() >= this.nextAllowedStartTime.getTime();
+  }
+  async recordJobStart() {
+    if (this.currentRunningJobs < this.maxConcurrentJobs) {
+      this.currentRunningJobs++;
+      this.nextAllowedStartTime = new Date(Date.now() + this.timeSliceInMilliseconds);
+    }
+  }
+  async recordJobCompletion() {
+    this.currentRunningJobs = Math.max(0, this.currentRunningJobs - 1);
+  }
+  async getNextAvailableTime() {
+    return this.currentRunningJobs < this.maxConcurrentJobs ? new Date : new Date(Date.now() + this.timeSliceInMilliseconds);
+  }
+  async setNextAvailableTime(date) {
+    if (date > this.nextAllowedStartTime) {
+      this.nextAllowedStartTime = date;
+    }
+  }
+  async clear() {
+    this.currentRunningJobs = 0;
+    this.nextAllowedStartTime = new Date;
+  }
+}
+// src/limiter/DelayLimiter.ts
+class DelayLimiter {
+  delayInMilliseconds;
+  nextAvailableTime = new Date;
+  constructor(delayInMilliseconds = 50) {
+    this.delayInMilliseconds = delayInMilliseconds;
+  }
+  async canProceed() {
+    return Date.now() >= this.nextAvailableTime.getTime();
+  }
+  async recordJobStart() {
+    this.nextAvailableTime = new Date(Date.now() + this.delayInMilliseconds);
+  }
+  async recordJobCompletion() {}
+  async getNextAvailableTime() {
+    return this.nextAvailableTime;
+  }
+  async setNextAvailableTime(date) {
+    if (date > this.nextAvailableTime) {
+      this.nextAvailableTime = date;
+    }
+  }
+  async clear() {
+    this.nextAvailableTime = new Date;
+  }
+}
+// src/limiter/EvenlySpacedRateLimiter.ts
+import { createServiceToken as createServiceToken4 } from "@workglow/util";
+var EVENLY_SPACED_JOB_RATE_LIMITER = createServiceToken4("jobqueue.limiter.rate.evenlyspaced");
+
+class EvenlySpacedRateLimiter {
+  maxExecutions;
+  windowSizeMs;
+  idealInterval;
+  nextAvailableTime = Date.now();
+  lastStartTime = 0;
+  durations = [];
+  constructor({ maxExecutions, windowSizeInSeconds }) {
+    if (maxExecutions <= 0) {
+      throw new Error("maxExecutions must be > 0");
+    }
+    if (windowSizeInSeconds <= 0) {
+      throw new Error("windowSizeInSeconds must be > 0");
+    }
+    this.maxExecutions = maxExecutions;
+    this.windowSizeMs = windowSizeInSeconds * 1000;
+    this.idealInterval = this.windowSizeMs / this.maxExecutions;
+  }
+  async canProceed() {
+    const now = Date.now();
+    return now >= this.nextAvailableTime;
+  }
+  async recordJobStart() {
+    const now = Date.now();
+    this.lastStartTime = now;
+    if (this.durations.length === 0) {
+      this.nextAvailableTime = now + this.idealInterval;
+    } else {
+      const sum = this.durations.reduce((a, b) => a + b, 0);
+      const avgDuration = sum / this.durations.length;
+      const waitMs = Math.max(0, this.idealInterval - avgDuration);
+      this.nextAvailableTime = now + waitMs;
+    }
+  }
+  async recordJobCompletion() {
+    const now = Date.now();
+    const duration = now - this.lastStartTime;
+    this.durations.push(duration);
+    if (this.durations.length > this.maxExecutions) {
+      this.durations.shift();
+    }
+  }
+  async getNextAvailableTime() {
+    return new Date(this.nextAvailableTime);
+  }
+  async setNextAvailableTime(date) {
+    const t = date.getTime();
+    if (t > this.nextAvailableTime) {
+      this.nextAvailableTime = t;
+    }
+  }
+  async clear() {
+    this.durations = [];
+    this.nextAvailableTime = Date.now();
+    this.lastStartTime = 0;
+  }
+}
+// src/limiter/InMemoryRateLimiter.ts
+import { createServiceToken as createServiceToken5 } from "@workglow/util";
+var MEMORY_JOB_RATE_LIMITER = createServiceToken5("jobqueue.limiter.rate.memory");
+
+class InMemoryRateLimiter {
+  requests = [];
+  nextAvailableTime = new Date;
+  currentBackoffDelay;
+  maxExecutions;
+  windowSizeInMilliseconds;
+  initialBackoffDelay;
+  backoffMultiplier;
+  maxBackoffDelay;
+  constructor({
+    maxExecutions,
+    windowSizeInSeconds,
+    initialBackoffDelay = 1000,
+    backoffMultiplier = 2,
+    maxBackoffDelay = 600000
+  }) {
+    if (maxExecutions <= 0) {
+      throw new Error("maxExecutions must be greater than 0");
+    }
+    if (windowSizeInSeconds <= 0) {
+      throw new Error("windowSizeInSeconds must be greater than 0");
+    }
+    if (initialBackoffDelay <= 0) {
+      throw new Error("initialBackoffDelay must be greater than 0");
+    }
+    if (backoffMultiplier <= 1) {
+      throw new Error("backoffMultiplier must be greater than 1");
+    }
+    if (maxBackoffDelay <= initialBackoffDelay) {
+      throw new Error("maxBackoffDelay must be greater than initialBackoffDelay");
+    }
+    this.maxExecutions = maxExecutions;
+    this.windowSizeInMilliseconds = windowSizeInSeconds * 1000;
+    this.initialBackoffDelay = initialBackoffDelay;
+    this.backoffMultiplier = backoffMultiplier;
+    this.maxBackoffDelay = maxBackoffDelay;
+    this.currentBackoffDelay = initialBackoffDelay;
+  }
+  removeOldRequests() {
+    const now = Date.now();
+    const cutoff = now - this.windowSizeInMilliseconds;
+    this.requests = this.requests.filter((d) => d.getTime() > cutoff);
+    if (this.nextAvailableTime.getTime() < now) {
+      this.nextAvailableTime = new Date(now);
+    }
+  }
+  increaseBackoff() {
+    this.currentBackoffDelay = Math.min(this.currentBackoffDelay * this.backoffMultiplier, this.maxBackoffDelay);
+  }
+  addJitter(base) {
+    return base + Math.random() * base;
+  }
+  async canProceed() {
+    this.removeOldRequests();
+    const now = Date.now();
+    const okRequestCount = this.requests.length < this.maxExecutions;
+    const okTime = now >= this.nextAvailableTime.getTime();
+    const canProceedNow = okRequestCount && okTime;
+    if (!canProceedNow) {
+      this.increaseBackoff();
+    } else {
+      this.currentBackoffDelay = this.initialBackoffDelay;
+    }
+    return canProceedNow;
+  }
+  async recordJobStart() {
+    this.requests.push(new Date);
+    if (this.requests.length >= this.maxExecutions) {
+      const earliest = this.requests[0].getTime();
+      const windowExpires = earliest + this.windowSizeInMilliseconds;
+      const backoffExpires = Date.now() + this.addJitter(this.currentBackoffDelay);
+      this.nextAvailableTime = new Date(Math.max(windowExpires, backoffExpires));
+    }
+  }
+  async recordJobCompletion() {}
+  async getNextAvailableTime() {
+    this.removeOldRequests();
+    return new Date(Math.max(Date.now(), this.nextAvailableTime.getTime()));
+  }
+  async setNextAvailableTime(date) {
+    if (date.getTime() > this.nextAvailableTime.getTime()) {
+      this.nextAvailableTime = date;
+    }
+  }
+  async clear() {
+    this.requests = [];
+    this.nextAvailableTime = new Date;
+    this.currentBackoffDelay = this.initialBackoffDelay;
+  }
+}
+export {
+  RetryableJobError,
+  QueueMode,
+  PermanentJobError,
+  NullLimiter,
+  NULL_JOB_LIMITER,
+  MEMORY_JOB_RATE_LIMITER,
+  JobStatus,
+  JobQueue,
+  JobNotFoundError,
+  JobError,
+  JobDisabledError,
+  Job,
+  JOB_LIMITER,
+  InMemoryRateLimiter,
+  EvenlySpacedRateLimiter,
+  EVENLY_SPACED_JOB_RATE_LIMITER,
+  DelayLimiter,
+  ConcurrencyLimiter,
+  CompositeLimiter,
+  CONCURRENT_JOB_LIMITER,
+  AbortSignalJobError
+};
+
+//# debugId=4FA097AF2EE0650C64756E2164756E21