@fellas/adonisjs-resque/build/chunk-ASV6JZ7C.js

Resque Queue for AdonisJS v6

// base_job.ts
import app from "@adonisjs/core/services/app";
import { LoggerManager } from "@adonisjs/core/logger";
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;
  logger;
  constructor(..._args) {
    this.logger = this.createLogger();
  }
  createLogger() {
    const loggerName = app.config.get("resque.logger");
    const loggerConfig = app.config.get("logger");
    const manager = new LoggerManager(loggerConfig);
    if (loggerName) {
      return manager.use(loggerName);
    } else {
      return manager.use();
    }
  }
  static enqueue(...args) {
    const job = new this();
    return job.enqueue(...args);
  }
  enqueue(...args) {
    this.args = args;
    this.hasEnqueued = true;
    return this;
  }
  static queue(queueName) {
    const job = new this();
    return job.queue(queueName);
  }
  queue(queueName) {
    this.queueName = queueName;
    return this;
  }
  static enqueueAll(args) {
    const job = new this();
    return job.enqueueAll(args);
  }
  enqueueAll(args) {
    this.allArgs = args;
    this.hasEnqueuedAll = true;
    return this;
  }
  static in(ms) {
    return new this().in(ms);
  }
  in(ms) {
    this.delayMs = ms;
    return this;
  }
  static at(ms) {
    return new this().at(ms);
  }
  at(ms) {
    this.runAtMs = ms;
    return this;
  }
  perform(..._args) {
  }
  handleError(error) {
    this.logger.error(error.message);
    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");
    if (this.hasEnqueued) {
      const getTips = () => {
        if (!resqueConfig.verbose) {
          return void 0;
        }
        const tips = `enqueued to queue ${queueName}, job ${jobName}`;
        if (this.delayMs) {
          return `${tips}, delay ${this.delayMs}ms`;
        } else if (this.runAtMs) {
          return `${tips}, run at ${this.runAtMs}`;
        } else {
          return tips;
        }
      };
      this.logger.info(getTips());
      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;
    }
  }
  /**
   * this method runs after an `await` statement
   * e.g, 
   * ```typescript
   * await job.enqueue().in(2000)
   * ```
   * @param fn 
   */
  then(fn) {
    this.execute().then(fn);
  }
};

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