rl-core-api 0.6.0 → 0.8.0

package/dist/core/queue/job.producer.js

@@ -0,0 +1,124 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var JobProducer_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobProducer = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+const bullmq_2 = require("bullmq");
+const ioredis_1 = __importDefault(require("ioredis"));
+const queue_constants_1 = require("./queue.constants");
+const redisConnection_1 = require("./redisConnection");
+const PROBE_TIMEOUT_MS = 5000;
+const HEALTH_TIMEOUT_MS = 1500;
+const isStoredProgress = (value) => typeof value === "object" && value !== null && "percent" in value;
+let JobProducer = JobProducer_1 = class JobProducer {
+    constructor(queue) {
+        this.queue = queue;
+        this.logger = new common_1.Logger(JobProducer_1.name);
+    }
+    async onApplicationBootstrap() {
+        if (!(0, queue_constants_1.isRedisConfigured)()) {
+            this.logger.log("Fila desligada: REDIS_HOST não declarado");
+            return;
+        }
+        await this.assertRedisReachable();
+    }
+    isAvailable() {
+        return Boolean(this.queue);
+    }
+    async enqueue(name, payload, options) {
+        const queue = this.requireQueue();
+        const envelope = {
+            ownerId: options.ownerId,
+            payload,
+        };
+        const job = await queue.add(name, envelope, {
+            jobId: options.jobId,
+            attempts: options.attempts ?? queue_constants_1.JOB_ATTEMPTS,
+            backoff: { type: "exponential", delay: queue_constants_1.JOB_BACKOFF_DELAY_MS },
+            removeOnComplete: { age: queue_constants_1.COMPLETED_RETENTION_SECONDS, count: 1000 },
+            removeOnFail: { age: queue_constants_1.FAILED_RETENTION_SECONDS },
+        });
+        return { jobId: String(job.id), name };
+    }
+    async status(jobId, ownerId) {
+        const queue = this.requireQueue();
+        const job = await queue.getJob(jobId);
+        if (!job || job.data?.ownerId !== ownerId) {
+            throw new common_1.NotFoundException("Job não encontrado");
+        }
+        const state = (await job.getState());
+        return {
+            id: String(job.id),
+            name: job.name,
+            state,
+            progress: isStoredProgress(job.progress) ? job.progress : null,
+            summary: job.returnvalue ?? null,
+            error: job.failedReason ? { code: null, message: job.failedReason } : null,
+            createdAt: new Date(job.timestamp).toISOString(),
+            finishedAt: job.finishedOn ? new Date(job.finishedOn).toISOString() : null,
+        };
+    }
+    async redisStatus() {
+        if (!(0, queue_constants_1.isRedisConfigured)()) {
+            return "off";
+        }
+        if (!this.queue) {
+            return "down";
+        }
+        const timeout = new Promise((resolve) => setTimeout(() => resolve("down"), HEALTH_TIMEOUT_MS).unref());
+        return Promise.race([
+            this.queue
+                .getJobCounts("waiting")
+                .then(() => "up")
+                .catch(() => "down"),
+            timeout,
+        ]);
+    }
+    requireQueue() {
+        if (!this.queue) {
+            throw new common_1.ServiceUnavailableException("Processamento em segundo plano indisponível neste ambiente");
+        }
+        return this.queue;
+    }
+    async assertRedisReachable() {
+        const probe = new ioredis_1.default({
+            ...(0, redisConnection_1.buildRedisOptions)(),
+            lazyConnect: true,
+            maxRetriesPerRequest: 1,
+            retryStrategy: () => null,
+            connectTimeout: PROBE_TIMEOUT_MS,
+        });
+        const failure = await probe
+            .connect()
+            .then(() => probe.ping())
+            .then(() => null)
+            .catch((err) => err);
+        probe.disconnect();
+        if (failure) {
+            throw new Error(`REDIS_HOST está declarado mas o Redis não respondeu: ${failure.message}`);
+        }
+    }
+};
+exports.JobProducer = JobProducer;
+exports.JobProducer = JobProducer = JobProducer_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, bullmq_1.InjectQueue)(queue_constants_1.JOBS_QUEUE)),
+    __metadata("design:paramtypes", [bullmq_2.Queue])
+], JobProducer);

package/dist/core/queue/jobEvents.interface.d.ts

@@ -0,0 +1,4 @@
+export interface JobEventsPublisher {
+    emitToUser<T>(userId: string, event: string, data: T): void;
+}
+export declare const JOB_EVENTS_PUBLISHER: unique symbol;

