rl-core-api 0.15.6 → 0.16.0

package/dist/core/images/imageStorage.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 ImageStorageService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageStorageService = void 0;
+const common_1 = require("@nestjs/common");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const env_service_1 = require("../config/env.service");
+const imageProfile_interface_1 = require("./imageProfile.interface");
+const SAFE_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const SAFE_FOLDER = /^[A-Za-z0-9_-]{1,64}$/;
+const PENDING = "pending";
+const PUBLIC_PATH = /^\/uploads\/(?<folder>[A-Za-z0-9_-]{1,64})\/(?:(?<pending>pending)\/)?(?<id>[A-Za-z0-9_-]{1,64})(?<ext>\.[a-z]{3,4})$/;
+let ImageStorageService = ImageStorageService_1 = class ImageStorageService {
+    constructor(env) {
+        this.env = env;
+        this.logger = new common_1.Logger(ImageStorageService_1.name);
+        this.uploadsRoot = this.absolute(this.env.get("UPLOADS_DIR"));
+        this.incomingRoot = this.absolute(this.env.get("IMAGE_INCOMING_DIR"));
+    }
+    async saveIncoming(buffer) {
+        const id = (0, crypto_1.randomUUID)();
+        const path = this.incomingPathFor(id);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+        await (0, promises_1.writeFile)(path, buffer);
+        return id;
+    }
+    async readIncoming(id) {
+        return await (0, promises_1.readFile)(this.incomingPathFor(id));
+    }
+    async removeIncoming(id) {
+        await (0, promises_1.rm)(this.incomingPathFor(id), { force: true });
+    }
+    async savePending(profile, data) {
+        const id = (0, crypto_1.randomUUID)();
+        const path = this.pathFor(profile.folder, id, imageProfile_interface_1.EXTENSION_BY_FORMAT[profile.format], true);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(path), { recursive: true });
+        await (0, promises_1.writeFile)(path, data);
+        return this.publicPathOf(profile.folder, id, imageProfile_interface_1.EXTENSION_BY_FORMAT[profile.format], true);
+    }
+    async promote(publicPath) {
+        const ref = this.parsePublicPath(publicPath);
+        if (!ref) {
+            return null;
+        }
+        if (!ref.pending) {
+            return publicPath;
+        }
+        const from = this.pathFor(ref.folder, ref.id, ref.extension, true);
+        const to = this.pathFor(ref.folder, ref.id, ref.extension, false);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(to), { recursive: true });
+        await (0, promises_1.rename)(from, to);
+        return this.publicPathOf(ref.folder, ref.id, ref.extension, false);
+    }
+    async remove(publicPath) {
+        const ref = this.parsePublicPath(publicPath);
+        if (!ref) {
+            return;
+        }
+        await (0, promises_1.rm)(this.pathFor(ref.folder, ref.id, ref.extension, ref.pending), {
+            force: true,
+        });
+    }
+    parsePublicPath(publicPath) {
+        const match = PUBLIC_PATH.exec(publicPath ?? "");
+        if (!match?.groups) {
+            return null;
+        }
+        return {
+            folder: match.groups.folder,
+            id: match.groups.id,
+            extension: match.groups.ext,
+            pending: match.groups.pending === PENDING,
+        };
+    }
+    async removeExpired(pendingMaxAgeMs, incomingMaxAgeMs) {
+        const folders = await (0, promises_1.readdir)(this.uploadsRoot, { withFileTypes: true }).catch(() => []);
+        let removed = 0;
+        for (const folder of folders) {
+            if (!folder.isDirectory() || !SAFE_FOLDER.test(folder.name)) {
+                continue;
+            }
+            removed += await this.sweep((0, path_1.join)(this.uploadsRoot, folder.name, PENDING), pendingMaxAgeMs);
+        }
+        removed += await this.sweep(this.incomingRoot, incomingMaxAgeMs);
+        if (removed > 0) {
+            this.logger.log(`Faxina de imagens: ${removed} arquivo(s) removido(s)`);
+        }
+        return removed;
+    }
+    pathFor(folder, id, extension, pending) {
+        if (!SAFE_FOLDER.test(folder) || !SAFE_ID.test(id)) {
+            throw new Error("Identificador inválido para caminho de imagem");
+        }
+        const path = pending
+            ? (0, path_1.resolve)(this.uploadsRoot, folder, PENDING, `${id}${extension}`)
+            : (0, path_1.resolve)(this.uploadsRoot, folder, `${id}${extension}`);
+        if (!path.startsWith((0, path_1.resolve)(this.uploadsRoot))) {
+            throw new Error("Caminho de imagem fora da pasta de uploads");
+        }
+        return path;
+    }
+    incomingPathFor(id) {
+        if (!SAFE_ID.test(id)) {
+            throw new Error("Identificador inválido para arquivo recebido");
+        }
+        const path = (0, path_1.resolve)(this.incomingRoot, id);
+        if (!path.startsWith((0, path_1.resolve)(this.incomingRoot))) {
+            throw new Error("Caminho fora da pasta de arquivos recebidos");
+        }
+        return path;
+    }
+    publicPathOf(folder, id, extension, pending) {
+        return pending
+            ? `/uploads/${folder}/${PENDING}/${id}${extension}`
+            : `/uploads/${folder}/${id}${extension}`;
+    }
+    absolute(configured) {
+        return (0, path_1.isAbsolute)(configured) ? configured : (0, path_1.join)(process.cwd(), configured);
+    }
+    async sweep(directory, maxAgeMs) {
+        const cutoff = Date.now() - maxAgeMs;
+        const files = await (0, promises_1.readdir)(directory).catch(() => []);
+        let removed = 0;
+        for (const file of files) {
+            const path = (0, path_1.join)(directory, 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;
+        }
+        return removed;
+    }
+};
+exports.ImageStorageService = ImageStorageService;
+exports.ImageStorageService = ImageStorageService = ImageStorageService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [env_service_1.EnvService])
+], ImageStorageService);

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

