@internxt/cli 1.6.4 → 1.6.6

package/dist/utils/cli.utils.js

@@ -175,17 +175,6 @@ class CLIUtils {
         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;
@@ -194,21 +183,50 @@ class CLIUtils {
         const seconds = milliseconds / 1000;
         return megabytes / seconds;
     };
-    static catchError = ({ error, logReporter, command, jsonFlag, }) => {
-        let message;
-        if ('message' in error && error.message.trim().length > 0) {
+    static catchError = ({ error, logReporter, command, jsonFlag, debugMode, }) => {
+        let message = '';
+        let requestId;
+        if ('requestId' in error) {
+            requestId = error.requestId;
+        }
+        else if ('xRequestId' in error) {
+            requestId = error.xRequestId;
+        }
+        if ('message' in error && typeof error.message === 'string' && error.message?.trim?.().length > 0) {
             message = error.message;
         }
-        else {
+        if ('data' in error) {
+            const errorData = error.data;
+            if (typeof errorData.message === 'string' && errorData.message?.trim?.().length > 0) {
+                message += ' [' + errorData.message + ']';
+            }
+            else if (Array.isArray(errorData.message) && errorData.message.length > 0) {
+                message += ' [' + errorData.message.join(', ') + ']';
+            }
+        }
+        if (message.length === 0) {
             message = JSON.stringify(error);
         }
         CLIUtils.failed(jsonFlag);
+        const jsonLog = {
+            success: false,
+            message,
+            command,
+        };
+        if (requestId) {
+            jsonLog.requestId = requestId;
+        }
+        if (command) {
+            jsonLog.command = command;
+        }
         if (jsonFlag) {
-            CLIUtils.consoleLog(JSON.stringify({ success: false, message }));
+            CLIUtils.consoleLog(JSON.stringify(jsonLog));
         }
         else {
-            errors_utils_1.ErrorUtils.report(error, { command });
-            CLIUtils.error(logReporter, message);
+            if (debugMode) {
+                errors_utils_1.ErrorUtils.report(error);
+            }
+            CLIUtils.error(logReporter, message + (requestId ? ` (requestId: ${requestId})` : ''));
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);

package/dist/utils/format.utils.js

@@ -10,8 +10,9 @@ const usage_service_1 = require("../services/usage.service");
 dayjs_1.default.extend(utc_1.default);
 class FormatUtils {
     static humanFileSize = (size) => {
-        const i = size == 0 ? 0 : Math.floor(Math.log(size) / Math.log(1024));
-        return Number((size / Math.pow(1024, i)).toFixed(2)) * 1 + ' ' + ['B', 'kB', 'MB', 'GB', 'TB'][i];
+        const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+        const unitIndex = size === 0 ? 0 : Math.min(Math.floor(Math.log(size) / Math.log(1024)), units.length - 1);
+        return Number((size / Math.pow(1024, unitIndex)).toFixed(2)) + ' ' + units[unitIndex];
     };
     static formatDate = (date) => {
         return (0, dayjs_1.default)(date).format('D MMMM, YYYY [at] HH:mm');

package/dist/utils/upload.utils.d.ts

@@ -0,0 +1,19 @@
+import { Readable } from 'node:stream';
+import { BufferStream } from './stream.utils';
+export declare class UploadUtils {
+    static readonly checkUploadSizeLimits: (size: number) => Promise<void>;
+    static readonly prepareUploadStreams: (readable: Readable, fileType: string) => {
+        fileStream: Readable;
+        thumbnailStream: BufferStream | undefined;
+        isThumbnailable: boolean;
+    };
+    static readonly getTimings: (size: number, timings: {
+        networkUpload: number;
+        driveUpload: number;
+        thumbnailUpload: number;
+    }) => {
+        totalTime: number;
+        throughputMBps: number;
+        timingBreakdown: string;
+    };
+}

package/dist/utils/upload.utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadUtils = void 0;
+const usage_service_1 = require("../services/usage.service");
+const format_utils_1 = require("./format.utils");
+const stream_utils_1 = require("./stream.utils");
+const thumbnail_utils_1 = require("./thumbnail.utils");
+const cli_utils_1 = require("./cli.utils");
+const DEFAULT_MAX_FILE_SIZE = 100 * 1024 * 1024 * 1024;
+class UploadUtils {
+    static checkUploadSizeLimits = async (size) => {
+        const limits = await usage_service_1.UsageService.instance.fetchLimits();
+        if (limits?.maxUploadFileSize && size > limits.maxUploadFileSize) {
+            const formattedSize = format_utils_1.FormatUtils.humanFileSize(size);
+            const formattedLimit = format_utils_1.FormatUtils.humanFileSize(limits.maxUploadFileSize);
+            throw new Error(`File is too big (${formattedSize} exceeds account upload limit of ${formattedLimit})`);
+        }
+        if (size > DEFAULT_MAX_FILE_SIZE) {
+            throw new Error('File is too big (more than 100 GB)');
+        }
+    };
+    static prepareUploadStreams = (readable, fileType) => {
+        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType);
+        if (!isThumbnailable) {
+            return { fileStream: readable, thumbnailStream: undefined, isThumbnailable };
+        }
+        const bufferStream = new stream_utils_1.BufferStream();
+        const fileStream = readable.pipe(bufferStream);
+        return { fileStream, thumbnailStream: bufferStream, isThumbnailable };
+    };
+    static getTimings = (size, timings) => {
+        const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+        const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(size, timings.networkUpload);
+        const timingBreakdown = `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`;
+        return { totalTime, throughputMBps, timingBreakdown };
+    };
+}
+exports.UploadUtils = UploadUtils;

package/dist/utils/webdav.utils.d.ts

@@ -6,9 +6,11 @@ export declare class WebDavUtils {
     static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
     static normalizeFolderPath(path: string): string;
     static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static tryGetFileOrFolderMetadata(url: string): Promise<DriveItem | undefined>;
     static getDriveFileFromResource(url: string): Promise<DriveFileItem | undefined>;
     static getDriveFolderFromResource(url: string): Promise<DriveFolderItem | undefined>;
     static getDriveItemFromResource(resource: WebDavRequestedResource): Promise<DriveItem | undefined>;
-    static deleteOrTrashItem(driveItem: DriveItem): Promise<void>;
+    static deleteOrTrashItem<T extends {
+        itemType: 'file' | 'folder';
+        uuid: string;
+    }>(driveItem: T): Promise<void>;
 }

package/dist/utils/webdav.utils.js

@@ -5,12 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const node_path_1 = __importDefault(require("node:path"));
-const drive_folder_service_1 = require("../services/drive/drive-folder.service");
-const drive_file_service_1 = require("../services/drive/drive-file.service");
+const drive_item_service_1 = require("../services/drive/drive-item.service");
 const logger_utils_1 = require("./logger.utils");
 const config_service_1 = require("../services/config.service");
 const trash_service_1 = require("../services/drive/trash.service");
 const format_utils_1 = require("./format.utils");
+const drive_item_repository_1 = require("../services/database/drive-item/drive-item.repository");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -49,28 +49,18 @@ class WebDavUtils {
             parentPath,
         };
     }
-    static async tryGetFileOrFolderMetadata(url) {
-        try {
-            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
-        }
-        catch {
-            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
-        }
-    }
     static async getDriveFileFromResource(url) {
         try {
-            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
+            return await drive_item_service_1.DriveItemService.instance.getFileByPath(url);
         }
-        catch (err) {
-            logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
+        catch {
         }
     }
     static async getDriveFolderFromResource(url) {
         try {
-            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
+            return await drive_item_service_1.DriveItemService.instance.getFolderByPath(url);
         }
-        catch (err) {
-            logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
+        catch {
         }
     }
     static async getDriveItemFromResource(resource) {
@@ -78,10 +68,15 @@ class WebDavUtils {
         const isFolder = resource.url.endsWith('/');
         try {
             if (isFolder) {
-                item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(resource.url);
+                item = await drive_item_service_1.DriveItemService.instance.getFolderByPath(resource.url);
             }
             else {
-                item = await this.tryGetFileOrFolderMetadata(resource.url);
+                try {
+                    item = await drive_item_service_1.DriveItemService.instance.getFileByPath(resource.url);
+                }
+                catch {
+                    item = await drive_item_service_1.DriveItemService.instance.getFolderByPath(resource.url);
+                }
             }
         }
         catch {
@@ -103,6 +98,7 @@ class WebDavUtils {
             });
             logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
         }
+        await drive_item_repository_1.DriveItemRepository.instance.delete([driveItem.uuid]);
     }
 }
 exports.WebDavUtils = WebDavUtils;

package/dist/utils/xml.utils.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XMLUtils = void 0;
 const fast_xml_parser_1 = require("fast-xml-parser");
+const fast_xml_builder_1 = __importDefault(require("fast-xml-builder"));
 class XMLUtils {
     static DEFAULT_NAMESPACE_LETTER = 'D';
     static toJSON(xml, options = {}) {
@@ -9,7 +13,7 @@ class XMLUtils {
         return parser.parse(xml);
     }
     static toXML(object, options) {
-        const builder = new fast_xml_parser_1.XMLBuilder(options);
+        const builder = new fast_xml_builder_1.default(options);
         return builder.build(object);
     }
     static toWebDavXML(object, options, rootObject = 'multistatus') {

package/dist/webdav/handlers/DELETE.handler.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
+const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
@@ -13,6 +14,7 @@ class DELETERequestHandler {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
         await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveItem);
+        await drive_item_repository_1.DriveItemRepository.instance.delete([driveItem.uuid]);
         res.status(204).send();
     };
 }

package/dist/webdav/handlers/LOCK.handler.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response } from 'express';
+import { WebDavMethodHandler } from '../../types/webdav.types';
+export declare class LOCKRequestHandler implements WebDavMethodHandler {
+    handle: (req: Request, res: Response) => Promise<void>;
+}

package/dist/webdav/handlers/LOCK.handler.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOCKRequestHandler = void 0;
+const node_crypto_1 = require("node:crypto");
+const logger_utils_1 = require("../../utils/logger.utils");
+const xml_utils_1 = require("../../utils/xml.utils");
+const LOCK_TIMEOUT_SECONDS = 300;
+class LOCKRequestHandler {
+    handle = async (req, res) => {
+        const lockToken = `opaquelocktoken:${(0, node_crypto_1.randomUUID)()}`;
+        logger_utils_1.webdavLogger.info(`[LOCK] Granted lock token ${lockToken} for ${req.url}`);
+        const depth = req.headers['depth'] ?? '0';
+        const timeout = req.headers['timeout'] ?? `Second-${LOCK_TIMEOUT_SECONDS}`;
+        let owner;
+        try {
+            const parsed = xml_utils_1.XMLUtils.toJSON(req.body, { ignoreAttributes: false });
+            const maybeOwner = parsed?.['D:lockinfo']?.['D:owner'];
+            if (maybeOwner != null) {
+                owner = { [xml_utils_1.XMLUtils.addDefaultNamespace('owner')]: maybeOwner };
+            }
+        }
+        catch {
+        }
+        const lockDiscoveryXml = xml_utils_1.XMLUtils.toWebDavXML({
+            [xml_utils_1.XMLUtils.addDefaultNamespace('lockdiscovery')]: {
+                [xml_utils_1.XMLUtils.addDefaultNamespace('activelock')]: {
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('locktype')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('write')]: '',
+                    },
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('lockscope')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('exclusive')]: '',
+                    },
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('depth')]: depth,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('timeout')]: timeout,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('locktoken')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: lockToken,
+                    },
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('lockroot')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: req.url,
+                    },
+                    ...owner,
+                },
+            },
+        }, { suppressEmptyNode: true }, 'prop');
+        res.set('Lock-Token', `<${lockToken}>`);
+        res.set('Content-Type', 'application/xml; charset="utf-8"');
+        res.status(200).send(lockDiscoveryXml);
+    };
+}
+exports.LOCKRequestHandler = LOCKRequestHandler;

