@internxt/cli 1.6.0 → 1.6.1

package/dist/commands/trash-restore-file.d.ts

@@ -5,9 +5,9 @@ export default class TrashRestoreFile extends Command {
     static readonly aliases: string[];
     static readonly examples: string[];
     static readonly flags: {
-        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly enableJsonFlag = true;
     run: () => Promise<{
@@ -16,7 +16,7 @@ export default class TrashRestoreFile extends Command {
         file: {
             id: number;
             uuid: string;
-            fileId: string;
+            fileId: string | null;
             name: string;
             type: string;
             size: string;

package/dist/commands/trash-restore-folder.d.ts

@@ -5,9 +5,9 @@ export default class TrashRestoreFolder extends Command {
     static readonly aliases: string[];
     static readonly examples: string[];
     static readonly flags: {
-        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        id: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly enableJsonFlag = true;
     run: () => Promise<{

package/dist/commands/upload-file.d.ts

@@ -5,9 +5,9 @@ export default class UploadFile extends Command {
     static readonly aliases: string[];
     static readonly examples: string[];
     static readonly flags: {
-        file: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        destination: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly enableJsonFlag = true;
     run: () => Promise<{
@@ -15,14 +15,14 @@ export default class UploadFile extends Command {
         message: string;
         file: {
             plainName: string;
+            status: "EXISTS" | "TRASHED" | "DELETED";
             name: string;
             id: number;
             uuid: string;
+            fileId: string | null;
             bucket: string;
-            folderUuid: string;
             folderId: number;
-            status: "EXISTS" | "TRASHED" | "DELETED";
-            fileId: string;
+            folderUuid: string;
             itemType: "file";
             size: number;
             createdAt: Date;
@@ -33,6 +33,5 @@ export default class UploadFile extends Command {
         };
     }>;
     catch: (error: Error) => Promise<never>;
-    private getDestinationFolderUuid;
     private getFilePath;
 }

package/dist/commands/upload-file.js

@@ -6,15 +6,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const promises_1 = require("node:fs/promises");
 const node_fs_1 = require("node:fs");
-const network_facade_service_1 = require("../services/network/network-facade.service");
-const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const auth_service_1 = require("../services/auth.service");
 const cli_utils_1 = require("../utils/cli.utils");
 const config_service_1 = require("../services/config.service");
 const node_path_1 = __importDefault(require("node:path"));
 const drive_file_service_1 = require("../services/drive/drive-file.service");
-const crypto_service_1 = require("../services/crypto.service");
-const download_service_1 = require("../services/network/download.service");
 const errors_utils_1 = require("../utils/errors.utils");
 const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("../services/validation.service");
@@ -22,7 +18,6 @@ const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const thumbnail_service_1 = require("../services/thumbnail.service");
 const stream_utils_1 = require("../utils/stream.utils");
 const thumbnail_utils_1 = require("../utils/thumbnail.utils");
-const inxt_js_1 = require("@internxt/inxt-js");
 class UploadFile extends core_1.Command {
     static args = {};
     static description = 'Upload a file to Internxt Drive';
@@ -54,24 +49,13 @@ class UploadFile extends core_1.Command {
         }
         const fileInfo = node_path_1.default.parse(filePath);
         const fileType = fileInfo.ext.replaceAll('.', '');
-        let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
-        if (destinationFolderUuid.trim().length === 0) {
-            destinationFolderUuid = user.rootFolderId;
-        }
-        cli_utils_1.CLIUtils.doing('Preparing Network', flags['json']);
-        const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
-            user: user.bridgeUser,
-            pass: user.userId,
-        });
-        const environment = new inxt_js_1.Environment({
-            bridgeUser: user.bridgeUser,
-            bridgePass: user.userId,
-            bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
-            encryptionKey: user.mnemonic,
-            appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
-        });
-        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
-        cli_utils_1.CLIUtils.done(flags['json']);
+        const destinationFolderUuid = (await cli_utils_1.CLIUtils.getDestinationFolderUuid({
+            destinationFolderUuidFlag: flags['destination'],
+            destinationFlagName: UploadFile.flags['destination'].name,
+            nonInteractive,
+            reporter: this.log.bind(this),
+        })) ?? user.rootFolderId;
+        const networkFacade = await cli_utils_1.CLIUtils.prepareNetwork({ loginUserDetails: user, jsonFlag: flags['json'] });
         const readStream = (0, node_fs_1.createReadStream)(filePath);
         const timer = cli_utils_1.CLIUtils.timer();
         const progressBar = cli_utils_1.CLIUtils.progress({
@@ -148,23 +132,6 @@ class UploadFile extends core_1.Command {
         });
         this.exit(1);
     };
-    getDestinationFolderUuid = async (destinationFolderUuidFlag, nonInteractive) => {
-        const destinationFolderUuid = await cli_utils_1.CLIUtils.getValueFromFlag({
-            value: destinationFolderUuidFlag,
-            name: UploadFile.flags['destination'].name,
-        }, {
-            nonInteractive,
-            prompt: {
-                message: 'What is the destination folder id? (leave empty for the root folder)',
-                options: { type: 'input' },
-            },
-        }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
-            error: new command_types_1.NotValidFolderUuidError(),
-            canBeEmpty: true,
-        }, this.log.bind(this));
-        return destinationFolderUuid;
-    };
     getFilePath = async (fileFlag, nonInteractive) => {
         const filePath = await cli_utils_1.CLIUtils.getValueFromFlag({
             value: fileFlag,

package/dist/commands/upload-folder.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class UploadFolder extends Command {
+    static readonly args: {};
+    static readonly description = "Upload a folder to Internxt Drive";
+    static readonly aliases: string[];
+    static readonly examples: string[];
+    static readonly flags: {
+        folder: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static readonly enableJsonFlag = true;
+    run: () => Promise<void>;
+    catch: (error: Error) => Promise<never>;
+    private getFolderPath;
+}

package/dist/commands/upload-folder.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const cli_utils_1 = require("../utils/cli.utils");
+const auth_service_1 = require("../services/auth.service");
+const validation_service_1 = require("../services/validation.service");
+const config_service_1 = require("../services/config.service");
+const upload_facade_service_1 = require("../services/network/upload/upload-facade.service");
+const command_types_1 = require("../types/command.types");
+class UploadFolder extends core_1.Command {
+    static args = {};
+    static description = 'Upload a folder to Internxt Drive';
+    static aliases = ['upload:folder'];
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        ...cli_utils_1.CLIUtils.CommonFlags,
+        folder: core_1.Flags.string({
+            char: 'f',
+            description: 'The path to the folder on your system.',
+            required: false,
+        }),
+        destination: core_1.Flags.string({
+            char: 'i',
+            description: 'The folder id where the folder is going to be uploaded to. Leave empty for the root folder.',
+            required: false,
+            parse: cli_utils_1.CLIUtils.parseEmpty,
+        }),
+    };
+    static enableJsonFlag = true;
+    run = async () => {
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        const { flags } = await this.parse(UploadFolder);
+        const localPath = await this.getFolderPath(flags['folder'], flags['non-interactive']);
+        const destinationFolderUuid = (await cli_utils_1.CLIUtils.getDestinationFolderUuid({
+            destinationFolderUuidFlag: flags['destination'],
+            destinationFlagName: UploadFolder.flags['destination'].name,
+            nonInteractive: flags['non-interactive'],
+            reporter: this.log.bind(this),
+        })) ?? user.rootFolderId;
+        const progressBar = cli_utils_1.CLIUtils.progress({
+            format: 'Uploading folder [{bar}] {percentage}%',
+            linewrap: true,
+        }, flags['json']);
+        progressBar?.start(100, 0);
+        const data = await upload_facade_service_1.UploadFacade.instance.uploadFolder({
+            localPath,
+            destinationFolderUuid,
+            loginUserDetails: user,
+            jsonFlag: flags['json'],
+            onProgress: (progress) => {
+                progressBar?.update(progress.percentage);
+            },
+        });
+        progressBar?.update(100);
+        progressBar?.stop();
+        const driveUrl = config_service_1.ConfigService.instance.get('DRIVE_WEB_URL');
+        const folderUrl = `${driveUrl}/folder/${data.rootFolderId}`;
+        const message = `Folder uploaded in ${data.uploadTimeMs}ms, view it at ${folderUrl} (${data.totalBytes} bytes)`;
+        cli_utils_1.CLIUtils.success(this.log.bind(this), message);
+    };
+    catch = async (error) => {
+        const { flags } = await this.parse(UploadFolder);
+        cli_utils_1.CLIUtils.catchError({
+            error,
+            command: this.id,
+            logReporter: this.log.bind(this),
+            jsonFlag: flags['json'],
+        });
+        this.exit(1);
+    };
+    getFolderPath = async (folderFlag, nonInteractive) => {
+        return await cli_utils_1.CLIUtils.getValueFromFlag({
+            value: folderFlag,
+            name: UploadFolder.flags['folder'].name,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the path to the folder on your computer?',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateDirectoryExists,
+            error: new command_types_1.NotValidDirectoryError(),
+        }, this.log.bind(this));
+    };
+}
+exports.default = UploadFolder;

package/dist/commands/webdav-config.d.ts

@@ -5,12 +5,12 @@ export default class WebDAVConfig extends Command {
     static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {
-        host: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        https: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        http: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        timeout: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        createFullPath: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        host: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        port: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        https: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        http: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        createFullPath: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     static readonly enableJsonFlag = true;
     run: () => Promise<{

package/dist/commands/webdav.d.ts

@@ -1,7 +1,7 @@
 import { Command } from '@oclif/core';
 export default class Webdav extends Command {
     static readonly args: {
-        action: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        action: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static readonly description = "Enable, disable, restart or get the status of the Internxt CLI WebDav server";
     static readonly aliases: never[];

package/dist/services/drive/drive-folder.service.d.ts

@@ -30,7 +30,7 @@ export declare class DriveFolderService {
         files: {
             id: number;
             uuid: string;
-            fileId: string;
+            fileId: string | null;
             name: string;
             type: string;
             size: string;

package/dist/services/drive/trash.service.d.ts

@@ -32,7 +32,7 @@ export declare class TrashService {
         files: {
             id: number;
             uuid: string;
-            fileId: string;
+            fileId: string | null;
             name: string;
             type: string;
             size: string;

package/dist/services/local-filesystem/local-filesystem.service.d.ts

@@ -0,0 +1,6 @@
+import { FileSystemNode, ScanResult } from './local-filesystem.types';
+export declare class LocalFilesystemService {
+    static readonly instance: LocalFilesystemService;
+    scanLocalDirectory(path: string): Promise<ScanResult>;
+    scanRecursive(currentPath: string, parentPath: string, folders: FileSystemNode[], files: FileSystemNode[]): Promise<number>;
+}

package/dist/services/local-filesystem/local-filesystem.service.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFilesystemService = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const logger_utils_1 = require("../../utils/logger.utils");
+class LocalFilesystemService {
+    static instance = new LocalFilesystemService();
+    async scanLocalDirectory(path) {
+        const folders = [];
+        const files = [];
+        const parentPath = (0, node_path_1.dirname)(path);
+        const totalBytes = await this.scanRecursive(path, parentPath, folders, files);
+        return {
+            folders,
+            files,
+            totalItems: folders.length + files.length,
+            totalBytes,
+        };
+    }
+    async scanRecursive(currentPath, parentPath, folders, files) {
+        try {
+            const stats = await node_fs_1.promises.stat(currentPath);
+            const relativePath = (0, node_path_1.relative)(parentPath, currentPath);
+            if (stats.isFile() && stats.size > 0) {
+                const fileInfo = (0, node_path_1.parse)(currentPath);
+                files.push({
+                    type: 'file',
+                    name: fileInfo.name,
+                    absolutePath: currentPath,
+                    relativePath,
+                    size: stats.size,
+                });
+                return stats.size;
+            }
+            if (stats.isDirectory()) {
+                folders.push({
+                    type: 'folder',
+                    name: (0, node_path_1.basename)(currentPath),
+                    absolutePath: currentPath,
+                    relativePath,
+                    size: 0,
+                });
+                const entries = await node_fs_1.promises.readdir(currentPath, { withFileTypes: true });
+                const validEntries = entries.filter((e) => !e.isSymbolicLink());
+                const bytesArray = await Promise.all(validEntries.map((e) => this.scanRecursive((0, node_path_1.join)(currentPath, e.name), parentPath, folders, files)));
+                return bytesArray.reduce((sum, bytes) => sum + bytes, 0);
+            }
+            return 0;
+        }
+        catch (error) {
+            logger_utils_1.logger.warn(`Error scanning path ${currentPath}: ${error.message} - skipping...`);
+            return 0;
+        }
+    }
+}
+exports.LocalFilesystemService = LocalFilesystemService;

package/dist/services/local-filesystem/local-filesystem.types.d.ts

@@ -0,0 +1,13 @@
+export interface FileSystemNode {
+    type: 'file' | 'folder';
+    name: string;
+    size: number;
+    absolutePath: string;
+    relativePath: string;
+}
+export interface ScanResult {
+    folders: FileSystemNode[];
+    files: FileSystemNode[];
+    totalItems: number;
+    totalBytes: number;
+}

package/dist/services/local-filesystem/local-filesystem.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,53 @@
+"use strict";
+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 }) {
+        const timer = cli_utils_1.CLIUtils.timer();
+        const network = cli_utils_1.CLIUtils.prepareNetwork({ jsonFlag, loginUserDetails });
+        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.`);
+        const currentProgress = { itemsUploaded: 0, bytesUploaded: 0 };
+        const emitProgress = () => {
+            const itemProgress = currentProgress.itemsUploaded / scanResult.totalItems;
+            const sizeProgress = currentProgress.bytesUploaded / scanResult.totalBytes;
+            const percentage = Math.floor((itemProgress * 0.5 + sizeProgress * 0.5) * 100);
+            onProgress({ percentage });
+        };
+        const folderMap = await upload_folder_service_1.UploadFolderService.instance.createFolders({
+            foldersToCreate: scanResult.folders,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        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,
+            filesToUpload: scanResult.files,
+            folderMap,
+            bucket: loginUserDetails.bucket,
+            destinationFolderUuid,
+            currentProgress,
+            emitProgress,
+        });
+        const rootFolderName = (0, node_path_1.basename)(localPath);
+        const rootFolderId = folderMap.get(rootFolderName) ?? '';
+        return {
+            totalBytes,
+            rootFolderId,
+            uploadTimeMs: timer.stop(),
+        };
+    }
+}
+exports.UploadFacade = UploadFacade;

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

@@ -0,0 +1,7 @@
+import { UploadFilesInBatchesParams, UploadFileWithRetryParams } from './upload.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;
+}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFileService = void 0;
+const logger_utils_1 = require("../../../utils/logger.utils");
+const upload_types_1 = require("./upload.types");
+const drive_file_service_1 = require("../../drive/drive-file.service");
+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");
+class UploadFileService {
+    static instance = new UploadFileService();
+    async uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+        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 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...`);
+                    return null;
+                }
+                const createdFileUuid = await this.uploadFileWithRetry({
+                    file,
+                    network,
+                    bucket,
+                    parentFolderUuid,
+                });
+                if (createdFileUuid) {
+                    bytesUploaded += file.size;
+                    currentProgress.bytesUploaded += file.size;
+                    currentProgress.itemsUploaded++;
+                }
+                emitProgress();
+            }));
+        }
+        return bytesUploaded;
+    }
+    async uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }) {
+        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 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);
+                    }, () => { });
+                });
+                const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+                    plainName: file.name,
+                    type: fileType,
+                    size: stats.size,
+                    folderUuid: parentFolderUuid,
+                    fileId,
+                    bucket,
+                    encryptVersion: types_1.EncryptionVersion.Aes03,
+                    creationTime: stats.birthtime?.toISOString(),
+                    modificationTime: stats.mtime?.toISOString(),
+                });
+                if (bufferStream) {
+                    void (0, thumbnail_utils_1.tryUploadThumbnail)({
+                        bufferStream,
+                        fileType,
+                        userBucket: bucket,
+                        fileUuid: createdDriveFile.uuid,
+                        networkFacade: network,
+                    });
+                }
+                return createdDriveFile.fileId;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.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})`);
+                    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`);
+                    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));
+        }
+        return chunks;
+    }
+}
+exports.UploadFileService = UploadFileService;

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

