rl-core-api 0.7.0 → 0.8.0

package/README.md

@@ -61,6 +61,7 @@ migrations do core vêm no pacote — você nunca copia nem reescreve nenhuma.
 | **Auditoria** | trilha de alterações de dados, log de requisições e log de erros, mantidos indefinidamente (sem retenção automática) |
 | **Notificações** | WebSocket com handshake por cookie ou Bearer, escopo resolvido na leitura |
 | **Listagens** | paginação, ordenação e filtro dinâmico com catálogo por listagem (`$AND`/`$OR` aninhados, 17 operadores) |
+| **Fila** | processamento em segundo plano com progresso em tempo real (BullMQ + Redis), opcional por ambiente |
 | **Infra** | config validada com Zod, mailer, agendador, rate-limit, CSRF, filtro global de exceções, logger Winston |
 
 ## Configuração
@@ -69,6 +70,59 @@ O pacote **não traz `.env`** — ele declara o que precisa e quebra no boot se
 faltar. Cada projeto tem os valores dele (banco próprio, segredo JWT próprio).
 Comece pelo `.env.example` do repositório.
 
+### Fila de processamento (opcional)
+
+Sem `REDIS_HOST` a aplicação sobe **sem fila e sem erro** — é o padrão.
+Declarado, o Redis passa a ser obrigatório: a subida falha se ele não responder,
+em vez de a falha aparecer no primeiro job.
+
+```env
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=redis
+REDIS_PREFIX=controlx   # um Redis para vários projetos: o prefixo os separa
+```
+
+Concorrência, tentativas, backoff e retenção não são variáveis de ambiente —
+são constantes em `queue.constants.ts`. São decisão de arquitetura da fila, e um
+número desses ajustado no `.env` de produção sem ninguém revisar é como se
+descobre, tarde, por que os jobs empilharam.
+
+O processador é sempre do projeto — o core não conhece o que a feature faz:
+
+```ts
+@Processor(JOBS_QUEUE, { concurrency: JOB_CONCURRENCY, autorun: false })
+export class FunkosImportProcessor extends JobWorkerHost<Payload, Summary> {
+  constructor(
+    jobEvents: JobEventsService,
+    private readonly imports: FunkosImportService,
+  ) {
+    super(jobEvents);
+  }
+
+  async handle(job: JobContext<Payload>): Promise<Summary> {
+    return this.imports.run(job.payload, (done, total) => job.report(done, total));
+  }
+}
+```
+
+Registre a classe como provider do módulo da feature, **atrás do
+`isRedisConfigured()`** — sem Redis não há conexão para o worker abrir:
+
+```ts
+@Module({ providers: isRedisConfigured() ? [FunkosImportProcessor] : [] })
+export class FunkosModule {}
+```
+
+Na rota, `jobs.enqueue(name, payload, { ownerId })` devolve o `jobId` na hora. O
+progresso vai para a sala do dono pela **mesma** conexão de socket das
+notificações (`job:progress`, `job:completed`, `job:failed`), e `GET /jobs/:id`
+responde a quem perdeu o socket.
+
+Quem opera vê tudo pela tela de **Filas** (`QueuesScreen`, no `rl-core-front`):
+contagem por estado, o motivo cru da falha, reprocessar e remover — com
+`queues:read:any` e `queues:manage:any`.
+
 ### Identidade do sistema
 
 O core não tem nome próprio. `APP_NAME` é o do projeto, e dele saem o título do

package/dist/core/config/env.schema.d.ts