@@ -0,0 +1,16 @@
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+import { ImagesService } from "./images.service";
+import { ImageAcceptedResponse } from "./responses/imageAccepted.response";
+import { ImageProfileResponse } from "./responses/imageProfile.response";
+import { ImageStatusResponse } from "./responses/imageStatus.response";
+import { UploadImageFromUrlCommand } from "./uploadImageFromUrl.command";
+export declare class ImagesController {
+    private readonly images;
+    constructor(images: ImagesService);
+    listProfiles(): ImageProfileResponse[];
+    getProfile(name: string): ImageProfileResponse;
+    upload(user: AuthenticatedUser, profile: string, file: Express.Multer.File): Promise<ImageAcceptedResponse>;
+    uploadFromUrl(user: AuthenticatedUser, profile: string, command: UploadImageFromUrlCommand): Promise<ImageAcceptedResponse>;
+    status(user: AuthenticatedUser, jobId: string): Promise<ImageStatusResponse>;
+    remove(user: AuthenticatedUser, profile: string, path: string): Promise<void>;
+}

package/dist/core/images/images.controller.js

@@ -0,0 +1,142 @@
+"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.ImagesController = void 0;
+const common_1 = require("@nestjs/common");
+const platform_express_1 = require("@nestjs/platform-express");
+const swagger_1 = require("@nestjs/swagger");
+const multer_1 = require("multer");
+const currentUser_decorator_1 = require("../auth/decorators/currentUser.decorator");
+const permissions_guard_1 = require("../auth/guards/permissions.guard");
+const images_service_1 = require("./images.service");
+const imageAccepted_response_1 = require("./responses/imageAccepted.response");
+const imageProfile_response_1 = require("./responses/imageProfile.response");
+const imageStatus_response_1 = require("./responses/imageStatus.response");
+const uploadImageFromUrl_command_1 = require("./uploadImageFromUrl.command");
+const ROUTE_MAX_BYTES = 20 * 1024 * 1024;
+const ACCEPTED_TYPES = ["image/jpeg", "image/png", "image/webp"];
+let ImagesController = class ImagesController {
+    constructor(images) {
+        this.images = images;
+    }
+    listProfiles() {
+        return this.images.profiles().map(toProfileResponse);
+    }
+    getProfile(name) {
+        return toProfileResponse(this.images.profile(name));
+    }
+    async upload(user, profile, file) {
+        return await this.images.fromFile(user, profile, file);
+    }
+    async uploadFromUrl(user, profile, command) {
+        return await this.images.fromUrl(user, profile, command.url);
+    }
+    async status(user, jobId) {
+        const job = await this.images.status(jobId, user.id);
+        const summary = job.summary;
+        return {
+            state: job.state,
+            percent: job.progress?.percent ?? 0,
+            path: summary?.path ?? null,
+            errorMessage: job.error?.message ?? null,
+        };
+    }
+    async remove(user, profile, path) {
+        await this.images.remove(user, profile, path);
+    }
+};
+exports.ImagesController = ImagesController;
+__decorate([
+    (0, common_1.Get)("profiles"),
+    (0, swagger_1.ApiOkResponse)({ type: imageProfile_response_1.ImageProfileResponse, isArray: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], ImagesController.prototype, "listProfiles", null);
+__decorate([
+    (0, common_1.Get)("profiles/:name"),
+    (0, swagger_1.ApiParam)({ name: "name", example: "funkos" }),
+    (0, swagger_1.ApiOkResponse)({ type: imageProfile_response_1.ImageProfileResponse }),
+    __param(0, (0, common_1.Param)("name")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", imageProfile_response_1.ImageProfileResponse)
+], ImagesController.prototype, "getProfile", null);
+__decorate([
+    (0, common_1.Post)(":profile"),
+    (0, common_1.HttpCode)(common_1.HttpStatus.ACCEPTED),
+    (0, swagger_1.ApiParam)({ name: "profile", example: "funkos" }),
+    (0, swagger_1.ApiConsumes)("multipart/form-data"),
+    (0, swagger_1.ApiResponse)({ status: 202, type: imageAccepted_response_1.ImageAcceptedResponse }),
+    (0, common_1.UseInterceptors)((0, platform_express_1.FileInterceptor)("file", {
+        storage: (0, multer_1.memoryStorage)(),
+        limits: { fileSize: ROUTE_MAX_BYTES, files: 1 },
+    })),
+    __param(0, (0, currentUser_decorator_1.CurrentUser)()),
+    __param(1, (0, common_1.Param)("profile")),
+    __param(2, (0, common_1.UploadedFile)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, Object]),
+    __metadata("design:returntype", Promise)
+], ImagesController.prototype, "upload", null);
+__decorate([
+    (0, common_1.Post)(":profile/from-url"),
+    (0, common_1.HttpCode)(common_1.HttpStatus.ACCEPTED),
+    (0, swagger_1.ApiParam)({ name: "profile", example: "funkos" }),
+    (0, swagger_1.ApiResponse)({ status: 202, type: imageAccepted_response_1.ImageAcceptedResponse }),
+    __param(0, (0, currentUser_decorator_1.CurrentUser)()),
+    __param(1, (0, common_1.Param)("profile")),
+    __param(2, (0, common_1.Body)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, uploadImageFromUrl_command_1.UploadImageFromUrlCommand]),
+    __metadata("design:returntype", Promise)
+], ImagesController.prototype, "uploadFromUrl", null);
+__decorate([
+    (0, common_1.Get)(":jobId/status"),
+    (0, swagger_1.ApiParam)({ name: "jobId", example: "312" }),
+    (0, swagger_1.ApiOkResponse)({ type: imageStatus_response_1.ImageStatusResponse }),
+    __param(0, (0, currentUser_decorator_1.CurrentUser)()),
+    __param(1, (0, common_1.Param)("jobId")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String]),
+    __metadata("design:returntype", Promise)
+], ImagesController.prototype, "status", null);
+__decorate([
+    (0, common_1.Delete)(":profile"),
+    (0, common_1.HttpCode)(common_1.HttpStatus.NO_CONTENT),
+    (0, swagger_1.ApiParam)({ name: "profile", example: "funkos" }),
+    (0, swagger_1.ApiResponse)({ status: 204, description: "Apagada, ou já não existia" }),
+    __param(0, (0, currentUser_decorator_1.CurrentUser)()),
+    __param(1, (0, common_1.Param)("profile")),
+    __param(2, (0, common_1.Query)("path")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, String, String]),
+    __metadata("design:returntype", Promise)
+], ImagesController.prototype, "remove", null);
+exports.ImagesController = ImagesController = __decorate([
+    (0, swagger_1.ApiTags)("Images"),
+    (0, swagger_1.ApiBearerAuth)(),
+    (0, common_1.UseGuards)(permissions_guard_1.PermissionsGuard),
+    (0, common_1.Controller)({ path: "images", version: "1" }),
+    __metadata("design:paramtypes", [images_service_1.ImagesService])
+], ImagesController);
+const toProfileResponse = (profile) => ({
+    name: profile.name,
+    width: profile.width,
+    height: profile.height ?? null,
+    fit: profile.fit,
+    format: profile.format,
+    maxBytes: profile.maxBytes,
+    accept: ACCEPTED_TYPES,
+});

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

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

