@internxt/cli 1.5.0 → 1.5.2

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

@@ -11,7 +11,7 @@ class GETRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFileService, authService, networkFacade } = this.dependencies;
+        const { driveFileService, authService, networkFacade } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
@@ -20,7 +20,6 @@ class GETRequestHandler {
         logger_utils_1.webdavLogger.info(`[GET] Request received for ${resource.type} at ${resource.url}`);
         const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
-            driveDatabaseManager,
             driveFileService,
         }));
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);

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

@@ -1,12 +1,10 @@
 import { Request, Response } from 'express';
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { DriveFileService } from '../../services/drive/drive-file.service';
-import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 export declare class HEADRequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
-        driveDatabaseManager: DriveDatabaseManager;
     });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -10,32 +10,37 @@ class HEADRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFileService } = this.dependencies;
+        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 driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
-            resource,
-            driveDatabaseManager,
-            driveFileService,
-        }));
-        logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
-        const range = req.headers['range'];
-        const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
-            range,
-            totalFileSize: driveFile.size,
-        });
-        let contentLength = driveFile.size;
-        if (rangeOptions) {
-            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
-            contentLength = rangeOptions.rangeSize;
+        try {
+            const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+                resource,
+                driveFileService,
+            }));
+            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+            const range = req.headers['range'];
+            const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+                range,
+                totalFileSize: driveFile.size,
+            });
+            let contentLength = driveFile.size;
+            if (rangeOptions) {
+                logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+                contentLength = rangeOptions.rangeSize;
+            }
+            res.header('Content-Type', 'application/octet-stream');
+            res.header('Content-length', contentLength.toString());
+            res.status(200).send();
+        }
+        catch {
+            res.header('Content-Type', 'application/octet-stream');
+            res.status(200).send();
         }
-        res.header('Content-Type', 'application/octet-stream');
-        res.header('Content-length', contentLength.toString());
-        res.status(200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

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

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

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

@@ -5,39 +5,38 @@ 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;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFolderService } = this.dependencies;
+        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);
+        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
         const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource: parentResource,
-            driveDatabaseManager,
             driveFolderService,
         }));
+        let folderAlreadyExists = true;
+        try {
+            await driveFolderService.getFolderMetadataByPath(resource.url);
+        }
+        catch {
+            folderAlreadyExists = false;
+        }
+        if (folderAlreadyExists) {
+            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 createFolder;
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
-        await driveDatabaseManager.createFolder({
-            name: newFolder.plainName,
-            status: 'EXISTS',
-            encryptedName: newFolder.name,
-            bucket: newFolder.bucket,
-            id: newFolder.id,
-            parentId: newFolder.parentId,
-            parentUuid: newFolder.parentUuid,
-            uuid: newFolder.uuid,
-            createdAt: new Date(newFolder.createdAt),
-            updatedAt: new Date(newFolder.updatedAt),
-        }, resource.url);
         await async_utils_1.AsyncUtils.sleep(500);
         res.status(201).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
     };

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

@@ -1,12 +1,10 @@
 import { Request, Response } from 'express';
-import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 import { DriveFileService } from '../../services/drive/drive-file.service';
 import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { WebDavMethodHandler } from '../../types/webdav.types';
 export declare class MOVERequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
-        driveDatabaseManager: DriveDatabaseManager;
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;
     });

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

@@ -10,7 +10,7 @@ class MOVERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
+        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 destinationUrl = req.header('destination');
@@ -22,7 +22,6 @@ class MOVERequestHandler {
         logger_utils_1.webdavLogger.info('[MOVE] Destination resource found', { destinationResource });
         const originalDriveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
-            driveDatabaseManager,
             driveFolderService,
             driveFileService,
         });
@@ -35,7 +34,6 @@ class MOVERequestHandler {
                     folderUuid: folder.uuid,
                     name: newName,
                 });
