rl-core-api 0.14.4 → 0.15.1

package/dist/core/export/exportEngine.service.js

@@ -0,0 +1,151 @@
+"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 ExportEngineService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportEngineService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const exceljs_1 = __importDefault(require("exceljs"));
+const typeorm_2 = require("typeorm");
+const env_service_1 = require("../config/env.service");
+const exportColumn_interface_1 = require("./exportColumn.interface");
+const applyFilter_util_1 = require("../query/applyFilter.util");
+const filterSort_util_1 = require("../query/filterSort.util");
+const paginateWithFilter_util_1 = require("../query/paginateWithFilter.util");
+const PROGRESS_EVERY_ROWS = 1000;
+const EMPTY_CELL = "-";
+const DEFAULT_WIDTH = 20;
+let ExportEngineService = ExportEngineService_1 = class ExportEngineService {
+    constructor(dataSource, env) {
+        this.dataSource = dataSource;
+        this.env = env;
+        this.logger = new common_1.Logger(ExportEngineService_1.name);
+    }
+    async run(handler, payload, ownerId, sink, onProgress) {
+        const maxRows = this.env.get("EXPORT_MAX_ROWS");
+        const [sql, parameters] = this.buildQuery(handler, payload, ownerId);
+        const workbook = new exceljs_1.default.stream.xlsx.WorkbookWriter({
+            stream: sink,
+            useSharedStrings: false,
+            useStyles: false,
+        });
+        const worksheet = workbook.addWorksheet(handler.sheetName);
+        worksheet.columns = handler.columns.map((column) => ({
+            header: column.header,
+            key: column.field,
+            width: column.width ?? DEFAULT_WIDTH,
+        }));
+        const runner = this.dataSource.createQueryRunner();
+        let totalRows = 0;
+        try {
+            await runner.connect();
+            const rows = await runner.stream(sql, parameters);
+            for await (const row of rows) {
+                if (totalRows >= maxRows) {
+                    throw new common_1.BadRequestException(`O relatório passou de ${maxRows.toLocaleString("pt-BR")} linhas. Refine o filtro e tente de novo.`);
+                }
+                worksheet
+                    .addRow(handler.columns.map((column) => toCellValue(row, column)))
+                    .commit();
+                totalRows += 1;
+                if (totalRows % PROGRESS_EVERY_ROWS === 0) {
+                    await onProgress(totalRows);
+                    await waitForDrain(sink);
+                }
+            }
+            worksheet.commit();
+            await workbook.commit();
+            await onProgress(totalRows);
+            this.logger.log(`Relatório "${handler.name}" gerado com ${totalRows} linha(s)`);
+            return { totalRows };
+        }
+        finally {
+            await runner.release();
+        }
+    }
+    buildQuery(handler, payload, ownerId) {
+        const qb = handler.buildQuery({ ownerId });
+        (0, applyFilter_util_1.applyFilter)(qb, payload.filter);
+        (0, paginateWithFilter_util_1.applySearch)(qb, payload.search, handler.catalog, handler.searchFields);
+        const order = (0, filterSort_util_1.resolveCatalogOrder)(payload.sortBy, payload.sortDir, handler.catalog, qb.alias, handler.defaultSort);
+        qb.orderBy(order.column, order.direction);
+        return qb.getQueryAndParameters();
+    }
+};
+exports.ExportEngineService = ExportEngineService;
+exports.ExportEngineService = ExportEngineService = ExportEngineService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectDataSource)()),
+    __metadata("design:paramtypes", [typeorm_2.DataSource,
+        env_service_1.EnvService])
+], ExportEngineService);
+const waitForDrain = async (sink) => {
+    if (!sink.writableNeedDrain) {
+        return;
+    }
+    await new Promise((done) => sink.once("drain", () => done()));
+};
+const toCellValue = (row, column) => {
+    const value = row[column.field];
+    if (value === null || value === undefined) {
+        return EMPTY_CELL;
+    }
+    if (column.format === exportColumn_interface_1.ExportColumnFormat.Date ||
+        column.format === exportColumn_interface_1.ExportColumnFormat.DateTime) {
+        return toLocaleDate(value, column.format);
+    }
+    if (column.format === exportColumn_interface_1.ExportColumnFormat.Currency) {
+        return toCurrency(value);
+    }
+    if (typeof value === "string" || typeof value === "number") {
+        return value;
+    }
+    if (typeof value === "boolean") {
+        return value ? "Sim" : "Não";
+    }
+    if (value instanceof Date) {
+        return toLocaleDate(value, exportColumn_interface_1.ExportColumnFormat.Date);
+    }
+    if (Buffer.isBuffer(value)) {
+        return value.toString("utf8");
+    }
+    return JSON.stringify(value) ?? EMPTY_CELL;
+};
+const toLocaleDate = (value, format) => {
+    if (!(value instanceof Date) &&
+        typeof value !== "string" &&
+        typeof value !== "number") {
+        return EMPTY_CELL;
+    }
+    const date = value instanceof Date ? value : new Date(value);
+    if (Number.isNaN(date.getTime())) {
+        return EMPTY_CELL;
+    }
+    return date.toLocaleString("pt-BR", {
+        day: "2-digit",
+        month: "2-digit",
+        year: "numeric",
+        ...(format === exportColumn_interface_1.ExportColumnFormat.DateTime && {
+            hour: "2-digit",
+            minute: "2-digit",
+        }),
+    });
+};
+const toCurrency = (value) => {
+    const parsed = typeof value === "number" ? value : Number(value);
+    return Number.isNaN(parsed) ? EMPTY_CELL : parsed;
+};