package/dist/core/images/images.module.js

@@ -0,0 +1,35 @@
+"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.ImagesModule = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const imageFetch_service_1 = require("./imageFetch.service");
+const imageProcessing_service_1 = require("./imageProcessing.service");
+const imageProfile_registry_1 = require("./imageProfile.registry");
+const imageStorage_service_1 = require("./imageStorage.service");
+let ImagesModule = class ImagesModule {
+};
+exports.ImagesModule = ImagesModule;
+exports.ImagesModule = ImagesModule = __decorate([
+    (0, common_1.Module)({
+        imports: [core_1.DiscoveryModule],
+        providers: [
+            imageProfile_registry_1.ImageProfileRegistry,
+            imageProcessing_service_1.ImageProcessingService,
+            imageFetch_service_1.ImageFetchService,
+            imageStorage_service_1.ImageStorageService,
+        ],
+        exports: [
+            imageProfile_registry_1.ImageProfileRegistry,
+            imageProcessing_service_1.ImageProcessingService,
+            imageFetch_service_1.ImageFetchService,
+            imageStorage_service_1.ImageStorageService,
+        ],
+    })
+], ImagesModule);

package/dist/core/images/images.processor.d.ts

@@ -0,0 +1,18 @@
+import { Logger } from "@nestjs/common";
+import { ImageFetchService } from "./imageFetch.service";
+import { ImageProcessingService } from "./imageProcessing.service";
+import { ImageJobPayload, ImageJobSummary } from "./imageProfile.interface";
+import { ImageProfileRegistry } from "./imageProfile.registry";
+import { ImageStorageService } from "./imageStorage.service";
+import { JobContext } from "../queue/job.interface";
+import { JobEventsService } from "../queue/jobEvents.service";
+import { JobWorkerHost } from "../queue/jobWorkerHost";
+export declare class ImagesProcessor extends JobWorkerHost<ImageJobPayload, ImageJobSummary> {
+    private readonly registry;
+    private readonly processing;
+    private readonly fetcher;
+    private readonly storage;
+    protected readonly logger: Logger;
+    constructor(jobEvents: JobEventsService, registry: ImageProfileRegistry, processing: ImageProcessingService, fetcher: ImageFetchService, storage: ImageStorageService);
+    handle(job: JobContext<ImageJobPayload>): Promise<ImageJobSummary>;
+}

