refactor: update thumbnail handling to use image size for thumbnailable checks and adjust related tests

Author: larryrider

src/utils/thumbnail.utils.ts

@@ -17,32 +17,21 @@ const imageExtensions: FileExtensionMap = {
   raw: ['raw', 'cr2', 'nef', 'orf', 'sr2'],
   webp: ['webp'],
 };
-const pdfExtensions: FileExtensionMap = {
-  pdf: ['pdf'],
-};
 const thumbnailableImageExtension: Set<string> = new Set([
   ...imageExtensions['jpg'],
   ...imageExtensions['png'],
   ...imageExtensions['webp'],
   ...imageExtensions['gif'],
   ...imageExtensions['tiff'],
 ]);
-const thumbnailablePdfExtension: Set<string> = new Set(pdfExtensions['pdf']);
-const thumbnailableExtension: Set<string> = new Set(thumbnailableImageExtension);
 
 export class ThumbnailUtils {
-  static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB = 500 * 1024 * 1024;
-
-  static readonly isFileThumbnailable = (fileType: string) => {
-    return fileType.trim().length > 0 && thumbnailableExtension.has(fileType.trim().toLowerCase());
-  };
-
-  static readonly isPDFThumbnailable = (fileType: string) => {
-    return fileType.trim().length > 0 && thumbnailablePdfExtension.has(fileType.trim().toLowerCase());
-  };
+  static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES = 128 * 1024 * 1024;
 
   static readonly isImageThumbnailable = (fileType: string, size: number) => {
-    if (size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB) return false;
+    if (size <= 0 || size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES) {
+      return false;
+    }
     return fileType.trim().length > 0 && thumbnailableImageExtension.has(fileType.trim().toLowerCase());
   };
 }

src/utils/upload.utils.ts

@@ -25,12 +25,13 @@ export class UploadUtils {
   static readonly prepareUploadStreams = (
     readable: Readable,
     fileType: string,
+    size: number,
   ): {
     fileStream: Readable;
     thumbnailStream: BufferStream | undefined;
     isThumbnailable: boolean;
   } => {
-    const isThumbnailable = ThumbnailUtils.isFileThumbnailable(fileType);
+    const isThumbnailable = ThumbnailUtils.isImageThumbnailable(fileType, size);
     if (!isThumbnailable) {
       return { fileStream: readable, thumbnailStream: undefined, isThumbnailable };
     }

src/webdav/handlers/PUT.handler.ts

@@ -63,7 +63,7 @@ export class PUTRequestHandler implements WebDavMethodHandler {
     const { user } = await AuthService.instance.getAuthDetails();
     const fileType = resource.path.ext.replace('.', '');
 
-    const { fileStream, thumbnailStream } = UploadUtils.prepareUploadStreams(req, fileType);
+    const { fileStream, thumbnailStream } = UploadUtils.prepareUploadStreams(req, fileType, contentLength);
 
     const { networkFacade, bucket } = await CLIUtils.prepareNetwork(user);
 

test/utils/thumbnail.utils.test.ts

@@ -2,139 +2,69 @@ import { describe, expect, test } from 'vitest';
 import { ThumbnailUtils } from '../../src/utils/thumbnail.utils';
 
 describe('Thumbnail Utils tests', () => {
-  describe('isFileThumbnailable', () => {
-    test('when a valid image extension is given, then true is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable('jpg')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('jpeg')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('png')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('webp')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('gif')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('tif')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('tiff')).toBe(true);
-    });
-
-    test('when an extension has mixed case, then true is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable('JPG')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('PNG')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('Webp')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('GIF')).toBe(true);
-    });
-
-    test('when an extension has surrounding whitespace, then true is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable(' jpg ')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('  png  ')).toBe(true);
-      expect(ThumbnailUtils.isFileThumbnailable('\tgif\t')).toBe(true);
-    });
-
-    test('when a non-thumbnailable extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable('pdf')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('doc')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('txt')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('mp4')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('bmp')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('raw')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('heic')).toBe(false);
-    });
-
-    test('when an empty or blank string is given, then false is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable('')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('   ')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('\t\n')).toBe(false);
-    });
-
-    test('when an invalid extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isFileThumbnailable('unknown')).toBe(false);
-      expect(ThumbnailUtils.isFileThumbnailable('jpgg')).toBe(false);
-    });
-  });
-
-  describe('isPDFThumbnailable', () => {
-    test('when a pdf extension is given, then true is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable('pdf')).toBe(true);
-    });
-
-    test('when an extension has mixed case, then true is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable('PDF')).toBe(true);
-      expect(ThumbnailUtils.isPDFThumbnailable('Pdf')).toBe(true);
-      expect(ThumbnailUtils.isPDFThumbnailable('pDf')).toBe(true);
-    });
-
-    test('when an extension has surrounding whitespace, then true is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable(' pdf ')).toBe(true);
-      expect(ThumbnailUtils.isPDFThumbnailable('  PDF  ')).toBe(true);
-      expect(ThumbnailUtils.isPDFThumbnailable('\tpdf\n')).toBe(true);
-    });
-
-    test('when a non-pdf extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable('jpg')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('png')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('doc')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('docx')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('txt')).toBe(false);
-    });
-
-    test('when an empty or blank string is given, then false is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable('')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('   ')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('\t\n')).toBe(false);
-    });
-
-    test('when an invalid extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isPDFThumbnailable('pdff')).toBe(false);
-      expect(ThumbnailUtils.isPDFThumbnailable('pd')).toBe(false);
-    });
-  });
-
   describe('isImageThumbnailable', () => {
+    const validSize = 1024;
+
     test('when a thumbnailable image extension is given, then true is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('jpg')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('jpeg')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('png')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('webp')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('gif')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('tif')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('tiff')).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('jpg', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('jpeg', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('png', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('webp', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('gif', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('tif', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('tiff', validSize)).toBe(true);
     });
 
     test('when an extension has mixed case, then true is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('JPG')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('PNG')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('GIF')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('Jpeg')).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('JPG', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('PNG', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('GIF', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('Jpeg', validSize)).toBe(true);
     });
 
     test('when an extension has surrounding whitespace, then true is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable(' jpg ')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('  png  ')).toBe(true);
-      expect(ThumbnailUtils.isImageThumbnailable('\twebp\n')).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable(' jpg ', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('  png  ', validSize)).toBe(true);
+      expect(ThumbnailUtils.isImageThumbnailable('\twebp\n', validSize)).toBe(true);
     });
 
     test('when a non-thumbnailable image format is given, then false is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('bmp')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('heic')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('raw')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('cr2')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('nef')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('eps')).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('bmp', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('heic', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('raw', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('cr2', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('nef', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('eps', validSize)).toBe(false);
     });
 
     test('when a non-image extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('pdf')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('doc')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('txt')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('mp4')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('mp3')).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('pdf', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('doc', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('txt', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('mp4', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('mp3', validSize)).toBe(false);
     });
 
     test('when an empty or blank string is given, then false is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('   ')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('\t\n')).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('   ', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('\t\n', validSize)).toBe(false);
     });
 
     test('when an invalid extension is given, then false is returned', () => {
-      expect(ThumbnailUtils.isImageThumbnailable('jpgg')).toBe(false);
-      expect(ThumbnailUtils.isImageThumbnailable('unknown')).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('jpgg', validSize)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('unknown', validSize)).toBe(false);
+    });
+
+    test('when the size is zero or negative, then false is returned', () => {
+      expect(ThumbnailUtils.isImageThumbnailable('jpg', 0)).toBe(false);
+      expect(ThumbnailUtils.isImageThumbnailable('jpg', -1)).toBe(false);
+    });
+
+    test('when the size exceeds the max thumbnailable size, then false is returned', () => {
+      expect(ThumbnailUtils.isImageThumbnailable('jpg', ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES + 1)).toBe(
+        false,
+      );
     });
   });
 });