package/dist/core/export/exportHandler.interface.d.ts

@@ -0,0 +1,32 @@
+import { ObjectLiteral, SelectQueryBuilder } from "typeorm";
+import { ExportColumn } from "./exportColumn.interface";
+import { FilterCatalog, FilterNode } from "../query/filterField.interface";
+import { SortDir } from "../utils/pagination.util";
+export interface ExportContext {
+    ownerId: string;
+}
+export interface ExportHandler<T extends ObjectLiteral = ObjectLiteral> {
+    readonly name: string;
+    readonly permission?: string;
+    readonly catalog: FilterCatalog;
+    readonly defaultSort: string;
+    readonly searchFields?: readonly string[];
+    readonly sheetName: string;
+    readonly columns: ExportColumn[];
+    buildFileName(): string;
+    buildQuery(context: ExportContext): SelectQueryBuilder<T>;
+}
+export declare const EXPORT_HANDLER = "rl-core:export-handler";
+export declare const ExportReport: () => ClassDecorator;
+export interface ExportJobPayload {
+    handler: string;
+    filter: FilterNode | null;
+    search?: string;
+    sortBy?: string;
+    sortDir?: SortDir;
+    fileName: string;
+}
+export interface ExportJobSummary {
+    fileName: string;
+    totalRows: number;
+}

package/dist/core/export/exportHandler.interface.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportReport = exports.EXPORT_HANDLER = void 0;
+const common_1 = require("@nestjs/common");
+exports.EXPORT_HANDLER = "rl-core:export-handler";
+const ExportReport = () => (0, common_1.SetMetadata)(exports.EXPORT_HANDLER, true);
+exports.ExportReport = ExportReport;

package/dist/core/export/exportHandler.registry.d.ts

@@ -0,0 +1,13 @@
+import { OnModuleInit } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+import { ExportHandler } from "./exportHandler.interface";
+export declare class ExportHandlerRegistry implements OnModuleInit {
+    private readonly discovery;
+    private readonly logger;
+    private readonly handlers;
+    constructor(discovery: DiscoveryService);
+    onModuleInit(): void;
+    find(name: string): ExportHandler | undefined;
+    require(name: string): ExportHandler;
+    names(): string[];
+}