package/dist/core/images/images.processor.js

@@ -0,0 +1,75 @@
+"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 ImagesProcessor_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImagesProcessor = void 0;
+const bullmq_1 = require("@nestjs/bullmq");
+const common_1 = require("@nestjs/common");
+const bullmq_2 = require("bullmq");
+const imageFetch_service_1 = require("./imageFetch.service");
+const imageProcessing_service_1 = require("./imageProcessing.service");
+const imageProfile_interface_1 = require("./imageProfile.interface");
+const imageProfile_registry_1 = require("./imageProfile.registry");
+const imageStorage_service_1 = require("./imageStorage.service");
+const jobEvents_service_1 = require("../queue/jobEvents.service");
+const jobWorkerHost_1 = require("../queue/jobWorkerHost");
+const queue_constants_1 = require("../queue/queue.constants");
+const STEPS = 2;
+let ImagesProcessor = ImagesProcessor_1 = class ImagesProcessor extends jobWorkerHost_1.JobWorkerHost {
+    constructor(jobEvents, registry, processing, fetcher, storage) {
+        super(jobEvents);
+        this.registry = registry;
+        this.processing = processing;
+        this.fetcher = fetcher;
+        this.storage = storage;
+        this.logger = new common_1.Logger(ImagesProcessor_1.name);
+    }
+    async handle(job) {
+        const { payload } = job;
+        const profile = this.registry.find(payload.profile);
+        if (!profile) {
+            throw new bullmq_2.UnrecoverableError(`Perfil de imagem "${payload.profile}" não registrado neste consumer`);
+        }
+        const fromUrl = payload.kind === imageProfile_interface_1.ImageSourceKind.URL;
+        await job.report(1, STEPS, fromUrl ? "Baixando a imagem" : "Lendo o arquivo");
+        const input = fromUrl
+            ? await this.fetcher.download(payload.source, profile.maxBytes)
+            : await this.storage.readIncoming(payload.source);
+        if (fromUrl) {
+            const detected = this.processing.detectType(input);
+            if (!detected) {
+                throw new common_1.BadRequestException("O endereço não devolveu uma imagem (use JPEG, PNG ou WebP)");
+            }
+        }
+        await job.report(2, STEPS, "Convertendo");
+        try {
+            return await this.processing.process(profile, input);
+        }
+        finally {
+            if (!fromUrl) {
+                await this.storage.removeIncoming(payload.source).catch(() => undefined);
+            }
+        }
+    }
+};
+exports.ImagesProcessor = ImagesProcessor;
+exports.ImagesProcessor = ImagesProcessor = ImagesProcessor_1 = __decorate([
+    (0, bullmq_1.Processor)(queue_constants_1.IMAGES_QUEUE, {
+        concurrency: queue_constants_1.IMAGE_CONCURRENCY,
+        lockDuration: queue_constants_1.IMAGE_LOCK_DURATION_MS,
+        autorun: false,
+    }),
+    __metadata("design:paramtypes", [jobEvents_service_1.JobEventsService,
+        imageProfile_registry_1.ImageProfileRegistry,
+        imageProcessing_service_1.ImageProcessingService,
+        imageFetch_service_1.ImageFetchService,
+        imageStorage_service_1.ImageStorageService])
+], ImagesProcessor);

