@internxt/cli 1.6.1 → 1.6.2

package/dist/services/config.service.js

@@ -4,23 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigService = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const os_1 = __importDefault(require("os"));
 const promises_1 = __importDefault(require("node:fs/promises"));
 const crypto_service_1 = require("./crypto.service");
+const errors_utils_1 = require("../utils/errors.utils");
+const configs_1 = require("../constants/configs");
 class ConfigService {
-    static INTERNXT_CLI_DATA_DIR = node_path_1.default.join(os_1.default.homedir(), '.internxt-cli');
-    static INTERNXT_CLI_LOGS_DIR = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'logs');
-    static INTERNXT_TMP_DIR = os_1.default.tmpdir();
-    static CREDENTIALS_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, '.inxtcli');
-    static DRIVE_SQLITE_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
-    static WEBDAV_SSL_CERTS_DIR = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
-    static WEBDAV_CONFIGS_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
-    static WEBDAV_DEFAULT_HOST = '127.0.0.1';
-    static WEBDAV_DEFAULT_PORT = '3005';
-    static WEBDAV_DEFAULT_PROTOCOL = 'https';
-    static WEBDAV_DEFAULT_TIMEOUT = 0;
-    static WEBDAV_DEFAULT_CREATE_FULL_PATH = true;
     static instance = new ConfigService();
     get = (key) => {
         const value = process.env[key];
@@ -32,17 +20,24 @@ class ConfigService {
         await this.ensureInternxtCliDataDirExists();
         const credentialsString = JSON.stringify(loginCredentials);
         const encryptedCredentials = crypto_service_1.CryptoService.instance.encryptText(credentialsString);
-        await promises_1.default.writeFile(ConfigService.CREDENTIALS_FILE, encryptedCredentials, 'utf8');
+        await promises_1.default.writeFile(configs_1.CREDENTIALS_FILE, encryptedCredentials, 'utf8');
     };
     clearUser = async () => {
-        const stat = await promises_1.default.stat(ConfigService.CREDENTIALS_FILE);
-        if (stat.size === 0)
-            throw new Error('Credentials file is already empty');
-        return promises_1.default.writeFile(ConfigService.CREDENTIALS_FILE, '', 'utf8');
+        try {
+            const stat = await promises_1.default.stat(configs_1.CREDENTIALS_FILE);
+            if (stat.size === 0)
+                return;
+            await promises_1.default.writeFile(configs_1.CREDENTIALS_FILE, '', 'utf8');
+        }
+        catch (error) {
+            if (!(0, errors_utils_1.isFileNotFoundError)(error)) {
+                throw error;
+            }
+        }
     };
     readUser = async () => {
         try {
-            const encryptedCredentials = await promises_1.default.readFile(ConfigService.CREDENTIALS_FILE, 'utf8');
+            const encryptedCredentials = await promises_1.default.readFile(configs_1.CREDENTIALS_FILE, 'utf8');
             const credentialsString = crypto_service_1.CryptoService.instance.decryptText(encryptedCredentials);
             const loginCredentials = JSON.parse(credentialsString);
             return loginCredentials;
@@ -54,52 +49,52 @@ class ConfigService {
     saveWebdavConfig = async (webdavConfig) => {
         await this.ensureInternxtCliDataDirExists();
         const configs = JSON.stringify(webdavConfig);
-        await promises_1.default.writeFile(ConfigService.WEBDAV_CONFIGS_FILE, configs, 'utf8');
+        await promises_1.default.writeFile(configs_1.WEBDAV_CONFIGS_FILE, configs, 'utf8');
     };
     readWebdavConfig = async () => {
         try {
-            const configsData = await promises_1.default.readFile(ConfigService.WEBDAV_CONFIGS_FILE, 'utf8');
+            const configsData = await promises_1.default.readFile(configs_1.WEBDAV_CONFIGS_FILE, 'utf8');
             const configs = JSON.parse(configsData);
             return {
-                host: configs?.host ?? ConfigService.WEBDAV_DEFAULT_HOST,
-                port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
-                protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-                timeoutMinutes: configs?.timeoutMinutes ?? ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-                createFullPath: configs?.createFullPath ?? ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+                host: configs?.host ?? configs_1.WEBDAV_DEFAULT_HOST,
+                port: configs?.port ?? configs_1.WEBDAV_DEFAULT_PORT,
+                protocol: configs?.protocol ?? configs_1.WEBDAV_DEFAULT_PROTOCOL,
+                timeoutMinutes: configs?.timeoutMinutes ?? configs_1.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: configs?.createFullPath ?? configs_1.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
         catch {
             return {
-                host: ConfigService.WEBDAV_DEFAULT_HOST,
-                port: ConfigService.WEBDAV_DEFAULT_PORT,
-                protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
-                timeoutMinutes: ConfigService.WEBDAV_DEFAULT_TIMEOUT,
-                createFullPath: ConfigService.WEBDAV_DEFAULT_CREATE_FULL_PATH,
+                host: configs_1.WEBDAV_DEFAULT_HOST,
+                port: configs_1.WEBDAV_DEFAULT_PORT,
+                protocol: configs_1.WEBDAV_DEFAULT_PROTOCOL,
+                timeoutMinutes: configs_1.WEBDAV_DEFAULT_TIMEOUT,
+                createFullPath: configs_1.WEBDAV_DEFAULT_CREATE_FULL_PATH,
             };
         }
     };
     ensureInternxtCliDataDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.INTERNXT_CLI_DATA_DIR);
+            await promises_1.default.access(configs_1.INTERNXT_CLI_DATA_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_DATA_DIR);
+            await promises_1.default.mkdir(configs_1.INTERNXT_CLI_DATA_DIR);
         }
     };
     ensureWebdavCertsDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.WEBDAV_SSL_CERTS_DIR);
+            await promises_1.default.access(configs_1.WEBDAV_SSL_CERTS_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.WEBDAV_SSL_CERTS_DIR);
+            await promises_1.default.mkdir(configs_1.WEBDAV_SSL_CERTS_DIR);
         }
     };
     ensureInternxtLogsDirExists = async () => {
         try {
-            await promises_1.default.access(ConfigService.INTERNXT_CLI_LOGS_DIR);
+            await promises_1.default.access(configs_1.INTERNXT_CLI_LOGS_DIR);
         }
         catch {
-            await promises_1.default.mkdir(ConfigService.INTERNXT_CLI_LOGS_DIR);
+            await promises_1.default.mkdir(configs_1.INTERNXT_CLI_LOGS_DIR);
         }
     };
 }

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