package/dist/core/export/exportHandler.registry.js

@@ -0,0 +1,58 @@
+"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 ExportHandlerRegistry_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportHandlerRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const exportHandler_interface_1 = require("./exportHandler.interface");
+let ExportHandlerRegistry = ExportHandlerRegistry_1 = class ExportHandlerRegistry {
+    constructor(discovery) {
+        this.discovery = discovery;
+        this.logger = new common_1.Logger(ExportHandlerRegistry_1.name);
+        this.handlers = new Map();
+    }
+    onModuleInit() {
+        const found = this.discovery
+            .getProviders()
+            .filter((wrapper) => wrapper.metatype &&
+            Reflect.getMetadata(exportHandler_interface_1.EXPORT_HANDLER, wrapper.metatype) === true)
+            .map((wrapper) => wrapper.instance)
+            .filter(Boolean);
+        for (const handler of found) {
+            if (this.handlers.has(handler.name)) {
+                throw new Error(`Dois relatórios registrados com o nome "${handler.name}"`);
+            }
+            this.handlers.set(handler.name, handler);
+        }
+        if (this.handlers.size > 0) {
+            this.logger.log(`Relatórios disponíveis: ${this.names().join(", ")}`);
+        }
+    }
+    find(name) {
+        return this.handlers.get(name);
+    }
+    require(name) {
+        const handler = this.find(name);
+        if (!handler) {
+            throw new common_1.NotFoundException("Relatório não encontrado");
+        }
+        return handler;
+    }
+    names() {
+        return [...this.handlers.keys()];
+    }
+};
+exports.ExportHandlerRegistry = ExportHandlerRegistry;
+exports.ExportHandlerRegistry = ExportHandlerRegistry = ExportHandlerRegistry_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService])
+], ExportHandlerRegistry);

package/dist/core/export/exportStorage.service.d.ts

@@ -0,0 +1,13 @@
+import { WriteStream } from "fs";
+import { EnvService } from "../config/env.service";
+export declare class ExportStorageService {
+    private readonly env;
+    private readonly logger;
+    private readonly root;
+    constructor(env: EnvService);
+    pathFor(ownerId: string, jobId: string): string;
+    openWriteStream(ownerId: string, jobId: string): Promise<WriteStream>;
+    exists(ownerId: string, jobId: string): Promise<boolean>;
+    remove(ownerId: string, jobId: string): Promise<void>;
+    removeExpired(maxAgeMs: number): Promise<number>;
+}

package/dist/core/export/exportStorage.service.js

