Class InlineScheduledTask

src/tasks/inline-scheduled-task.ts:13–238

class TaskEmitter extends EventEmitter{}

export class InlineScheduledTask implements ScheduledTask {
  emitter: TaskEmitter;
  cronExpression: string;
  timeMatcher: TimeMatcher;
  runner: Runner;
  id: string;
  name: string;
  stateMachine: StateMachine;
  timezone?: string;
  logger: Logger;
  suppressMissedWarning: boolean;
  // The last actual execution. Recorded when a run really finishes or fails,
  // keyed off the execution's own timestamps rather than the tick that armed it.
  private _lastRun: LastRun | null = null;

  constructor(cronExpression: string, taskFn: TaskFn, options?: TaskOptions){
    this.emitter = new TaskEmitter();
    this.cronExpression = cronExpression;

    this.id = createID();
    this.name = options?.name || this.id;
    this.timezone = options?.timezone;
    this.logger = options?.logger || logger;
    this.suppressMissedWarning = options?.suppressMissedWarning || false;

    this.timeMatcher = new TimeMatcher(cronExpression, options?.timezone)
    this.stateMachine = new StateMachine();

    const runnerOptions: RunnerOptions = {
      timezone: options?.timezone,
      noOverlap: options?.noOverlap,
      maxExecutions: options?.maxExecutions,
      maxRandomDelay: options?.maxRandomDelay,
      missedExecutionTolerance: options?.missedExecutionTolerance,
      logger: this.logger,
      beforeRun: (date: Date, execution: Execution) => {
        if(execution.reason === 'scheduled'){
          this.changeState('running');
        }
        this.emitter.emit('execution:started', this.createContext(date, execution));
        return true;
      },
      onFinished: (date: Date, execution: Execution) => {
        if(execution.reason === 'scheduled'){
          this.changeState('idle');
        }
        this.recordLastRun(execution);
        this.emitter.emit('execution:finished', this.createContext(date, execution));
        return true;
      },
      onError: (date: Date, error: Error, execution: Execution) => {
        this.logger.error(error);
        this.recordLastRun(execution);
        this.emitter.emit('execution:failed', this.createContext(date, execution));
        this.changeState('idle');
      },
      onOverlap: (date: Date) => {
        this.emitter.emit('execution:overlap', this.createContext(date));