@internxt/cli 1.5.7 → 1.6.0

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

@@ -11,8 +11,8 @@ class DELETERequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService, driveFolderService, trashService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[DELETE] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[DELETE] Request received for item at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
@@ -21,12 +21,12 @@ class DELETERequestHandler {
         if (!driveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
-        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${resource.type}`);
+        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
         await trashService.trashItems({
-            items: [{ type: resource.type, uuid: driveItem.uuid, id: null }],
+            items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
         });
         res.status(204).send();
-        const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);
+        const type = driveItem.itemType.charAt(0).toUpperCase() + driveItem.itemType.substring(1);
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }

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

@@ -12,20 +12,17 @@ class GETRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService, authService, networkFacade } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
-        if (resource.type === 'folder')
-            throw new errors_utils_1.NotFoundError('Folders cannot be listed with GET. Use PROPFIND instead.');
-        logger_utils_1.webdavLogger.info(`[GET] Request received for ${resource.type} at ${resource.url}`);
-        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        logger_utils_1.webdavLogger.info(`[GET] Request received item at ${resource.url}`);
+        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+            url: resource.url,
             driveFileService,
         });
-        if (!driveItem) {
-            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        if (!driveFile) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}, if trying to access a folder use PROPFIND instead.`);
         }
-        const driveFile = driveItem;
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
         const { user } = await authService.getAuthDetails();
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);

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

@@ -12,21 +12,16 @@ class HEADRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        if (resource.type === 'folder') {
-            res.status(200).send();
-            return;
-        }
-        logger_utils_1.webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[HEAD] Request received for file at ${resource.url}`);
         try {
-            const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource,
+            const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+                url: resource.url,
                 driveFileService,
             });
-            if (!driveItem) {
+            if (!driveFile) {
                 throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
             }
-            const driveFile = driveItem;
             logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
             const range = req.headers['range'];
             const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({

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

@@ -1,10 +1,12 @@
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
 import { DriveFolderService } from '../../services/drive/drive-folder.service';
+import { WebDavFolderService } from '../services/webdav-folder.service';
 export declare class MKCOLRequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFolderService: DriveFolderService;
+        webDavFolderService: WebDavFolderService;
     });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -4,7 +4,6 @@ exports.MKCOLRequestHandler = void 0;
 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 async_utils_1 = require("../../utils/async.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
 class MKCOLRequestHandler {
     dependencies;
@@ -12,20 +11,13 @@ class MKCOLRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveFolderService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[MKCOL] Request received for ${resource.type} at ${resource.url}`);
-        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource: parentResource,
-            driveFolderService,
-        });
-        if (!parentDriveItem) {
-            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
-        }
-        const parentFolderItem = parentDriveItem;
-        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        const { driveFolderService, webDavFolderService } = this.dependencies;
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[MKCOL] Request received for folder at ${resource.url}`);
+        const parentDriveFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
+            (await webDavFolderService.createParentPathOrThrow(resource.parentPath));
+        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
+            url: resource.url,
             driveFolderService,
         });
         const folderAlreadyExists = !!driveFolderItem;
@@ -33,13 +25,11 @@ class MKCOLRequestHandler {
             logger_utils_1.webdavLogger.info(`[MKCOL] ❌ Folder '${resource.url}' already exists`);
             throw new errors_utils_1.MethodNotAllowed('Folder already exists');
         }
-        const [createFolder] = driveFolderService.createFolder({
-            plainName: resource.path.base,
-            parentFolderUuid: parentFolderItem.uuid,
+        const newFolder = await webDavFolderService.createFolder({
+            folderName: resource.path.base,
+            parentFolderUuid: parentDriveFolderItem.uuid,
         });
-        const newFolder = await createFolder;
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
-        await async_utils_1.AsyncUtils.sleep(500);
         res.status(201).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
     };
 }

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

@@ -2,11 +2,13 @@ import { Request, Response } from 'express';
 import { DriveFileService } from '../../services/drive/drive-file.service';
 import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { WebDavMethodHandler } from '../../types/webdav.types';
+import { WebDavFolderService } from '../services/webdav-folder.service';
 export declare class MOVERequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;
+        webDavFolderService: WebDavFolderService;
     });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -10,9 +10,9 @@ class MOVERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveFolderService, driveFileService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[MOVE] Request received for ${resource.type} at ${resource.url}`);