test/utils/upload.utils.test.ts

@@ -93,27 +93,48 @@ describe('UploadUtils', () => {
 
   describe('prepareUploadStreams', () => {
     test('when the file type does not support thumbnails, then the original stream is returned without a thumbnail', () => {
-      vi.spyOn(ThumbnailUtils, 'isFileThumbnailable').mockReturnValue(false);
+      vi.spyOn(ThumbnailUtils, 'isImageThumbnailable').mockReturnValue(false);
       const readable = Readable.from(['test']);
 
-      const result = UploadUtils.prepareUploadStreams(readable, 'pdf');
+      const result = UploadUtils.prepareUploadStreams(readable, 'pdf', 1024);
 
       expect(result.fileStream).toBe(readable);
       expect(result.thumbnailStream).toBeUndefined();
       expect(result.isThumbnailable).toBe(false);
     });
 
     test('when the file type supports thumbnails, then a piped stream and thumbnail stream are returned', () => {
-      vi.spyOn(ThumbnailUtils, 'isFileThumbnailable').mockReturnValue(true);
+      vi.spyOn(ThumbnailUtils, 'isImageThumbnailable').mockReturnValue(true);
       const readable = Readable.from(['test-data']);
 
-      const result = UploadUtils.prepareUploadStreams(readable, 'jpg');
+      const result = UploadUtils.prepareUploadStreams(readable, 'jpg', 1024);
 
       expect(result.fileStream).not.toBe(readable);
       expect(result.fileStream).toBeInstanceOf(Readable);
       expect(result.thumbnailStream).toBeInstanceOf(BufferStream);
       expect(result.isThumbnailable).toBe(true);
     });
+
+    test('when the file exceeds the max thumbnailable size, then no thumbnail stream is created', () => {
+      const readable = Readable.from(['test-data']);
+      const size = ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES + 1;
+
+      const result = UploadUtils.prepareUploadStreams(readable, 'jpg', size);
+
+      expect(result.fileStream).toBe(readable);
+      expect(result.thumbnailStream).toBeUndefined();
+      expect(result.isThumbnailable).toBe(false);
+    });
+
+    test('when the file size is zero, then no thumbnail stream is created', () => {
+      const readable = Readable.from([]);
+
+      const result = UploadUtils.prepareUploadStreams(readable, 'jpg', 0);
+
+      expect(result.fileStream).toBe(readable);
+      expect(result.thumbnailStream).toBeUndefined();
+      expect(result.isThumbnailable).toBe(false);
+    });
   });
 
   describe('getTimings', () => {