package/dist/core/images/images.service.d.ts

@@ -0,0 +1,34 @@
+import { AuthenticatedUser } from "../auth/authenticatedUser.interface";
+import { ImageFetchService } from "./imageFetch.service";
+import { ImageProcessingService } from "./imageProcessing.service";
+import { ImageJobSummary, ImageProfile } from "./imageProfile.interface";
+import { ImageProfileRegistry } from "./imageProfile.registry";
+import { ImageStorageService } from "./imageStorage.service";
+import { JobStatus } from "../queue/job.interface";
+import { JobProducer } from "../queue/job.producer";
+export interface ImageAccepted {
+    jobId: string | null;
+    path: string | null;
+}
+export declare class ImagesService {
+    private readonly registry;
+    private readonly producer;
+    private readonly processing;
+    private readonly fetcher;
+    private readonly storage;
+    constructor(registry: ImageProfileRegistry, producer: JobProducer, processing: ImageProcessingService, fetcher: ImageFetchService, storage: ImageStorageService);
+    profiles(): ImageProfile[];
+    profile(name: string): ImageProfile;
+    fromFile(user: AuthenticatedUser, profileName: string, file?: Express.Multer.File): Promise<ImageAccepted>;
+    fromFileNow(user: AuthenticatedUser, profileName: string, file?: Express.Multer.File): Promise<string>;
+    fromUrl(user: AuthenticatedUser, profileName: string, url: string): Promise<ImageAccepted>;
+    status(jobId: string, ownerId: string): Promise<JobStatus<ImageJobSummary>>;
+    remove(user: AuthenticatedUser, profileName: string, path: string): Promise<void>;
+    discard(path: string | null | undefined): Promise<void>;
+    promote(path: string | null | undefined): Promise<string | null>;
+    private authorize;
+    private enqueue;
+    private processNow;
+    private tooLarge;
+    private labelOf;
+}

