adonis-resque/build/chunk-ZV4D6HN4.js

Resque Queue for AdonisJS v6

// base_job.ts
import app from "@adonisjs/core/services/app";
var BaseJob = class {
  interval;
  cron;
  plugins = [];
  delayMs = 0;
  runAtMs;
  /**
   * the default JobName is this class name  
   * it **MUST be a unique name**
   */
  jobName;
  /**
   * set a queueName for this job
   * default configured in `config/resque.ts`
   */
  queueName;
  args = [];
  allArgs = [];
  hasEnqueued = false;
  hasEnqueuedAll = false;
  app = app;
  constructor(..._args) {
  }
  queue(queueName) {
    this.queueName = queueName;
    return this;
  }
  static async enqueueAll(args) {
    const job = await app.container.make(this);
    return job.enqueueAll(args);
  }
  async enqueueAll(args) {
    this.allArgs = args;
    this.hasEnqueuedAll = true;
    return this.execute();
  }
  perform(..._args) {
  }
  handleError(error) {
    throw error;
  }
  onFailure(_failure) {
  }
  async execute() {
    const resqueConfig = app.config.get("resque");
    const jobName = this.jobName ?? this.constructor.name;
    const queueName = this.queueName ?? resqueConfig.queueNameForJobs;
    const queue = await app.container.make("queue");
    let logger = await app.container.make("logger");
    if (resqueConfig.logger) {
      logger.use(resqueConfig.logger);
    }
    if (this.hasEnqueued) {
      const getTips = () => {
        if (!resqueConfig.verbose) {
          return void 0;
        }
        const tips2 = `enqueued to queue ${queueName}, job ${jobName}`;
        if (this.delayMs) {
          return `${tips2}, delay ${this.delayMs}ms`;
        } else if (this.runAtMs) {
          return `${tips2}, run at ${this.runAtMs}`;
        } else {
          return tips2;
        }
      };
      const tips = getTips();
      if (tips) {
        logger.info(tips);
      }
      if (this.delayMs) {
        return queue.enqueueIn(this.delayMs, queueName, jobName, this.args);
      } else if (this.runAtMs) {
        return queue.enqueueAt(this.runAtMs, queueName, jobName, this.args);
      } else {
        return queue.enqueue(queueName, jobName, this.args);
      }
    } else if (this.hasEnqueuedAll) {
      return Promise.all(this.allArgs.map((arg) => queue.enqueue(queueName, jobName, arg)));
    } else {
      return false;
    }
  }
  push({ args, delayMs, runAtMs }) {
    this.args = args;
    this.hasEnqueued = true;
    this.delayMs = delayMs ? delayMs : 0;
    this.runAtMs = runAtMs;
    return this.execute();
  }
  static async enqueue(...args) {
    const job = await app.container.make(this);
    return job.enqueue(...args);
  }
  async enqueue(...args) {
    return this.push({
      args
    });
  }
  /**
   * 
   * @param this 
   * @param delayMs In ms, the number of ms to delay before this job is able to start being worked on
   * @param args
   * @returns 
   */
  static async enqueueIn(delayMs, ...args) {
    const job = await app.container.make(this);
    return job.enqueueIn(delayMs, ...args);
  }
  async enqueueIn(delayMs, ...args) {
    return this.push({
      args,
      delayMs
    });
  }
  static async enqueueAt(runAtMs, ...args) {
    const job = await app.container.make(this);
    return job.enqueueAt(runAtMs, ...args);
  }
  async enqueueAt(runAtMs, ...args) {
    return this.push({
      args,
      runAtMs
    });
  }
};

export {
  BaseJob
};
//# sourceMappingURL=chunk-ZV4D6HN4.js.map