-                await driveDatabaseManager.createFolder(folder, destinationResource.url);
             }
             else if (resource.type === 'file') {
                 const newType = destinationResource.path.ext.replace('.', '');
@@ -44,7 +42,6 @@ class MOVERequestHandler {
                     plainName: newName,
                     type: newType,
                 });
-                await driveDatabaseManager.createFile(file, destinationResource.url);
             }
         }
         else {
@@ -52,7 +49,6 @@ class MOVERequestHandler {
             const destinationFolderResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationResource.parentPath);
             const destinationFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
                 resource: destinationFolderResource,
-                driveDatabaseManager,
                 driveFolderService,
             }));
             if (resource.type === 'folder') {
@@ -61,7 +57,6 @@ class MOVERequestHandler {
                     folderUuid: folder.uuid,
                     destinationFolderUuid: destinationFolderItem.uuid,
                 });
-                await driveDatabaseManager.createFolder(folder, destinationPath);
             }
             else if (resource.type === 'file') {
                 const file = originalDriveItem;
@@ -69,7 +64,6 @@ class MOVERequestHandler {
                     fileUuid: file.uuid,
                     destinationFolderUuid: destinationFolderItem.uuid,
                 });
-                await driveDatabaseManager.createFile(file, destinationPath);
             }
         }
         res.status(204).send();

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

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

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

@@ -17,28 +17,32 @@ class PROPFINDRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
+        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 driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
-            resource,
-            driveDatabaseManager,
-            driveFolderService,
-            driveFileService,
-        });
-        switch (resource.type) {
-            case 'file': {
-                const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
-                res.status(207).send(fileMetaXML);
-                break;
-            }
-            case 'folder': {
-                const depth = req.header('depth') ?? '1';
-                const folderMetaXML = await this.getFolderContentXML(resource, driveItem, depth);
-                res.status(207).send(folderMetaXML);
-                break;
+        try {
+            const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+                resource,
+                driveFolderService,
+                driveFileService,
+            });
+            switch (resource.type) {
+                case 'file': {
+                    const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
+                    res.status(207).send(fileMetaXML);
+                    break;
+                }
+                case 'folder': {
+                    const depth = req.header('depth') ?? '1';
+                    const folderMetaXML = await this.getFolderContentXML(resource, driveItem, depth);
+                    res.status(207).send(folderMetaXML);
+                    break;
+                }
             }
         }
+        catch {
+            res.status(207).send();
+        }
     };
     getFileMetaXML = async (resource, driveFileItem) => {
         const driveFile = this.driveFileItemToXMLNode({
@@ -94,7 +98,7 @@ class PROPFINDRequestHandler {
         return xml;
     };
     getFolderChildsXMLNode = async (relativePath, folderUuid) => {
-        const { driveFolderService, driveDatabaseManager } = this.dependencies;
+        const { driveFolderService } = this.dependencies;
         const folderContent = await driveFolderService.getFolderContent(folderUuid);
         const foldersXML = folderContent.folders.map((folder) => {
             const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
@@ -111,15 +115,6 @@ class PROPFINDRequestHandler {
                 parentUuid: null,
             }, folderRelativePath);
         });
-        await Promise.all(folderContent.folders.map((folder) => {
-            const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
-            return driveDatabaseManager.createFolder({
-                ...folder,
-                name: folder.plainName,
-                encryptedName: folder.name,
-                status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
-            }, folderRelativePath);
-        }));
         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({
@@ -138,16 +133,6 @@ class PROPFINDRequestHandler {
                 size: Number(file.size),
             }, fileRelativePath);
         });
-        await Promise.all(folderContent.files.map((file) => {
-            const fileRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, file.type ? `${file.plainName}.${file.type}` : file.plainName);
-            return driveDatabaseManager.createFile({
-                ...file,
-                name: file.plainName,
-                fileId: file.fileId,
-                size: Number(file.size),
-                encryptedName: file.name,
-            }, fileRelativePath);
-        }));
         return foldersXML.concat(filesXML);
     };
     driveFolderRootStatsToXMLNode = async (driveFolderItem, relativePath) => {

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

@@ -3,7 +3,6 @@ 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 { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { TrashService } from '../../services/drive/trash.service';
 export declare class PUTRequestHandler implements WebDavMethodHandler {
@@ -11,7 +10,6 @@ export declare class PUTRequestHandler implements WebDavMethodHandler {
     constructor(dependencies: {
         driveFileService: DriveFileService;
         driveFolderService: DriveFolderService;
-        driveDatabaseManager: DriveDatabaseManager;
         trashService: TrashService;
         authService: AuthService;
         networkFacade: NetworkFacade;

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

@@ -16,7 +16,7 @@ class PUTRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, authService, networkFacade, driveFileService, driveFolderService, trashService } = this.dependencies;
+        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');
@@ -26,21 +26,18 @@ class PUTRequestHandler {
             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);
+        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
         const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource: parentResource,
-            driveDatabaseManager,
             driveFolderService,
         }));
         try {
             const driveFileItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
                 resource: resource,
-                driveDatabaseManager,
                 driveFileService,
             }));
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
                 logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