@@ -32,7 +32,7 @@ class UploadFacade {
             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({
+        const totalBytes = await upload_file_service_1.UploadFileService.instance.uploadFilesConcurrently({
             network,
             filesToUpload: scanResult.files,
             folderMap,

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, }: UploadFilesConcurrentlyParams): Promise<number>;
+    uploadFileWithRetry({ file, network, bucket, parentFolderUuid, }: UploadFileWithRetryParams): Promise<DriveFileItem | null>;
+    private concurrencyArray;
 }

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

@@ -9,13 +9,14 @@ 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");
 class UploadFileService {
     static instance = new UploadFileService();
-    async uploadFilesInChunks({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, }) {
+    async uploadFilesConcurrently({ 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 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) {
@@ -42,27 +43,37 @@ class UploadFileService {
         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 } = (0, thumbnail_utils_1.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,16 +81,27 @@ class UploadFileService {
                     creationTime: stats.birthtime?.toISOString(),
                     modificationTime: stats.mtime?.toISOString(),
                 });
-                if (bufferStream) {
+                timings.driveUpload = driveTimer.stop();
+                const thumbnailTimer = cli_utils_1.CLIUtils.timer();
+                if (thumbnailStream && fileSize > 0) {
                     void (0, thumbnail_utils_1.tryUploadThumbnail)({
-                        bufferStream,
+                        bufferStream: thumbnailStream,
                         fileType,
                         userBucket: bucket,
                         fileUuid: createdDriveFile.uuid,
                         networkFacade: network,
                     });
                 }
-                return createdDriveFile.fileId;
+                timings.thumbnailUpload = thumbnailTimer.stop();
+                const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+                const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
+                logger_utils_1.logger.info(`Uploaded '${file.name}' (${cli_utils_1.CLIUtils.formatBytesToString(stats.size)})`);
+                logger_utils_1.logger.info(`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)) {
@@ -101,12 +123,12 @@ class UploadFileService {
         }
         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.types.d.ts

@@ -30,7 +30,7 @@ export interface CreateFolderWithRetryParams {
     folderName: string;
     parentFolderUuid: string;
 }
-export interface UploadFilesInBatchesParams {
+export interface UploadFilesConcurrentlyParams {
     network: NetworkFacade;
     filesToUpload: FileSystemNode[];
     folderMap: Map<string, string>;
@@ -48,6 +48,6 @@ export interface UploadFileWithRetryParams {
     bucket: string;
     parentFolderUuid: string;
 }
-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

@@ -6,8 +6,8 @@ export declare class 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;

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

@@ -18,8 +18,8 @@ class SdkManager {
     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;
     };

package/dist/services/validation.service.d.ts

@@ -9,6 +9,11 @@ export declare class ValidationService {
     validateStringIsNotEmpty: (str: string) => boolean;
     validateDirectoryExists: (path: string) => Promise<boolean>;
     validateFileExists: (path: string) => Promise<boolean>;
+    validateJwtAndCheckExpiration: (token?: string) => number | null;
+    checkTokenExpiration: (expirationTimestamp: number) => {
+        expired: boolean;
+        refreshRequired: boolean;
+    };
     validateTokenAndCheckExpiration: (token?: string) => {
         isValid: boolean;
         expiration: {

package/dist/services/validation.service.js

@@ -38,29 +38,33 @@ class ValidationService {
         const fileStat = await promises_1.default.stat(path);
         return fileStat.isFile();
     };
-    validateTokenAndCheckExpiration = (token) => {
-        if (!token || typeof token !== 'string') {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
-        }
-        const parts = token.split('.');
-        if (parts.length !== 3) {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+    validateJwtAndCheckExpiration = (token) => {
+        if (!token || typeof token !== 'string' || token.split('.').length !== 3) {
+            return null;
         }
         try {
-            const payload = JSON.parse(atob(parts[1]));
-            if (typeof payload.exp !== 'number') {
-                return { isValid: false, expiration: { expired: true, refreshRequired: false } };
-            }
-            const currentTime = Math.floor(Date.now() / 1000);
-            const twoDaysInSeconds = 2 * 24 * 60 * 60;
-            const remainingSeconds = payload.exp - currentTime;
-            const expired = remainingSeconds <= 0;
-            const refreshRequired = remainingSeconds > 0 && remainingSeconds <= twoDaysInSeconds;
-            return { isValid: true, expiration: { expired, refreshRequired } };
+            const payload = JSON.parse(atob(token.split('.')[1]));
+            return typeof payload.exp === 'number' ? payload.exp : null;
         }
         catch {
-            return { isValid: false, expiration: { expired: true, refreshRequired: false } };
+            return null;
         }
     };
+    checkTokenExpiration = (expirationTimestamp) => {
+        const TWO_DAYS_IN_SECONDS = 2 * 24 * 60 * 60;
+        const currentTime = Math.floor(Date.now() / 1000);
+        const remainingSeconds = expirationTimestamp - currentTime;
+        return {
+            expired: remainingSeconds <= 0,
+            refreshRequired: remainingSeconds > 0 && remainingSeconds <= TWO_DAYS_IN_SECONDS,
+        };
+    };
+    validateTokenAndCheckExpiration = (token) => {
+        const expiration = this.validateJwtAndCheckExpiration(token);
+        return {
+            isValid: expiration !== null,
+            expiration: expiration ? this.checkTokenExpiration(expiration) : { expired: true, refreshRequired: false },
+        };
+    };
 }
 exports.ValidationService = ValidationService;

package/dist/utils/cli.utils.d.ts

@@ -43,6 +43,9 @@ export declare class CLIUtils {
     static readonly timer: () => {
         stop: () => number;
     };
+    static readonly formatDuration: (milliseconds: number) => string;
+    static readonly formatBytesToString: (bytes: number) => string;
+    static readonly calculateThroughputMBps: (bytes: number, milliseconds: number) => number;
     static readonly catchError: ({ error, logReporter, command, jsonFlag, }: {
         error: Error;
         command?: string;

package/dist/utils/cli.utils.js

@@ -143,11 +143,11 @@ class CLIUtils {
                 }
             }
         } while (!isValid && currentAttempts < maxAttempts);
-        if (!isValid) {
-            throw validation.error;
+        if (isValid) {
+            return promptValue;
         }
         else {
-            return promptValue;
+            throw validation.error;
         }
     };
     static timer = () => {
@@ -160,6 +160,40 @@ class CLIUtils {
             },
         };
     };
+    static formatDuration = (milliseconds) => {
+        if (milliseconds <= 0) {
+            return '00:00:00.000';
+        }
+        const totalSeconds = Math.floor(milliseconds / 1000);
+        const hours = Math.floor(totalSeconds / 3600);
+        const minutes = Math.floor((totalSeconds % 3600) / 60);
+        const seconds = totalSeconds % 60;
+        const ms = Math.floor(milliseconds % 1000);
+        const hoursFormated = hours.toString().padStart(2, '0');
+        const minutesFormated = minutes.toString().padStart(2, '0');
+        const secondsFormated = seconds.toString().padStart(2, '0');
+        const msFormated = ms.toString().padStart(3, '0');
+        return `${hoursFormated}:${minutesFormated}:${secondsFormated}.${msFormated}`;
+    };
+    static formatBytesToString = (bytes) => {
+        if (bytes <= 0) {
+            return '0.00 KB';
+        }
+        const kb = bytes / 1024;
+        if (kb < 1024) {
+            return `${kb.toFixed(2)} KB`;
+        }
+        const mb = kb / 1024;
+        return `${mb.toFixed(2)} MB`;
+    };
+    static calculateThroughputMBps = (bytes, milliseconds) => {
+        if (bytes <= 0 || milliseconds <= 0) {
+            return 0;
+        }
+        const megabytes = bytes / 1024 / 1024;
+        const seconds = milliseconds / 1000;
+        return megabytes / seconds;
+    };
     static catchError = ({ error, logReporter, command, jsonFlag, }) => {
         let message;
         if ('message' in error && error.message.trim().length > 0) {

package/dist/utils/errors.utils.d.ts

@@ -1,5 +1,6 @@
 export declare function isError(error: unknown): error is Error;
 export declare function isAlreadyExistsError(error: unknown): error is Error;
+export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;
 export declare class ErrorUtils {
     static report(error: unknown, props?: Record<string, unknown>): void;
 }

package/dist/utils/errors.utils.js

@@ -3,15 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
 exports.isError = isError;
 exports.isAlreadyExistsError = isAlreadyExistsError;
+exports.isFileNotFoundError = isFileNotFoundError;
 const logger_utils_1 = require("./logger.utils");
-const node_util_1 = require("node:util");
 function isError(error) {
-    return node_util_1.types.isNativeError(error);
+    return typeof Error.isError === 'function'
+        ? Error.isError(error)
+        : error instanceof Error ||
+            (typeof error === 'object' && error !== null && 'message' in error && ('stack' in error || 'name' in error));
 }
 function isAlreadyExistsError(error) {
     return ((isError(error) && error.message.includes('already exists')) ||
         (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
 }
+function isFileNotFoundError(error) {
+    return isError(error) && 'code' in error && error.code === 'ENOENT';
+}
 class ErrorUtils {
     static report(error, props = {}) {
         if (isError(error)) {

package/dist/utils/logger.utils.js

@@ -5,7 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webdavLogger = exports.logger = void 0;
 const winston_1 = __importDefault(require("winston"));
-const config_service_1 = require("../services/config.service");
+const configs_1 = require("../constants/configs");
 const maxLogSize = 40 * 1024 * 1024;
 const maxLogsFiles = 5;
 exports.logger = winston_1.default.createLogger({
@@ -16,14 +16,14 @@ exports.logger = winston_1.default.createLogger({
         new winston_1.default.transports.File({
             filename: 'internxt-cli-error.log',
             level: 'error',
-            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            dirname: configs_1.INTERNXT_CLI_LOGS_DIR,
             maxsize: maxLogSize,
             maxFiles: maxLogsFiles,
             tailable: true,
         }),
         new winston_1.default.transports.File({
             filename: 'internxt-cli-combined.log',
-            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            dirname: configs_1.INTERNXT_CLI_LOGS_DIR,
             maxsize: maxLogSize,
             maxFiles: maxLogsFiles,
             tailable: true,
@@ -38,14 +38,14 @@ exports.webdavLogger = winston_1.default.createLogger({
         new winston_1.default.transports.File({
             filename: 'internxt-webdav-error.log',
             level: 'error',
-            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            dirname: configs_1.INTERNXT_CLI_LOGS_DIR,
             maxsize: maxLogSize,
             maxFiles: maxLogsFiles,
             tailable: true,
         }),
         new winston_1.default.transports.File({
             filename: 'internxt-webdav-combined.log',
-            dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            dirname: configs_1.INTERNXT_CLI_LOGS_DIR,
             maxsize: maxLogSize,
             maxFiles: maxLogsFiles,
             tailable: true,

package/dist/utils/network.utils.js

@@ -9,7 +9,7 @@ const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const selfsigned_1 = __importDefault(require("selfsigned"));
 const range_parser_1 = __importDefault(require("range-parser"));
-const config_service_1 = require("../services/config.service");
+const configs_1 = require("../constants/configs");
 class NetworkUtils {
     static getAuthFromCredentials(creds) {
         return {
@@ -18,8 +18,8 @@ class NetworkUtils {
         };
     }
     static WEBDAV_SSL_CERTS_PATH = {
-        cert: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
-        privateKey: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
+        cert: node_path_1.default.join(configs_1.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
+        privateKey: node_path_1.default.join(configs_1.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
     };
     static async generateNewSelfsignedCerts(configs) {
         const newCerts = await this.generateSelfSignedSSLCerts(configs);
@@ -59,17 +59,16 @@ class NetworkUtils {
     }
     static async generateSelfSignedSSLCerts(configs) {
         const attrs = [{ name: 'commonName', value: configs.host }];
-        const extensions = [
-            {
-                name: 'subjectAltName',
-                altNames: [
-                    {
-                        type: 2,
-                        value: configs.host,
-                    },
-                ],
-            },
-        ];
+        const extension = {
+            name: 'subjectAltName',
+            altNames: [
+                {
+                    type: 2,
+                    value: configs.host,
+                },
+            ],
+        };
+        const extensions = [extension];
         const notAfterDate = new Date();
         notAfterDate.setDate(notAfterDate.getDate() + 365);
         const pems = await selfsigned_1.default.generate(attrs, { notAfterDate, algorithm: 'sha256', keySize: 2048, extensions });
@@ -87,10 +86,7 @@ class NetworkUtils {
             else if (parsed.length <= 0) {
                 throw new Error(`Empty Range-Request. ${JSON.stringify(rangeOptions)}`);
             }
-            else if (parsed.type !== 'bytes') {
-                throw new Error(`Unkwnown Range-Request type "${parsed.type}". ${JSON.stringify(rangeOptions)}`);
-            }
-            else {
+            if (parsed.type === 'bytes') {
                 const rangeSize = parsed[0].end - parsed[0].start + 1;
                 return {
                     range: rangeOptions.range,
@@ -99,6 +95,9 @@ class NetworkUtils {
                     parsed: parsed[0],
                 };
             }
+            else {
+                throw new Error(`Unkwnown Range-Request type "${parsed.type}". ${JSON.stringify(rangeOptions)}`);
+            }
         }
         else if (parsed === -1) {
             throw new Error(`Malformed Range-Request. ${JSON.stringify(rangeOptions)}`);

package/dist/utils/thumbnail.utils.d.ts

@@ -11,7 +11,7 @@ export declare const isFileThumbnailable: (fileType: string) => boolean;
 export declare const isPDFThumbnailable: (fileType: string) => boolean;
 export declare const isImageThumbnailable: (fileType: string) => boolean;
 export declare const tryUploadThumbnail: ({ bufferStream, fileType, userBucket, fileUuid, networkFacade, }: {
-    bufferStream: BufferStream;
+    bufferStream?: BufferStream;
     fileType: string;
     userBucket: string;
     fileUuid: string;