package/dist/core/images/images.service.js

@@ -0,0 +1,137 @@
+"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.ImagesService = void 0;
+const common_1 = require("@nestjs/common");
+const imageFetch_service_1 = require("./imageFetch.service");
+const imageProcessing_service_1 = require("./imageProcessing.service");
+const imageProfile_interface_1 = require("./imageProfile.interface");
+const imageProfile_registry_1 = require("./imageProfile.registry");
+const imageStorage_service_1 = require("./imageStorage.service");
+const job_producer_1 = require("../queue/job.producer");
+const queue_constants_1 = require("../queue/queue.constants");
+let ImagesService = class ImagesService {
+    constructor(registry, producer, processing, fetcher, storage) {
+        this.registry = registry;
+        this.producer = producer;
+        this.processing = processing;
+        this.fetcher = fetcher;
+        this.storage = storage;
+    }
+    profiles() {
+        return this.registry.all();
+    }
+    profile(name) {
+        return this.registry.require(name);
+    }
+    async fromFile(user, profileName, file) {
+        const profile = this.authorize(user, profileName);
+        if (!file?.buffer?.length) {
+            throw new common_1.BadRequestException("Nenhum arquivo recebido");
+        }
+        if (file.size > profile.maxBytes) {
+            throw this.tooLarge(profile);
+        }
+        this.processing.assertSupported(file.buffer, file.mimetype);
+        if (!this.producer.isAvailable(queue_constants_1.IMAGES_QUEUE)) {
+            return await this.processNow(profile, file.buffer);
+        }
+        const source = await this.storage.saveIncoming(file.buffer);
+        return await this.enqueue(user.id, profile, {
+            profile: profile.name,
+            kind: imageProfile_interface_1.ImageSourceKind.FILE,
+            source,
+            label: file.originalname,
+        });
+    }
+    async fromFileNow(user, profileName, file) {
+        const profile = this.authorize(user, profileName);
+        if (!file?.buffer?.length) {
+            throw new common_1.BadRequestException("Nenhum arquivo recebido");
+        }
+        if (file.size > profile.maxBytes) {
+            throw this.tooLarge(profile);
+        }
+        this.processing.assertSupported(file.buffer, file.mimetype);
+        const summary = await this.processing.process(profile, file.buffer);
+        const path = await this.storage.promote(summary.path);
+        return path ?? summary.path;
+    }
+    async fromUrl(user, profileName, url) {
+        const profile = this.authorize(user, profileName);
+        await this.fetcher.assertAllowed(url);
+        if (!this.producer.isAvailable(queue_constants_1.IMAGES_QUEUE)) {
+            const downloaded = await this.fetcher.download(url, profile.maxBytes);
+            return await this.processNow(profile, downloaded, true);
+        }
+        return await this.enqueue(user.id, profile, {
+            profile: profile.name,
+            kind: imageProfile_interface_1.ImageSourceKind.URL,
+            source: url,
+            label: this.labelOf(url),
+        });
+    }
+    async status(jobId, ownerId) {
+        return await this.producer.status(jobId, ownerId, queue_constants_1.IMAGES_QUEUE);
+    }
+    async remove(user, profileName, path) {
+        const profile = this.authorize(user, profileName);
+        const ref = this.storage.parsePublicPath(path);
+        if (!ref || ref.folder !== profile.folder) {
+            throw new common_1.BadRequestException("Caminho de imagem inválido");
+        }
+        await this.storage.remove(path);
+    }
+    async discard(path) {
+        await this.storage.remove(path);
+    }
+    async promote(path) {
+        return await this.storage.promote(path);
+    }
+    authorize(user, profileName) {
+        const profile = this.registry.require(profileName);
+        if (profile.permission && !user.permissions.includes(profile.permission)) {
+            throw new common_1.ForbiddenException("Você não tem permissão para enviar imagem aqui");
+        }
+        return profile;
+    }
+    async enqueue(ownerId, profile, payload) {
+        const ref = await this.producer.enqueue(profile.name, payload, {
+            ownerId,
+            queue: queue_constants_1.IMAGES_QUEUE,
+        });
+        return { jobId: ref.jobId, path: null };
+    }
+    async processNow(profile, buffer, detect = false) {
+        if (detect) {
+            this.processing.assertSupported(buffer, this.processing.detectType(buffer) ?? "");
+        }
+        const summary = await this.processing.process(profile, buffer);
+        return { jobId: null, path: summary.path };
+    }
+    tooLarge(profile) {
+        const mb = Math.round(profile.maxBytes / (1024 * 1024));
+        return new common_1.BadRequestException(`A imagem passa do limite de ${mb}MB`);
+    }
+    labelOf(url) {
+        const last = url.split("?")[0].split("/").filter(Boolean).pop();
+        return last?.slice(0, 60) ?? "imagem";
+    }
+};
+exports.ImagesService = ImagesService;
+exports.ImagesService = ImagesService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [imageProfile_registry_1.ImageProfileRegistry,
+        job_producer_1.JobProducer,
+        imageProcessing_service_1.ImageProcessingService,
+        imageFetch_service_1.ImageFetchService,
+        imageStorage_service_1.ImageStorageService])
+], ImagesService);

package/dist/core/images/imagesApi.module.d.ts

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

package/dist/core/images/imagesApi.module.js

@@ -0,0 +1,25 @@
+"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.ImagesApiModule = void 0;
+const common_1 = require("@nestjs/common");
+const imageCleanup_service_1 = require("./imageCleanup.service");
+const images_controller_1 = require("./images.controller");
+const images_module_1 = require("./images.module");
+const images_service_1 = require("./images.service");
+let ImagesApiModule = class ImagesApiModule {
+};
+exports.ImagesApiModule = ImagesApiModule;
+exports.ImagesApiModule = ImagesApiModule = __decorate([
+    (0, common_1.Module)({
+        imports: [images_module_1.ImagesModule],
+        controllers: [images_controller_1.ImagesController],
+        providers: [images_service_1.ImagesService, imageCleanup_service_1.ImageCleanupService],
+        exports: [images_service_1.ImagesService, images_module_1.ImagesModule],
+    })
+], ImagesApiModule);

package/dist/core/images/imagesWorker.module.d.ts

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