+        const { driveFolderService, driveFileService, webDavFolderService } = this.dependencies;
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[MOVE] Request received for item at ${resource.url}`);
         const destinationUrl = req.header('destination');
         if (!destinationUrl) {
             throw new errors_utils_1.NotFoundError('[MOVE] Destination folder not received');
@@ -28,50 +28,45 @@ class MOVERequestHandler {
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
-        const newName = destinationResource.name;
         if (destinationResource.path.dir === resource.path.dir) {
-            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
-            if (resource.type === 'folder') {
+            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${originalDriveItem.itemType}
+        with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.renameFolder({
                     folderUuid: folder.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
-                const newType = destinationResource.path.ext.replace('.', '');
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.renameFile(file.uuid, {
-                    plainName: newName,
-                    type: newType,
+                    plainName: plainName,
+                    type: fileType,
                 });
             }
         }
         else {
-            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
-            const destinationFolderResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationResource.parentPath);
-            const destinationDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource: destinationFolderResource,
-                driveFolderService,
-            });
-            if (!destinationDriveFolderItem) {
-                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-            }
-            const destinationFolderItem = destinationDriveFolderItem;
-            if (resource.type === 'folder') {
+            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${originalDriveItem.itemType} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
+            const destinationFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(destinationResource.parentPath)) ??
+                (await webDavFolderService.createParentPathOrThrow(destinationResource.parentPath));
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.moveFolder(folder.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
-                const newType = destinationResource.path.ext.replace('.', '');
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.moveFile(file.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
-                    type: newType,
+                    name: plainName,
+                    type: fileType,
                 });
             }
         }

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

@@ -5,8 +5,8 @@ const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 class OPTIONSRequestHandler {
     handle = async (req, res) => {
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[OPTIONS] Request received for ${resource.type} at ${resource.url}`);
+        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';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
@@ -14,7 +14,7 @@ class OPTIONSRequestHandler {
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
-        else if (resource.type === 'folder') {
+        else if (resource.url.endsWith('/')) {
             const allowedMethods = 'DELETE, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);

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

@@ -18,29 +18,18 @@ class PROPFINDRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFolderService, driveFileService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[PROPFIND] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[PROPFIND] Request received for item at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
             driveFileService,
         });
         if (!driveItem) {
-            res.status(207).send(xml_utils_1.XMLUtils.toWebDavXML({
-                [xml_utils_1.XMLUtils.addDefaultNamespace('response')]: {
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(resource.url),
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
-                        [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 404 Not Found',
-                        [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {},
-                    },
-                },
-            }, {
-                ignoreAttributes: false,
-                suppressEmptyNode: true,
-            }));
+            res.status(404).send();
             return;
         }
-        switch (resource.type) {
+        switch (driveItem.itemType) {
             case 'file': {
                 const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
                 res.status(207).send(fileMetaXML);
@@ -55,22 +44,7 @@ class PROPFINDRequestHandler {
         }
     };
     getFileMetaXML = async (resource, driveFileItem) => {
-        const driveFile = this.driveFileItemToXMLNode({
-            name: driveFileItem.name,
-            type: driveFileItem.type,
-            bucket: driveFileItem.bucket,
-            id: driveFileItem.id,
-            uuid: driveFileItem.uuid,
-            fileId: driveFileItem.fileId,
-            size: driveFileItem.size,
-            createdAt: driveFileItem.createdAt,
-            updatedAt: driveFileItem.updatedAt,
-            status: driveFileItem.status,
-            folderId: driveFileItem.folderId,
-            folderUuid: driveFileItem.folderUuid,
-            creationTime: driveFileItem.creationTime,
-            modificationTime: driveFileItem.modificationTime,
-        }, resource.url);
+        const driveFile = this.driveFileItemToXMLNode(driveFileItem, resource.url);
         const xml = xml_utils_1.XMLUtils.toWebDavXML([driveFile], {
             arrayNodeName: xml_utils_1.XMLUtils.addDefaultNamespace('response'),
         });
@@ -114,6 +88,7 @@ class PROPFINDRequestHandler {
         const foldersXML = folderContent.folders.map((folder) => {
             const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
             return this.driveFolderItemToXMLNode({
+                itemType: 'folder',
                 name: folder.plainName,
                 bucket: folder.bucket,
                 status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
@@ -129,6 +104,7 @@ class PROPFINDRequestHandler {
         const filesXML = folderContent.files.map((file) => {
             const fileRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, file.type ? `${file.plainName}.${file.type}` : file.plainName);
             return this.driveFileItemToXMLNode({
+                itemType: 'file',
                 name: file.plainName,
                 bucket: file.bucket,
                 id: file.id,

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

@@ -3,13 +3,15 @@ import { DriveFileService } from '../../services/drive/drive-file.service';
 import { NetworkFacade } from '../../services/network/network-facade.service';
 import { AuthService } from '../../services/auth.service';
 import { WebDavMethodHandler } from '../../types/webdav.types';
-import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { TrashService } from '../../services/drive/trash.service';
+import { WebDavFolderService } from '../services/webdav-folder.service';
+import { DriveFolderService } from '../../services/drive/drive-folder.service';
 export declare class PUTRequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
         driveFolderService: DriveFolderService;
+        webDavFolderService: WebDavFolderService;
         trashService: TrashService;
         authService: AuthService;
         networkFacade: NetworkFacade;

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

@@ -10,46 +10,41 @@ const cli_utils_1 = require("../../utils/cli.utils");
 const stream_utils_1 = require("../../utils/stream.utils");
 const thumbnail_utils_1 = require("../../utils/thumbnail.utils");
 const thumbnail_service_1 = require("../../services/thumbnail.service");
+const async_utils_1 = require("../../utils/async.utils");
 class PUTRequestHandler {
     dependencies;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { authService, networkFacade, driveFileService, driveFolderService, trashService } = this.dependencies;
         const contentLength = Number(req.headers['content-length']);
         if (!contentLength || isNaN(contentLength) || contentLength <= 0) {
             throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
         }
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        if (resource.type === '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 ${resource.type} at ${resource.url}`);
-        logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' to '${resource.parentPath}'`);
-        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource: parentResource,
-            driveFolderService,
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            resource: resource,
+            driveFileService: this.dependencies.driveFileService,
+            driveFolderService: this.dependencies.driveFolderService,
         });
-        if (!parentDriveFolderItem) {
-            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
+        if (driveFileItem?.itemType === 'folder') {
+            throw new errors_utils_1.NotFoundError('Folders cannot be created with PUT. Use MKCOL instead.');
         }
-        const parentFolderItem = parentDriveFolderItem;
+        logger_utils_1.webdavLogger.info(`[PUT] Request received for file at ${resource.url}`);
+        logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' to '${resource.parentPath}'`);
+        const parentDriveFolderItem = (await this.dependencies.webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
+            (await this.dependencies.webDavFolderService.createParentPathOrThrow(resource.parentPath));
         try {
-            const driveFileItem = (await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource: resource,
-                driveFileService,
-            }));
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
                 logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
-                await trashService.trashItems({
-                    items: [{ type: resource.type, uuid: driveFileItem.uuid, id: null }],
+                await this.dependencies.trashService.trashItems({
+                    items: [{ type: driveFileItem.itemType, uuid: driveFileItem.uuid }],
                 });
             }
         }
         catch {
         }
-        const { user } = await authService.getAuthDetails();
+        const { user } = await this.dependencies.authService.getAuthDetails();
         const fileType = resource.path.ext.replace('.', '');
         const timer = cli_utils_1.CLIUtils.timer();
         let bufferStream;
@@ -66,7 +61,7 @@ class PUTRequestHandler {
             }
         };
         const fileId = await new Promise((resolve, reject) => {
-            const state = networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
+            const state = this.dependencies.networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
                 if (err) {
                     aborted = true;
                     return reject(err);
@@ -87,7 +82,7 @@ class PUTRequestHandler {
             plainName: resource.path.name,
             type: fileType,
             size: contentLength,
-            folderUuid: parentFolderItem.uuid,
+            folderUuid: parentDriveFolderItem.uuid,
             fileId: fileId,
             bucket: user.bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
@@ -96,7 +91,7 @@ class PUTRequestHandler {
             if (isThumbnailable && bufferStream) {
                 const thumbnailBuffer = bufferStream.getBuffer();
                 if (thumbnailBuffer) {
-                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, networkFacade);
+                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, this.dependencies.networkFacade);
                 }
             }
         }
@@ -105,6 +100,8 @@ class PUTRequestHandler {
         }
         const uploadTime = timer.stop();
         logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${uploadTime}ms to Internxt Drive`);
+        await async_utils_1.AsyncUtils.sleep(500);
+        logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-201] ${resource.url} - Returning 201 Created after ${uploadTime}ms (+ 500ms propagation delay)`);
         res.status(201).send();
     };
 }

package/dist/webdav/middewares/auth.middleware.js

@@ -4,6 +4,7 @@ exports.AuthMiddleware = void 0;
 const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 const AuthMiddleware = (authService) => {
     return (_, res, next) => {
         (async () => {
@@ -14,10 +15,15 @@ const AuthMiddleware = (authService) => {
             }
             catch (error) {
                 let message = 'Authentication required to access this resource.';
-                if ('message' in error && error.message.trim().length > 0) {
+                if ((0, errors_utils_1.isError)(error)) {
                     message = error.message;
+                    if (error.stack) {
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}\nStack: ${error.stack}`);
+                    }
+                    else {
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}`);
+                    }
                 }
-                logger_utils_1.webdavLogger.error('Error from AuthMiddleware: ' + message);
                 const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({
                     [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
                 }, {}, 'error');

package/dist/webdav/middewares/errors.middleware.js

@@ -3,10 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorHandlingMiddleware = void 0;
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 const ErrorHandlingMiddleware = (err, req, res, _) => {
-    logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}]`, err);
+    const message = (0, errors_utils_1.isError)(err) ? err.message : 'Something went wrong';
+    if ((0, errors_utils_1.isError)(err) && err.stack) {
+        logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}] ${message}\nStack: ${err.stack}`);
+    }
+    else {
+        logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}] ${message}`);
+    }
     const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({
-        [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: 'message' in err ? err.message : 'Something went wrong',
+        [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
     }, {}, 'error');
     let statusCode = 500;
     if ('statusCode' in err && !isNaN(err.statusCode)) {

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

@@ -0,0 +1,17 @@
+import { ConfigService } from '../../services/config.service';
+import { DriveFolderService } from '../../services/drive/drive-folder.service';
+import { DriveFolderItem } from '../../types/drive.types';
+export declare class WebDavFolderService {
+    private readonly dependencies;
+    constructor(dependencies: {
+        driveFolderService: DriveFolderService;
+        configService: ConfigService;
+    });
+    getDriveFolderItemFromPath: (path: string) => Promise<DriveFolderItem | undefined>;
+    createFolder: ({ folderName, parentFolderUuid, }: {
+        folderName: string;
+        parentFolderUuid: string;
+    }) => Promise<DriveFolderItem>;
+    createParentPathOrThrow: (parentPath: string) => Promise<DriveFolderItem>;
+    private createFolderRecursively;
+}

package/dist/webdav/services/webdav-folder.service.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDavFolderService = void 0;
+const errors_utils_1 = require("../../utils/errors.utils");
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const async_utils_1 = require("../../utils/async.utils");
+const auth_service_1 = require("../../services/auth.service");
+const drive_utils_1 = require("../../utils/drive.utils");
+class WebDavFolderService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    getDriveFolderItemFromPath = async (path) => {
+        const { url } = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
+        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
+            url,
+            driveFolderService: this.dependencies.driveFolderService,
+        });
+    };
+    createFolder = async ({ folderName, parentFolderUuid, }) => {
+        const [createFolderPromise] = this.dependencies.driveFolderService.createFolder({
+            plainName: folderName,
+            parentFolderUuid: parentFolderUuid,
+        });
+        const newFolder = await createFolderPromise;
+        await async_utils_1.AsyncUtils.sleep(500);
+        return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
+    };
+    createParentPathOrThrow = async (parentPath) => {
+        const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
+        if (!createFullPath) {
+            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)},
+        createFullPath flag is set to: ${createFullPath}`);
+        }
+        const folders = parentPath.split('/').filter((f) => f.length > 0);
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        return await this.createFolderRecursively(folders, user.rootFolderId);
+    };
+    async createFolderRecursively(remainingFolders, parentFolderUuid, accumulatedPath = '') {
+        const [currentFolderName, ...rest] = remainingFolders;
+        const newPath = webdav_utils_1.WebDavUtils.joinURL(accumulatedPath, currentFolderName);
+        const folderPath = webdav_utils_1.WebDavUtils.normalizeFolderPath(newPath);
+        const folder = (await this.getDriveFolderItemFromPath(folderPath)) ??
+            (await this.createFolder({ folderName: currentFolderName, parentFolderUuid }));
+        if (rest.length === 0) {
+            return folder;
+        }
+        return await this.createFolderRecursively(rest, folder.uuid, newPath);
+    }
+}
+exports.WebDavFolderService = WebDavFolderService;

package/dist/webdav/webdav-server.js

@@ -31,6 +31,7 @@ const MOVE_handler_1 = require("./handlers/MOVE.handler");
 const COPY_handler_1 = require("./handlers/COPY.handler");
 const inxt_js_1 = require("@internxt/inxt-js");
 const mkcol_middleware_1 = require("./middewares/mkcol.middleware");
+const webdav_folder_service_1 = require("./services/webdav-folder.service");
 class WebDavServer {
     app;
     configService;
@@ -82,6 +83,10 @@ class WebDavServer {
     registerHandlers = async () => {
         const serverListenPath = /(.*)/;
         const networkFacade = await this.getNetworkFacade();
+        const webDavFolderService = new webdav_folder_service_1.WebDavFolderService({
+            driveFolderService: this.driveFolderService,
+            configService: this.configService,
+        });
         this.app.head(serverListenPath, (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler({
             driveFileService: this.driveFileService,
         }).handle));
@@ -100,12 +105,14 @@ class WebDavServer {
         this.app.put(serverListenPath, (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler({
             driveFileService: this.driveFileService,
             driveFolderService: this.driveFolderService,
+            webDavFolderService: webDavFolderService,
             authService: this.authService,
             trashService: this.trashService,
             networkFacade: networkFacade,
         }).handle));
         this.app.mkcol(serverListenPath, (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler({
             driveFolderService: this.driveFolderService,
+            webDavFolderService: webDavFolderService,
         }).handle));
         this.app.delete(serverListenPath, (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler({
             trashService: this.trashService,
@@ -116,6 +123,7 @@ class WebDavServer {
         this.app.move(serverListenPath, (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler({
             driveFolderService: this.driveFolderService,
             driveFileService: this.driveFileService,
+            webDavFolderService,
         }).handle));
         this.app.copy(serverListenPath, (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
     };