@hed-hog/core 0.0.400 → 0.0.402

package/dist/file/file.service.js

@@ -34,7 +34,7 @@ var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _ar
 var _a;
 var FileService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileService = void 0;
+exports.FileService = exports.DIRECT_UPLOAD_DEFAULT_TTL_SECONDS = exports.DIRECT_UPLOAD_MAX_PARTS = exports.DIRECT_UPLOAD_MIN_PART_BYTES = void 0;
 const client_s3_1 = require("@aws-sdk/client-s3");
 const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
 const client_lambda_1 = require("@aws-sdk/client-lambda");
@@ -57,6 +57,8 @@ const mimetype_sniff_util_1 = require("./mimetype-sniff.util");
 const image_optimization_service_1 = require("./image-optimization.service");
 const abstract_provider_1 = require("./provider/abstract.provider");
 const provider_factory_1 = require("./provider/provider.factory");
+/** Códigos de erro do S3/Spaces que indicam indisponibilidade passageira, não arquivo ruim. */
+const STORAGE_UNAVAILABLE_CODES = ['SlowDown', 'ServiceUnavailable', 'InternalError', 'RequestTimeout'];
 /**
  * Resolver o provider custa 3 queries (setting + integration_profile, que ainda decifra o
  * config, + file_provider) e reconstrói o client de storage a cada arquivo. Em upload em
@@ -65,6 +67,17 @@ const provider_factory_1 = require("./provider/provider.factory");
  * A janela curta mantém a troca de perfil de storage praticamente imediata.
  */
 const PROVIDER_CACHE_TTL_MS = Math.max(0, Number((_a = process.env.FILE_PROVIDER_CACHE_TTL_MS) !== null && _a !== void 0 ? _a : 30000));
+/** Upload direto em partes: mínimo de 16 MiB por parte e até 9000 partes (regra do Studio). */
+exports.DIRECT_UPLOAD_MIN_PART_BYTES = 16 * 1024 * 1024;
+exports.DIRECT_UPLOAD_MAX_PARTS = 9000;
+/** Validade do token e das URLs de parte: um vídeo grande em conexão lenta leva horas. */
+exports.DIRECT_UPLOAD_DEFAULT_TTL_SECONDS = 86400;
+const DIRECT_UPLOAD_TOKEN_TYPE = 'file-direct-upload';
+/**
+ * `file.size` é BIGINT no banco, e o PrismaService o devolve como number: o teto real é o
+ * maior inteiro exato de um number (~9 PB).
+ */
+const FILE_SIZE_COLUMN_MAX = Number.MAX_SAFE_INTEGER;
 let FileService = FileService_1 = class FileService {
     resolveProviderPath(file) {
         // Supports legacy basename-only values while prioritizing full provider keys.
@@ -226,14 +239,30 @@ let FileService = FileService_1 = class FileService {
         });
         return file;
     }