package/dist/core/queue/jobEvents.interface.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JOB_EVENTS_PUBLISHER = void 0;
+exports.JOB_EVENTS_PUBLISHER = Symbol("JOB_EVENTS_PUBLISHER");

package/dist/core/queue/jobEvents.service.d.ts

@@ -0,0 +1,12 @@
+import { ModuleRef } from "@nestjs/core";
+export declare class JobEventsService {
+    private readonly moduleRef;
+    private readonly logger;
+    private publisher;
+    constructor(moduleRef: ModuleRef);
+    progress(ownerId: string, data: unknown): void;
+    completed(ownerId: string, data: unknown): void;
+    failed(ownerId: string, data: unknown): void;
+    private emit;
+    private resolve;
+}

package/dist/core/queue/jobEvents.service.js

@@ -0,0 +1,53 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var JobEventsService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobEventsService = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const jobEvents_interface_1 = require("./jobEvents.interface");
+const queue_constants_1 = require("./queue.constants");
+let JobEventsService = JobEventsService_1 = class JobEventsService {
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+        this.logger = new common_1.Logger(JobEventsService_1.name);
+    }
+    progress(ownerId, data) {
+        this.emit(ownerId, queue_constants_1.JOB_PROGRESS_EVENT, data);
+    }
+    completed(ownerId, data) {
+        this.emit(ownerId, queue_constants_1.JOB_COMPLETED_EVENT, data);
+    }
+    failed(ownerId, data) {
+        this.emit(ownerId, queue_constants_1.JOB_FAILED_EVENT, data);
+    }
+    emit(ownerId, event, data) {
+        this.resolve()?.emitToUser(ownerId, event, data);
+    }
+    resolve() {
+        if (this.publisher !== undefined) {
+            return this.publisher;
+        }
+        try {
+            this.publisher = this.moduleRef.get(jobEvents_interface_1.JOB_EVENTS_PUBLISHER, { strict: false });
+        }
+        catch {
+            this.logger.warn("Fila sem canal de tempo real: o andamento só sai por GET /jobs/:id");
+            this.publisher = null;
+        }
+        return this.publisher;
+    }
+};
+exports.JobEventsService = JobEventsService;
+exports.JobEventsService = JobEventsService = JobEventsService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
+], JobEventsService);

package/dist/core/queue/jobStatus.controller.d.ts

@@ -0,0 +1,8 @@
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+import { JobStatus } from "./job.interface";
+import { JobProducer } from "./job.producer";
+export declare class JobStatusController {
+    private readonly jobs;
+    constructor(jobs: JobProducer);
+    status(id: string, actor: AuthenticatedUser): Promise<JobStatus>;
+}

package/dist/core/queue/jobStatus.controller.js

@@ -0,0 +1,44 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobStatusController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const currentUser_decorator_1 = require("../auth/decorators/currentUser.decorator");
+const job_producer_1 = require("./job.producer");
+const jobStatus_response_1 = require("./jobStatus.response");
+let JobStatusController = class JobStatusController {
+    constructor(jobs) {
+        this.jobs = jobs;
+    }
+    status(id, actor) {
+        return this.jobs.status(id, actor.id);
+    }
+};
+exports.JobStatusController = JobStatusController;
+__decorate([
+    (0, common_1.Get)(":id"),
+    (0, swagger_1.ApiOkResponse)({ type: jobStatus_response_1.JobStatusResponse }),
+    __param(0, (0, common_1.Param)("id")),
+    __param(1, (0, currentUser_decorator_1.CurrentUser)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object]),
+    __metadata("design:returntype", Promise)
+], JobStatusController.prototype, "status", null);
+exports.JobStatusController = JobStatusController = __decorate([
+    (0, swagger_1.ApiTags)("Jobs"),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.Controller)({ path: "jobs", version: "1" }),
+    __metadata("design:paramtypes", [job_producer_1.JobProducer])
+], JobStatusController);

package/dist/core/queue/jobStatus.response.d.ts

@@ -0,0 +1,20 @@
+export declare class JobProgressResponse {
+    processed: number;
+    total: number;
+    percent: number;
+    message?: string;
+}
+export declare class JobErrorResponse {
+    code: string | null;
+    message: string;
+}
+export declare class JobStatusResponse {
+    id: string;
+    name: string;
+    state: string;
+    progress: JobProgressResponse | null;
+    summary: unknown;
+    error: JobErrorResponse | null;
+    createdAt: string;
+    finishedAt: string | null;
+}

package/dist/core/queue/jobStatus.response.js

