refactor: replace BufferStream with createReadStream for file uploads and update thumbnail handling

Author: larryrider

src/commands/upload-file.ts

@@ -11,7 +11,6 @@ import { EncryptionVersion } from '@internxt/sdk/dist/drive/storage/types';
 import { ThumbnailService } from '../services/thumbnail.service';
 import { AuthService } from '../services/auth.service';
 import { UploadUtils } from '../utils/upload.utils';
-import { BufferStream } from '../utils/stream.utils';
 
 export default class UploadFile extends Command {
   static readonly args = {};
@@ -81,14 +80,11 @@ export default class UploadFile extends Command {
     progressBar?.start(100, 0);
 
     let fileId: string | undefined;
-    let thumbnailStream: BufferStream | undefined;
     const fileSize = stats.size ?? 0;
 
     if (fileSize > 0) {
       // Upload file to the Network
       const readStream = createReadStream(filePath);
-      const preparedStreams = UploadUtils.prepareUploadStreams(readStream, fileType);
-      thumbnailStream = preparedStreams.thumbnailStream;
 
       const progressCallback = (progress: number) => {
         progressBar?.update(progress * 100 * 0.99);
@@ -97,7 +93,7 @@ export default class UploadFile extends Command {
       const abortable = new AbortController();
 
       fileId = await networkFacade.uploadFile({
-        from: preparedStreams.fileStream,
+        from: readStream,
         size: fileSize,
         bucketId: bucket,
         progressCallback,
@@ -128,7 +124,7 @@ export default class UploadFile extends Command {
 
     const thumbnailTimer = CLIUtils.timer();
     await ThumbnailService.instance.tryUploadThumbnail({
-      bufferStream: thumbnailStream,
+      input: filePath,
       fileType,
       bucket,
       fileUuid: createdDriveFile.uuid,

src/services/network/upload/upload-file.service.ts

@@ -11,11 +11,11 @@ import { dirname, extname } from 'node:path';
 import { ErrorUtils } from '../../../utils/errors.utils';
 import { stat } from 'node:fs/promises';
 import { EncryptionVersion } from '@internxt/sdk/dist/drive/storage/types';
-import { BufferStream } from '../../../utils/stream.utils';
 import { DriveFileItem } from '../../../types/drive.types';
 import { CLIUtils } from '../../../utils/cli.utils';
 import { ThumbnailService } from '../../thumbnail.service';
 import { FormatUtils } from '../../../utils/format.utils';
+import { createReadStream } from 'node:fs';
 
 export class UploadFileService {
   static readonly instance = new UploadFileService();
@@ -84,7 +84,6 @@ export class UploadFileService {
         const fileType = extname(file.absolutePath).replaceAll('.', '');
 
         let fileId: string | undefined;
-        let thumbnailStream: BufferStream | undefined;
 
         const timings = {
           networkUpload: 0,
@@ -93,16 +92,12 @@ export class UploadFileService {
         };
 
         if (fileSize > 0) {
-          const { fileStream, bufferStream } = ThumbnailService.instance.createFileStreamWithBuffer({
-            path: file.absolutePath,
-            fileType,
-          });
+          const readStream = createReadStream(file.absolutePath);
 
           const uploadTimer = CLIUtils.timer();
-          thumbnailStream = bufferStream;
 
           fileId = await network.uploadFile({
-            from: fileStream,
+            from: readStream,
             size: fileSize,
             bucketId: bucket,
             progressCallback: () => {},
@@ -125,9 +120,9 @@ export class UploadFileService {
         timings.driveUpload = driveTimer.stop();
 
         const thumbnailTimer = CLIUtils.timer();
-        if (thumbnailStream && fileSize > 0) {
+        if (fileSize > 0) {
           await ThumbnailService.instance.tryUploadThumbnail({
-            bufferStream: thumbnailStream,
+            input: file.absolutePath,
             fileType,
             bucket,
             fileUuid: createdDriveFile.uuid,

src/services/thumbnail.service.ts

@@ -1,10 +1,8 @@
 import { Readable } from 'node:stream';
-import { createReadStream } from 'node:fs';
 import { DriveFileService } from './drive/drive-file.service';
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { NetworkFacade } from './network/network-facade.service';
 import { ThumbnailConfig, ThumbnailUtils } from '../utils/thumbnail.utils';
-import { BufferStream } from '../utils/stream.utils';
 import { ErrorUtils } from '../utils/errors.utils';
 import { AsyncUtils } from '../utils/async.utils';
 
@@ -26,7 +24,7 @@ export class ThumbnailService {
   private static readonly MAX_THUMBNAIL_TIMEOUT = 30000;
 
   public uploadThumbnail = async (
-    fileContent: Buffer,
+    input: string | Buffer,
     fileType: string,
     userBucket: string,
     file_id: string,
@@ -35,7 +33,7 @@ export class ThumbnailService {
   ): Promise<StorageTypes.Thumbnail | undefined> => {
     let thumbnailBuffer: Buffer | undefined;
     if (ThumbnailUtils.isImageThumbnailable(fileType, fileSize)) {
-      thumbnailBuffer = await this.getThumbnailFromImageBuffer(fileContent);
+      thumbnailBuffer = await this.generateThumbnail(input);
     }
     if (thumbnailBuffer) {
       const size = thumbnailBuffer.length;
@@ -61,10 +59,10 @@ export class ThumbnailService {
     }
   };
 
-  private readonly getThumbnailFromImageBuffer = async (buffer: Buffer): Promise<Buffer | undefined> => {
+  private readonly generateThumbnail = async (input: string | Buffer): Promise<Buffer | undefined> => {
     const sharp = await getSharp();
     if (sharp) {
-      return sharp(buffer, { failOn: 'none' })
+      return sharp(input, { failOn: 'none' })
         .resize({
           height: ThumbnailConfig.MaxHeight,
           width: ThumbnailConfig.MaxWidth,
@@ -78,25 +76,24 @@ export class ThumbnailService {
   };
 
   public tryUploadThumbnail = async ({
-    bufferStream,
+    input,
     fileType,
     bucket,
     fileUuid,
     networkFacade,
     size,
   }: {
-    bufferStream?: BufferStream;
+    input?: string | Buffer;
     fileType: string;
     bucket: string;
     fileUuid: string;
     networkFacade: NetworkFacade;
     size: number;
   }) => {
     try {
-      const thumbnailBuffer = bufferStream?.getBuffer();
-      if (thumbnailBuffer && size > 0) {
+      if (input && size > 0) {
         await AsyncUtils.withTimeout(
-          ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, bucket, fileUuid, networkFacade, size),
+          ThumbnailService.instance.uploadThumbnail(input, fileType, bucket, fileUuid, networkFacade, size),
           ThumbnailService.MAX_THUMBNAIL_TIMEOUT,
           'Thumbnail upload timeout',
         );
@@ -105,25 +102,4 @@ export class ThumbnailService {
       ErrorUtils.report(error);
     }
   };
-
-  public createFileStreamWithBuffer = ({
-    path,
-    fileType,
-  }: {
-    path: string;
-    fileType: string;
-  }): {
-    bufferStream?: BufferStream;
-    fileStream: Readable;
-  } => {
-    const readable: Readable = createReadStream(path);
-    if (ThumbnailUtils.isFileThumbnailable(fileType)) {
-      const bufferStream = new BufferStream();
-      return {
-        bufferStream,
-        fileStream: readable.pipe(bufferStream),
-      };
-    }
-    return { fileStream: readable };
-  };
 }

src/webdav/handlers/PUT.handler.ts

@@ -128,7 +128,7 @@ export class PUTRequestHandler implements WebDavMethodHandler {
     const thumbnailTimer = CLIUtils.timer();
     await ThumbnailService.instance.tryUploadThumbnail({
       fileUuid: file.uuid,
-      bufferStream: thumbnailStream,
+      input: thumbnailStream?.getBuffer(),
       fileType,
       bucket,
       networkFacade,

test/services/network/upload/upload-file.service.test.ts

@@ -13,7 +13,6 @@ import {
   createProgressFixtures,
 } from './upload.service.helpers';
 import { newFileItem } from '../../../fixtures/drive.fixture';
-import { ThumbnailUtils } from '../../../../src/utils/thumbnail.utils';
 import { ThumbnailService } from '../../../../src/services/thumbnail.service';
 
 vi.mock('fs', () => ({
@@ -37,12 +36,7 @@ describe('Upload File Service', () => {
     vi.mocked(stat).mockResolvedValue(createMockStats(1024) as Awaited<ReturnType<typeof stat>>);
     vi.mocked(createReadStream).mockReturnValue(createMockReadStream() as ReturnType<typeof createReadStream>);
     vi.spyOn(ErrorUtils, 'isAlreadyExistsError').mockReturnValue(false);
-    vi.spyOn(ThumbnailUtils, 'isFileThumbnailable').mockReturnValue(false);
     vi.spyOn(ThumbnailService.instance, 'tryUploadThumbnail').mockResolvedValue(undefined);
-    vi.spyOn(ThumbnailService.instance, 'createFileStreamWithBuffer').mockReturnValue({
-      fileStream: createMockReadStream() as ReturnType<typeof createReadStream>,
-      bufferStream: undefined,
-    });
     vi.spyOn(DriveFileService.instance, 'createFile').mockResolvedValue(mockFile);
   });
 
@@ -300,14 +294,6 @@ describe('Upload File Service', () => {
     });
 
     test('when a thumbnailable file is uploaded, then a thumbnail is generated', async () => {
-      const mockBufferStream = { getBuffer: vi.fn() };
-      vi.spyOn(ThumbnailService.instance, 'createFileStreamWithBuffer').mockReturnValue({
-        fileStream: createMockReadStream() as ReturnType<typeof createReadStream>,
-        bufferStream: mockBufferStream as unknown as ReturnType<
-          typeof ThumbnailService.instance.createFileStreamWithBuffer
-        >['bufferStream'],
-      });
-
       const file = createFileSystemNodeFixture({
         type: 'file',
         name: 'image.png',
@@ -325,7 +311,7 @@ describe('Upload File Service', () => {
       });
 
       expect(ThumbnailService.instance.tryUploadThumbnail).toHaveBeenCalledWith({
-        bufferStream: mockBufferStream,
+        input: file.absolutePath,
         fileType: 'png',
         bucket,
         fileUuid: mockFile.uuid,

test/services/thumbnail.service.test.ts

@@ -1,28 +1,80 @@
-import { describe, expect, test } from 'vitest';
-import { BufferStream } from '../../src/utils/stream.utils';
+import { afterEach, describe, expect, test, vi } from 'vitest';
 import { ThumbnailService } from '../../src/services/thumbnail.service';
-import path from 'node:path';
-import { Readable } from 'node:stream';
+import { NetworkFacade } from '../../src/services/network/network-facade.service';
 
 describe('Thumbnail Service tests', () => {
-  const testFilePath = path.join(process.cwd(), 'test/fixtures/test-content.fixture.txt');
+  const networkFacade = {} as NetworkFacade;
 
-  describe('createFileStreamWithBuffer', () => {
-    test('when the file has a supported image type, then a buffer stream and file stream are created', () => {
-      const result = ThumbnailService.instance.createFileStreamWithBuffer({ path: testFilePath, fileType: 'png' });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('tryUploadThumbnail', () => {
+    test('when an input is provided and the size is greater than zero, then the thumbnail is uploaded', async () => {
+      const uploadThumbnailSpy = vi.spyOn(ThumbnailService.instance, 'uploadThumbnail').mockResolvedValue(undefined);
+
+      await ThumbnailService.instance.tryUploadThumbnail({
+        input: '/path/to/image.png',
+        fileType: 'png',
+        bucket: 'bucket-id',
+        fileUuid: 'file-uuid',
+        networkFacade,
+        size: 1024,
+      });
+
+      expect(uploadThumbnailSpy).toHaveBeenCalledWith(
+        '/path/to/image.png',
+        'png',
+        'bucket-id',
+        'file-uuid',
+        networkFacade,
+        1024,
+      );
+    });
+
+    test('when no input is provided, then no thumbnail is uploaded', async () => {
+      const uploadThumbnailSpy = vi.spyOn(ThumbnailService.instance, 'uploadThumbnail').mockResolvedValue(undefined);
+
+      await ThumbnailService.instance.tryUploadThumbnail({
+        input: undefined,
+        fileType: 'png',
+        bucket: 'bucket-id',
+        fileUuid: 'file-uuid',
+        networkFacade,
+        size: 1024,
+      });
+
+      expect(uploadThumbnailSpy).not.toHaveBeenCalled();
+    });
+
+    test('when the size is zero, then no thumbnail is uploaded', async () => {
+      const uploadThumbnailSpy = vi.spyOn(ThumbnailService.instance, 'uploadThumbnail').mockResolvedValue(undefined);
+
+      await ThumbnailService.instance.tryUploadThumbnail({
+        input: '/path/to/image.png',
+        fileType: 'png',
+        bucket: 'bucket-id',
+        fileUuid: 'file-uuid',
+        networkFacade,
+        size: 0,
+      });
 
-      expect(result.bufferStream).toBeDefined();
-      expect(result.bufferStream).toBeInstanceOf(BufferStream);
-      expect(result.fileStream).toBeDefined();
-      expect(result.fileStream).toBeInstanceOf(Readable);
+      expect(uploadThumbnailSpy).not.toHaveBeenCalled();
     });
 
-    test('when the file has an unsupported type, then only a file stream is created without buffering', () => {
-      const result = ThumbnailService.instance.createFileStreamWithBuffer({ path: testFilePath, fileType: 'txt' });
+    test('when the thumbnail upload fails, then the error is swallowed', async () => {
+      vi.spyOn(ThumbnailService.instance, 'uploadThumbnail').mockRejectedValue(new Error('upload failed'));
 
-      expect(result.bufferStream).toBeUndefined();
-      expect(result.fileStream).toBeDefined();
-      expect(result.fileStream).toBeInstanceOf(Readable);
+      await expect(
+        ThumbnailService.instance.tryUploadThumbnail({
+          input: '/path/to/image.png',
+          fileType: 'png',
+          bucket: 'bucket-id',
+          fileUuid: 'file-uuid',
+          networkFacade,
+          size: 1024,
+        }),
+      ).resolves.toBeUndefined();
     });
   });
 });