@@ -57,6 +57,9 @@ export declare const envSchema: z.ZodObject<{
     PASSWORD_RESET_TOKEN_EXPIRY: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     FIRST_ACCESS_TOKEN_EXPIRY: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     PASSWORD_MAX_AGE_DAYS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    REDIS_HOST: z.ZodOptional<z.ZodString>;
+    REDIS_PORT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    REDIS_PASSWORD: z.ZodOptional<z.ZodString>;
     TOKEN_CLEANUP_CRON: z.ZodDefault<z.ZodString>;
     AUDIT_SLOW_REQUEST_MS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
     AUDIT_IP_SALT: z.ZodOptional<z.ZodString>;

package/dist/core/config/env.schema.js

@@ -68,6 +68,9 @@ exports.envSchema = zod_1.z
         .positive()
         .default(1440),
     PASSWORD_MAX_AGE_DAYS: zod_1.z.coerce.number().int().positive().default(90),
+    REDIS_HOST: zod_1.z.string().min(1).optional(),
+    REDIS_PORT: zod_1.z.coerce.number().int().positive().default(6379),
+    REDIS_PASSWORD: zod_1.z.string().optional(),
     TOKEN_CLEANUP_CRON: zod_1.z.string().default("0 */6 * * *"),
     AUDIT_SLOW_REQUEST_MS: zod_1.z.coerce.number().int().positive().default(1000),
     AUDIT_IP_SALT: zod_1.z.string().optional(),

package/dist/core/core.module.js

@@ -21,6 +21,7 @@ const config_module_1 = require("./config/config.module");
 const env_service_1 = require("./config/env.service");
 const health_controller_1 = require("./health/health.controller");
 const mailer_module_1 = require("./mailer/mailer.module");
+const queue_module_1 = require("./queue/queue.module");
 let CoreModule = CoreModule_1 = class CoreModule {
     static forRoot(options) {
         return {
@@ -28,6 +29,7 @@ let CoreModule = CoreModule_1 = class CoreModule {
             imports: [
                 config_module_1.ConfigModule.forRoot({ validateEnv: options.validateEnv }),
                 mailer_module_1.MailerModule,
+                queue_module_1.QueueModule,
                 schedule_1.ScheduleModule.forRoot(),
                 event_emitter_1.EventEmitterModule.forRoot(),
                 typeorm_1.TypeOrmModule.forRootAsync({
@@ -63,7 +65,7 @@ let CoreModule = CoreModule_1 = class CoreModule {
                 { provide: core_1.APP_GUARD, useClass: csrf_guard_1.CsrfGuard },
                 { provide: core_1.APP_FILTER, useClass: allExceptions_filter_1.AllExceptionsFilter },
             ],
-            exports: [mailer_module_1.MailerModule],
+            exports: [mailer_module_1.MailerModule, queue_module_1.QueueModule],
         };
     }
 };

package/dist/core/events/appEvent.enum.d.ts

@@ -2,6 +2,7 @@ export declare enum AppEvent {
     USER_LOCKED = "user.locked",
     USER_TWO_FACTOR_RESET = "user.two-factor-reset",
     USER_ROLES_CHANGED = "user.roles-changed",
+    USER_PERMISSIONS_CHANGED = "user.permissions-changed",
     USER_PASSWORD_RESET_REQUESTED = "user.password-reset-requested",
     USER_PASSWORD_EXPIRING = "user.password-expiring",
     SYSTEM_CLEANUP_FAILED = "system.cleanup-failed",
@@ -20,6 +21,11 @@ export interface UserRolesChangedEvent {
     roleNames: string[];
     previousRoleNames: string[];
 }
+export interface UserPermissionsChangedEvent {
+    userId: string;
+    codes: string[];
+    previousCodes: string[];
+}
 export interface UserPasswordResetRequestedEvent {
     userId: string;
 }

package/dist/core/events/appEvent.enum.js

@@ -6,6 +6,7 @@ var AppEvent;
     AppEvent["USER_LOCKED"] = "user.locked";
     AppEvent["USER_TWO_FACTOR_RESET"] = "user.two-factor-reset";
     AppEvent["USER_ROLES_CHANGED"] = "user.roles-changed";
+    AppEvent["USER_PERMISSIONS_CHANGED"] = "user.permissions-changed";
     AppEvent["USER_PASSWORD_RESET_REQUESTED"] = "user.password-reset-requested";
     AppEvent["USER_PASSWORD_EXPIRING"] = "user.password-expiring";
     AppEvent["SYSTEM_CLEANUP_FAILED"] = "system.cleanup-failed";

package/dist/core/health/health.controller.d.ts

@@ -1,11 +1,14 @@
 import { DataSource } from "typeorm";
+import { JobProducer } from "../queue/job.producer";
 export declare class HealthController {
     private readonly ds;
+    private readonly jobs;
     private readonly logger;
-    constructor(ds: DataSource);
+    constructor(ds: DataSource, jobs: JobProducer);
     check(): Promise<{
         status: string;
         database: string;
+        queue: string;
         timestamp: string;
     }>;
 }

package/dist/core/health/health.controller.js

@@ -19,9 +19,11 @@ const swagger_1 = require("@nestjs/swagger");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const public_decorator_1 = require("../auth/decorators/public.decorator");
+const job_producer_1 = require("../queue/job.producer");
 let HealthController = HealthController_1 = class HealthController {
-    constructor(ds) {
+    constructor(ds, jobs) {
         this.ds = ds;
+        this.jobs = jobs;
         this.logger = new common_1.Logger(HealthController_1.name);
     }
     async check() {
@@ -33,9 +35,12 @@ let HealthController = HealthController_1 = class HealthController {
             this.logger.error(`Healthcheck do banco falhou: ${err.message}`);
             database = "down";
         }
+        const queue = await this.jobs.redisStatus();
+        const healthy = database === "up" && queue !== "down";
         return {
-            status: database === "up" ? "ok" : "degraded",
+            status: healthy ? "ok" : "degraded",
             database,
+            queue,
             timestamp: new Date().toISOString(),
         };
     }
@@ -52,5 +57,6 @@ exports.HealthController = HealthController = HealthController_1 = __decorate([
     (0, swagger_1.ApiTags)("Health"),
     (0, common_1.Controller)({ path: "health", version: "1" }),
     __param(0, (0, typeorm_1.InjectDataSource)()),
-    __metadata("design:paramtypes", [typeorm_2.DataSource])
+    __metadata("design:paramtypes", [typeorm_2.DataSource,
+        job_producer_1.JobProducer])
 ], HealthController);

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

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

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

@@ -0,0 +1,27 @@
+"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.BullConnectionModule = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+const queue_constants_1 = require("./queue.constants");
+const redisConnection_1 = require("./redisConnection");
+let BullConnectionModule = class BullConnectionModule {
+};
+exports.BullConnectionModule = BullConnectionModule;
+exports.BullConnectionModule = BullConnectionModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            bullmq_1.BullModule.forRoot({
+                connection: (0, redisConnection_1.buildRedisOptions)(),
+                prefix: (0, queue_constants_1.queuePrefix)(),
+            }),
+        ],
+        exports: [bullmq_1.BullModule],
+    })
+], BullConnectionModule);

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

@@ -0,0 +1,70 @@
+export type JobState = "waiting" | "active" | "completed" | "failed" | "delayed" | "unknown";
+export interface JobRef {
+    jobId: string;
+    name: string;
+}
+export interface JobProgress {
+    jobId: string;
+    name: string;
+    processed: number;
+    total: number;
+    percent: number;
+    message?: string;
+}
+export interface JobCompleted<TSummary = unknown> {
+    jobId: string;
+    name: string;
+    summary: TSummary;
+}
+export interface JobFailed {
+    jobId: string;
+    name: string;
+    errorCode: string | null;
+    message: string;
+}
+export interface JobStatus<TSummary = unknown> {
+    id: string;
+    name: string;
+    state: JobState;
+    progress: Omit<JobProgress, "jobId" | "name"> | null;
+    summary: TSummary | null;
+    error: {
+        code: string | null;
+        message: string;
+    } | null;
+    createdAt: string;
+    finishedAt: string | null;
+}
+export interface EnqueueOptions {
+    ownerId: string;
+    jobId?: string;
+    attempts?: number;
+}
+export interface QueueJobSummary {
+    id: string;
+    name: string;
+    state: JobState;
+    ownerId: string | null;
+    attemptsMade: number;
+    percent: number | null;
+    failedReason: string | null;
+    createdAt: string;
+    finishedAt: string | null;
+}
+export interface QueueCounts {
+    waiting: number;
+    active: number;
+    completed: number;
+    failed: number;
+    delayed: number;
+}
+export interface JobContext<TPayload = unknown> {
+    jobId: string;
+    ownerId: string;
+    payload: TPayload;
+    report: (processed: number, total: number, message?: string) => Promise<void>;
+}
+export interface JobEnvelope<TPayload = unknown> {
+    ownerId: string;
+    payload: TPayload;
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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;
+}