@@ -0,0 +1,84 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobStatusResponse = exports.JobErrorResponse = exports.JobProgressResponse = void 0;
+const swagger_1 = require("@nestjs/swagger");
+class JobProgressResponse {
+}
+exports.JobProgressResponse = JobProgressResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 120 }),
+    __metadata("design:type", Number)
+], JobProgressResponse.prototype, "processed", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 175 }),
+    __metadata("design:type", Number)
+], JobProgressResponse.prototype, "total", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: 69, description: "Inteiro de 0 a 100" }),
+    __metadata("design:type", Number)
+], JobProgressResponse.prototype, "percent", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ required: false, example: "Lendo a planilha" }),
+    __metadata("design:type", String)
+], JobProgressResponse.prototype, "message", void 0);
+class JobErrorResponse {
+}
+exports.JobErrorResponse = JobErrorResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, nullable: true, example: "INVALID_FILTER" }),
+    __metadata("design:type", Object)
+], JobErrorResponse.prototype, "code", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: "Falha ao processar. Tente novamente" }),
+    __metadata("design:type", String)
+], JobErrorResponse.prototype, "message", void 0);
+class JobStatusResponse {
+}
+exports.JobStatusResponse = JobStatusResponse;
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: "42" }),
+    __metadata("design:type", String)
+], JobStatusResponse.prototype, "id", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ example: "funkos:import" }),
+    __metadata("design:type", String)
+], JobStatusResponse.prototype, "name", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        example: "active",
+        enum: ["waiting", "active", "completed", "failed", "delayed", "unknown"],
+    }),
+    __metadata("design:type", String)
+], JobStatusResponse.prototype, "state", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: JobProgressResponse, nullable: true }),
+    __metadata("design:type", Object)
+], JobStatusResponse.prototype, "progress", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({
+        nullable: true,
+        description: "Relatório que o processador devolveu, no formato da feature",
+    }),
+    __metadata("design:type", Object)
+], JobStatusResponse.prototype, "summary", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: JobErrorResponse, nullable: true }),
+    __metadata("design:type", Object)
+], JobStatusResponse.prototype, "error", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ format: "date-time" }),
+    __metadata("design:type", String)
+], JobStatusResponse.prototype, "createdAt", void 0);
+__decorate([
+    (0, swagger_1.ApiProperty)({ type: String, format: "date-time", nullable: true }),
+    __metadata("design:type", Object)
+], JobStatusResponse.prototype, "finishedAt", void 0);

package/dist/core/queue/jobWorkerHost.d.ts

@@ -0,0 +1,17 @@
+import { WorkerHost } from "@nestjs/bullmq";
+import { Logger, OnApplicationBootstrap } from "@nestjs/common";
+import { Job } from "bullmq";
+import { JobContext, JobEnvelope } from "./job.interface";
+import { JobEventsService } from "./jobEvents.service";
+export declare abstract class JobWorkerHost<TPayload = unknown, TSummary = unknown> extends WorkerHost implements OnApplicationBootstrap {
+    protected readonly jobEvents: JobEventsService;
+    protected readonly logger: Logger;
+    constructor(jobEvents: JobEventsService);
+    onApplicationBootstrap(): void;
+    abstract handle(job: JobContext<TPayload>): Promise<TSummary>;
+    process(job: Job<JobEnvelope<TPayload>>): Promise<TSummary>;
+}
+export declare const toSafeError: (err: Error) => {
+    errorCode: string | null;
+    message: string;
+};

package/dist/core/queue/jobWorkerHost.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSafeError = exports.JobWorkerHost = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+class JobWorkerHost extends bullmq_1.WorkerHost {
+    constructor(jobEvents) {
+        super();
+        this.jobEvents = jobEvents;
+        this.logger = new common_1.Logger(this.constructor.name);
+    }
+    onApplicationBootstrap() {
+        if (!this.worker.isRunning()) {
+            void this.worker.run();
+        }
+    }
+    async process(job) {
+        const jobId = String(job.id);
+        const { ownerId, payload } = job.data;
+        try {
+            const summary = await this.handle({
+                jobId,
+                ownerId,
+                payload,
+                report: async (processed, total, message) => {
+                    const percent = total > 0 ? Math.min(100, Math.round((processed / total) * 100)) : 0;
+                    await job.updateProgress({ processed, total, percent, message });
+                    this.jobEvents.progress(ownerId, {
+                        jobId,
+                        name: job.name,
+                        processed,
+                        total,
+                        percent,
+                        message,
+                    });
+                },
+            });
+            this.jobEvents.completed(ownerId, {
+                jobId,
+                name: job.name,
+                summary,
+            });
+            return summary;
+        }
+        catch (err) {
+            this.logger.error(`Job ${job.name} #${jobId} falhou: ${err.message}`, err.stack);
+            if (job.attemptsMade + 1 >= (job.opts.attempts ?? 1)) {
+                this.jobEvents.failed(ownerId, {
+                    jobId,
+                    name: job.name,
+                    ...(0, exports.toSafeError)(err),
+                });
+            }
+            throw err;
+        }
+    }
+}
+exports.JobWorkerHost = JobWorkerHost;
+const toSafeError = (err) => {
+    if (err instanceof common_1.HttpException) {
+        const response = err.getResponse();
+        const code = typeof response === "object" && response !== null
+            ? (response.errorCode ?? null)
+            : null;
+        return { errorCode: code, message: err.message };
+    }
+    return {
+        errorCode: null,
+        message: "Falha ao processar. Tente novamente ou avise o suporte",
+    };
+};
+exports.toSafeError = toSafeError;

