File JobProcessor.ts has 463 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import * as debug from 'debug';
import type { IAgendaJobStatus, IAgendaStatus } from './types/AgendaStatus';
import type { IJobDefinition } from './types/JobDefinition';
import type { Agenda, JobWithId } from './index';
import type { IJobParameters } from './types/JobParameters';

File index.ts has 387 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import { EventEmitter } from 'events';
import * as debug from 'debug';

import type { Db, Filter, MongoClientOptions, Sort } from 'mongodb';
import { SortDirection } from 'mongodb';

Function runOrRetry has 118 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private async runOrRetry(job: JobWithId): Promise<void> {
        if (!this.isRunning) {
            // const a = new Error();
            // console.log('STACK', a.stack);
            log.extend('runOrRetry')(

Function runOrRetry has a Cognitive Complexity of 31 (exceeds 5 allowed). Consider refactoring.

Open

    private async runOrRetry(job: JobWithId): Promise<void> {
        if (!this.isRunning) {
            // const a = new Error();
            // console.log('STACK', a.stack);
            log.extend('runOrRetry')(

• Read up
  Read up

Function jobProcessing has a Cognitive Complexity of 30 (exceeds 5 allowed). Consider refactoring.

Open

    private async jobProcessing(handledJobs: IJobParameters['_id'][] = []) {
        // Ensure we have jobs
        if (this.jobQueue.length === 0) {
            return;
        }

• Read up
  Read up

File Job.ts has 350 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import * as date from 'date.js';
import * as debug from 'debug';
import { ObjectId } from 'mongodb';
import { ChildProcess, fork } from 'child_process';
import type { Agenda } from './index';

Function run has 88 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async run(): Promise<void> {
        this.attrs.lastRunAt = new Date();
        log(
            '[%s:%s] setting lastRunAt to: %s',
            this.attrs.name,

Function saveJob has 84 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async saveJob<DATA = unknown | void>(job: Job<DATA>): Promise<Job<DATA>> {
        try {
            log('attempting to save a job');

            // Grab information needed to save job but that we don't want to persist in MongoDB

Agenda has 27 functions (exceeds 20 allowed). Consider refactoring.

Open

export class Agenda extends EventEmitter {
    readonly attrs: IAgendaConfig & IDbConfig;

    public readonly forkedWorker?: boolean;

File JobDbRepository.ts has 297 lines of code (exceeds 250 allowed). Consider refactoring.

Open

import * as debug from 'debug';
import {
    Collection,
    Db,
    Filter,

Function jobProcessing has 73 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private async jobProcessing(handledJobs: IJobParameters['_id'][] = []) {
        // Ensure we have jobs
        if (this.jobQueue.length === 0) {
            return;
        }

Job has 24 functions (exceeds 20 allowed). Consider refactoring.

Open

export class Job<DATA = unknown | void> {
    readonly attrs: IJobParameters<DATA>;

    /** this flag is set to true, if a job got canceled (e.g. due to a timeout or other exception),
     * you can use it for long running tasks to periodically check if canceled is true,

Function lockOnTheFly has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.

Open

    async lockOnTheFly(): Promise<void> {
        // Already running this? Return
        if (this.isLockingOnTheFly) {
            log.extend('lockOnTheFly')('already running, returning');
            return;

• Read up
  Read up

Function lockOnTheFly has 55 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async lockOnTheFly(): Promise<void> {
        // Already running this? Return
        if (this.isLockingOnTheFly) {
            log.extend('lockOnTheFly')('already running, returning');
            return;

Function computeFromInterval has 47 lines of code (exceeds 25 allowed). Consider refactoring.

Open

export const computeFromInterval = (attrs: IJobParameters<any>): Date => {
    const previousNextRunAt = attrs.nextRunAt || new Date();
    log('[%s:%s] computing next run via interval [%s]', attrs.name, attrs._id, attrs.repeatInterval);

    const lastRun = dateForTimezone(attrs.lastRunAt || new Date(), attrs.repeatTimezone);

Function getStatus has 46 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    async getStatus(fullDetails = false): Promise<IAgendaStatus> {
        const jobStatus = Object.keys(this.jobStatus).reduce((obj, key) => {
            // eslint-disable-next-line no-param-reassign
            obj[key] = {
                ...this.jobStatus[key],

Function jobQueueFilling has 41 lines of code (exceeds 25 allowed). Consider refactoring.

Open

    private async jobQueueFilling(name: string): Promise<void> {
        this.isJobQueueFilling.set(name, true);

        try {
            // Don't lock because of a limit we have set (lockLimit, etc)

Function checkIfJobIsStillAlive has 40 lines of code (exceeds 25 allowed). Consider refactoring.

Open

                    new Promise<void>((resolve, reject) => {
                        setTimeout(async () => {
                            // when job is not running anymore, just finish
                            if (!jobIsRunning) {
                                log.extend('runOrRetry')(

Function saveJob has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    async saveJob<DATA = unknown | void>(job: Job<DATA>): Promise<Job<DATA>> {
        try {
            log('attempting to save a job');

            // Grab information needed to save job but that we don't want to persist in MongoDB

• Read up
  Read up

Function insert has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.

Open

    insert(job: Job): void {
        const matchIndex = this._queue.findIndex(element => {
            if (
                element.attrs.nextRunAt &&
                job.attrs.nextRunAt &&

• Read up
  Read up