rl-core-api 0.15.6 → 0.16.1

package/dist/core/bootstrap/bootstrapCore.util.js

@@ -29,7 +29,7 @@ const bootstrapCore = async (appModule, options = {}) => {
     if (options.bodyParser === "all") {
         app.useBodyParser("urlencoded", { extended: true });
     }
-    app.useStaticAssets((0, path_1.join)(process.cwd(), options.uploadsDir ?? "uploads"), {
+    app.useStaticAssets((0, path_1.join)(process.cwd(), options.uploadsDir ?? process.env.UPLOADS_DIR ?? "uploads"), {
         prefix: "/uploads/",
         setHeaders: (res) => {
             res.setHeader("Cross-Origin-Resource-Policy", "cross-origin");

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

@@ -69,6 +69,13 @@ export declare const envSchema: z.ZodObject<{
         false: "false";
     }>, z.ZodTransform<boolean, "true" | "false">>>;
     EXPORT_MAX_ROWS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    UPLOADS_DIR: z.ZodDefault<z.ZodString>;
+    IMAGE_INCOMING_DIR: z.ZodDefault<z.ZodString>;
+    IMAGE_PENDING_TTL_HOURS: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    IMAGE_CLEANUP_ENABLED: z.ZodDefault<z.ZodPipe<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>, z.ZodTransform<boolean, "true" | "false">>>;
     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

@@ -85,6 +85,10 @@ exports.envSchema = zod_1.z
     EXPORT_TTL_HOURS: zod_1.z.coerce.number().int().positive().default(3),
     EXPORT_CLEANUP_ENABLED: booleanFromString.default(true),
     EXPORT_MAX_ROWS: zod_1.z.coerce.number().int().positive().default(500_000),
+    UPLOADS_DIR: zod_1.z.string().min(1).default("uploads"),
+    IMAGE_INCOMING_DIR: zod_1.z.string().min(1).default("incoming"),
+    IMAGE_PENDING_TTL_HOURS: zod_1.z.coerce.number().int().positive().default(24),
+    IMAGE_CLEANUP_ENABLED: booleanFromString.default(true),
     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/database/migrations/1789171200000-NotificationDismissal.d.ts

@@ -0,0 +1,6 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+export declare class NotificationDismissal1789171200000 implements MigrationInterface {
+    name: string;
+    up(queryRunner: QueryRunner): Promise<void>;
+    down(queryRunner: QueryRunner): Promise<void>;
+}

package/dist/core/database/migrations/1789171200000-NotificationDismissal.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationDismissal1789171200000 = void 0;
+class NotificationDismissal1789171200000 {
+    constructor() {
+        this.name = "NotificationDismissal1789171200000";
+    }
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE notification_reads
+         ADD COLUMN dismissed_at datetime NULL AFTER read_at`);
+    }
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE notification_reads DROP COLUMN dismissed_at`);
+    }
+}
+exports.NotificationDismissal1789171200000 = NotificationDismissal1789171200000;

package/dist/core/database/migrations/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.coreMigrations = void 0;
+const _1789171200000_NotificationDismissal_1 = require("./1789171200000-NotificationDismissal");
 const _1710000000000_InitialSchema_1 = require("./1710000000000-InitialSchema");
 exports.coreMigrations = [
     _1710000000000_InitialSchema_1.InitialSchema1710000000000,
+    _1789171200000_NotificationDismissal_1.NotificationDismissal1789171200000,
 ];

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

@@ -0,0 +1,9 @@
+import { EnvService } from "../config/env.service";
+import { ImageStorageService } from "./imageStorage.service";
+export declare class ImageCleanupService {
+    private readonly storage;
+    private readonly env;
+    private readonly logger;
+    constructor(storage: ImageStorageService, env: EnvService);
+    sweep(): Promise<void>;
+}

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

@@ -0,0 +1,50 @@
+"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 ImageCleanupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageCleanupService = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const env_service_1 = require("../config/env.service");
+const imageStorage_service_1 = require("./imageStorage.service");
+const HOUR_IN_MS = 60 * 60 * 1000;
+const INCOMING_MAX_AGE_MS = HOUR_IN_MS;
+let ImageCleanupService = ImageCleanupService_1 = class ImageCleanupService {
+    constructor(storage, env) {
+        this.storage = storage;
+        this.env = env;
+        this.logger = new common_1.Logger(ImageCleanupService_1.name);
+    }
+    async sweep() {
+        if (!this.env.get("IMAGE_CLEANUP_ENABLED")) {
+            return;
+        }
+        const pendingMaxAgeMs = this.env.get("IMAGE_PENDING_TTL_HOURS") * HOUR_IN_MS;
+        try {
+            await this.storage.removeExpired(pendingMaxAgeMs, INCOMING_MAX_AGE_MS);
+        }
+        catch (error) {
+            this.logger.error(`Falha na faxina de imagens: ${error.message}`, error.stack);
+        }
+    }
+};
+exports.ImageCleanupService = ImageCleanupService;
+__decorate([
+    (0, schedule_1.Cron)(schedule_1.CronExpression.EVERY_30_MINUTES),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ImageCleanupService.prototype, "sweep", null);
+exports.ImageCleanupService = ImageCleanupService = ImageCleanupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [imageStorage_service_1.ImageStorageService,
+        env_service_1.EnvService])
+], ImageCleanupService);

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

@@ -0,0 +1,11 @@
+export declare const isBlockedAddress: (address: string) => boolean;
+export declare class ImageFetchService {
+    private readonly logger;
+    assertAllowed(rawUrl: string): Promise<void>;
+    download(rawUrl: string, maxBytes: number): Promise<Buffer>;
+    private parse;
+    private request;
+    private guardedLookup;
+    private tooLarge;
+    private wrap;
+}

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

@@ -0,0 +1,190 @@
+"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 ImageFetchService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageFetchService = exports.isBlockedAddress = void 0;
+const common_1 = require("@nestjs/common");
+const dns_1 = require("dns");
+const http_1 = require("http");
+const https_1 = require("https");
+const net_1 = require("net");
+const TOTAL_TIMEOUT_MS = 15_000;
+const SOCKET_TIMEOUT_MS = 8_000;
+const MAX_REDIRECTS = 3;
+const isBlockedIPv4 = (address) => {
+    const [a, b] = address.split(".").map(Number);
+    return (a === 0 ||
+        a === 10 ||
+        a === 127 ||
+        (a === 100 && b >= 64 && b <= 127) ||
+        (a === 169 && b === 254) ||
+        (a === 172 && b >= 16 && b <= 31) ||
+        (a === 192 && b === 168) ||
+        (a === 192 && b === 0) ||
+        (a === 198 && (b === 18 || b === 19)) ||
+        a >= 224);
+};
+const isBlockedIPv6 = (address) => {
+    const value = address.toLowerCase().replace(/^\[|\]$/g, "");
+    const mapped = /^::ffff:(?<v4>\d+\.\d+\.\d+\.\d+)$/.exec(value);
+    if (mapped?.groups) {
+        return isBlockedIPv4(mapped.groups.v4);
+    }
+    return (value === "::" ||
+        value === "::1" ||
+        value.startsWith("fe8") ||
+        value.startsWith("fe9") ||
+        value.startsWith("fea") ||
+        value.startsWith("feb") ||
+        value.startsWith("fc") ||
+        value.startsWith("fd") ||
+        value.startsWith("ff"));
+};
+const isBlockedAddress = (address) => (0, net_1.isIP)(address) === 6 ? isBlockedIPv6(address) : isBlockedIPv4(address);
+exports.isBlockedAddress = isBlockedAddress;
+const lookupAll = (hostname) => new Promise((resolve, reject) => {
+    (0, dns_1.lookup)(hostname, { all: true }, (error, addresses) => {
+        if (error) {
+            reject(error);
+            return;
+        }
+        resolve(addresses);
+    });
+});
+let ImageFetchService = ImageFetchService_1 = class ImageFetchService {
+    constructor() {
+        this.logger = new common_1.Logger(ImageFetchService_1.name);
+        this.guardedLookup = (hostname, options, callback) => {
+            (0, dns_1.lookup)(hostname, { all: true }, (error, addresses) => {
+                if (error) {
+                    callback(error, "", undefined);
+                    return;
+                }
+                const blocked = addresses.find((entry) => (0, exports.isBlockedAddress)(entry.address));
+                if (blocked) {
+                    this.logger.warn(`Endereço recusado por apontar para a rede interna: ${hostname} → ${blocked.address}`);
+                    callback(Object.assign(new Error("endereço não permitido"), {
+                        code: "EACCES",
+                    }), "", undefined);
+                    return;
+                }
+                callback(null, addresses, undefined);
+            });
+        };
+    }
+    async assertAllowed(rawUrl) {
+        const url = this.parse(rawUrl);
+        const host = url.hostname.replace(/^\[|\]$/g, "");
+        if ((0, net_1.isIP)(host)) {
+            return;
+        }
+        const addresses = await lookupAll(host).catch(() => []);
+        const blocked = addresses.find((entry) => (0, exports.isBlockedAddress)(entry.address));
+        if (blocked) {
+            this.logger.warn(`Endereço recusado por apontar para a rede interna: ${host} → ${blocked.address}`);
+            throw new common_1.BadRequestException("Endereço não permitido");
+        }
+    }
+    async download(rawUrl, maxBytes) {
+        let url = this.parse(rawUrl);
+        for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects += 1) {
+            const response = await this.request(url, maxBytes);
+            if (!response.location) {
+                return response.body;
+            }
+            response.discard();
+            url = this.parse(new URL(response.location, url).toString());
+        }
+        throw new common_1.BadRequestException("O endereço redireciona demais. Baixe a imagem e envie o arquivo");
+    }
+    parse(rawUrl) {
+        let url;
+        try {
+            url = new URL(rawUrl);
+        }
+        catch {
+            throw new common_1.BadRequestException("Endereço inválido");
+        }
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+            throw new common_1.BadRequestException("Endereço precisa começar com http ou https");
+        }
+        const literal = url.hostname.replace(/^\[|\]$/g, "");
+        if ((0, net_1.isIP)(literal) && (0, exports.isBlockedAddress)(literal)) {
+            throw new common_1.BadRequestException("Endereço não permitido");
+        }
+        return url;
+    }
+    request(url, maxBytes) {
+        const get = url.protocol === "https:" ? https_1.get : http_1.get;
+        return new Promise((resolve, reject) => {
+            const request = get(url, {
+                timeout: SOCKET_TIMEOUT_MS,
+                lookup: this.guardedLookup,
+                headers: {
+                    accept: "image/*",
+                },
+            }, (response) => {
+                const status = response.statusCode ?? 0;
+                if (status >= 300 && status < 400 && response.headers.location) {
+                    resolve({
+                        body: Buffer.alloc(0),
+                        location: response.headers.location,
+                        discard: () => response.resume(),
+                    });
+                    return;
+                }
+                if (status !== 200) {
+                    response.resume();
+                    reject(new common_1.BadRequestException(`O endereço respondeu ${status || "sem status"}. Baixe a imagem e envie o arquivo`));
+                    return;
+                }
+                const declared = Number(response.headers["content-length"] ?? 0);
+                if (declared > maxBytes) {
+                    response.destroy();
+                    reject(this.tooLarge(maxBytes));
+                    return;
+                }
+                const chunks = [];
+                let received = 0;
+                response.on("data", (chunk) => {
+                    received += chunk.length;
+                    if (received > maxBytes) {
+                        response.destroy();
+                        reject(this.tooLarge(maxBytes));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                response.on("end", () => resolve({ body: Buffer.concat(chunks), discard: () => undefined }));
+                response.on("error", (error) => reject(this.wrap(error)));
+            });
+            const timer = setTimeout(() => {
+                request.destroy(new Error("tempo esgotado"));
+            }, TOTAL_TIMEOUT_MS);
+            timer.unref();
+            request.on("timeout", () => request.destroy(new Error("tempo esgotado")));
+            request.on("error", (error) => {
+                clearTimeout(timer);
+                reject(this.wrap(error));
+            });
+            request.on("close", () => clearTimeout(timer));
+        });
+    }
+    tooLarge(maxBytes) {
+        const mb = Math.round(maxBytes / (1024 * 1024));
+        return new common_1.BadRequestException(`A imagem passa do limite de ${mb}MB`);
+    }
+    wrap(error) {
+        this.logger.warn(`Falha ao baixar imagem: ${error.message}`);
+        return new common_1.BadRequestException("Não foi possível baixar a imagem deste endereço");
+    }
+};
+exports.ImageFetchService = ImageFetchService;
+exports.ImageFetchService = ImageFetchService = ImageFetchService_1 = __decorate([
+    (0, common_1.Injectable)()
+], ImageFetchService);

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

@@ -0,0 +1,9 @@
+import { ImageJobSummary, ImageProfile } from "./imageProfile.interface";
+import { ImageStorageService } from "./imageStorage.service";
+export declare class ImageProcessingService {
+    private readonly storage;
+    constructor(storage: ImageStorageService);
+    assertSupported(buffer: Buffer, declaredType?: string): void;
+    detectType(buffer: Buffer): string | null;
+    process(profile: ImageProfile, input: Buffer): Promise<ImageJobSummary>;
+}

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

@@ -0,0 +1,74 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageProcessingService = void 0;
+const common_1 = require("@nestjs/common");
+const sharp_1 = __importDefault(require("sharp"));
+const imageStorage_service_1 = require("./imageStorage.service");
+const ALLOWED_INPUT = ["image/jpeg", "image/png", "image/webp"];
+const MAGIC_BYTES = {
+    "image/jpeg": (buffer) => buffer.length >= 3 &&
+        buffer[0] === 0xff &&
+        buffer[1] === 0xd8 &&
+        buffer[2] === 0xff,
+    "image/png": (buffer) => buffer.length >= 8 &&
+        buffer
+            .subarray(0, 8)
+            .equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])),
+    "image/webp": (buffer) => buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP",
+};
+const TRANSPARENT = { r: 0, g: 0, b: 0, alpha: 0 };
+let ImageProcessingService = class ImageProcessingService {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    assertSupported(buffer, declaredType) {
+        const type = ALLOWED_INPUT.find((allowed) => allowed === declaredType);
+        if (!type) {
+            throw new common_1.BadRequestException("Formato inválido (use JPEG, PNG ou WebP)");
+        }
+        if (!MAGIC_BYTES[type](buffer)) {
+            throw new common_1.BadRequestException("O conteúdo do arquivo não corresponde ao formato declarado");
+        }
+    }
+    detectType(buffer) {
+        return (ALLOWED_INPUT.find((type) => MAGIC_BYTES[type](buffer)) ?? null);
+    }
+    async process(profile, input) {
+        const pipeline = (0, sharp_1.default)(input, { failOn: "none" })
+            .rotate()
+            .resize({
+            width: profile.width,
+            height: profile.height,
+            fit: profile.fit,
+            withoutEnlargement: true,
+            background: TRANSPARENT,
+        });
+        const { data, info } = await pipeline
+            .toFormat(profile.format, { quality: profile.quality })
+            .toBuffer({ resolveWithObject: true })
+            .catch(() => {
+            throw new common_1.BadRequestException("Não foi possível processar esta imagem. Tente outro arquivo");
+        });
+        const path = await this.storage.savePending(profile, data);
+        return { path, width: info.width, height: info.height, bytes: info.size };
+    }
+};
+exports.ImageProcessingService = ImageProcessingService;
+exports.ImageProcessingService = ImageProcessingService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [imageStorage_service_1.ImageStorageService])
+], ImageProcessingService);