package/dist/webdav/handlers/MKCOL.handler.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MKCOLRequestHandler = void 0;
+const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
 const webdav_folder_service_1 = require("../../services/webdav/webdav-folder.service");
-const errors_utils_1 = require("../../utils/errors.utils");
+const async_utils_1 = require("../../utils/async.utils");
 class MKCOLRequestHandler {
     handle = async (req, res) => {
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
@@ -15,14 +16,25 @@ class MKCOLRequestHandler {
         const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource(resource.url);
         const folderAlreadyExists = !!driveFolderItem;
         if (folderAlreadyExists) {
-            logger_utils_1.webdavLogger.info(`[MKCOL] ❌ Folder '${resource.url}' already exists`);
-            throw new errors_utils_1.MethodNotAllowed('Folder already exists');
+            logger_utils_1.webdavLogger.info(`[MKCOL] Folder '${resource.url}' already exists, ignoring the creation request`);
+            res.status(200).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
+            return;
         }
         const newFolder = await webdav_folder_service_1.WebDavFolderService.instance.createFolder({
             folderName: resource.path.base,
             parentFolderUuid: parentDriveFolderItem.uuid,
         });
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
+        await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+            {
+                uuid: newFolder.uuid,
+                path: resource.url,
+                type: 'folder',
+                createdAt: newFolder.createdAt,
+                updatedAt: new Date(),
+            },
+        ]);
+        await async_utils_1.AsyncUtils.sleep(500);
         res.status(201).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
     };
 }