package/dist/core/queue/queue.constants.d.ts

@@ -0,0 +1,11 @@
+export declare const JOBS_QUEUE = "jobs";
+export declare const JOB_PROGRESS_EVENT = "job:progress";
+export declare const JOB_COMPLETED_EVENT = "job:completed";
+export declare const JOB_FAILED_EVENT = "job:failed";
+export declare const JOB_CONCURRENCY = 5;
+export declare const JOB_ATTEMPTS = 3;
+export declare const JOB_BACKOFF_DELAY_MS = 30000;
+export declare const COMPLETED_RETENTION_SECONDS = 86400;
+export declare const FAILED_RETENTION_SECONDS = 14400;
+export declare const isRedisConfigured: () => boolean;
+export declare const queuePrefix: () => string;

package/dist/core/queue/queue.constants.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queuePrefix = exports.isRedisConfigured = exports.FAILED_RETENTION_SECONDS = exports.COMPLETED_RETENTION_SECONDS = exports.JOB_BACKOFF_DELAY_MS = exports.JOB_ATTEMPTS = exports.JOB_CONCURRENCY = exports.JOB_FAILED_EVENT = exports.JOB_COMPLETED_EVENT = exports.JOB_PROGRESS_EVENT = exports.JOBS_QUEUE = void 0;
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();
+exports.JOBS_QUEUE = "jobs";
+exports.JOB_PROGRESS_EVENT = "job:progress";
+exports.JOB_COMPLETED_EVENT = "job:completed";
+exports.JOB_FAILED_EVENT = "job:failed";
+exports.JOB_CONCURRENCY = 5;
+exports.JOB_ATTEMPTS = 3;
+exports.JOB_BACKOFF_DELAY_MS = 30_000;
+exports.COMPLETED_RETENTION_SECONDS = 86_400;
+exports.FAILED_RETENTION_SECONDS = 14_400;
+const isRedisConfigured = () => Boolean(process.env.REDIS_HOST);
+exports.isRedisConfigured = isRedisConfigured;
+const queuePrefix = () => process.env.REDIS_PREFIX ?? "core";
+exports.queuePrefix = queuePrefix;

package/dist/core/queue/queue.module.d.ts

@@ -0,0 +1,2 @@
+export declare class QueueModule {
+}

package/dist/core/queue/queue.module.js

@@ -0,0 +1,38 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueModule = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+const bullConnection_module_1 = require("./bullConnection.module");
+const job_producer_1 = require("./job.producer");
+const jobEvents_service_1 = require("./jobEvents.service");
+const jobStatus_controller_1 = require("./jobStatus.controller");
+const queue_constants_1 = require("./queue.constants");
+const queueAdmin_controller_1 = require("./queueAdmin.controller");
+const queueAdmin_service_1 = require("./queueAdmin.service");
+const logger = new common_1.Logger("QueueModule");
+const buildImports = () => {
+    if (!(0, queue_constants_1.isRedisConfigured)()) {
+        logger.warn("REDIS_HOST não configurado — a fila não será registrada e o enfileiramento fica indisponível");
+        return [];
+    }
+    return [bullConnection_module_1.BullConnectionModule, bullmq_1.BullModule.registerQueue({ name: queue_constants_1.JOBS_QUEUE })];
+};
+let QueueModule = class QueueModule {
+};
+exports.QueueModule = QueueModule;
+exports.QueueModule = QueueModule = __decorate([
+    (0, common_1.Global)(),
+    (0, common_1.Module)({
+        imports: buildImports(),
+        controllers: [jobStatus_controller_1.JobStatusController, queueAdmin_controller_1.QueueAdminController],
+        providers: [job_producer_1.JobProducer, jobEvents_service_1.JobEventsService, queueAdmin_service_1.QueueAdminService],
+        exports: [job_producer_1.JobProducer, jobEvents_service_1.JobEventsService],
+    })
+], QueueModule);