package/dist/core/images/imageProfile.interface.d.ts

@@ -0,0 +1,40 @@
+export declare enum ImageFit {
+    CONTAIN = "contain",
+    COVER = "cover",
+    INSIDE = "inside"
+}
+export declare enum ImageFormat {
+    WEBP = "webp",
+    JPEG = "jpeg",
+    PNG = "png"
+}
+export declare const EXTENSION_BY_FORMAT: Record<ImageFormat, string>;
+export interface ImageProfile {
+    readonly name: string;
+    readonly folder: string;
+    readonly width: number;
+    readonly height?: number;
+    readonly fit: ImageFit;
+    readonly format: ImageFormat;
+    readonly quality: number;
+    readonly maxBytes: number;
+    readonly permission?: string;
+}
+export declare const IMAGE_PROFILE = "rl-core:image-profile";
+export declare const ImageUploadProfile: () => ClassDecorator;
+export declare enum ImageSourceKind {
+    FILE = "file",
+    URL = "url"
+}
+export interface ImageJobPayload {
+    profile: string;
+    kind: ImageSourceKind;
+    source: string;
+    label?: string;
+}
+export interface ImageJobSummary {
+    path: string;
+    width: number;
+    height: number;
+    bytes: number;
+}

package/dist/core/images/imageProfile.interface.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageSourceKind = exports.ImageUploadProfile = exports.IMAGE_PROFILE = exports.EXTENSION_BY_FORMAT = exports.ImageFormat = exports.ImageFit = void 0;
+const common_1 = require("@nestjs/common");
+var ImageFit;
+(function (ImageFit) {
+    ImageFit["CONTAIN"] = "contain";
+    ImageFit["COVER"] = "cover";
+    ImageFit["INSIDE"] = "inside";
+})(ImageFit || (exports.ImageFit = ImageFit = {}));
+var ImageFormat;
+(function (ImageFormat) {
+    ImageFormat["WEBP"] = "webp";
+    ImageFormat["JPEG"] = "jpeg";
+    ImageFormat["PNG"] = "png";
+})(ImageFormat || (exports.ImageFormat = ImageFormat = {}));
+exports.EXTENSION_BY_FORMAT = {
+    [ImageFormat.WEBP]: ".webp",
+    [ImageFormat.JPEG]: ".jpg",
+    [ImageFormat.PNG]: ".png",
+};
+exports.IMAGE_PROFILE = "rl-core:image-profile";
+const ImageUploadProfile = () => (0, common_1.SetMetadata)(exports.IMAGE_PROFILE, true);
+exports.ImageUploadProfile = ImageUploadProfile;
+var ImageSourceKind;
+(function (ImageSourceKind) {
+    ImageSourceKind["FILE"] = "file";
+    ImageSourceKind["URL"] = "url";
+})(ImageSourceKind || (exports.ImageSourceKind = ImageSourceKind = {}));