@@ -0,0 +1,87 @@
+"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 ExportStorageService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportStorageService = void 0;
+const common_1 = require("@nestjs/common");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const env_service_1 = require("../config/env.service");
+const SAFE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const EXTENSION = ".xlsx";
+let ExportStorageService = ExportStorageService_1 = class ExportStorageService {
+    constructor(env) {
+        this.env = env;
+        this.logger = new common_1.Logger(ExportStorageService_1.name);
+        const configured = this.env.get("EXPORT_DIR");
+        this.root = (0, path_1.isAbsolute)(configured)
+            ? configured
+            : (0, path_1.join)(process.cwd(), configured);
+    }
+    pathFor(ownerId, jobId) {
+        if (!SAFE_ID.test(ownerId) || !SAFE_ID.test(jobId)) {
+            throw new Error("Identificador inválido para caminho de relatório");
+        }
+        const path = (0, path_1.resolve)(this.root, ownerId, `${jobId}${EXTENSION}`);
+        if (!path.startsWith((0, path_1.resolve)(this.root))) {
+            throw new Error("Caminho de relatório fora da pasta de exportação");
+        }
+        return path;
+    }
+    async openWriteStream(ownerId, jobId) {
+        const path = this.pathFor(ownerId, jobId);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+        return (0, fs_1.createWriteStream)(path);
+    }
+    async exists(ownerId, jobId) {
+        return await (0, promises_1.stat)(this.pathFor(ownerId, jobId))
+            .then(() => true)
+            .catch(() => false);
+    }
+    async remove(ownerId, jobId) {
+        await (0, promises_1.rm)(this.pathFor(ownerId, jobId), { force: true });
+    }
+    async removeExpired(maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        const owners = await (0, promises_1.readdir)(this.root, { withFileTypes: true }).catch(() => []);
+        let removed = 0;
+        for (const owner of owners) {
+            if (!owner.isDirectory()) {
+                continue;
+            }
+            const ownerDir = (0, path_1.join)(this.root, owner.name);
+            const files = await (0, promises_1.readdir)(ownerDir).catch(() => []);
+            for (const file of files) {
+                const path = (0, path_1.join)(ownerDir, file);
+                const info = await (0, promises_1.stat)(path).catch(() => null);
+                if (!info?.isFile() || info.mtimeMs > cutoff) {
+                    continue;
+                }
+                await (0, promises_1.rm)(path, { force: true });
+                removed += 1;
+            }
+            const left = await (0, promises_1.readdir)(ownerDir).catch(() => ["-"]);
+            if (left.length === 0) {
+                await (0, promises_1.rm)(ownerDir, { recursive: true, force: true });
+            }
+        }
+        if (removed > 0) {
+            this.logger.log(`Faxina de relatórios: ${removed} arquivo(s) removido(s)`);
+        }
+        return removed;
+    }
+};
+exports.ExportStorageService = ExportStorageService;
+exports.ExportStorageService = ExportStorageService = ExportStorageService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
+], ExportStorageService);

package/dist/core/export/exportWorker.module.d.ts

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

package/dist/core/export/exportWorker.module.js

@@ -0,0 +1,22 @@
+"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.ExportWorkerModule = void 0;
+const common_1 = require("@nestjs/common");
+const export_module_1 = require("./export.module");
+const export_processor_1 = require("./export.processor");
+const queue_constants_1 = require("../queue/queue.constants");
+let ExportWorkerModule = class ExportWorkerModule {
+};
+exports.ExportWorkerModule = ExportWorkerModule;
+exports.ExportWorkerModule = ExportWorkerModule = __decorate([
+    (0, common_1.Module)({
+        imports: [export_module_1.ExportModule],
+        providers: (0, queue_constants_1.isRedisConfigured)() ? [export_processor_1.ExportProcessor] : [],
+    })
+], ExportWorkerModule);

package/dist/core/export/requestExport.command.d.ts

@@ -0,0 +1,6 @@
+export declare class RequestExportCommand {
+    filter?: string;
+    search?: string;
+    sortBy?: string;
+    sortDir?: "ASC" | "DESC";
+}

package/dist/core/export/requestExport.command.js

@@ -0,0 +1,51 @@
+"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.RequestExportCommand = void 0;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const filter_constants_1 = require("../query/filter.constants");
+const SEARCH_MAX_LENGTH = 200;
+class RequestExportCommand {
+}
+exports.RequestExportCommand = RequestExportCommand;
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: "Filtro dinâmico, no mesmo formato da listagem",
+        example: '{"createdAt":{"$BETWEEN":["2026-01-01","2026-06-30"]}}',
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(filter_constants_1.FILTER_MAX_LENGTH),
+    __metadata("design:type", String)
+], RequestExportCommand.prototype, "filter", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({
+        description: "Busca livre, a mesma da toolbar da listagem",
+        example: "marvel",
+    }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MaxLength)(SEARCH_MAX_LENGTH),
+    __metadata("design:type", String)
+], RequestExportCommand.prototype, "search", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ description: "Campo de ordenação do catálogo" }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RequestExportCommand.prototype, "sortBy", void 0);
+__decorate([
+    (0, swagger_1.ApiPropertyOptional)({ enum: ["ASC", "DESC"] }),
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsIn)(["ASC", "DESC"]),
+    __metadata("design:type", String)
+], RequestExportCommand.prototype, "sortDir", void 0);

