refactor(upload): streamline file upload process and rename methods for clarity

Author: larryrider

src/commands/upload-file.ts

@@ -83,37 +83,18 @@ export default class UploadFile extends Command {
     });
     progressBar.start(100, 0);
 
-    const minimumMultipartThreshold = 100 * 1024 * 1024;
-    const useMultipart = stats.size > minimumMultipartThreshold;
-    const partSize = 30 * 1024 * 1024;
-    const parts = Math.ceil(stats.size / partSize);
-
-    let uploadOperation: Promise<
-      [
-        Promise<{
-          fileId: string;
-          hash: Buffer;
-        }>,
-        AbortController,
-      ]
-    >;
-
-    if (useMultipart) {
-      uploadOperation = networkFacade.uploadMultipartFromStream(user.bucket, user.mnemonic, stats.size, fileStream, {
-        parts,
-        progressCallback: (progress) => {
-          progressBar.update(progress * 0.99);
-        },
-      });
-    } else {
-      uploadOperation = networkFacade.uploadFromStream(user.bucket, user.mnemonic, stats.size, fileStream, {
-        progressCallback: (progress) => {
-          progressBar.update(progress * 0.99);
-        },
-      });
-    }
-
-    const [uploadPromise, abortable] = await uploadOperation;
+    const progressCallback = (progress: number) => {
+      progressBar.update(progress * 0.99);
+    };
+
+    const [uploadPromise, abortable] = await UploadService.instance.uploadFileStream(
+      fileStream,
+      user.bucket,
+      user.mnemonic,
+      stats.size,
+      networkFacade,
+      progressCallback,
+    );
 
     process.on('SIGINT', () => {
       abortable.abort('SIGINT received');

src/services/network/network-facade.service.ts

@@ -165,7 +165,7 @@ export class NetworkFacade {
     };
 
     const uploadFile: UploadFileFunction = async (url) => {
-      await this.uploadService.uploadFile(url, encryptionTransform, {
+      await this.uploadService.uploadFileToNetwork(url, encryptionTransform, {
         abortController: abortable,
         progressCallback: onProgress,
       });
@@ -244,7 +244,7 @@ export class NetworkFacade {
       const limitConcurrency = 6;
 
       const uploadPart = async (upload: UploadTask) => {
-        const { etag } = await this.uploadService.uploadFile(upload.urlToUpload, upload.contentToUpload, {
+        const { etag } = await this.uploadService.uploadFileToNetwork(upload.urlToUpload, upload.contentToUpload, {
           abortController: abortable,
           progressCallback: (loadedBytes: number) => {
             onProgress(upload.index, loadedBytes);

src/services/network/upload.service.ts

@@ -1,11 +1,16 @@
 import { Readable } from 'node:stream';
 import axios from 'axios';
 import { UploadOptions } from '../../types/network.types';
+import { NetworkFacade } from './network-facade.service';
 
 export class UploadService {
   public static readonly instance: UploadService = new UploadService();
 
-  async uploadFile(url: string, from: Readable | Buffer, options: UploadOptions): Promise<{ etag: string }> {
+  public uploadFileToNetwork = async (
+    url: string,
+    from: Readable | Buffer,
+    options: UploadOptions,
+  ): Promise<{ etag: string }> => {
     const response = await axios.put(url, from, {
       signal: options.abortController?.signal,
       onUploadProgress: (progressEvent) => {
@@ -20,5 +25,44 @@ export class UploadService {
       throw new Error('Missing Etag in response when uploading file');
     }
     return { etag };
-  }
+  };
+
+  public uploadFileStream = async (
+    fileStream: Readable,
+    userBucket: string,
+    userMnemonic: string,
+    fileSize: number,
+    networkFacade: NetworkFacade,
+    progressCallback?: (progress: number) => void,
+  ) => {
+    const minimumMultipartThreshold = 100 * 1024 * 1024;
+    const useMultipart = fileSize > minimumMultipartThreshold;
+    const partSize = 30 * 1024 * 1024;
+    const parts = Math.ceil(fileSize / partSize);
+
+    let uploadOperation: Promise<
+      [
+        Promise<{
+          fileId: string;
+          hash: Buffer;
+        }>,
+        AbortController,
+      ]
+    >;
+
+    if (useMultipart) {
+      uploadOperation = networkFacade.uploadMultipartFromStream(userBucket, userMnemonic, fileSize, fileStream, {
+        parts,
+        progressCallback,
+      });
+    } else {
+      uploadOperation = networkFacade.uploadFromStream(userBucket, userMnemonic, fileSize, fileStream, {
+        progressCallback,
+      });
+    }
+
+    const uploadFileOperation = await uploadOperation;
+
+    return uploadFileOperation;
+  };
 }

src/types/network.types.ts

@@ -6,7 +6,7 @@ export interface NetworkCredentials {
 export type DownloadProgressCallback = (downloadedBytes: number) => void;
 export type UploadProgressCallback = (uploadedBytes: number) => void;
 export interface NetworkOperationBaseOptions {
-  progressCallback: UploadProgressCallback;
+  progressCallback?: UploadProgressCallback;
   abortController?: AbortController;
 }
 

src/webdav/handlers/PUT.handler.ts

@@ -12,6 +12,7 @@ import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { TrashService } from '../../services/drive/trash.service';
 import { EncryptionVersion } from '@internxt/sdk/dist/drive/storage/types';
 import { CLIUtils } from '../../utils/cli.utils';
+import { UploadService } from '../../services/network/upload.service';
 
 export class PUTRequestHandler implements WebDavMethodHandler {
   constructor(
@@ -71,37 +72,18 @@ export class PUTRequestHandler implements WebDavMethodHandler {
 
     const timer = CLIUtils.timer();
 
-    const minimumMultipartThreshold = 100 * 1024 * 1024;
-    const useMultipart = contentLength > minimumMultipartThreshold;
-    const partSize = 30 * 1024 * 1024;
-    const parts = Math.ceil(contentLength / partSize);
-
-    let uploadOperation: Promise<
-      [
-        Promise<{
-          fileId: string;
-          hash: Buffer;
-        }>,
-        AbortController,
-      ]
-    >;
-
     const progressCallback = (progress: number) => {
       webdavLogger.info(`[PUT] Upload progress for file ${resource.name}: ${progress}%`);
     };
 
-    if (useMultipart) {
-      uploadOperation = networkFacade.uploadMultipartFromStream(user.bucket, user.mnemonic, contentLength, req, {
-        parts,
-        progressCallback,
-      });
-    } else {
-      uploadOperation = networkFacade.uploadFromStream(user.bucket, user.mnemonic, contentLength, req, {
-        progressCallback,
-      });
-    }
-
-    const [uploadPromise, abortable] = await uploadOperation;
+    const [uploadPromise, abortable] = await UploadService.instance.uploadFileStream(
+      req,
+      user.bucket,
+      user.mnemonic,
+      contentLength,
+      networkFacade,
+      progressCallback,
+    );
 
     let uploaded = false;
     res.on('close', () => {

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

@@ -28,7 +28,7 @@ describe('Upload Service', () => {
     nock('https://example.com').put('/upload').reply(200, '', {});
 
     try {
-      await sut.uploadFile(url, data, options);
+      await sut.uploadFileToNetwork(url, data, options);
     } catch (error) {
       expect((error as Error).message).to.contain('Missing Etag');
     }
@@ -52,7 +52,7 @@ describe('Upload Service', () => {
       etag: 'test-etag',
     });
 
-    const result = await sut.uploadFile(url, data, options);
+    const result = await sut.uploadFileToNetwork(url, data, options);
     expect(result.etag).to.be.equal('test-etag');
   });
 
@@ -74,7 +74,7 @@ describe('Upload Service', () => {
       etag: 'test-etag',
     });
 
-    await sut.uploadFile(url, data, options);
+    await sut.uploadFileToNetwork(url, data, options);
     expect(options.progressCallback).toHaveBeenCalledWith(file.length);
   });