package/dist/core/images/imageProfile.registry.d.ts

@@ -0,0 +1,14 @@
+import { OnModuleInit } from "@nestjs/common";
+import { DiscoveryService } from "@nestjs/core";
+import { ImageProfile } from "./imageProfile.interface";
+export declare class ImageProfileRegistry implements OnModuleInit {
+    private readonly discovery;
+    private readonly logger;
+    private readonly profiles;
+    constructor(discovery: DiscoveryService);
+    onModuleInit(): void;
+    find(name: string): ImageProfile | undefined;
+    require(name: string): ImageProfile;
+    all(): ImageProfile[];
+    names(): string[];
+}

package/dist/core/images/imageProfile.registry.js

@@ -0,0 +1,61 @@
+"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 ImageProfileRegistry_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageProfileRegistry = void 0;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const imageProfile_interface_1 = require("./imageProfile.interface");
+let ImageProfileRegistry = ImageProfileRegistry_1 = class ImageProfileRegistry {
+    constructor(discovery) {
+        this.discovery = discovery;
+        this.logger = new common_1.Logger(ImageProfileRegistry_1.name);
+        this.profiles = new Map();
+    }
+    onModuleInit() {
+        const found = this.discovery
+            .getProviders()
+            .filter((wrapper) => wrapper.metatype &&
+            Reflect.getMetadata(imageProfile_interface_1.IMAGE_PROFILE, wrapper.metatype) === true)
+            .map((wrapper) => wrapper.instance)
+            .filter(Boolean);
+        for (const profile of found) {
+            if (this.profiles.has(profile.name)) {
+                throw new Error(`Dois perfis de imagem registrados com o nome "${profile.name}"`);
+            }
+            this.profiles.set(profile.name, profile);
+        }
+        if (this.profiles.size > 0) {
+            this.logger.log(`Perfis de imagem disponíveis: ${this.names().join(", ")}`);
+        }
+    }
+    find(name) {
+        return this.profiles.get(name);
+    }
+    require(name) {
+        const profile = this.find(name);
+        if (!profile) {
+            throw new common_1.NotFoundException("Perfil de imagem não encontrado");
+        }
+        return profile;
+    }
+    all() {
+        return [...this.profiles.values()];
+    }
+    names() {
+        return [...this.profiles.keys()];
+    }
+};
+exports.ImageProfileRegistry = ImageProfileRegistry;
+exports.ImageProfileRegistry = ImageProfileRegistry = ImageProfileRegistry_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService])
+], ImageProfileRegistry);

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

@@ -0,0 +1,28 @@
+import { EnvService } from "../config/env.service";
+import { ImageProfile } from "./imageProfile.interface";
+export interface StoredImageRef {
+    folder: string;
+    id: string;
+    extension: string;
+    pending: boolean;
+}
+export declare class ImageStorageService {
+    private readonly env;
+    private readonly logger;
+    private readonly uploadsRoot;
+    private readonly incomingRoot;
+    constructor(env: EnvService);
+    saveIncoming(buffer: Buffer): Promise<string>;
+    readIncoming(id: string): Promise<Buffer>;
+    removeIncoming(id: string): Promise<void>;
+    savePending(profile: ImageProfile, data: Buffer): Promise<string>;
+    promote(publicPath: string | null | undefined): Promise<string | null>;
+    remove(publicPath: string | null | undefined): Promise<void>;
+    parsePublicPath(publicPath: string | null | undefined): StoredImageRef | null;
+    removeExpired(pendingMaxAgeMs: number, incomingMaxAgeMs: number): Promise<number>;
+    private pathFor;
+    private incomingPathFor;
+    private publicPathOf;
+    private absolute;
+    private sweep;
+}