package/dist/webdav/handlers/MOVE.handler.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOVERequestHandler = void 0;
 const drive_file_service_1 = require("../../services/drive/drive-file.service");
 const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
+const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const errors_utils_1 = require("../../utils/errors.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
@@ -64,6 +65,16 @@ class MOVERequestHandler {
                 });
             }
         }
+        await drive_item_repository_1.DriveItemRepository.instance.delete([originalDriveItem.uuid]);
+        await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+            {
+                uuid: originalDriveItem.uuid,
+                path: destinationResource.url,
+                type: originalDriveItem.itemType,
+                createdAt: new Date(originalDriveItem.createdAt),
+                updatedAt: new Date(),
+            },
+        ]);
         res.status(204).send();
     };
 }

package/dist/webdav/handlers/OPTIONS.handler.js

@@ -8,21 +8,21 @@ class OPTIONSRequestHandler {
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[OPTIONS] Request received for item at ${resource.url}`);
         if (resource.url === '/' || resource.url === '') {
-            const allowedMethods = 'DELETE, GET, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND, PUT';
+            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, PUT, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
-            res.header('Allow', 'DELETE, GET, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND, PUT');
+            res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
         else if (resource.url.endsWith('/')) {
-            const allowedMethods = 'DELETE, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND';
+            const allowedMethods = 'DELETE, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
         else {
-            const allowedMethods = 'DELETE, GET, HEAD, MOVE, OPTIONS, PROPFIND, PUT';
+            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MOVE, OPTIONS, PROPFIND, PUT, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');

package/dist/webdav/handlers/PROPFIND.handler.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROPFINDRequestHandler = void 0;
 const xml_utils_1 = require("../../utils/xml.utils");
+const drive_item_domain_1 = require("../../services/database/drive-item/drive-item.domain");
+const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const format_utils_1 = require("../../utils/format.utils");
 const node_crypto_1 = require("node:crypto");
@@ -76,9 +78,11 @@ class PROPFINDRequestHandler {
     };
     getFolderChildsXMLNode = async (relativePath, folderUuid) => {
         const folderContent = await drive_folder_service_1.DriveFolderService.instance.getFolderContent(folderUuid);
-        const foldersXML = folderContent.folders.map((folder) => {
+        const xmlNodes = [];
+        const cachedItems = [];
+        for (const folder of folderContent.folders) {
             const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
-            return this.driveFolderItemToXMLNode({
+            xmlNodes.push(this.driveFolderItemToXMLNode({
                 itemType: 'folder',
                 name: folder.plainName,
                 bucket: folder.bucket,
@@ -89,11 +93,18 @@ class PROPFINDRequestHandler {
                 modificationTime: new Date(folder.modificationTime),
                 uuid: folder.uuid,
                 parentUuid: folder.parentUuid,
-            }, folderRelativePath);
-        });
-        const filesXML = folderContent.files.map((file) => {
+            }, folderRelativePath));
+            cachedItems.push(new drive_item_domain_1.DriveItemBD({
+                uuid: folder.uuid,
+                path: folderRelativePath,
+                type: 'folder',
+                createdAt: new Date(folder.createdAt),
+                updatedAt: new Date(),
+            }));
+        }
+        for (const file of folderContent.files) {
             const fileRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, file.type ? `${file.plainName}.${file.type}` : file.plainName);
-            return this.driveFileItemToXMLNode({
+            xmlNodes.push(this.driveFileItemToXMLNode({
                 itemType: 'file',
                 name: file.plainName,
                 bucket: file.bucket,
@@ -107,9 +118,19 @@ class PROPFINDRequestHandler {
                 modificationTime: new Date(file.modificationTime),
                 createdAt: new Date(file.createdAt),
                 updatedAt: new Date(file.updatedAt),
-            }, fileRelativePath);
-        });
-        return foldersXML.concat(filesXML);
+            }, fileRelativePath));
+            cachedItems.push(new drive_item_domain_1.DriveItemBD({
+                uuid: file.uuid,
+                path: fileRelativePath,
+                type: 'file',
+                createdAt: new Date(file.createdAt),
+                updatedAt: new Date(),
+            }));
+        }
+        if (cachedItems.length > 0) {
+            await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate(cachedItems);
+        }
+        return xmlNodes;
     };
     driveFolderRootStatsToXMLNode = async (driveFolderItem, relativePath) => {
         const totalUsage = await usage_service_1.UsageService.instance.fetchUsage();

package/dist/webdav/handlers/PUT.handler.js

@@ -2,30 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PUTRequestHandler = void 0;
 const drive_file_service_1 = require("../../services/drive/drive-file.service");
+const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const auth_service_1 = require("../../services/auth.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const cli_utils_1 = require("../../utils/cli.utils");
-const stream_utils_1 = require("../../utils/stream.utils");
 const webdav_folder_service_1 = require("../../services/webdav/webdav-folder.service");
-const async_utils_1 = require("../../utils/async.utils");
-const thumbnail_utils_1 = require("../../utils/thumbnail.utils");
 const thumbnail_service_1 = require("../../services/thumbnail.service");
+const format_utils_1 = require("../../utils/format.utils");
+const upload_utils_1 = require("../../utils/upload.utils");
 class PUTRequestHandler {
     handle = async (req, res) => {
         let contentLength = Number(req.headers['content-length']);
         if (!contentLength || Number.isNaN(contentLength) || contentLength <= 0) {
             contentLength = 0;
         }
+        await upload_utils_1.UploadUtils.checkUploadSizeLimits(contentLength);
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
-        const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
-        if (driveFileItem?.itemType === 'folder') {
-            throw new errors_utils_1.NotFoundError('Folders cannot be created with PUT. Use MKCOL instead.');
-        }
         logger_utils_1.webdavLogger.info(`[PUT] Request received for file at ${resource.url}`);
-        logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' (${cli_utils_1.CLIUtils.formatBytesToString(contentLength)}) to '${resource.parentPath}'`);
+        logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' (${format_utils_1.FormatUtils.humanFileSize(contentLength)}) to '${resource.parentPath}'`);
         const timings = {
             networkUpload: 0,
             driveUpload: 0,
@@ -33,23 +30,25 @@ class PUTRequestHandler {
         };
         const parentDriveFolderItem = (await webdav_folder_service_1.WebDavFolderService.instance.getDriveFolderItemFromPath(resource.parentPath)) ??
             (await webdav_folder_service_1.WebDavFolderService.instance.createParentPathOrThrow(resource.parentPath));
-        try {
-            if (driveFileItem && driveFileItem.status === 'EXISTS') {
-                logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', it will be replaced...`);
+        let isReplacement = false;
+        const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
+        if (driveFileItem && driveFileItem.status === 'EXISTS') {
+            if (driveFileItem.itemType === 'folder') {
+                logger_utils_1.webdavLogger.info('[PUT] ❌ A folder exists on the cloud with the same name.');
+                throw new errors_utils_1.ConflictError('A folder exists on the cloud with the same name');
+            }
+            isReplacement = true;
+            logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', it will be replaced...`);
+            try {
                 await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveFileItem);
+                await drive_item_repository_1.DriveItemRepository.instance.delete([driveFileItem.uuid]);
+            }
+            catch {
             }
-        }
-        catch {
         }
         const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const fileType = resource.path.ext.replace('.', '');
-        let bufferStream;
-        let fileStream = req;
-        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType);
-        if (isThumbnailable) {
-            bufferStream = new stream_utils_1.BufferStream();
-            fileStream = req.pipe(bufferStream);
-        }
+        const { fileStream, thumbnailStream } = upload_utils_1.UploadUtils.prepareUploadStreams(req, fileType);
         const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(user);
         let fileId;
         if (contentLength > 0) {
@@ -90,28 +89,33 @@ class PUTRequestHandler {
             encryptVersion: types_1.EncryptionVersion.Aes03,
         });
         timings.driveUpload = driveTimer.stop();
+        await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+            {
+                uuid: file.uuid,
+                path: resource.url,
+                type: 'file',
+                createdAt: file.createdAt,
+                updatedAt: new Date(),
+            },
+        ]);
         const thumbnailTimer = cli_utils_1.CLIUtils.timer();
