@internxt/cli 1.6.1 → 1.6.3

package/dist/utils/cli.utils.js

@@ -15,8 +15,7 @@ const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const inxt_js_1 = require("@internxt/inxt-js");
 const config_service_1 = require("../services/config.service");
 const network_facade_service_1 = require("../services/network/network-facade.service");
-const download_service_1 = require("../services/network/download.service");
-const crypto_service_1 = require("../services/crypto.service");
+const auth_service_1 = require("../services/auth.service");
 class CLIUtils {
     static clearPreviousLine = (jsonFlag) => {
         if (!jsonFlag) {
@@ -77,6 +76,12 @@ class CLIUtils {
             description: 'Prevents the CLI from being interactive. When enabled, the CLI will not request input through the console and will throw errors directly.',
             required: false,
         }),
+        debug: core_1.Flags.boolean({
+            env: 'INXT_DEBUG',
+            helpGroup: 'helper',
+            description: 'Enables debug mode. When enabled, the CLI will print debug messages to the console.',
+            required: false,
+        }),
     };
     static getValueFromFlag = async (flag, command, validation, reporter) => {
         if (flag.value) {
@@ -117,12 +122,7 @@ class CLIUtils {
             error: new command_types_1.NotValidFolderUuidError(),
             canBeEmpty: true,
         }, reporter);
-        if (destinationFolderUuid.trim().length === 0) {
-            return undefined;
-        }
-        else {
-            return destinationFolderUuid;
-        }
+        return destinationFolderUuid;
     };
     static promptWithAttempts = async (prompt, maxAttempts, validation, reporter) => {
         let isValid = false;
@@ -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) {
@@ -178,22 +212,52 @@ class CLIUtils {
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
-    static prepareNetwork = ({ jsonFlag, loginUserDetails, }) => {
-        CLIUtils.doing('Preparing Network', jsonFlag);
+    static prepareNetwork = async (loginUserDetails) => {
+        const { credentials, mnemonic, bucket } = await this.getNetworkCreds(loginUserDetails);
         const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
-            user: loginUserDetails.bridgeUser,
-            pass: loginUserDetails.userId,
+            user: credentials.user,
+            pass: credentials.pass,
         });
         const environment = new inxt_js_1.Environment({
-            bridgeUser: loginUserDetails.bridgeUser,
-            bridgePass: loginUserDetails.userId,
+            bridgeUser: credentials.user,
+            bridgePass: credentials.pass,
+            encryptionKey: mnemonic,
             bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
-            encryptionKey: loginUserDetails.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);
-        CLIUtils.done(jsonFlag);
-        return networkFacade;
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment);
+        return { networkFacade, bucket, mnemonic };
+    };
+    static fallbackToRootFolderIdIfEmpty = async (folderId) => {
+        if (folderId.trim().length === 0) {
+            return await auth_service_1.AuthService.instance.getCurrentRootFolder();
+        }
+        else {
+            return folderId;
+        }
+    };
+    static getNetworkCreds = async (userCredentials) => {
+        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
+        if (currentWorkspace) {
+            return {
+                bucket: currentWorkspace.workspaceCredentials.bucket,
+                credentials: {
+                    user: currentWorkspace.workspaceCredentials.credentials.user,
+                    pass: currentWorkspace.workspaceCredentials.credentials.pass,
+                },
+                mnemonic: currentWorkspace.workspaceData.workspaceUser.key,
+            };
+        }
+        else {
+            return {
+                bucket: userCredentials.bucket,
+                credentials: {
+                    user: userCredentials.bridgeUser,
+                    pass: userCredentials.userId,
+                },
+                mnemonic: userCredentials.mnemonic,
+            };
+        }
     };
 }
 exports.CLIUtils = CLIUtils;

package/dist/utils/crypto.utils.d.ts

@@ -1,6 +1,8 @@
 export declare class CryptoUtils {
-    static getAesInit(): {
+    static readonly getAesInit: () => {
         iv: string;
         salt: string;
     };
+    static readonly extendSecret: (secret: Uint8Array, length: number) => Promise<string>;
+    static readonly XORhex: (a: string, b: string) => string;
 }

package/dist/utils/crypto.utils.js

@@ -1,10 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CryptoUtils = void 0;
+const hash_wasm_1 = require("hash-wasm");
 const config_service_1 = require("../services/config.service");
 class CryptoUtils {
-    static getAesInit() {
+    static getAesInit = () => {
         return { iv: config_service_1.ConfigService.instance.get('APP_MAGIC_IV'), salt: config_service_1.ConfigService.instance.get('APP_MAGIC_SALT') };
-    }
+    };
+    static extendSecret = (secret, length) => {
+        return (0, hash_wasm_1.blake3)(secret, length);
+    };
+    static XORhex = (a, b) => {
+        let res = '', i = a.length, j = b.length;
+        if (i != j) {
+            throw new Error('Can XOR only strings with identical length');
+        }
+        while (i-- > 0 && j-- > 0)
+            res = (Number.parseInt(a.charAt(i), 16) ^ Number.parseInt(b.charAt(j), 16)).toString(16) + res;
+        return res;
+    };
 }
 exports.CryptoUtils = CryptoUtils;

package/dist/utils/database.utils.d.ts

@@ -0,0 +1,11 @@
+export declare class DatabaseUtils {
+    static readonly CREATE_BATCH_SIZE = 100;
+    static readonly getFolderByPathGeneric: <T>({ path, parentUuid, onFound, getByParentAndName, }: {
+        path: string;
+        parentUuid: string;
+        onFound: (uuid: string) => Promise<T>;
+        getByParentAndName: (parentUuid: string, name: string) => Promise<{
+            uuid: string;
+        } | null | undefined>;
+    }) => Promise<T | undefined>;
+}

package/dist/utils/database.utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUtils = void 0;
+class DatabaseUtils {
+    static CREATE_BATCH_SIZE = 100;
+    static getFolderByPathGeneric = async ({ path, parentUuid, onFound, getByParentAndName, }) => {
+        path = path.replace(/^\//, '').replace(/\/$/, '');
+        if (path.trim().length === 0) {
+            return onFound(parentUuid);
+        }
+        const slashIndex = path.indexOf('/');
+        const currentFolder = slashIndex === -1 ? path : path.substring(0, slashIndex);
+        const nextPath = slashIndex === -1 ? '' : path.substring(slashIndex + 1);
+        const folder = await getByParentAndName(parentUuid, currentFolder);
+        if (!folder) {
+            return;
+        }
+        return this.getFolderByPathGeneric({
+            path: nextPath,
+            parentUuid: folder.uuid,
+            onFound,
+            getByParentAndName,
+        });
+    };
+}
+exports.DatabaseUtils = DatabaseUtils;

package/dist/utils/drive.utils.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveUtils = void 0;
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
             itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
-            folderId: fileMeta.folderId,
             folderUuid: fileMeta.folderUuid,
             size: Number(fileMeta.size),
             name: fileMeta.plainName ?? fileMeta.name,
@@ -17,7 +17,6 @@ class DriveUtils {
             creationTime: new Date(fileMeta.creationTime ?? fileMeta.createdAt),
             modificationTime: new Date(fileMeta.modificationTime ?? fileMeta.updatedAt),
             fileId: fileMeta.fileId,
-            id: fileMeta.id,
             type: fileMeta.type,
         };
     }
@@ -25,30 +24,28 @@ class DriveUtils {
         return {
             itemType: 'folder',
             uuid: folderMeta.uuid,
-            id: folderMeta.id,
             bucket: folderMeta.bucket,
-            status: folderMeta.deleted || folderMeta.removed ? 'TRASHED' : 'EXISTS',
+            status: folderMeta.deleted || folderMeta.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.EXISTS,
             name: folderMeta.plainName ?? folderMeta.name,
-            encryptedName: folderMeta.name,
-            parentId: folderMeta.parentId,
             parentUuid: folderMeta.parentUuid,
             createdAt: new Date(folderMeta.createdAt),
             updatedAt: new Date(folderMeta.updatedAt),
+            creationTime: new Date(folderMeta.creation_time),
+            modificationTime: new Date(folderMeta.creation_time),
         };
     }
     static createFolderResponseToItem(folderResponse) {
         return {
             itemType: 'folder',
             uuid: folderResponse.uuid,
-            id: folderResponse.id,
             bucket: folderResponse.bucket,
-            status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+            status: folderResponse.deleted || folderResponse.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.EXISTS,
             name: folderResponse.plainName ?? folderResponse.name,
-            encryptedName: folderResponse.name,
-            parentId: folderResponse.parentId,
             parentUuid: folderResponse.parentUuid,
             createdAt: new Date(folderResponse.createdAt),
             updatedAt: new Date(folderResponse.updatedAt),
+            creationTime: new Date(folderResponse.creationTime),
+            modificationTime: new Date(folderResponse.modificationTime),
         };
     }
 }

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

@@ -1,7 +1,8 @@
-export declare function isError(error: unknown): error is Error;
-export declare function isAlreadyExistsError(error: unknown): error is Error;
 export declare class ErrorUtils {
-    static report(error: unknown, props?: Record<string, unknown>): void;
+    static readonly isError: (error: unknown) => error is Error;
+    static readonly report: (error: unknown, props?: Record<string, unknown>) => void;
+    static readonly isAlreadyExistsError: (error: unknown) => error is Error;
+    static readonly isFileNotFoundError: (error: unknown) => error is NodeJS.ErrnoException;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -1,26 +1,29 @@
 "use strict";
 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;
 const logger_utils_1 = require("./logger.utils");
-const node_util_1 = require("node:util");
-function isError(error) {
-    return node_util_1.types.isNativeError(error);
-}
-function isAlreadyExistsError(error) {
-    return ((isError(error) && error.message.includes('already exists')) ||
-        (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
-}
 class ErrorUtils {
-    static report(error, props = {}) {
-        if (isError(error)) {
+    static isError = (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));
+    };
+    static report = (error, props = {}) => {
+        if (this.isError(error)) {
             logger_utils_1.logger.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
             logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
-    }
+    };
+    static isAlreadyExistsError = (error) => {
+        return ((this.isError(error) && error.message.includes('already exists')) ||
+            (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
+    };
+    static isFileNotFoundError = (error) => {
+        return this.isError(error) && 'code' in error && error.code === 'ENOENT';
+    };
 }
 exports.ErrorUtils = ErrorUtils;
 class ConflictError extends Error {

package/dist/utils/format.utils.d.ts

@@ -3,4 +3,5 @@ export declare class FormatUtils {
     static readonly formatDate: (date: string | Date) => string;
     static readonly formatDateForWebDav: (date: string | Date) => string;
     static readonly formatLimit: (limit: number) => string;
+    static readonly capitalizeFirstLetter: (string: string) => string;
 }

package/dist/utils/format.utils.js

@@ -26,5 +26,8 @@ class FormatUtils {
         }
         return result;
     };
+    static capitalizeFirstLetter = (string) => {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    };
 }
 exports.FormatUtils = FormatUtils;

package/dist/utils/inquirer.utils.js

@@ -15,7 +15,16 @@ class InquirerUtils {
                 const confirmation = await (0, prompts_1.confirm)({ message, default: options.confirm?.default || false });
                 return confirmation ? 'y' : 'n';
             }
-            case 'input': {
+            case 'list':
+                if (!options.choices)
+                    throw new Error('Missing choices');
+                return (0, prompts_1.select)({
+                    message,
+                    choices: options.choices.values,
+                    default: options.choices.values[options.choices.default ?? 0],
+                });
+            case 'input':
+            default: {
                 return (0, prompts_1.input)({ message });
             }
         }

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/path.utils.d.ts

@@ -0,0 +1,7 @@
+export declare class PathUtils {
+    static getPathFileData(filePath: string): {
+        folderPath: string;
+        fileName: string;
+        fileType: string | null;
+    };
+}

package/dist/utils/path.utils.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathUtils = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class PathUtils {
+    static getPathFileData(filePath) {
+        const folderPath = node_path_1.default.dirname(filePath);
+        const fileExt = node_path_1.default.extname(filePath);
+        const fileName = node_path_1.default.basename(filePath, fileExt);
+        const fileExtWithoutDot = fileExt.replace('.', '').trim();
+        const fileType = fileExtWithoutDot.length > 0 ? fileExtWithoutDot : null;
+        return { folderPath, fileName, fileType };
+    }
+}
+exports.PathUtils = PathUtils;

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

@@ -1,26 +1,12 @@
-import { Readable } from 'node:stream';
-import { NetworkFacade } from '../services/network/network-facade.service';
-import { BufferStream } from './stream.utils';
 export declare const ThumbnailConfig: {
     readonly MaxWidth: 300;
     readonly MaxHeight: 300;
     readonly Quality: 100;
     readonly Type: "png";
 };
-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;
-    fileType: string;
-    userBucket: string;
-    fileUuid: string;
-    networkFacade: NetworkFacade;
-}) => Promise<void>;
-export declare const createFileStreamWithBuffer: ({ path, fileType, }: {
-    path: string;
-    fileType: string;
-}) => {
-    bufferStream?: BufferStream;
-    fileStream: Readable;
-};
+export declare class ThumbnailUtils {
+    static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB: number;
+    static readonly isFileThumbnailable: (fileType: string) => boolean;
+    static readonly isPDFThumbnailable: (fileType: string) => boolean;
+    static readonly isImageThumbnailable: (fileType: string, size: number) => boolean;
+}

package/dist/utils/thumbnail.utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createFileStreamWithBuffer = exports.tryUploadThumbnail = exports.isImageThumbnailable = exports.isPDFThumbnailable = exports.isFileThumbnailable = exports.ThumbnailConfig = void 0;
-const thumbnail_service_1 = require("../services/thumbnail.service");
-const errors_utils_1 = require("./errors.utils");
-const stream_utils_1 = require("./stream.utils");
-const node_fs_1 = require("node:fs");
+exports.ThumbnailUtils = exports.ThumbnailConfig = void 0;
 exports.ThumbnailConfig = {
     MaxWidth: 300,
     MaxHeight: 300,
@@ -25,48 +21,27 @@ const imageExtensions = {
 const pdfExtensions = {
     pdf: ['pdf'],
 };
-const thumbnailableImageExtension = [
+const thumbnailableImageExtension = new Set([
     ...imageExtensions['jpg'],
     ...imageExtensions['png'],
     ...imageExtensions['webp'],
     ...imageExtensions['gif'],
     ...imageExtensions['tiff'],
-];
-const thumbnailablePdfExtension = pdfExtensions['pdf'];
-const thumbnailableExtension = [...thumbnailableImageExtension];
-const isFileThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType.trim().toLowerCase());
-};
-exports.isFileThumbnailable = isFileThumbnailable;
-const isPDFThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType.trim().toLowerCase());
-};
-exports.isPDFThumbnailable = isPDFThumbnailable;
-const isImageThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType.trim().toLowerCase());
-};
-exports.isImageThumbnailable = isImageThumbnailable;
-const tryUploadThumbnail = async ({ bufferStream, fileType, userBucket, fileUuid, networkFacade, }) => {
-    try {
-        const thumbnailBuffer = bufferStream.getBuffer();
-        if (thumbnailBuffer) {
-            await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, userBucket, fileUuid, networkFacade);
-        }
-    }
-    catch (error) {
-        errors_utils_1.ErrorUtils.report(error);
-    }
-};
-exports.tryUploadThumbnail = tryUploadThumbnail;
-const createFileStreamWithBuffer = ({ path, fileType, }) => {
-    const readable = (0, node_fs_1.createReadStream)(path);
-    if ((0, exports.isFileThumbnailable)(fileType)) {
-        const bufferStream = new stream_utils_1.BufferStream();
-        return {
-            bufferStream,
-            fileStream: readable.pipe(bufferStream),
-        };
-    }
-    return { fileStream: readable };
-};
-exports.createFileStreamWithBuffer = createFileStreamWithBuffer;
+]);
+const thumbnailablePdfExtension = new Set(pdfExtensions['pdf']);
+const thumbnailableExtension = new Set(thumbnailableImageExtension);
+class ThumbnailUtils {
+    static MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB = 500 * 1024 * 1024;
+    static isFileThumbnailable = (fileType) => {
+        return fileType.trim().length > 0 && thumbnailableExtension.has(fileType.trim().toLowerCase());
+    };
+    static isPDFThumbnailable = (fileType) => {
+        return fileType.trim().length > 0 && thumbnailablePdfExtension.has(fileType.trim().toLowerCase());
+    };
+    static isImageThumbnailable = (fileType, size) => {
+        if (size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB)
+            return false;
+        return fileType.trim().length > 0 && thumbnailableImageExtension.has(fileType.trim().toLowerCase());
+    };
+}
+exports.ThumbnailUtils = ThumbnailUtils;