-                await driveDatabaseManager.deleteFileById(driveFileItem.id);
                 await trashService.trashItems({
                     items: [{ type: resource.type, uuid: driveFileItem.uuid }],
                 });
@@ -105,8 +102,7 @@ class PUTRequestHandler {
         }
         const uploadTime = timer.stop();
         logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${uploadTime}ms to Internxt Drive`);
-        await driveDatabaseManager.createFile(file, resource.path.dir + '/');
-        res.status(200).send();
+        res.status(201).send();
     };
 }
 exports.PUTRequestHandler = PUTRequestHandler;

package/dist/webdav/index.js

@@ -8,9 +8,6 @@ const webdav_server_1 = require("./webdav-server");
 const express_1 = __importDefault(require("express"));
 const config_service_1 = require("../services/config.service");
 const drive_folder_service_1 = require("../services/drive/drive-folder.service");
-const drive_database_manager_service_1 = require("../services/database/drive-database-manager.service");
-const drive_file_repository_1 = require("../services/database/drive-file/drive-file.repository");
-const drive_folder_repository_1 = require("../services/database/drive-folder/drive-folder.repository");
 const drive_file_service_1 = require("../services/drive/drive-file.service");
 const download_service_1 = require("../services/network/download.service");
 const auth_service_1 = require("../services/auth.service");
@@ -23,13 +20,12 @@ const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtCliDataDirExists();
     await config_service_1.ConfigService.instance.ensureWebdavCertsDirExists();
     await config_service_1.ConfigService.instance.ensureInternxtLogsDirExists();
-    await drive_database_manager_service_1.DriveDatabaseManager.init();
     const { token, newToken } = await auth_service_1.AuthService.instance.getAuthDetails();
     sdk_manager_service_1.SdkManager.init({
         token,
         newToken,
     });
-    new webdav_server_1.WebDavServer((0, express_1.default)(), config_service_1.ConfigService.instance, drive_file_service_1.DriveFileService.instance, drive_folder_service_1.DriveFolderService.instance, new drive_database_manager_service_1.DriveDatabaseManager(new drive_file_repository_1.DriveFileRepository(), new drive_folder_repository_1.DriveFolderRepository()), download_service_1.DownloadService.instance, auth_service_1.AuthService.instance, crypto_service_1.CryptoService.instance, trash_service_1.TrashService.instance)
+    new webdav_server_1.WebDavServer((0, express_1.default)(), config_service_1.ConfigService.instance, drive_file_service_1.DriveFileService.instance, drive_folder_service_1.DriveFolderService.instance, download_service_1.DownloadService.instance, auth_service_1.AuthService.instance, crypto_service_1.CryptoService.instance, trash_service_1.TrashService.instance)
         .start()
         .then()
         .catch((err) => logger_utils_1.webdavLogger.error('Failed to start WebDAV server', err));

package/dist/webdav/middewares/mkcol.middleware.d.ts

@@ -0,0 +1,2 @@
+import { RequestHandler } from 'express';
+export declare const MkcolMiddleware: RequestHandler;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MkcolMiddleware = void 0;
+const errors_utils_1 = require("../../utils/errors.utils");
+const MkcolMiddleware = (req, _, next) => {
+    if (req.method === 'MKCOL') {
+        let contentType = req.headers['Content-Type'] ?? req.get('content-type');
+        if (contentType && contentType.length > 0) {
+            if (Array.isArray(contentType)) {
+                contentType = contentType[0];
+            }
+            contentType = contentType.toLowerCase().trim();
+            if (contentType !== 'application/xml' && contentType !== 'text/xml') {
+                throw new errors_utils_1.UnsupportedMediaTypeError('Unsupported Media Type');
+            }
+        }
+        if (req.body && Object.keys(req.body).length > 0) {
+            throw new errors_utils_1.UnsupportedMediaTypeError('Unsupported Media Type');
+        }
+    }
+    next();
+};
+exports.MkcolMiddleware = MkcolMiddleware;

package/dist/webdav/webdav-server.d.ts

@@ -1,7 +1,6 @@
 import { Express } from 'express';
 import { ConfigService } from '../services/config.service';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
-import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
 import { DownloadService } from '../services/network/download.service';
 import { AuthService } from '../services/auth.service';
@@ -12,12 +11,11 @@ export declare class WebDavServer {
     private readonly configService;
     private readonly driveFileService;
     private readonly driveFolderService;
-    private readonly driveDatabaseManager;
     private readonly downloadService;
     private readonly authService;
     private readonly cryptoService;
     private readonly trashService;
-    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, driveDatabaseManager: DriveDatabaseManager, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
+    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
     private readonly getNetworkFacade;
     private readonly registerMiddlewares;
     private readonly registerHandlers;

package/dist/webdav/webdav-server.js

@@ -30,22 +30,21 @@ const PROPPATCH_handler_1 = require("./handlers/PROPPATCH.handler");
 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");
 class WebDavServer {
     app;
     configService;
     driveFileService;
     driveFolderService;
-    driveDatabaseManager;
     downloadService;
     authService;
     cryptoService;
     trashService;
-    constructor(app, configService, driveFileService, driveFolderService, driveDatabaseManager, downloadService, authService, cryptoService, trashService) {
+    constructor(app, configService, driveFileService, driveFolderService, downloadService, authService, cryptoService, trashService) {
         this.app = app;
         this.configService = configService;
         this.driveFileService = driveFileService;
         this.driveFolderService = driveFolderService;
-        this.driveDatabaseManager = driveDatabaseManager;
         this.downloadService = downloadService;
         this.authService = authService;
         this.cryptoService = cryptoService;
@@ -69,58 +68,53 @@ class WebDavServer {
         return networkFacade;
     };
     registerMiddlewares = async () => {
-        this.app.use(body_parser_1.default.text({ type: ['application/xml', 'text/xml'] }));
         this.app.use(errors_middleware_1.ErrorHandlingMiddleware);
         this.app.use((0, auth_middleware_1.AuthMiddleware)(auth_service_1.AuthService.instance));
         this.app.use((0, request_logger_middleware_1.RequestLoggerMiddleware)({
             enable: true,
         }));
+        this.app.use(body_parser_1.default.text({ type: ['application/xml', 'text/xml'] }));
+        this.app.use(mkcol_middleware_1.MkcolMiddleware);
     };
     registerHandlers = async () => {
+        const serverListenPath = /(.*)/;
         const networkFacade = await this.getNetworkFacade();
-        this.app.head('*', (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler({
+        this.app.head(serverListenPath, (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler({
             driveFileService: this.driveFileService,
-            driveDatabaseManager: this.driveDatabaseManager,
         }).handle));
-        this.app.get('*', (0, express_async_handler_1.default)(new GET_handler_1.GETRequestHandler({
+        this.app.get(serverListenPath, (0, express_async_handler_1.default)(new GET_handler_1.GETRequestHandler({
             driveFileService: this.driveFileService,
-            driveDatabaseManager: this.driveDatabaseManager,
             downloadService: this.downloadService,
             cryptoService: this.cryptoService,
             authService: this.authService,
             networkFacade: networkFacade,
         }).handle));
-        this.app.options('*', (0, express_async_handler_1.default)(new OPTIONS_handler_1.OPTIONSRequestHandler().handle));
-        this.app.propfind('*', (0, express_async_handler_1.default)(new PROPFIND_handler_1.PROPFINDRequestHandler({
+        this.app.options(serverListenPath, (0, express_async_handler_1.default)(new OPTIONS_handler_1.OPTIONSRequestHandler().handle));
+        this.app.propfind(serverListenPath, (0, express_async_handler_1.default)(new PROPFIND_handler_1.PROPFINDRequestHandler({
             driveFileService: this.driveFileService,
             driveFolderService: this.driveFolderService,
-            driveDatabaseManager: this.driveDatabaseManager,
         }).handle));
-        this.app.put('*', (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler({
+        this.app.put(serverListenPath, (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler({
             driveFileService: this.driveFileService,
             driveFolderService: this.driveFolderService,
-            driveDatabaseManager: this.driveDatabaseManager,
             authService: this.authService,
             trashService: this.trashService,
             networkFacade: networkFacade,
         }).handle));
-        this.app.mkcol('*', (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler({
-            driveDatabaseManager: this.driveDatabaseManager,
+        this.app.mkcol(serverListenPath, (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler({
             driveFolderService: this.driveFolderService,
         }).handle));
-        this.app.delete('*', (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler({
-            driveDatabaseManager: this.driveDatabaseManager,
+        this.app.delete(serverListenPath, (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler({
             trashService: this.trashService,
             driveFileService: this.driveFileService,
             driveFolderService: this.driveFolderService,
         }).handle));
-        this.app.proppatch('*', (0, express_async_handler_1.default)(new PROPPATCH_handler_1.PROPPATCHRequestHandler().handle));
-        this.app.move('*', (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler({
-            driveDatabaseManager: this.driveDatabaseManager,
+        this.app.proppatch(serverListenPath, (0, express_async_handler_1.default)(new PROPPATCH_handler_1.PROPPATCHRequestHandler().handle));
+        this.app.move(serverListenPath, (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler({
             driveFolderService: this.driveFolderService,
             driveFileService: this.driveFileService,
         }).handle));
-        this.app.copy('*', (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
+        this.app.copy(serverListenPath, (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
     };
     start = async () => {
         const configs = await this.configService.readWebdavConfig();
@@ -136,7 +130,7 @@ class WebDavServer {
             const httpsCerts = await network_utils_1.NetworkUtils.getWebdavSSLCerts();
             server = https_1.default.createServer(httpsCerts, this.app);
         }
-        server.requestTimeout = 15 * 60 * 1000;
+        server.requestTimeout = configs.timeoutMinutes * 60 * 1000;
         server.listen(configs.port, () => {
             logger_utils_1.webdavLogger.info(`Internxt ${sdk_manager_service_1.SdkManager.getAppDetails().clientVersion} WebDav server ` +
                 `listening at ${configs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${configs.port}`);

package/oclif.manifest.json

@@ -1163,6 +1163,15 @@
           "required": false,
           "allowNo": false,
           "type": "boolean"
+        },
+        "timeout": {
+          "char": "t",
+          "description": "Configures the WebDAV server to use this timeout in minutes.",
+          "name": "timeout",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
         }
       },
       "hasDynamicHelp": false,
@@ -1257,5 +1266,5 @@
       ]
     }
   },
-  "version": "1.5.0"
+  "version": "1.5.2"
 }