@@ -0,0 +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>;
+}

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadFolderService = void 0;
+const node_path_1 = require("node:path");
+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");
+class UploadFolderService {
+    static instance = new UploadFolderService();
+    async createFolders({ foldersToCreate, destinationFolderUuid, currentProgress, emitProgress, }) {
+        const folderMap = new Map();
+        for (const folder of foldersToCreate) {
+            const parentPath = (0, node_path_1.dirname)(folder.relativePath);
+            const parentUuid = parentPath === '.' ? destinationFolderUuid : folderMap.get(parentPath);
+            if (!parentUuid) {
+                logger_utils_1.logger.warn(`Parent folder not found for ${folder.relativePath}, skipping...`);
+                continue;
+            }
+            const createdFolderUuid = await this.createFolderWithRetry({
+                folderName: folder.name,
+                parentFolderUuid: parentUuid,
+            });
+            if (createdFolderUuid) {
+                folderMap.set(folder.relativePath, createdFolderUuid);
+                currentProgress.itemsUploaded++;
+                emitProgress();
+            }
+        }
+        return folderMap;
+    }
+    async createFolderWithRetry({ folderName, parentFolderUuid }) {
+        for (let attempt = 0; attempt <= upload_types_1.MAX_RETRIES; attempt++) {
+            try {
+                const [createFolderPromise] = drive_folder_service_1.DriveFolderService.instance.createFolder({
+                    plainName: folderName,
+                    parentFolderUuid,
+                });
+                const createdFolder = await createFolderPromise;
+                return createdFolder.uuid;
+            }
+            catch (error) {
+                if ((0, errors_utils_1.isAlreadyExistsError)(error)) {
+                    logger_utils_1.logger.info(`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})`);
+                    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`);
+                    throw error;
+                }
+            }
+        }
+        return null;
+    }
+}
+exports.UploadFolderService = UploadFolderService;