package/dist/core/query/paginateWithFilter.util.d.ts

@@ -9,3 +9,4 @@ export interface PaginateWithFilterOptions {
     searchFields?: readonly string[];
 }
 export declare const paginateWithFilter: <T extends ObjectLiteral>(qb: SelectQueryBuilder<T>, options: PaginateWithFilterOptions) => Promise<[T[], number]>;
+export declare const applySearch: <T extends ObjectLiteral>(qb: SelectQueryBuilder<T>, search: string | undefined, catalog: FilterCatalog, searchFields: readonly string[] | undefined) => void;

package/dist/core/query/paginateWithFilter.util.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.paginateWithFilter = void 0;
+exports.applySearch = exports.paginateWithFilter = void 0;
 const applyFilter_util_1 = require("./applyFilter.util");
 const filterOperator_enum_1 = require("./filterOperator.enum");
 const filterSort_util_1 = require("./filterSort.util");
@@ -8,7 +8,7 @@ const parseFilter_util_1 = require("./parseFilter.util");
 const paginateWithFilter = async (qb, options) => {
     const { query, catalog, defaultSort, permissions, searchFields } = options;
     (0, applyFilter_util_1.applyFilter)(qb, (0, parseFilter_util_1.parseFilter)(query.filter, catalog, permissions));
-    applySearch(qb, query.search, catalog, searchFields);
+    (0, exports.applySearch)(qb, query.search, catalog, searchFields);
     const order = (0, filterSort_util_1.resolveCatalogOrder)(query.sortBy, query.sortDir, catalog, qb.alias, defaultSort);
     return await qb
         .orderBy(order.column, order.direction)
@@ -39,3 +39,4 @@ const applySearch = (qb, search, catalog, searchFields) => {
     }
     qb.andWhere(`(${parts.map((part) => part.sql).join(" OR ")})`, Object.assign({}, ...parts.map((part) => part.params)));
 };
+exports.applySearch = applySearch;

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

