@penkov/tasks_queue/dist/tasks-queue.module.js

A lightweight PostgreSQL-backed task queue system with scheduling, retries, backoff strategies, and priority handling. Designed for efficiency and observability in modern Node.js applications.

var TasksQueueModule_1;
import { __decorate, __metadata } from "tslib";
import { Module, } from "@nestjs/common";
import { TasksQueueDao } from "./tasks-queue.dao.js";
import { TasksPoolsService } from "./tasks-pools.service.js";
import { TASKS_QUEUE_OPTIONS, } from "./tasks-queue-async-options.js";
import { ModuleRef } from "@nestjs/core";
import { TimeUtils } from "./time-utils.js";
import { ManageTasksQueueService } from "./manage-tasks-queue.service.js";
import { identity, option } from "scats";
let TasksQueueModule = TasksQueueModule_1 = class TasksQueueModule {
    moduleRef;
    constructor(moduleRef) {
        this.moduleRef = moduleRef;
    }
    static forRootAsync(options) {
        const asyncProviders = this.createAsyncProviders(options);
        return {
            module: TasksQueueModule_1,
            imports: options.imports,
            providers: [
                ...asyncProviders,
                {
                    provide: TasksQueueDao,
                    inject: [TASKS_QUEUE_OPTIONS],
                    useFactory: (opts) => new TasksQueueDao(opts.db),
                },
                {
                    provide: ManageTasksQueueService,
                    inject: [TASKS_QUEUE_OPTIONS],
                    useFactory: (opts) => new ManageTasksQueueService(opts.db),
                },
                {
                    provide: TasksPoolsService,
                    inject: [TasksQueueDao, ManageTasksQueueService, TASKS_QUEUE_OPTIONS],
                    useFactory: (dao, manageService, opts) => new TasksPoolsService(dao, manageService, option(opts.runAuxiliaryWorker).forall(identity), opts.pools),
                },
            ],
            exports: [TasksPoolsService, ManageTasksQueueService],
        };
    }
    static createAsyncProviders(options) {
        if (options.useExisting || options.useFactory) {
            return [this.createAsyncOptionsProvider(options)];
        }
        const useClass = options.useClass;
        return [
            this.createAsyncOptionsProvider(options),
            {
                provide: useClass,
                useClass,
            },
        ];
    }
    static createAsyncOptionsProvider(options) {
        if (options.useFactory) {
            return {
                provide: TASKS_QUEUE_OPTIONS,
                useFactory: options.useFactory,
                inject: options.inject || [],
            };
        }
        const inject = [
            (options.useClass ||
                options.useExisting),
        ];
        return {
            provide: TASKS_QUEUE_OPTIONS,
            useFactory: async (optionsFactory) => await optionsFactory.createTelegrafOptions(),
            inject,
        };
    }
    onApplicationBootstrap() {
        const poolsService = this.moduleRef.get(TasksPoolsService);
        poolsService.start();
    }
    async onApplicationShutdown() {
        const poolsService = this.moduleRef.get(TasksPoolsService);
        await poolsService.stop(TimeUtils.minute);
    }
};
TasksQueueModule = TasksQueueModule_1 = __decorate([
    Module({}),
    __metadata("design:paramtypes", [ModuleRef])
], TasksQueueModule);
export { TasksQueueModule };