-        if (contentLength > 0 && isThumbnailable && bufferStream) {
-            await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
-                fileUuid: file.uuid,
-                bufferStream,
-                fileType,
-                bucket,
-                networkFacade,
-                size: contentLength,
-            });
-        }
+        await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
+            fileUuid: file.uuid,
+            bufferStream: thumbnailStream,
+            fileType,
+            bucket,
+            networkFacade,
+            size: contentLength,
+        });
         timings.thumbnailUpload = thumbnailTimer.stop();
-        const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
-        const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(contentLength, timings.networkUpload);
-        logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${cli_utils_1.CLIUtils.formatDuration(totalTime)} to Internxt Drive`);
-        logger_utils_1.webdavLogger.info('[PUT] 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`);
-        await async_utils_1.AsyncUtils.sleep(500);
-        logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-201] ${resource.url} - Returning 201 Created after ${cli_utils_1.CLIUtils.formatDuration(totalTime)}`);
-        res.status(201).send();
+        const { totalTime, timingBreakdown } = upload_utils_1.UploadUtils.getTimings(contentLength, timings);
+        logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${cli_utils_1.CLIUtils.formatDuration(totalTime)} to Internxt Drive\n` +
+            '[PUT] Timing breakdown:\n' +
+            timingBreakdown);
+        const statusCode = isReplacement ? 204 : 201;
+        logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-${statusCode}] ${resource.url} - Returning ${statusCode} ` +
+            `after ${cli_utils_1.CLIUtils.formatDuration(totalTime)}`);
+        res.status(statusCode).send();
     };
 }
 exports.PUTRequestHandler = PUTRequestHandler;

package/dist/webdav/handlers/UNLOCK.handler.d.ts

@@ -0,0 +1,5 @@
+import { Request, Response } from 'express';
+import { WebDavMethodHandler } from '../../types/webdav.types';
+export declare class UNLOCKRequestHandler implements WebDavMethodHandler {
+    handle: (req: Request, res: Response) => Promise<void>;
+}