@hed-hog/core 0.0.370 → 0.0.373

package/src/file/file.service.ts

@@ -32,7 +32,7 @@ import {
 } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { createWriteStream, promises as fs } from 'fs';
-import { basename, dirname } from 'path';
+import { basename, dirname, extname } from 'path';
 import { pipeline } from 'stream/promises';
 import {
   buildStorageConfigFromIntegration,
@@ -104,15 +104,14 @@ export class FileService implements OnModuleInit {
 
   async getProvider(): Promise<AbstractProvider> {
     const settings = await this.settingService.getSettingValues(['file-storage-profile-id']);
-    const rawProfileId = settings['file-storage-profile-id'];
-    const profileId = Number(rawProfileId);
+    const profileSlug = String(settings['file-storage-profile-id'] ?? '').trim();
 
-    if (!Number.isFinite(profileId) || profileId <= 0) {
+    if (!profileSlug) {
       throw new BadRequestException('No file storage profile configured. Set a storage profile in the File Storage settings.');
     }
 
     const profile = await this.prismaService.integration_profile.findUnique({
-      where: { id: profileId },
+      where: { slug: profileSlug },
       include: {
         integration_type: { select: { slug: true } },
         integration_provider: { select: { slug: true } },
@@ -120,12 +119,12 @@ export class FileService implements OnModuleInit {
     });
 
     if (!profile) {
-      throw new NotFoundException(`Storage profile with id ${profileId} not found.`);
+      throw new NotFoundException(`Storage profile with slug "${profileSlug}" not found.`);
     }
 
     if (profile.integration_type.slug !== 'storage') {
       throw new BadRequestException(
-        `Integration profile with id ${profileId} is not a storage profile.`,
+        `Integration profile with slug "${profileSlug}" is not a storage profile.`,
       );
     }
 
@@ -212,17 +211,19 @@ export class FileService implements OnModuleInit {
       throw new BadRequestException(`No filename provided`);
     }
 
+    const effectiveMimetype = await this.resolveEffectiveMimetype(mimetype, filename);
+
     const provider = await this.getProvider();
 
-    if (!(await this.acceptMimetypes(mimetype))) {
-      throw new BadRequestException(`Invalid file type: ${mimetype}`);
+    if (!(await this.acceptMimetypes(effectiveMimetype))) {
+      throw new BadRequestException(`Invalid file type: ${effectiveMimetype}`);
     }
 
     const url = await provider.uploadFromString(
       destination,
       filename,
       filecontent,
-      mimetype,
+      effectiveMimetype,
     );
 
     const file = await this.prismaService.file.create({
@@ -231,7 +232,7 @@ export class FileService implements OnModuleInit {
         path: url,
         provider_id: this.providerId,
         location: destination,
-        mimetype_id: await this.getMimeType(mimetype),
+        mimetype_id: await this.getMimeType(effectiveMimetype),
         size: filecontent.length,
       },
     });
@@ -425,7 +426,11 @@ export class FileService implements OnModuleInit {
     res.send(buffer);
   }
 
-  async upload(destination: string, fileBuffer: MulterFile) {
+  async upload(
+    destination: string,
+    fileBuffer: MulterFile,
+    resize?: { maxWidth?: number; maxHeight?: number },
+  ) {
 
     if (!fileBuffer) {
       throw new BadRequestException(`No file provided`);
@@ -451,10 +456,17 @@ export class FileService implements OnModuleInit {
       fileBuffer.originalname,
     );
 
+    const effectiveMimetype = await this.resolveEffectiveMimetype(
+      fileBuffer.mimetype,
+      normalizedFilename,
+      fileBuffer.buffer,
+    );
+
     const optimized = await this.imageOptimizationService.optimizeBuffer(
       fileBuffer.buffer,
-      fileBuffer.mimetype,
+      effectiveMimetype,
       normalizedFilename,
+      { maxWidth: resize?.maxWidth, maxHeight: resize?.maxHeight },
     );
 
     const normalizedFile = {
@@ -491,6 +503,7 @@ export class FileService implements OnModuleInit {
       size?: number;
       encoding?: string;
       skipMimeValidation?: boolean;
+      skipSizeValidation?: boolean;
     },
   ) {
     if (!filePath) {
@@ -507,19 +520,49 @@ export class FileService implements OnModuleInit {
     }
 
     const size = metadata?.size ?? stats.size;
-    const mimetype = metadata?.mimetype ?? 'application/octet-stream';
     const originalname = this.normalizeUploadedFilename(
       metadata?.originalname ?? metadata?.filename ?? basename(filePath),
     );
+    // Recupera o tipo real quando o caller não informou o mimetype (default antigo era
+    // application/octet-stream, que fazia imagens caírem fora da otimização e do serve).
+    const mimetype = await this.resolveEffectiveMimetype(
+      metadata?.mimetype,
+      originalname,
+    );
 
     if (!metadata?.skipMimeValidation && !(await this.acceptMimetypes(mimetype))) {
       throw new BadRequestException(`Invalid file type: ${mimetype}`);
     }
 
-    if (!(await this.maxFileSize(size))) {
+    if (!metadata?.skipSizeValidation && !(await this.maxFileSize(size))) {
       throw new BadRequestException(`File too large: ${size} bytes`);
     }
 
+    const provider = await this.getProvider();
+
+    // Para não-imagens (ex.: pacotes SCORM .zip de vários GB), enviamos por
+    // 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/')) {
+      const url = await provider.uploadFromPath(destination, filePath, {
+        filename: originalname,
+        mimetype,
+      });
+
+      return this.prismaService.file.create({
+        data: {
+          filename: originalname,
+          path: url,
+          provider_id: this.providerId,
+          location: destination,
+          mimetype_id: await this.getMimeType(mimetype),
+          size,
+        },
+      });
+    }
+
     // Read buffer to allow image optimization regardless of provider support
     const rawBuffer = await fs.readFile(filePath);
     const optimized = await this.imageOptimizationService.optimizeBuffer(
@@ -528,7 +571,6 @@ export class FileService implements OnModuleInit {
       originalname,
     );
 
-    const provider = await this.getProvider();
     const url = await provider.upload(destination, {
       fieldname: 'file',
       originalname: optimized.originalname,
@@ -555,6 +597,95 @@ export class FileService implements OnModuleInit {
     return file;
   }
 
+  /**
+   * Re-applies the current image-optimization settings to an already-stored file,
+   * rewriting it in place: the `file` record keeps the same id, so every row that
+   * references it (course_image, course_lesson_video_frame, ...) stays valid without
+   * any FK juggling. Only replaces the stored object when the optimized result is
+   * strictly smaller or the mimetype changed (e.g. PNG → WebP) — this keeps the
+   * operation idempotent and avoids repeated lossy recompression. Non-image files are
+   * left untouched.
+   */
+  async reoptimizeFile(fileId: number): Promise<{
+    changed: boolean;
+    oldSize: number;
+    newSize: number;
+    mimetypeChanged: boolean;
+  }> {
+    const { file, buffer } = await this.getBuffer(fileId);
+    const currentMimetype = file.file_mimetype.name;
+    const oldSize = file.size ?? buffer.length;
+
+    if (!currentMimetype.startsWith('image/')) {
+      return { changed: false, oldSize, newSize: oldSize, mimetypeChanged: false };
+    }
+
+    const optimized = await this.imageOptimizationService.optimizeBuffer(
+      buffer,
+      currentMimetype,
+      file.filename,
+    );
+
+    const mimetypeChanged = optimized.mimetype !== currentMimetype;
+    const smaller = optimized.buffer.length < oldSize;
+
+    if (!mimetypeChanged && !smaller) {
+      return {
+        changed: false,
+        oldSize,
+        newSize: optimized.buffer.length,
+        mimetypeChanged: false,
+      };
+    }
+
+    const provider = await this.getProvider();
+    const destination = file.location;
+    const oldPath = file.path;
+
+    const newUrl = await provider.upload(destination, {
+      fieldname: 'file',
+      originalname: optimized.originalname,
+      encoding: '7bit',
+      mimetype: optimized.mimetype,
+      size: optimized.buffer.length,
+      destination: '',
+      filename: optimized.originalname,
+      path: '',
+      buffer: optimized.buffer,
+    });
+
+    await this.prismaService.file.update({
+      where: { id: fileId },
+      data: {
+        path: newUrl,
+        filename: optimized.originalname,
+        size: optimized.buffer.length,
+        mimetype_id: await this.getMimeType(optimized.mimetype),
+      },
+    });
+
+    // Best-effort cleanup of the previous stored object; an orphaned blob must not
+    // fail the optimization since the DB already points at the new object.
+    const oldResolved = this.resolveProviderPath({ location: destination, path: oldPath });
+    const newResolved = this.resolveProviderPath({ location: destination, path: newUrl });
+    if (oldResolved !== newResolved) {
+      try {
+        await provider.delete(oldResolved);
+      } catch (err) {
+        this.logger.warn(
+          `reoptimizeFile(${fileId}): failed to delete previous object "${oldResolved}": ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
+    return {
+      changed: true,
+      oldSize,
+      newSize: optimized.buffer.length,
+      mimetypeChanged,
+    };
+  }
+
   async delete(locale:string,{ ids }: DeleteDTO) {
     const files = await this.prismaService.file.findMany({
       where: {
@@ -712,6 +843,200 @@ export class FileService implements OnModuleInit {
     };
   }
 
+  private async getCacheTtl(slug: string, fallback: number): Promise<number> {
+    const settings = await this.settingService.getSettingValues(slug);
+    const value = Number(settings[slug]);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+
+  /**
+   * Resolves the file record and its storage metadata (mimetype + size) without
+   * opening a read stream — so callers can answer a conditional 304 cheaply.
+   */
+  private async resolveFileMeta(locale: string, id: number) {
+    const file = await this.prismaService.file.findFirst({
+      where: { id },
+      include: { file_mimetype: true },
+    });
+
+    if (!file) {
+      throw new NotFoundException(
+        getLocaleText('file.download.not_found', locale, `Not found: ${id}`),
+      );
+    }
+
+    const provider = await this.getProvider();
+    const providerPath = this.resolveProviderPath(file);
+    const metadata = await provider.metaData(providerPath);
+    const size = this.getFileSizeFromMetadata(metadata);
+
+    return {
+      provider,
+      providerPath,
+      size,
+      mimetype: file?.file_mimetype?.name || 'application/octet-stream',
+      filename: file?.filename || 'download',
+    };
+  }
+
+  private setInlineHeaders(
+    res: any,
+    filename: string,
+    mimetype: string,
+    size: number | undefined,
+    cacheControl: string,
+    etag: string,
+  ) {
+    const encodedFilename = encodeURIComponent(filename);
+    res.set({
+      'Content-Type': mimetype || 'application/octet-stream',
+      'Content-Disposition':
+        `inline; filename="${filename}"; filename*=UTF-8''${encodedFilename}`,
+      'Cache-Control': cacheControl,
+      ETag: etag,
+    });
+    if (typeof size === 'number') {
+      res.set('Content-Length', `${size}`);
+    }
+  }
+
+  /**
+   * Best-effort image MIME type from a filename/key extension. Used to serve images
+   * whose stored mimetype is generic (e.g. application/octet-stream from imports or
+   * extractions) with a correct Content-Type instead of rejecting them.
+   */
+  private inferImageContentType(nameOrPath?: string): string | null {
+    if (!nameOrPath) return null;
+    const ext = extname(nameOrPath).toLowerCase().replace(/^\./, '');
+    const map: Record<string, string> = {
+      jpg: 'image/jpeg',
+      jpeg: 'image/jpeg',
+      png: 'image/png',
+      webp: 'image/webp',
+      gif: 'image/gif',
+      svg: 'image/svg+xml',
+      bmp: 'image/bmp',
+      tif: 'image/tiff',
+      tiff: 'image/tiff',
+      avif: 'image/avif',
+      ico: 'image/x-icon',
+      heic: 'image/heic',
+      heif: 'image/heif',
+    };
+    return map[ext] ?? null;
+  }
+
+  /**
+   * Resolves the MIME type to persist for an upload. When the incoming mimetype is
+   * generic (application/octet-stream or empty), recovers the real image type from
+   * the filename extension and, when raw bytes are available, by sniffing with sharp.
+   * Concrete non-image types (video, pdf, ...) are returned unchanged.
+   */
+  private async resolveEffectiveMimetype(
+    mimetype: string | undefined,
+    name: string,
+    buffer?: Buffer,
+  ): Promise<string> {
+    if (mimetype && mimetype.startsWith('image/')) return mimetype;
+    // Tipos concretos não-imagem (video, pdf, ...) são mantidos como estão.
+    if (mimetype && mimetype !== 'application/octet-stream') return mimetype;
+
+    // Aqui o mimetype é vazio/undefined ou application/octet-stream: recupera o real.
+    const byExtension = this.inferImageContentType(name);
+    if (byExtension) return byExtension;
+
+    if (buffer) {
+      const sniffed = await this.imageOptimizationService.detectImageMimetype(buffer);
+      if (sniffed) return sniffed;
+    }
+
+    return mimetype ?? 'application/octet-stream';
+  }
+
+  /**
+   * Serves an image by id with strong, immutable HTTP caching. The content of a
+   * given fileId never changes (a new upload yields a new id), so the ETag is
+   * derived from id+size instead of hashing the buffer, keeping it streaming.
+   */
+  async serveImageById(
+    locale: string,
+    id: number,
+    ifNoneMatch: string | undefined,
+    res: any,
+  ) {
+    const { provider, providerPath, size, mimetype, filename } =
+      await this.resolveFileMeta(locale, id);
+
+    // Many legacy/imported files store a generic mimetype (application/octet-stream).
+    // Since this endpoint serves images referenced by <img> tags, infer the
+    // Content-Type from the extension instead of rejecting; only block concretely
+    // non-image types (pdf, video, ...).
+    const contentType = mimetype.startsWith('image/')
+      ? mimetype
+      : (this.inferImageContentType(filename) ??
+        this.inferImageContentType(providerPath) ??
+        mimetype);
+
+    const isGenericBinary = !mimetype || mimetype === 'application/octet-stream';
+    if (!contentType.startsWith('image/') && !isGenericBinary) {
+      throw new NotFoundException(
+        getLocaleText('file.download.not_found', locale, `Not an image: ${id}`),
+      );
+    }
+
+    const etag = `"img-${id}-${size ?? 0}"`;
+    if (ifNoneMatch && ifNoneMatch === etag) {
+      res.status(304).end();
+      return;
+    }
+
+    const ttl = await this.getCacheTtl('image-cache-ttl-seconds', 2592000);
+    this.setInlineHeaders(
+      res,
+      filename,
+      contentType,
+      size,
+      `public, max-age=${ttl}, immutable`,
+      etag,
+    );
+
+    const stream = await provider.readStream(providerPath);
+    stream.pipe(res);
+  }
+
+  /**
+   * Serves any file by id with configurable HTTP caching (not immutable, shorter
+   * TTL than images). Used by the generic open endpoint's numeric-id branch.
+   */
+  async serveFileById(
+    locale: string,
+    id: number,
+    ifNoneMatch: string | undefined,
+    res: any,
+  ) {
+    const { provider, providerPath, size, mimetype, filename } =
+      await this.resolveFileMeta(locale, id);
+
+    const etag = `"file-${id}-${size ?? 0}"`;
+    if (ifNoneMatch && ifNoneMatch === etag) {
+      res.status(304).end();
+      return;
+    }
+
+    const ttl = await this.getCacheTtl('file-cache-ttl-seconds', 86400);
+    this.setInlineHeaders(
+      res,
+      filename,
+      mimetype,
+      size,
+      `public, max-age=${ttl}`,
+      etag,
+    );
+
+    const stream = await provider.readStream(providerPath);
+    stream.pipe(res);
+  }
+
   async tempURL(filepath: string, expires = 3600) {
     return (await this.getProvider()).tempURL(filepath, expires);
   }

package/src/file/image-optimization.service.ts

@@ -9,6 +9,12 @@ export interface OptimizedImage {
   originalname: string;
 }
 
+export interface OptimizeOptions {
+  /** Precise target dimensions (e.g. from a cropped course banner/logo/square). */
+  maxWidth?: number;
+  maxHeight?: number;
+}
+
 @Injectable()
 export class ImageOptimizationService {
   private readonly logger = new Logger(ImageOptimizationService.name);
@@ -33,15 +39,47 @@ export class ImageOptimizationService {
     return `${base}.${newExt}`;
   }
 
+  private pngCompressionLevel(quality: number): number {
+    // sharp compressionLevel is 0-9 (9 = max); invert from quality scale
+    return Math.round(((100 - quality) / 100) * 9);
+  }
+
+  /**
+   * Detects the image MIME type from the raw bytes using sharp. Returns null when
+   * the buffer is not a recognizable image (or sharp fails). Used to recover the
+   * real type of files uploaded with a generic mimetype (application/octet-stream).
+   */
+  async detectImageMimetype(buffer: Buffer): Promise<string | null> {
+    try {
+      const { format } = await sharp(buffer).metadata();
+      const map: Record<string, string> = {
+        jpeg: 'image/jpeg',
+        jpg: 'image/jpeg',
+        png: 'image/png',
+        webp: 'image/webp',
+        gif: 'image/gif',
+        svg: 'image/svg+xml',
+        tiff: 'image/tiff',
+        avif: 'image/avif',
+        heif: 'image/heif',
+      };
+      return format ? (map[format] ?? null) : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
-   * Applies image compression and/or WebP conversion to the given buffer
-   * based on the current settings. Returns the original data unchanged if
-   * the settings are disabled or the MIME type is not in the configured lists.
+   * Applies optional resize, compression and/or WebP conversion to the given
+   * buffer based on the current settings. Returns the original data unchanged
+   * when there is nothing to do (no resize and the MIME type is not in any
+   * configured optimization list).
    */
   async optimizeBuffer(
     buffer: Buffer,
     mimetype: string,
     originalname: string,
+    options: OptimizeOptions = {},
   ): Promise<OptimizedImage> {
     if (!mimetype.startsWith('image/')) {
       return { buffer, mimetype, originalname };
@@ -53,71 +91,98 @@ export class ImageOptimizationService {
       'image-compression-types',
       'image-webp-conversion-enabled',
       'image-webp-convert-types',
+      'image-max-dimension',
     ]);
 
     const compressionEnabled = settings['image-compression-enabled'] === 'true';
     const webpEnabled = settings['image-webp-conversion-enabled'] === 'true';
 
-    if (!compressionEnabled && !webpEnabled) {
-      return { buffer, mimetype, originalname };
-    }
-
     const quality = Math.min(
       100,
       Math.max(1, Number(settings['image-compression-quality']) || 80),
     );
     const compressionTypes = this.parseArraySetting(settings['image-compression-types']);
     const webpConvertTypes = this.parseArraySetting(settings['image-webp-convert-types']);
+    const maxDimension = Math.max(0, Number(settings['image-max-dimension']) || 0);
+
+    // Resolve the resize operation: a precise target (cropped uploads) wins over
+    // the generic max-dimension cap.
+    const targetWidth = Number(options.maxWidth) || 0;
+    const targetHeight = Number(options.maxHeight) || 0;
+
+    let resize: sharp.ResizeOptions | null = null;
+    if (targetWidth > 0 && targetHeight > 0) {
+      resize = { width: targetWidth, height: targetHeight, fit: 'cover' };
+    } else if (maxDimension > 0) {
+      resize = {
+        width: maxDimension,
+        height: maxDimension,
+        fit: 'inside',
+        withoutEnlargement: true,
+      };
+    }
+
+    const willConvertWebp = webpEnabled && webpConvertTypes.includes(mimetype);
+    const willCompress = compressionEnabled && compressionTypes.includes(mimetype);
 
-    // WebP conversion has priority over plain compression
-    if (webpEnabled && webpConvertTypes.includes(mimetype)) {
-      try {
-        const optimized = await sharp(buffer).webp({ quality }).toBuffer();
+    // Nothing to do for this image.
+    if (!resize && !willConvertWebp && !willCompress) {
+      return { buffer, mimetype, originalname };
+    }
+
+    try {
+      let instance = sharp(buffer);
+      if (resize) {
+        instance = instance.resize(resize);
+      }
+
+      // WebP conversion has priority over plain compression.
+      if (willConvertWebp) {
+        const optimized = await instance.webp({ quality }).toBuffer();
         return {
           buffer: optimized,
           mimetype: 'image/webp',
           originalname: this.replaceExtension(originalname, 'webp'),
         };
-      } catch (err) {
-        this.logger.warn(
-          `WebP conversion failed for "${originalname}" (${mimetype}): ${err instanceof Error ? err.message : String(err)}. Falling back to original.`,
-        );
-        return { buffer, mimetype, originalname };
       }
-    }
 
-    if (compressionEnabled && compressionTypes.includes(mimetype)) {
-      try {
-        let instance = sharp(buffer);
-        if (mimetype === 'image/jpeg') {
-          instance = instance.jpeg({ quality });
-        } else if (mimetype === 'image/png') {
-          // sharp compressionLevel is 0-9 (9 = max); invert from quality scale
-          const compressionLevel = Math.round(((100 - quality) / 100) * 9);
-          instance = instance.png({ compressionLevel });
-        } else if (mimetype === 'image/webp') {
-          instance = instance.webp({ quality });
-        } else if (mimetype === 'image/bmp' || mimetype === 'image/tiff') {
-          // Convert to PNG as a compressed lossless alternative
-          instance = instance.png({ compressionLevel: Math.round(((100 - quality) / 100) * 9) });
-          return {
-            buffer: await instance.toBuffer(),
-            mimetype: 'image/png',
-            originalname: this.replaceExtension(originalname, 'png'),
-          };
-        } else {
-          return { buffer, mimetype, originalname };
-        }
+      // Re-encode keeping the original format. Reached when compressing, or when
+      // only resizing (a resize always requires re-encoding the buffer).
+      if (mimetype === 'image/jpeg') {
+        const optimized = await instance.jpeg({ quality }).toBuffer();
+        return { buffer: optimized, mimetype, originalname };
+      } else if (mimetype === 'image/png') {
+        const optimized = await instance
+          .png({ compressionLevel: this.pngCompressionLevel(quality) })
+          .toBuffer();
+        return { buffer: optimized, mimetype, originalname };
+      } else if (mimetype === 'image/webp') {
+        const optimized = await instance.webp({ quality }).toBuffer();
+        return { buffer: optimized, mimetype, originalname };
+      } else if (mimetype === 'image/bmp' || mimetype === 'image/tiff') {
+        // Convert to PNG as a compressed lossless alternative.
+        const optimized = await instance
+          .png({ compressionLevel: this.pngCompressionLevel(quality) })
+          .toBuffer();
+        return {
+          buffer: optimized,
+          mimetype: 'image/png',
+          originalname: this.replaceExtension(originalname, 'png'),
+        };
+      }
+
+      // Unknown image format: only re-encode if a resize was requested,
+      // otherwise leave it untouched.
+      if (resize) {
         const optimized = await instance.toBuffer();
         return { buffer: optimized, mimetype, originalname };
-      } catch (err) {
-        this.logger.warn(
-          `Image compression failed for "${originalname}" (${mimetype}): ${err instanceof Error ? err.message : String(err)}. Falling back to original.`,
-        );
-        return { buffer, mimetype, originalname };
       }
+      return { buffer, mimetype, originalname };
+    } catch (err) {
+      this.logger.warn(
+        `Image optimization failed for "${originalname}" (${mimetype}): ${err instanceof Error ? err.message : String(err)}. Falling back to original.`,
+      );
+      return { buffer, mimetype, originalname };
     }
-
-    return { buffer, mimetype, originalname };
   }
 }