@@ -1,3 +1,4 @@
+import { QueueName } from "./queue.constants";
 export type JobState = "waiting" | "active" | "completed" | "failed" | "delayed" | "unknown";
 export interface JobRef {
     jobId: string;
@@ -36,6 +37,7 @@ export interface JobStatus<TSummary = unknown> {
     finishedAt: string | null;
 }
 export interface EnqueueOptions {
+    queue?: QueueName;
     ownerId: string;
     jobId?: string;
     attempts?: number;
@@ -45,6 +47,7 @@ export interface QueueJobSummary {
     name: string;
     state: JobState;
     ownerId: string | null;
+    payload: unknown;
     attemptsMade: number;
     percent: number | null;
     failedReason: string | null;

package/dist/core/queue/job.producer.d.ts

@@ -1,15 +1,17 @@
 import { OnApplicationBootstrap } from "@nestjs/common";
 import { Queue } from "bullmq";
 import { EnqueueOptions, JobEnvelope, JobRef, JobStatus } from "./job.interface";
+import { QueueName } from "./queue.constants";
 export declare class JobProducer implements OnApplicationBootstrap {
-    private readonly queue?;
     private readonly logger;
-    constructor(queue?: Queue<JobEnvelope> | undefined);
+    private readonly queues;
+    constructor(jobs?: Queue<JobEnvelope>, exports?: Queue<JobEnvelope>);
     onApplicationBootstrap(): Promise<void>;
-    isAvailable(): boolean;
+    isAvailable(queue?: QueueName): boolean;
     enqueue<TPayload>(name: string, payload: TPayload, options: EnqueueOptions): Promise<JobRef>;
-    status<TSummary>(jobId: string, ownerId: string): Promise<JobStatus<TSummary>>;
+    status<TSummary>(jobId: string, ownerId: string, queueName?: QueueName): Promise<JobStatus<TSummary>>;
     redisStatus(): Promise<"up" | "down" | "off">;
-    requireQueue(): Queue<JobEnvelope>;
+    requireQueue(name?: QueueName): Queue<JobEnvelope>;
+    private withTimeout;
     private assertRedisReachable;
 }

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

@@ -24,12 +24,19 @@ const ioredis_1 = __importDefault(require("ioredis"));
 const queue_constants_1 = require("./queue.constants");
 const redisConnection_1 = require("./redisConnection");
 const PROBE_TIMEOUT_MS = 5000;
+const ENQUEUE_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;
+    constructor(jobs, exports) {
         this.logger = new common_1.Logger(JobProducer_1.name);
+        this.queues = new Map();
+        if (jobs) {
+            this.queues.set(queue_constants_1.JOBS_QUEUE, jobs);
+        }
+        if (exports) {
+            this.queues.set(queue_constants_1.EXPORTS_QUEUE, exports);
+        }
     }
     async onApplicationBootstrap() {
         if (!(0, queue_constants_1.isRedisConfigured)()) {
@@ -38,26 +45,26 @@ let JobProducer = JobProducer_1 = class JobProducer {
         }
         await this.assertRedisReachable();
     }
-    isAvailable() {
-        return Boolean(this.queue);
+    isAvailable(queue = queue_constants_1.JOBS_QUEUE) {
+        return this.queues.has(queue);
     }
     async enqueue(name, payload, options) {
-        const queue = this.requireQueue();
+        const queue = this.requireQueue(options.queue);
         const envelope = {
             ownerId: options.ownerId,
             payload,
         };
-        const job = await queue.add(name, envelope, {
+        const job = await this.withTimeout(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();
+    async status(jobId, ownerId, queueName) {
+        const queue = this.requireQueue(queueName);
         const job = await queue.getJob(jobId);
         if (!job || job.data?.ownerId !== ownerId) {
             throw new common_1.NotFoundException("Job não encontrado");
@@ -78,23 +85,38 @@ let JobProducer = JobProducer_1 = class JobProducer {
         if (!(0, queue_constants_1.isRedisConfigured)()) {
             return "off";
         }
-        if (!this.queue) {
+        const queue = this.queues.get(queue_constants_1.JOBS_QUEUE);
+        if (!queue) {
             return "down";
         }
         const timeout = new Promise((resolve) => setTimeout(() => resolve("down"), HEALTH_TIMEOUT_MS).unref());
         return Promise.race([
-            this.queue
+            queue
                 .getJobCounts("waiting")
                 .then(() => "up")
                 .catch(() => "down"),
             timeout,
         ]);
     }
-    requireQueue() {
-        if (!this.queue) {
+    requireQueue(name = queue_constants_1.JOBS_QUEUE) {
+        const queue = this.queues.get(name);
+        if (!queue) {
             throw new common_1.ServiceUnavailableException("Processamento em segundo plano indisponível neste ambiente");
         }
-        return this.queue;
+        return queue;
+    }
+    async withTimeout(operation) {
+        let timer;
+        const expired = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new common_1.ServiceUnavailableException("Processamento em segundo plano não respondeu. Tente de novo em instantes")), ENQUEUE_TIMEOUT_MS);
+            timer.unref();
+        });
+        try {
+            return await Promise.race([operation, expired]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
     }
     async assertRedisReachable() {
         const probe = new ioredis_1.default({
@@ -120,5 +142,8 @@ 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])
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, bullmq_1.InjectQueue)(queue_constants_1.EXPORTS_QUEUE)),
+    __metadata("design:paramtypes", [bullmq_2.Queue,
+        bullmq_2.Queue])
 ], JobProducer);