@internxt/cli 1.6.1 → 1.6.3

package/dist/services/network/download.service.d.ts

@@ -1,9 +1,9 @@
 import { DownloadProgressCallback } from '../../types/network.types';
 export declare class DownloadService {
     static readonly instance: DownloadService;
-    downloadFile(url: string, options: {
+    downloadFile: (url: string, options: {
         progressCallback?: DownloadProgressCallback;
         abortController?: AbortController;
         rangeHeader?: string;
-    }): Promise<ReadableStream<Uint8Array>>;
+    }) => Promise<ReadableStream<Uint8Array>>;
 }

package/dist/services/network/download.service.js

@@ -7,7 +7,7 @@ exports.DownloadService = void 0;
 const axios_1 = __importDefault(require("axios"));
 class DownloadService {
     static instance = new DownloadService();
-    async downloadFile(url, options) {
+    downloadFile = async (url, options) => {
         const response = await axios_1.default.get(url, {
             responseType: 'stream',
             onDownloadProgress(progressEvent) {
@@ -30,6 +30,6 @@ class DownloadService {
             },
         });
         return readable;
-    }
+    };
 }
 exports.DownloadService = DownloadService;

package/dist/services/network/network-facade.service.d.ts

@@ -2,17 +2,13 @@ import { Network } from '@internxt/sdk';
 import { Environment } from '@internxt/inxt-js';
 import { Readable } from 'node:stream';
 import { DownloadOptions } from '../../types/network.types';
-import { CryptoService } from '../crypto.service';
-import { DownloadService } from './download.service';
 import { RangeOptions } from '../../utils/network.utils';
 import { ActionState } from '@internxt/inxt-js/build/api';
 export declare class NetworkFacade {
     private readonly network;
     private readonly environment;
-    private readonly downloadService;
-    private readonly cryptoService;
     private readonly cryptoLib;
-    constructor(network: Network.Network, environment: Environment, downloadService: DownloadService, cryptoService: CryptoService);
-    downloadToStream(bucketId: string, mnemonic: string, fileId: string, size: number, to: WritableStream, rangeOptions?: RangeOptions, options?: DownloadOptions): Promise<[Promise<void>, AbortController]>;
-    uploadFile(from: Readable, size: number, bucketId: string, finishedCallback: (err: Error | null, res: string | null) => void, progressCallback: (progress: number) => void): ActionState;
+    constructor(network: Network.Network, environment: Environment);
+    downloadToStream: (bucketId: string, mnemonic: string, fileId: string, size: number, to: WritableStream, rangeOptions?: RangeOptions, options?: DownloadOptions) => Promise<[Promise<void>, AbortController]>;
+    uploadFile: (from: Readable, size: number, bucketId: string, finishedCallback: (err: Error | null, res: string | null) => void, progressCallback: (progress: number) => void) => ActionState;
 }

package/dist/services/network/network-facade.service.js

@@ -38,19 +38,17 @@ const sdk_1 = require("@internxt/sdk");
 const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
 const inxt_js_1 = require("@internxt/inxt-js");
 const node_crypto_1 = require("node:crypto");
+const crypto_service_1 = require("../crypto.service");
+const download_service_1 = require("./download.service");
 const validation_service_1 = require("../validation.service");
 const TWENTY_GIGABYTES = 20 * 1024 * 1024 * 1024;
 class NetworkFacade {
     network;
     environment;
-    downloadService;
-    cryptoService;
     cryptoLib;
-    constructor(network, environment, downloadService, cryptoService) {
+    constructor(network, environment) {
         this.network = network;
         this.environment = environment;
-        this.downloadService = downloadService;
-        this.cryptoService = cryptoService;
         this.cryptoLib = {
             algorithm: sdk_1.Network.ALGORITHMS.AES256CTR,
             validateMnemonic: (mnemonic) => {
@@ -62,7 +60,7 @@ class NetworkFacade {
             randomBytes: node_crypto_1.randomBytes,
         };
     }
-    async downloadToStream(bucketId, mnemonic, fileId, size, to, rangeOptions, options) {
+    downloadToStream = async (bucketId, mnemonic, fileId, size, to, rangeOptions, options) => {
         const encryptedContentStreams = [];
         let fileStream;
         const abortable = options?.abortController ?? new AbortController();
@@ -77,7 +75,7 @@ class NetworkFacade {
             if (rangeOptions) {
                 startOffsetByte = rangeOptions.parsed.start;
             }
-            fileStream = this.cryptoService.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv), startOffsetByte);
+            fileStream = crypto_service_1.CryptoService.instance.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv), startOffsetByte);
             await fileStream.pipeTo(to);
         };
         const downloadFile = async (downloadables) => {
@@ -88,7 +86,7 @@ class NetworkFacade {
                 if (abortable.signal.aborted) {
                     throw new Error('Download aborted');
                 }
-                const encryptedContentStream = await this.downloadService.downloadFile(downloadable.url, {
+                const encryptedContentStream = await download_service_1.DownloadService.instance.downloadFile(downloadable.url, {
                     progressCallback: onProgress,
                     abortController: options?.abortController,
                     rangeHeader: rangeOptions?.range,
@@ -100,8 +98,8 @@ class NetworkFacade {
             await NetworkDownload.downloadFile(fileId, bucketId, mnemonic, this.network, this.cryptoLib, Buffer.from, downloadFile, decryptFile);
         };
         return [downloadOperation(), abortable];
-    }
-    uploadFile(from, size, bucketId, finishedCallback, progressCallback) {
+    };
+    uploadFile = (from, size, bucketId, finishedCallback, progressCallback) => {
         if (size > TWENTY_GIGABYTES) {
             throw new Error('File is too big (more than 20 GB)');
         }
@@ -123,6 +121,6 @@ class NetworkFacade {
                 progressCallback,
             });
         }
-    }
+    };
 }
 exports.NetworkFacade = NetworkFacade;

package/dist/services/network/upload/upload-facade.service.d.ts

@@ -1,7 +1,7 @@
 import { UploadFolderParams } from './upload.types';
 export declare class UploadFacade {
     static readonly instance: UploadFacade;
-    uploadFolder({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, onProgress }: UploadFolderParams): Promise<{
+    uploadFolder: ({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, debugMode, onProgress, reporter, }: UploadFolderParams) => Promise<{
         totalBytes: number;
         rootFolderId: string;
         uploadTimeMs: number;

package/dist/services/network/upload/upload-facade.service.js

@@ -3,18 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UploadFacade = void 0;
 const node_path_1 = require("node:path");
 const cli_utils_1 = require("../../../utils/cli.utils");
-const logger_utils_1 = require("../../../utils/logger.utils");
 const local_filesystem_service_1 = require("../../local-filesystem/local-filesystem.service");
 const upload_folder_service_1 = require("./upload-folder.service");
 const upload_file_service_1 = require("./upload-file.service");
 const async_utils_1 = require("../../../utils/async.utils");
 class UploadFacade {
     static instance = new UploadFacade();
-    async uploadFolder({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, onProgress }) {
+    uploadFolder = async ({ localPath, destinationFolderUuid, loginUserDetails, jsonFlag, debugMode, onProgress, reporter, }) => {
         const timer = cli_utils_1.CLIUtils.timer();
-        const network = cli_utils_1.CLIUtils.prepareNetwork({ jsonFlag, loginUserDetails });
+        cli_utils_1.CLIUtils.doing('Preparing Network', jsonFlag);
+        const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(loginUserDetails);
+        cli_utils_1.CLIUtils.done(jsonFlag);
         const scanResult = await local_filesystem_service_1.LocalFilesystemService.instance.scanLocalDirectory(localPath);
-        logger_utils_1.logger.info(`Scanned folder ${localPath}: found ${scanResult.totalItems} items, total size ${scanResult.totalBytes} bytes.`);
+        if (debugMode) {
+            cli_utils_1.CLIUtils.success(reporter, `Scanned folder ${localPath}: found ${scanResult.totalItems} items, total size ${scanResult.totalBytes} bytes.`);
+        }
         const currentProgress = { itemsUploaded: 0, bytesUploaded: 0 };
         const emitProgress = () => {
             const itemProgress = currentProgress.itemsUploaded / scanResult.totalItems;
@@ -27,19 +30,23 @@ class UploadFacade {
             destinationFolderUuid,
             currentProgress,
             emitProgress,
+            reporter,
+            debugMode,
         });
         if (folderMap.size === 0) {
             throw new Error('Failed to create folders, cannot upload files');
         }
         await async_utils_1.AsyncUtils.sleep(500);
-        const totalBytes = await upload_file_service_1.UploadFileService.instance.uploadFilesInChunks({
-            network,
+        const totalBytes = await upload_file_service_1.UploadFileService.instance.uploadFilesConcurrently({
+            network: networkFacade,
             filesToUpload: scanResult.files,
             folderMap,
-            bucket: loginUserDetails.bucket,
+            bucket,
             destinationFolderUuid,
             currentProgress,
             emitProgress,
+            debugMode,
+            reporter,
         });
         const rootFolderName = (0, node_path_1.basename)(localPath);
         const rootFolderId = folderMap.get(rootFolderName) ?? '';
@@ -48,6 +55,6 @@ class UploadFacade {
             rootFolderId,
             uploadTimeMs: timer.stop(),
         };
-    }
+    };
 }
 exports.UploadFacade = UploadFacade;

package/dist/services/network/upload/upload-file.service.d.ts

@@ -1,7 +1,8 @@
-import { UploadFilesInBatchesParams, UploadFileWithRetryParams } from './upload.types';
+import { UploadFilesConcurrentlyParams, UploadFileWithRetryParams } from './upload.types';
+import { DriveFileItem } from '../../../types/drive.types';
 export declare class UploadFileService {
     static readonly instance: UploadFileService;
-    uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }: UploadFilesInBatchesParams): Promise<number>;
-    uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }: UploadFileWithRetryParams): Promise<string | null>;
-    private chunkArray;
+    uploadFilesConcurrently: ({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }: UploadFilesConcurrentlyParams) => Promise<number>;
+    uploadFileWithRetry: ({ file, network, bucket, parentFolderUuid, debugMode, reporter, }: UploadFileWithRetryParams) => Promise<DriveFileItem | null>;
+    private readonly concurrencyArray;
 }

package/dist/services/network/upload/upload-file.service.js

@@ -8,18 +8,21 @@ const node_path_1 = require("node:path");
 const errors_utils_1 = require("../../../utils/errors.utils");
 const promises_1 = require("node:fs/promises");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
-const thumbnail_utils_1 = require("../../../utils/thumbnail.utils");
+const cli_utils_1 = require("../../../utils/cli.utils");
+const thumbnail_service_1 = require("../../thumbnail.service");
 class UploadFileService {
     static instance = new UploadFileService();
-    async uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+    uploadFilesConcurrently = async ({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }) => {
         let bytesUploaded = 0;
-        const chunks = this.chunkArray(filesToUpload, upload_types_1.MAX_CONCURRENT_UPLOADS);
-        for (const chunk of chunks) {
-            await Promise.allSettled(chunk.map(async (file) => {
+        const concurrentFiles = this.concurrencyArray(filesToUpload, upload_types_1.MAX_CONCURRENT_UPLOADS);
+        for (const fileArray of concurrentFiles) {
+            await Promise.allSettled(fileArray.map(async (file) => {
                 const parentPath = (0, node_path_1.dirname)(file.relativePath);
                 const parentFolderUuid = parentPath === '.' || parentPath === '' ? destinationFolderUuid : folderMap.get(parentPath);
                 if (!parentFolderUuid) {
-                    logger_utils_1.logger.warn(`Parent folder not found for ${file.relativePath}, skipping...`);
+                    if (debugMode) {
+                        cli_utils_1.CLIUtils.warning(reporter, `Parent folder not found for ${file.relativePath}, skipping...`);
+                    }
                     return null;
                 }
                 const createdFileUuid = await this.uploadFileWithRetry({
@@ -27,6 +30,8 @@ class UploadFileService {
                     network,
                     bucket,
                     parentFolderUuid,
+                    debugMode,
+                    reporter,
                 });
                 if (createdFileUuid) {
                     bytesUploaded += file.size;
@@ -37,32 +42,42 @@ class UploadFileService {
             }));
         }
         return bytesUploaded;
-    }
-    async uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }) {
+    };
+    uploadFileWithRetry = async ({ file, network, bucket, parentFolderUuid, debugMode, reporter, }) => {
         for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
             try {
                 const stats = await (0, promises_1.stat)(file.absolutePath);
-                if (!stats.size) {
-                    logger_utils_1.logger.warn(`Skipping empty file: ${file.relativePath}`);
-                    return null;
-                }
+                const fileSize = stats.size ?? 0;
                 const fileType = (0, node_path_1.extname)(file.absolutePath).replaceAll('.', '');
-                const { fileStream, bufferStream } = (0, thumbnail_utils_1.createFileStreamWithBuffer)({
-                    path: file.absolutePath,
-                    fileType,
-                });
-                const fileId = await new Promise((resolve, reject) => {
-                    network.uploadFile(fileStream, stats.size, bucket, (err, res) => {
-                        if (err) {
-                            return reject(err);
-                        }
-                        resolve(res);
-                    }, () => { });
-                });
+                let fileId;
+                let thumbnailStream;
+                const timings = {
+                    networkUpload: 0,
+                    driveUpload: 0,
+                    thumbnailUpload: 0,
+                };
+                if (fileSize > 0) {
+                    const { fileStream, bufferStream } = thumbnail_service_1.ThumbnailService.instance.createFileStreamWithBuffer({
+                        path: file.absolutePath,
+                        fileType,
+                    });
+                    const uploadTimer = cli_utils_1.CLIUtils.timer();
+                    thumbnailStream = bufferStream;
+                    fileId = await new Promise((resolve, reject) => {
+                        network.uploadFile(fileStream, fileSize, bucket, (err, res) => {
+                            if (err) {
+                                return reject(err);
+                            }
+                            resolve(res);
+                        }, () => { });
+                    });
+                    timings.networkUpload = uploadTimer.stop();
+                }
+                const driveTimer = cli_utils_1.CLIUtils.timer();
                 const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
                     plainName: file.name,
                     type: fileType,
-                    size: stats.size,
+                    size: fileSize,
                     folderUuid: parentFolderUuid,
                     fileId,
                     bucket,
@@ -70,43 +85,60 @@ class UploadFileService {
                     creationTime: stats.birthtime?.toISOString(),
                     modificationTime: stats.mtime?.toISOString(),
                 });
-                if (bufferStream) {
-                    void (0, thumbnail_utils_1.tryUploadThumbnail)({
-                        bufferStream,
+                timings.driveUpload = driveTimer.stop();
+                const thumbnailTimer = cli_utils_1.CLIUtils.timer();
+                if (thumbnailStream && fileSize > 0) {
+                    await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
+                        bufferStream: thumbnailStream,
                         fileType,
-                        userBucket: bucket,
+                        bucket,
                         fileUuid: createdDriveFile.uuid,
                         networkFacade: network,
+                        size: fileSize,
                     });
                 }
-                return createdDriveFile.fileId;
+                timings.thumbnailUpload = thumbnailTimer.stop();
+                if (debugMode) {
+                    const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+                    const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
+                    cli_utils_1.CLIUtils.success(reporter, `Uploaded '${file.name}' (${cli_utils_1.CLIUtils.formatBytesToString(stats.size)})`);
+                    cli_utils_1.CLIUtils.log(reporter, 'Timing breakdown:\n' +
+                        `Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)}` +
+                        ` (${throughputMBps.toFixed(2)} MB/s)\n` +
+                        `Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n` +
+                        `Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n` +
+                        `Total: ${cli_utils_1.CLIUtils.formatDuration(totalTime)}\n`);
+                }
+                return createdDriveFile;
             }
             catch (error) {
-                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                if (errors_utils_1.ErrorUtils.isAlreadyExistsError(error)) {
                     const msg = `File ${file.name} already exists, skipping...`;
                     logger_utils_1.logger.info(msg);
                     return null;
                 }
                 if (attempt < upload_types_1.MAX_RETRIES) {
                     const delay = upload_types_1.DELAYS_MS[attempt];
-                    const retryMsg = `Failed to upload file ${file.name}, retrying in ${delay}ms...`;
-                    logger_utils_1.logger.warn(`${retryMsg} (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    if (debugMode) {
+                        const retryMsg = `Failed to upload file ${file.name}, retrying in ${delay}ms...`;
+                        cli_utils_1.CLIUtils.warning(reporter, `${retryMsg} (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    }
                     await new Promise((resolve) => setTimeout(resolve, delay));
                 }
                 else {
-                    logger_utils_1.logger.error(`Failed to upload file ${file.name} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    cli_utils_1.CLIUtils.error(reporter, `Failed to upload file '${file.name}' after ${upload_types_1.MAX_RETRIES + 1} attempts`);
                     return null;
                 }
             }
         }
         return null;
-    }
-    chunkArray(array, chunkSize) {
-        const chunks = [];
-        for (let i = 0; i < array.length; i += chunkSize) {
-            chunks.push(array.slice(i, i + chunkSize));
+    };
+    concurrencyArray = (array, arraySize) => {
+        const arrays = [];
+        for (let i = 0; i < array.length; i += arraySize) {
+            arrays.push(array.slice(i, i + arraySize));
         }
-        return chunks;
-    }
+        return arrays;
+    };
 }
 exports.UploadFileService = UploadFileService;

package/dist/services/network/upload/upload-folder.service.d.ts

@@ -1,6 +1,6 @@
 import { CreateFoldersParams, CreateFolderWithRetryParams } from './upload.types';
 export declare class UploadFolderService {
     static readonly instance: UploadFolderService;
-    createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }: CreateFoldersParams): Promise<Map<string, string>>;
-    createFolderWithRetry({ folderName, parentFolderUuid }: CreateFolderWithRetryParams): Promise<string | null>;
+    createFolders: ({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }: CreateFoldersParams) => Promise<Map<string, string>>;
+    createFolderWithRetry: ({ folderName, parentFolderUuid, debugMode, reporter, }: CreateFolderWithRetryParams) => Promise<string | null>;
 }

package/dist/services/network/upload/upload-folder.service.js

@@ -6,9 +6,10 @@ const errors_utils_1 = require("../../../utils/errors.utils");
 const logger_utils_1 = require("../../../utils/logger.utils");
 const drive_folder_service_1 = require("../../drive/drive-folder.service");
 const upload_types_1 = require("./upload.types");
+const cli_utils_1 = require("../../../utils/cli.utils");
 class UploadFolderService {
     static instance = new UploadFolderService();
-    async createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }) {
+    createFolders = async ({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }) => {
         const folderMap = new Map();
         for (const folder of foldersToCreate) {
             const parentPath = (0, node_path_1.dirname)(folder.relativePath);
@@ -20,6 +21,8 @@ class UploadFolderService {
             const createdFolderUuid = await this.createFolderWithRetry({
                 folderName: folder.name,
                 parentFolderUuid: parentUuid,
+                debugMode,
+                reporter,
             });
             if (createdFolderUuid) {
                 folderMap.set(folder.relativePath, createdFolderUuid);
@@ -28,11 +31,11 @@ class UploadFolderService {
             }
         }
         return folderMap;
-    }
-    async createFolderWithRetry({ folderName, parentFolderUuid }) {
+    };
+    createFolderWithRetry = async ({ folderName, parentFolderUuid, debugMode, reporter, }) => {
         for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
             try {
-                const [createFolderPromise] = drive_folder_service_1.DriveFolderService.instance.createFolder({
+                const [createFolderPromise] = await drive_folder_service_1.DriveFolderService.instance.createFolder({
                     plainName: folderName,
                     parentFolderUuid,
                 });
@@ -40,23 +43,25 @@ class UploadFolderService {
                 return createdFolder.uuid;
             }
             catch (error) {
-                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
-                    logger_utils_1.logger.info(`Folder ${folderName} already exists, skipping...`);
+                if (errors_utils_1.ErrorUtils.isAlreadyExistsError(error)) {
+                    logger_utils_1.logger.warn(`Folder ${folderName} already exists, skipping...`);
                     return null;
                 }
                 if (attempt < upload_types_1.MAX_RETRIES) {
                     const delay = upload_types_1.DELAYS_MS[attempt];
-                    logger_utils_1.logger.warn(`Failed to create folder ${folderName},
-                retrying in ${delay}ms... (attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    if (debugMode) {
+                        cli_utils_1.CLIUtils.warning(reporter, `Failed to create folder '${folderName}', retrying in ${delay}ms... ` +
+                            `(attempt ${attempt + 1}/${upload_types_1.MAX_RETRIES + 1})`);
+                    }
                     await new Promise((resolve) => setTimeout(resolve, delay));
                 }
                 else {
-                    logger_utils_1.logger.error(`Failed to create folder ${folderName} after ${upload_types_1.MAX_RETRIES + 1} attempts`);
+                    cli_utils_1.CLIUtils.error(reporter, `Failed to create folder '${folderName}' after ${upload_types_1.MAX_RETRIES + 1} attempts`);
                     throw error;
                 }
             }
         }
         return null;
-    }
+    };
 }
 exports.UploadFolderService = UploadFolderService;

package/dist/services/network/upload/upload.types.d.ts

@@ -1,4 +1,5 @@
 import { LoginUserDetails } from '../../../types/command.types';
+import { LogReporter } from '../../../utils/cli.utils';
 import { FileSystemNode } from '../../local-filesystem/local-filesystem.types';
 import { NetworkFacade } from '../network-facade.service';
 export interface UploadResult {
@@ -12,6 +13,8 @@ export interface UploadFolderParams {
     loginUserDetails: LoginUserDetails;
     jsonFlag?: boolean;
     onProgress: (progress: UploadProgress) => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface UploadProgress {
     percentage: number;
@@ -25,12 +28,16 @@ export interface CreateFoldersParams {
         bytesUploaded: number;
     };
     emitProgress: () => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface CreateFolderWithRetryParams {
     folderName: string;
     parentFolderUuid: string;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
-export interface UploadFilesInBatchesParams {
+export interface UploadFilesConcurrentlyParams {
     network: NetworkFacade;
     filesToUpload: FileSystemNode[];
     folderMap: Map<string, string>;
@@ -41,13 +48,17 @@ export interface UploadFilesInBatchesParams {
         bytesUploaded: number;
     };
     emitProgress: () => void;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
 export interface UploadFileWithRetryParams {
     file: FileSystemNode;
     network: NetworkFacade;
     bucket: string;
     parentFolderUuid: string;
+    debugMode: boolean;
+    reporter: LogReporter;
 }
-export declare const MAX_CONCURRENT_UPLOADS = 5;
+export declare const MAX_CONCURRENT_UPLOADS = 10;
 export declare const DELAYS_MS: number[];
 export declare const MAX_RETRIES = 2;

package/dist/services/network/upload/upload.types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MAX_RETRIES = exports.DELAYS_MS = exports.MAX_CONCURRENT_UPLOADS = void 0;
-exports.MAX_CONCURRENT_UPLOADS = 5;
+exports.MAX_CONCURRENT_UPLOADS = 10;
 exports.DELAYS_MS = [500, 1000, 2000];
 exports.MAX_RETRIES = 2;

package/dist/services/sdk-manager.service.d.ts

@@ -1,22 +1,24 @@
 import { Auth, Drive, Network as NetworkModule } from '@internxt/sdk';
 import { ApiSecurity, AppDetails } from '@internxt/sdk/dist/shared';
+import { Workspaces } from '@internxt/sdk/dist/workspaces';
 export type SdkManagerApiSecurity = ApiSecurity;
 export declare class SdkManager {
     static readonly instance: SdkManager;
     private static apiSecurity?;
     static readonly init: (apiSecurity: SdkManagerApiSecurity) => void;
     static readonly clean: () => void;
-    static readonly getApiSecurity: (config?: {
-        throwErrorOnMissingCredentials: boolean;
+    static readonly getApiSecurity: ({ throwErrorOnMissingCredentials }?: {
+        throwErrorOnMissingCredentials?: boolean | undefined;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
-    getAuth(): Auth;
-    getUsers(): Drive.Users;
-    getStorage(): Drive.Storage;
-    getTrash(): Drive.Trash;
-    getShare(): Drive.Share;
-    getNetwork(credentials: {
+    getAuth: () => Auth;
+    getUsers: () => Drive.Users;
+    getStorage: () => Drive.Storage;
+    getTrash: () => Drive.Trash;
+    getShare: () => Drive.Share;
+    getWorkspaces: () => Workspaces;
+    getNetwork: (credentials: {
         user: string;
         pass: string;
-    }): NetworkModule.Network;
+    }) => NetworkModule.Network;
 }

package/dist/services/sdk-manager.service.js

@@ -9,17 +9,25 @@ const drive_1 = require("@internxt/sdk/dist/drive");
 const config_service_1 = require("./config.service");
 const package_json_1 = __importDefault(require("../../package.json"));
 const network_utils_1 = require("../utils/network.utils");
+const workspaces_1 = require("@internxt/sdk/dist/workspaces");
+const MAX_RETRIES = 3;
 class SdkManager {
     static instance = new SdkManager();
     static apiSecurity;
     static init = (apiSecurity) => {
-        SdkManager.apiSecurity = apiSecurity;
+        const newApiSecurity = {
+            ...apiSecurity,
+            retryOptions: {
+                maxRetries: MAX_RETRIES,
+            },
+        };
+        SdkManager.apiSecurity = newApiSecurity;
     };
     static clean = () => {
         SdkManager.apiSecurity = undefined;
     };
-    static getApiSecurity = (config = { throwErrorOnMissingCredentials: true }) => {
-        if (!SdkManager.apiSecurity && config.throwErrorOnMissingCredentials)
+    static getApiSecurity = ({ throwErrorOnMissingCredentials = true } = {}) => {
+        if (!SdkManager.apiSecurity && throwErrorOnMissingCredentials)
             throw new Error('Api security properties not found in SdkManager');
         return SdkManager.apiSecurity;
     };
@@ -30,37 +38,43 @@ class SdkManager {
             desktopHeader: config_service_1.ConfigService.instance.get('DESKTOP_HEADER'),
         };
     };
-    getAuth() {
+    getAuth = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Auth.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getUsers() {
+    };
+    getUsers = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getStorage() {
+    };
+    getStorage = () => {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getTrash() {
+    };
+    getTrash = () => {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
-    }
-    getShare() {
+    };
+    getShare = () => {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
-    }
-    getNetwork(credentials) {
+    };
+    getWorkspaces = () => {
+        const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
+        const apiSecurity = SdkManager.getApiSecurity();
+        const appDetails = SdkManager.getAppDetails();
+        return workspaces_1.Workspaces.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
+    };
+    getNetwork = (credentials) => {
         const appDetails = SdkManager.getAppDetails();
         const auth = network_utils_1.NetworkUtils.getAuthFromCredentials({
             user: credentials.user,
@@ -70,6 +84,6 @@ class SdkManager {
             bridgeUser: auth.username,
             userId: auth.password,
         });
-    }
+    };
 }
 exports.SdkManager = SdkManager;