-    mapStorageNotFoundError(error, fileId) {
-        var _a;
-        const missingInStorage = (error === null || error === void 0 ? void 0 : error.name) === 'NoSuchKey' ||
-            (error === null || error === void 0 ? void 0 : error.Code) === 'NoSuchKey' ||
-            ((_a = error === null || error === void 0 ? void 0 : error.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 404;
-        if (missingInStorage) {
+    /**
+     * Traduz a falha do provider de storage para a resposta HTTP certa.
+     *
+     * 5xx e throttle do S3/Spaces são indisponibilidade passageira, não defeito:
+     * viram 503 com `code: STORAGE_UNAVAILABLE`, que o HttpExceptionFilter da API
+     * responde com `Retry-After` e reporta deduplicado. Sem isso, um 503 do Spaces
+     * com corpo que não é XML (ex.: `upstream connect error` do balanceador)
+     * estourava no parse do SDK como `char 'u' is not expected` e virava 500.
+     *
+     * O status vem de `$metadata.httpStatusCode`, que o SDK carimba mesmo quando a
+     * desserialização do erro falha; `$response.statusCode` cobre o resto.
+     */
+    mapStorageError(error, fileId) {
+        var _a, _b, _c;
+        const status = (_b = (_a = error === null || error === void 0 ? void 0 : error.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode) !== null && _b !== void 0 ? _b : (_c = error === null || error === void 0 ? void 0 : error.$response) === null || _c === void 0 ? void 0 : _c.statusCode;
+        const codes = [error === null || error === void 0 ? void 0 : error.name, error === null || error === void 0 ? void 0 : error.Code];
+        if (codes.includes('NoSuchKey') || status === 404) {
             throw new common_1.NotFoundException(`File not found in storage: ${fileId}`);
         }
+        const unavailable = (typeof status === 'number' && status >= 500) ||
+            codes.some((c) => STORAGE_UNAVAILABLE_CODES.includes(c));
+        if (unavailable) {
+            throw new common_1.ServiceUnavailableException({ message: 'Storage temporarily unavailable', code: 'STORAGE_UNAVAILABLE' }, { cause: error });
+        }
         throw error;
     }
     async openReadStreamById(fileId) {
@@ -254,12 +283,16 @@ let FileService = FileService_1 = class FileService {
         }
         const provider = await this.getProvider();
         const providerPath = this.resolveProviderPath(file);
+        // O HEAD só serve para descobrir o tamanho quando a tabela não o tem. Feito
+        // sempre, dobrava as requisições ao storage em cada segmento HLS.
         let metadata;
-        try {
-            metadata = await provider.metaData(providerPath);
-        }
-        catch (_b) {
-            metadata = undefined;
+        if (file.size == null) {
+            try {
+                metadata = await provider.metaData(providerPath);
+            }
+            catch (_b) {
+                metadata = undefined;
+            }
         }
         try {
             const stream = await provider.readStream(providerPath);
@@ -270,7 +303,7 @@ let FileService = FileService_1 = class FileService {
             };
         }
         catch (error) {
-            this.mapStorageNotFoundError(error, fileId);
+            this.mapStorageError(error, fileId);
         }
     }
     async openReadStreamWithRange(fileId, start, end) {
@@ -285,11 +318,17 @@ let FileService = FileService_1 = class FileService {
             throw new common_1.NotFoundException(`File not found: ${fileId}`);
         const provider = await this.getProvider();
         const providerPath = this.resolveProviderPath(file);
-        const totalSize = (_a = file.size) !== null && _a !== void 0 ? _a : 0;
+        const totalSize = Number((_a = file.size) !== null && _a !== void 0 ? _a : 0);
         const resolvedStart = start !== null && start !== void 0 ? start : 0;
         const resolvedEnd = end !== undefined ? end : totalSize > 0 ? totalSize - 1 : undefined;
         const hasRange = start !== undefined;
-        const stream = await provider.readStream(providerPath, hasRange ? { start: resolvedStart, end: resolvedEnd } : undefined);
+        let stream;
+        try {
+            stream = await provider.readStream(providerPath, hasRange ? { start: resolvedStart, end: resolvedEnd } : undefined);
+        }
+        catch (error) {
+            this.mapStorageError(error, fileId);
+        }
         const contentLength = resolvedEnd !== undefined ? resolvedEnd - resolvedStart + 1 : totalSize;
         return {
             file,
@@ -329,7 +368,6 @@ let FileService = FileService_1 = class FileService {
         }
     }
     async getBuffer(fileId) {
-        var _a;
         if (!fileId) {
             throw new common_1.BadRequestException(`No file ID provided`);
         }
@@ -351,13 +389,7 @@ let FileService = FileService_1 = class FileService {
             providerBuffer = await provider.buffer(providerPath);
         }
         catch (error) {
-            const missingInStorage = (error === null || error === void 0 ? void 0 : error.name) === 'NoSuchKey' ||
-                (error === null || error === void 0 ? void 0 : error.Code) === 'NoSuchKey' ||
-                ((_a = error === null || error === void 0 ? void 0 : error.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 404;
-            if (missingInStorage) {
-                throw new common_1.NotFoundException(`File not found in storage: ${fileId}`);
-            }
-            throw error;
+            this.mapStorageError(error, fileId);
         }
         const buffer = Buffer.from(providerBuffer);
         return {
@@ -428,7 +460,13 @@ let FileService = FileService_1 = class FileService {
         }
         const normalizedFilename = this.normalizeUploadedFilename(fileBuffer.originalname);
         const effectiveMimetype = await this.resolveEffectiveMimetype(fileBuffer.mimetype, normalizedFilename, fileBuffer.buffer);
-        const optimized = await this.imageOptimizationService.optimizeBuffer(fileBuffer.buffer, effectiveMimetype, normalizedFilename, { maxWidth: resize === null || resize === void 0 ? void 0 : resize.maxWidth, maxHeight: resize === null || resize === void 0 ? void 0 : resize.maxHeight });
+        const optimized = (options === null || options === void 0 ? void 0 : options.skipImageOptimization)
+            ? {
+                buffer: fileBuffer.buffer,
+                mimetype: effectiveMimetype,
+                originalname: normalizedFilename,
+            }
+            : await this.imageOptimizationService.optimizeBuffer(fileBuffer.buffer, effectiveMimetype, normalizedFilename, { maxWidth: resize === null || resize === void 0 ? void 0 : resize.maxWidth, maxHeight: resize === null || resize === void 0 ? void 0 : resize.maxHeight });
         const normalizedFile = Object.assign(Object.assign({}, fileBuffer), { buffer: optimized.buffer, mimetype: optimized.mimetype, originalname: optimized.originalname, size: optimized.buffer.length });
         const url = await provider.upload(destination, normalizedFile);
         const file = await this.prismaService.file.create({
@@ -480,8 +518,9 @@ let FileService = FileService_1 = class FileService {
         // streaming direto do disco via provider.uploadFromPath. Isso evita carregar
         // o arquivo inteiro na RAM (fs.readFile estoura o limite de Buffer / causa OOM)
         // e habilita upload multipart no S3. A otimização de imagem só se aplica a
-        // image/*, então não há perda nesse caminho.
-        if (!mimetype.startsWith('image/')) {
+        // image/*, então não há perda nesse caminho. `skipImageOptimization` manda a
+        // imagem pelo mesmo caminho: o chamador quer os bytes exatamente como estão.
+        if (!mimetype.startsWith('image/') || (metadata === null || metadata === void 0 ? void 0 : metadata.skipImageOptimization)) {
             const url = await provider.uploadFromPath(destination, filePath, {
                 filename: originalname,
                 mimetype,
@@ -530,6 +569,222 @@ let FileService = FileService_1 = class FileService {
         });
         return file;
     }
+    /**
+     * O storage ativo aceita upload direto em partes assinadas (S3 e Spaces)? Sem provider
+     * configurado, ou com um que não implementa, é `false` — quem oferece o caminho cai no
+     * upload pela API.
+     */
+    async supportsDirectUpload() {
+        try {
+            return (0, abstract_provider_1.supportsDirectUpload)(await this.getProvider());
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async getDirectUploadProvider() {
+        const provider = await this.getProvider();
+        if (!(0, abstract_provider_1.supportsDirectUpload)(provider)) {
+            throw new common_1.ConflictException('The file storage does not support direct uploads');
+        }
+        return provider;
+    }
+    /** `key` gravada pelo start: `${destination}/${uuid.ext}`, sem subpasta extra. */
+    assertDirectUploadKey(key, destination) {
+        const prefix = `${destination}/`;
+        const storedFilename = typeof key === 'string' && key.startsWith(prefix)
+            ? key.slice(prefix.length)
+            : '';
+        if (!storedFilename || storedFilename.includes('/')) {
+            throw new common_1.BadRequestException('Invalid direct upload key');
+        }
+        return storedFilename;
+    }
+    /**
+     * Abre um upload multipart direto no storage. A chave segue o mesmo formato que o
+     * `uploadFromPath` grava (`file.location` = destination, `file.path` = uuid.ext do
+     * `getFilename` do provider), então o arquivo final é servido como qualquer outro.
+     *
+     * Nada vai para o banco aqui: o estado entre as chamadas fica com quem chamou (token
+     * assinado, ver `signDirectUploadToken`) e a linha `file` só nasce no complete.
+     * Tamanho da parte com a regra do Studio: no mínimo 16 MiB e no máximo 9000 partes.
+     */
+    async startDirectUpload(destination, info) {
+        var _a, _b;
+        if (!destination) {
+            throw new common_1.BadRequestException(`No destination provided`);
+        }
+        const size = Number(info === null || info === void 0 ? void 0 : info.size);
+        if (!Number.isInteger(size) || size <= 0) {
+            throw new common_1.BadRequestException(`No size provided`);
+        }
+        // Acima disso o tamanho não cabe exato num number, e a linha não teria como ser lida.
+        if (size > FILE_SIZE_COLUMN_MAX) {
+            throw new common_1.BadRequestException(`File too large: ${size} bytes`);
+        }
+        const mimetype = String((_a = info === null || info === void 0 ? void 0 : info.mimetype) !== null && _a !== void 0 ? _a : '').trim();
+        if (!(info === null || info === void 0 ? void 0 : info.skipMimeValidation) && !(await this.acceptMimetypes(mimetype))) {
+            throw new common_1.BadRequestException(`Invalid file type: ${mimetype}`);
+        }
+        if (!(info === null || info === void 0 ? void 0 : info.skipSizeValidation) && !(await this.maxFileSize(size))) {
+            throw new common_1.BadRequestException(`File too large: ${size} bytes`);
+        }
+        const originalname = this.normalizeUploadedFilename(String((_b = info === null || info === void 0 ? void 0 : info.originalname) !== null && _b !== void 0 ? _b : '').trim() || 'file');
+        const provider = await this.getDirectUploadProvider();
+        const key = `${destination}/${provider.getFilename(originalname)}`;
+        const uploadId = await provider.createMultipartUpload(key, mimetype || 'application/octet-stream');
+        const partSize = Math.max(exports.DIRECT_UPLOAD_MIN_PART_BYTES, Math.ceil(size / exports.DIRECT_UPLOAD_MAX_PARTS));
+        return {
+            key,
+            uploadId,
+            partSize,
+            partCount: Math.max(1, Math.ceil(size / partSize)),
+        };
+    }
+    /** URLs assinadas de PUT para as partes pedidas (1-based, sem repetir). */
+    async signDirectUploadParts(key, uploadId, partNumbers, ttlSeconds = exports.DIRECT_UPLOAD_DEFAULT_TTL_SECONDS) {
+        if (!key || !uploadId) {
+            throw new common_1.BadRequestException('Invalid direct upload');
+        }
+        const numbers = Array.isArray(partNumbers) ? partNumbers.map(Number) : [];
+        if (numbers.length === 0 ||
+            numbers.some((n) => !Number.isInteger(n) || n < 1 || n > exports.DIRECT_UPLOAD_MAX_PARTS)) {
+            throw new common_1.BadRequestException('Invalid part numbers');
+        }
+        const provider = await this.getDirectUploadProvider();
+        return provider.signUploadParts(key, uploadId, [...new Set(numbers)], Math.max(60, Math.floor(ttlSeconds)));
+    }
+    /** Aborta o multipart (as partes já enviadas somem do bucket). Upload já fechado não é erro. */
+    async abortDirectUpload(key, uploadId) {
+        var _a;
+        if (!key || !uploadId) {
+            throw new common_1.BadRequestException('Invalid direct upload');
+        }
+        const provider = await this.getDirectUploadProvider();
+        try {
+            await provider.abortMultipartUpload(key, uploadId);
+        }
+        catch (error) {
+            const status = (_a = error === null || error === void 0 ? void 0 : error.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode;
+            if ((error === null || error === void 0 ? void 0 : error.name) === 'NoSuchUpload' || (error === null || error === void 0 ? void 0 : error.Code) === 'NoSuchUpload' || status === 404) {
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Fecha o multipart e registra o arquivo. Confere o que o storage gravou antes de criar
+     * a linha — tamanho pelo HeadObject (tem que bater com o declarado no start), teto
+     * `storage-max-size`, allowlist `storage-accept-mimetype` e, quando pedido, os primeiros
+     * bytes (`verifyHead`) — e apaga o objeto quando algo não confere: um upload recusado
+     * não deixa blob órfão no bucket.
+     */
+    async completeDirectUpload(input) {
+        var _a, _b, _c, _d, _e;
+        const { key, uploadId, destination } = input !== null && input !== void 0 ? input : {};
+        if (!destination) {
+            throw new common_1.BadRequestException(`No destination provided`);
+        }
+        if (!uploadId) {
+            throw new common_1.BadRequestException('Invalid direct upload');
+        }
+        const storedFilename = this.assertDirectUploadKey(key, destination);
+        const parts = Array.isArray(input.parts) ? input.parts : [];
+        if (parts.length === 0 ||
+            parts.some((part) => !Number.isInteger(Number(part === null || part === void 0 ? void 0 : part.partNumber)) ||
+                Number(part.partNumber) < 1 ||
+                typeof (part === null || part === void 0 ? void 0 : part.etag) !== 'string' ||
+                !part.etag.trim())) {
+            throw new common_1.BadRequestException('Invalid upload parts');
+        }
+        const provider = await this.getDirectUploadProvider();
+        try {
+            await provider.completeMultipartUpload(key, uploadId, parts.map((part) => ({ partNumber: Number(part.partNumber), etag: part.etag.trim() })));
+        }
+        catch (error) {
+            const status = (_a = error === null || error === void 0 ? void 0 : error.$metadata) === null || _a === void 0 ? void 0 : _a.httpStatusCode;
+            if (typeof status === 'number' && status >= 400 && status < 500) {
+                // Parte faltando, ETag errado, parte pequena demais: o multipart não tem conserto.
+                await this.abortDirectUpload(key, uploadId).catch(() => undefined);
+                throw new common_1.BadRequestException('The uploaded parts could not be assembled');
+            }
+            throw error;
+        }
+        const discard = async () => {
+            await provider.delete(key).catch((error) => this.logger.warn(`Failed to delete rejected direct upload ${key}: ${error === null || error === void 0 ? void 0 : error.message}`));
+        };
+        const declaredSize = Number(input.size);
+        const storedSize = this.getFileSizeFromMetadata(await provider.metaData(key));
+        if (storedSize === undefined || storedSize !== declaredSize) {
+            await discard();
+            throw new common_1.BadRequestException(`Stored size (${storedSize !== null && storedSize !== void 0 ? storedSize : 'unknown'} bytes) differs from the declared size (${declaredSize} bytes)`);
+        }
+        if (storedSize > FILE_SIZE_COLUMN_MAX ||
+            (!input.skipSizeValidation && !(await this.maxFileSize(storedSize)))) {
+            await discard();
+            throw new common_1.BadRequestException(`File too large: ${storedSize} bytes`);
+        }
+        let mimetype = String((_b = input.mimetype) !== null && _b !== void 0 ? _b : '').trim();
+        if (input.verifyHead) {
+            try {
+                const verified = await input.verifyHead.check(await provider.readHead(key, input.verifyHead.bytes));
+                if (typeof verified === 'string' && verified.trim()) {
+                    mimetype = verified.trim();
+                }
+            }
+            catch (error) {
+                await discard();
+                throw error;
+            }
+        }
+        if (!input.skipMimeValidation && !(await this.acceptMimetypes(mimetype))) {
+            await discard();
+            throw new common_1.BadRequestException(`Invalid file type: ${mimetype}`);
+        }
+        try {
+            return await this.prismaService.file.create({
+                data: {
+                    filename: this.normalizeUploadedFilename(String((_c = input.originalname) !== null && _c !== void 0 ? _c : '').trim() || storedFilename),
+                    path: storedFilename,
+                    provider_id: this.providerId,
+                    location: destination,
+                    mimetype_id: await this.getMimeType(mimetype),
+                    size: storedSize,
+                    is_private: (_d = input.isPrivate) !== null && _d !== void 0 ? _d : false,
+                    created_by_user_id: (_e = input.createdByUserId) !== null && _e !== void 0 ? _e : null,
+                },
+            });
+        }
+        catch (error) {
+            await discard();
+            throw error;
+        }
+    }
+    /**
+     * Token opaco que carrega o estado de um upload direto entre as chamadas (sem tabela):
+     * JWT HS256 com o JWT_SECRET da API e o tipo `file-direct-upload`, como o token do
+     * `file-upload-ticket`. Quem chama põe nas claims o que precisa amarrar (marca, usuário).
+     */
+    signDirectUploadToken(claims, ttlSeconds = exports.DIRECT_UPLOAD_DEFAULT_TTL_SECONDS) {
+        return this.jwtService.sign(Object.assign(Object.assign({}, claims), { t: DIRECT_UPLOAD_TOKEN_TYPE }), {
+            secret: process.env.JWT_SECRET,
+            expiresIn: `${Math.max(1, Math.floor(ttlSeconds))}s`,
+        });
+    }
+    /** Claims do token de upload direto; assinatura inválida, expirado ou de outro tipo = 400. */
+    readDirectUploadToken(token) {
+        let payload;
+        try {
+            payload = this.jwtService.verify(String(token !== null && token !== void 0 ? token : ''), { secret: process.env.JWT_SECRET });
+        }
+        catch (_a) {
+            throw new common_1.BadRequestException('Invalid or expired upload token');
+        }
+        if ((payload === null || payload === void 0 ? void 0 : payload.t) !== DIRECT_UPLOAD_TOKEN_TYPE) {
+            throw new common_1.BadRequestException('Token is not a direct upload token');
+        }
+        return payload;
+    }
     /**
      * Lista as imagens armazenadas que valem uma passada por `reoptimizeFile`, para a
      * operação em massa de reprocessamento do acervo.
@@ -591,7 +846,7 @@ let FileService = FileService_1 = class FileService {
         var _a;
         const { file, buffer } = await this.getBuffer(fileId);
         const currentMimetype = file.file_mimetype.name;
-        const oldSize = (_a = file.size) !== null && _a !== void 0 ? _a : buffer.length;
+        const oldSize = Number((_a = file.size) !== null && _a !== void 0 ? _a : buffer.length);
         if (!currentMimetype.startsWith('image/')) {
             return { changed: false, oldSize, newSize: oldSize, mimetypeChanged: false };
         }
@@ -1454,6 +1709,21 @@ let FileService = FileService_1 = class FileService {
             expiresIn: (_a = params.expiresInSeconds) !== null && _a !== void 0 ? _a : 900,
         });
     }
+    /**
+     * Apaga um objeto de bucket avulso, com as credenciais de quem o configurou.
+     *
+     * Mesmo motivo do `headS3Object` e do `signS3Object`: o bucket e de outra
+     * library (o Studio guarda os brutos no perfil de armazenamento dele), e nao o
+     * destino ativo do core. O S3 responde 204 tambem para key inexistente, entao
+     * apagar duas vezes nao e erro.
+     */
+    async deleteS3Object(params) {
+        const s3 = new client_s3_1.S3Client({
+            region: params.region,
+            credentials: Object.assign({ accessKeyId: params.accessKeyId, secretAccessKey: params.secretAccessKey }, (params.sessionToken ? { sessionToken: params.sessionToken } : {})),
+        });
+        await s3.send(new client_s3_1.DeleteObjectCommand({ Bucket: params.bucket, Key: params.key }));
+    }
     async headS3Bucket(params) {
         const s3 = new client_s3_1.S3Client({
             region: params.region,