package/dist/core/queue/queueAdmin.controller.d.ts

@@ -0,0 +1,11 @@
+import { QueueCounts, QueueJobSummary } from "./job.interface";
+import { QueueAdminService } from "./queueAdmin.service";
+import { Paginated } from "../utils/pagination.util";
+export declare class QueueAdminController {
+    private readonly queues;
+    constructor(queues: QueueAdminService);
+    counts(): Promise<QueueCounts>;
+    jobs(state: string, page?: string, limit?: string): Promise<Paginated<QueueJobSummary>>;
+    retry(id: string): Promise<void>;
+    remove(id: string): Promise<void>;
+}

package/dist/core/queue/queueAdmin.controller.js

@@ -0,0 +1,93 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueAdminController = void 0;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+const requirePermission_decorator_1 = require("../auth/decorators/requirePermission.decorator");
+const permissions_guard_1 = require("../auth/guards/permissions.guard");
+const queueAdmin_response_1 = require("./queueAdmin.response");
+const queueAdmin_service_1 = require("./queueAdmin.service");
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+let QueueAdminController = class QueueAdminController {
+    constructor(queues) {
+        this.queues = queues;
+    }
+    counts() {
+        return this.queues.counts();
+    }
+    jobs(state, page, limit) {
+        return this.queues.list(toState(state), toPositive(page, 1), Math.min(toPositive(limit, DEFAULT_LIMIT), MAX_LIMIT));
+    }
+    retry(id) {
+        return this.queues.retry(id);
+    }
+    remove(id) {
+        return this.queues.remove(id);
+    }
+};
+exports.QueueAdminController = QueueAdminController;
+__decorate([
+    (0, common_1.Get)("counts"),
+    (0, requirePermission_decorator_1.RequirePermission)("queues:read:any"),
+    (0, swagger_1.ApiOkResponse)({ type: queueAdmin_response_1.QueueCountsResponse }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], QueueAdminController.prototype, "counts", null);
+__decorate([
+    (0, common_1.Get)("jobs"),
+    (0, requirePermission_decorator_1.RequirePermission)("queues:read:any"),
+    (0, swagger_1.ApiQuery)({ name: "state", enum: queueAdmin_service_1.LISTABLE_STATES }),
+    (0, swagger_1.ApiOkResponse)({ type: queueAdmin_response_1.PaginatedQueueJobsResponse }),
+    __param(0, (0, common_1.Query)("state")),
+    __param(1, (0, common_1.Query)("page")),
+    __param(2, (0, common_1.Query)("limit")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String]),
+    __metadata("design:returntype", Promise)
+], QueueAdminController.prototype, "jobs", null);
+__decorate([
+    (0, common_1.Post)("jobs/:id/retry"),
+    (0, common_1.HttpCode)(204),
+    (0, requirePermission_decorator_1.RequirePermission)("queues:manage:any"),
+    __param(0, (0, common_1.Param)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], QueueAdminController.prototype, "retry", null);
+__decorate([
+    (0, common_1.Delete)("jobs/:id"),
+    (0, common_1.HttpCode)(204),
+    (0, requirePermission_decorator_1.RequirePermission)("queues:manage:any"),
+    __param(0, (0, common_1.Param)("id")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], QueueAdminController.prototype, "remove", null);
+exports.QueueAdminController = QueueAdminController = __decorate([
+    (0, swagger_1.ApiTags)("Queues"),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(permissions_guard_1.PermissionsGuard),
+    (0, common_1.Controller)({ path: "queues", version: "1" }),
+    __metadata("design:paramtypes", [queueAdmin_service_1.QueueAdminService])
+], QueueAdminController);
+const toState = (value) => queueAdmin_service_1.LISTABLE_STATES.includes(value)
+    ? value
+    : "failed";
+const toPositive = (value, fallback) => {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+};

package/dist/core/queue/queueAdmin.response.d.ts

@@ -0,0 +1,23 @@
+import { PaginationMetaResponse } from "../utils/paginationMeta.response";
+export declare class QueueCountsResponse {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+}
+export declare class QueueJobResponse {
+    id: string;
+    name: string;
+    state: string;
+    ownerId: string | null;
+    attemptsMade: number;
+    percent: number | null;
+    failedReason: string | null;
+    createdAt: string;
+    finishedAt: string | null;
+}
+export declare class PaginatedQueueJobsResponse {
+    items: QueueJobResponse[];
+    meta: PaginationMetaResponse;
+}