@internxt/cli 1.6.1 → 1.6.3

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

@@ -2,106 +2,119 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PUTRequestHandler = void 0;
 const drive_file_service_1 = require("../../services/drive/drive-file.service");
+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 trash_service_1 = require("../../services/drive/trash.service");
 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 async_utils_1 = require("../../utils/async.utils");
 class PUTRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const contentLength = Number(req.headers['content-length']);
-        if (!contentLength || isNaN(contentLength) || contentLength <= 0) {
-            throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
+        let contentLength = Number(req.headers['content-length']);
+        if (!contentLength || Number.isNaN(contentLength) || contentLength <= 0) {
+            contentLength = 0;
         }
         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,
-        });
+        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}' to '${resource.parentPath}'`);
-        const parentDriveFolderItem = (await this.dependencies.webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
-            (await this.dependencies.webDavFolderService.createParentPathOrThrow(resource.parentPath));
+        logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' (${cli_utils_1.CLIUtils.formatBytesToString(contentLength)}) to '${resource.parentPath}'`);
+        const timings = {
+            networkUpload: 0,
+            driveUpload: 0,
+            thumbnailUpload: 0,
+        };
+        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}', trashing it...`);
-                await this.dependencies.trashService.trashItems({
+                await trash_service_1.TrashService.instance.trashItems({
                     items: [{ type: driveFileItem.itemType, uuid: driveFileItem.uuid }],
                 });
             }
         }
         catch {
         }
-        const { user } = await this.dependencies.authService.getAuthDetails();
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const fileType = resource.path.ext.replace('.', '');
-        const timer = cli_utils_1.CLIUtils.timer();
         let bufferStream;
         let fileStream = req;
-        const isThumbnailable = (0, thumbnail_utils_1.isFileThumbnailable)(fileType);
+        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType);
         if (isThumbnailable) {
             bufferStream = new stream_utils_1.BufferStream();
             fileStream = req.pipe(bufferStream);
         }
-        let uploaded = false, aborted = false;
-        const progressCallback = (progress) => {
-            if (!uploaded && !aborted) {
-                logger_utils_1.webdavLogger.info(`[PUT] Upload progress for file ${resource.name}: ${(progress * 100).toFixed(2)}%`);
-            }
-        };
-        const fileId = await new Promise((resolve, reject) => {
-            const state = this.dependencies.networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
-                if (err) {
-                    aborted = true;
-                    return reject(err);
-                }
-                resolve(res);
-            }, progressCallback);
-            res.on('close', async () => {
-                aborted = true;
-                if (!uploaded) {
-                    logger_utils_1.webdavLogger.info('[PUT] ❌ HTTP Client has been disconnected, res has been closed.');
-                    state.stop();
+        const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(user);
+        let fileId;
+        if (contentLength > 0) {
+            let uploaded = false, aborted = false;
+            const progressCallback = (progress) => {
+                if (!uploaded && !aborted) {
+                    logger_utils_1.webdavLogger.info(`[PUT] Upload progress for file ${resource.name}: ${(progress * 100).toFixed(2)}%`);
                 }
+            };
+            const networkUploadTimer = cli_utils_1.CLIUtils.timer();
+            fileId = await new Promise((resolve, reject) => {
+                const state = networkFacade.uploadFile(fileStream, contentLength, bucket, (err, res) => {
+                    if (err) {
+                        aborted = true;
+                        return reject(err);
+                    }
+                    resolve(res);
+                }, progressCallback);
+                res.on('close', async () => {
+                    aborted = true;
+                    if (!uploaded) {
+                        logger_utils_1.webdavLogger.info('[PUT] ❌ HTTP Client has been disconnected, res has been closed.');
+                        state.stop();
+                    }
+                });
             });
-        });
-        uploaded = true;
-        logger_utils_1.webdavLogger.info('[PUT] ✅ File uploaded to network');
+            uploaded = true;
+            timings.networkUpload = networkUploadTimer.stop();
+            logger_utils_1.webdavLogger.info('[PUT] ✅ File uploaded to network');
+        }
+        const driveTimer = cli_utils_1.CLIUtils.timer();
         const file = await drive_file_service_1.DriveFileService.instance.createFile({
             plainName: resource.path.name,
             type: fileType,
             size: contentLength,
             folderUuid: parentDriveFolderItem.uuid,
-            fileId: fileId,
-            bucket: user.bucket,
+            fileId,
+            bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
         });
-        try {
-            if (isThumbnailable && bufferStream) {
-                const thumbnailBuffer = bufferStream.getBuffer();
-                if (thumbnailBuffer) {
-                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, this.dependencies.networkFacade);
-                }
-            }
-        }
-        catch (error) {
-            logger_utils_1.webdavLogger.info(`[PUT] ❌ File thumbnail upload failed ${error.message}`);
+        timings.driveUpload = driveTimer.stop();
+        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,
+            });
         }
-        const uploadTime = timer.stop();
-        logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${uploadTime}ms to Internxt Drive`);
+        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 ${uploadTime}ms (+ 500ms propagation delay)`);
+        logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-201] ${resource.url} - Returning 201 Created after ${cli_utils_1.CLIUtils.formatDuration(totalTime)}`);
         res.status(201).send();
     };
 }

package/dist/webdav/index.js

@@ -7,22 +7,20 @@ const dotenv_1 = __importDefault(require("dotenv"));
 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_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");
-const crypto_service_1 = require("../services/crypto.service");
-const trash_service_1 = require("../services/drive/trash.service");
 const logger_utils_1 = require("../utils/logger.utils");
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const database_service_1 = require("../services/database/database.service");
 dotenv_1.default.config({ quiet: true });
 const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtCliDataDirExists();
     await config_service_1.ConfigService.instance.ensureWebdavCertsDirExists();
     await config_service_1.ConfigService.instance.ensureInternxtLogsDirExists();
-    const { token } = await auth_service_1.AuthService.instance.getAuthDetails();
-    sdk_manager_service_1.SdkManager.init({ token });
-    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)
+    await database_service_1.DatabaseService.instance.initialize();
+    await database_service_1.DatabaseService.instance.clear();
+    const { token, workspace } = await auth_service_1.AuthService.instance.getAuthDetails();
+    sdk_manager_service_1.SdkManager.init({ token, workspaceToken: workspace?.workspaceCredentials.token });
+    new webdav_server_1.WebDavServer((0, express_1.default)())
         .start()
         .then()
         .catch((err) => logger_utils_1.webdavLogger.error('Failed to start WebDAV server', err));

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

@@ -1,3 +1,2 @@
 import { RequestHandler } from 'express';
-import { AuthService } from '../../services/auth.service';
-export declare const AuthMiddleware: (authService: AuthService) => RequestHandler;
+export declare const AuthMiddleware: () => RequestHandler;

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

@@ -2,20 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthMiddleware = void 0;
 const sdk_manager_service_1 = require("../../services/sdk-manager.service");
+const auth_service_1 = require("../../services/auth.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) => {
+const AuthMiddleware = () => {
     return (_, res, next) => {
         (async () => {
             try {
-                const { token } = await authService.getAuthDetails();
-                sdk_manager_service_1.SdkManager.init({ token });
+                const { token, workspace } = await auth_service_1.AuthService.instance.getAuthDetails();
+                sdk_manager_service_1.SdkManager.init({ token, workspaceToken: workspace?.workspaceCredentials.token });
                 next();
             }
             catch (error) {
                 let message = 'Authentication required to access this resource.';
-                if ((0, errors_utils_1.isError)(error)) {
+                if (errors_utils_1.ErrorUtils.isError(error)) {
                     message = error.message;
                     if (error.stack) {
                         logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}\nStack: ${error.stack}`);

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

@@ -5,8 +5,8 @@ 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, _) => {
-    const message = (0, errors_utils_1.isError)(err) ? err.message : 'Something went wrong';
-    if ((0, errors_utils_1.isError)(err) && err.stack) {
+    const message = errors_utils_1.ErrorUtils.isError(err) ? err.message : 'Something went wrong';
+    if (errors_utils_1.ErrorUtils.isError(err) && err.stack) {
         logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}] ${message}\nStack: ${err.stack}`);
     }
     else {
@@ -16,7 +16,7 @@ const ErrorHandlingMiddleware = (err, req, res, _) => {
         [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
     }, {}, 'error');
     let statusCode = 500;
-    if ('statusCode' in err && !isNaN(err.statusCode)) {
+    if ('statusCode' in err && !Number.isNaN(err.statusCode)) {
         statusCode = err.statusCode;
     }
     res.status(statusCode).send(errorBodyXML);

package/dist/webdav/middewares/webdav-auth.middleware.d.ts

@@ -0,0 +1,3 @@
+import { RequestHandler } from 'express';
+import { WebdavConfig } from '../../types/command.types';
+export declare const WebDAVAuthMiddleware: (configs: WebdavConfig) => RequestHandler;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDAVAuthMiddleware = void 0;
+const xml_utils_1 = require("../../utils/xml.utils");
+const WebDAVAuthMiddleware = (configs) => {
+    return (req, res, next) => {
+        (async () => {
+            if (configs.customAuth) {
+                const authHeader = req.headers.authorization;
+                if (!authHeader) {
+                    return sendUnauthorizedError(res, 'Missing Authorization header.');
+                }
+                if (!authHeader.startsWith('Basic ')) {
+                    return sendUnauthorizedError(res, 'Unsupported authentication method. Only Basic authentication is supported.');
+                }
+                const base64Credentials = authHeader.substring(6);
+                const credentials = Buffer.from(base64Credentials, 'base64').toString('utf-8');
+                const [username, password] = credentials.split(':');
+                if (!username || !password) {
+                    return sendUnauthorizedError(res, 'Invalid authentication credentials format.');
+                }
+                if (username !== configs.username || password !== configs.password) {
+                    return sendUnauthorizedError(res, 'Authentication failed. Please check your WebDAV custom credentials.');
+                }
+                else {
+                    next();
+                    return;
+                }
+            }
+            else {
+                next();
+                return;
+            }
+        })();
+    };
+};
+exports.WebDAVAuthMiddleware = WebDAVAuthMiddleware;
+const sendUnauthorizedError = (res, message) => {
+    const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({
+        [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
+    }, {}, 'error');
+    res.status(401).send(errorBodyXML);
+    return;
+};

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

@@ -1,24 +1,11 @@
 import { Express } from 'express';
-import { ConfigService } from '../services/config.service';
-import { DriveFolderService } from '../services/drive/drive-folder.service';
-import { DriveFileService } from '../services/drive/drive-file.service';
-import { DownloadService } from '../services/network/download.service';
-import { AuthService } from '../services/auth.service';
-import { CryptoService } from '../services/crypto.service';
-import { TrashService } from '../services/drive/trash.service';
+import { WebdavConfig } from '../types/command.types';
 export declare class WebDavServer {
     private readonly app;
-    private readonly configService;
-    private readonly driveFileService;
-    private readonly driveFolderService;
-    private readonly downloadService;
-    private readonly authService;
-    private readonly cryptoService;
-    private readonly trashService;
-    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
-    private readonly getNetworkFacade;
+    constructor(app: Express);
     private readonly registerStartMiddlewares;
     private readonly registerEndMiddleWares;
     private readonly registerHandlers;
+    static readonly checkwebDAVCredentials: (configs: WebdavConfig) => void;
     start: () => Promise<void>;
 }

package/dist/webdav/webdav-server.js

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavServer = void 0;
-const https_1 = __importDefault(require("https"));
-const http_1 = __importDefault(require("http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_http_1 = __importDefault(require("node:http"));
 const config_service_1 = require("../services/config.service");
 const OPTIONS_handler_1 = require("./handlers/OPTIONS.handler");
 const PROPFIND_handler_1 = require("./handlers/PROPFIND.handler");
@@ -15,13 +15,9 @@ const auth_middleware_1 = require("./middewares/auth.middleware");
 const request_logger_middleware_1 = require("./middewares/request-logger.middleware");
 const GET_handler_1 = require("./handlers/GET.handler");
 const HEAD_handler_1 = require("./handlers/HEAD.handler");
-const download_service_1 = require("../services/network/download.service");
-const auth_service_1 = require("../services/auth.service");
-const crypto_service_1 = require("../services/crypto.service");
 const errors_middleware_1 = require("./middewares/errors.middleware");
 const express_async_handler_1 = __importDefault(require("express-async-handler"));
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
-const network_facade_service_1 = require("../services/network/network-facade.service");
 const network_utils_1 = require("../utils/network.utils");
 const PUT_handler_1 = require("./handlers/PUT.handler");
 const MKCOL_handler_1 = require("./handlers/MKCOL.handler");
@@ -29,48 +25,16 @@ const DELETE_handler_1 = require("./handlers/DELETE.handler");
 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");
-const webdav_folder_service_1 = require("./services/webdav-folder.service");
+const webdav_auth_middleware_1 = require("./middewares/webdav-auth.middleware");
 class WebDavServer {
     app;
-    configService;
-    driveFileService;
-    driveFolderService;
-    downloadService;
-    authService;
-    cryptoService;
-    trashService;
-    constructor(app, configService, driveFileService, driveFolderService, downloadService, authService, cryptoService, trashService) {
+    constructor(app) {
         this.app = app;
-        this.configService = configService;
-        this.driveFileService = driveFileService;
-        this.driveFolderService = driveFolderService;
-        this.downloadService = downloadService;
-        this.authService = authService;
-        this.cryptoService = cryptoService;
-        this.trashService = trashService;
     }
-    getNetworkFacade = async () => {
-        const credentials = await this.configService.readUser();
-        if (!credentials)
-            throw new Error('Credentials not found in Config service, do login first');
-        const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
-            user: credentials.user.bridgeUser,
-            pass: credentials.user.userId,
-        });
-        const environment = new inxt_js_1.Environment({
-            bridgeUser: credentials.user.bridgeUser,
-            bridgePass: credentials.user.userId,
-            bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
-            encryptionKey: credentials.user.mnemonic,
-            appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
-        });
-        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
-        return networkFacade;
-    };
-    registerStartMiddlewares = () => {
-        this.app.use((0, auth_middleware_1.AuthMiddleware)(auth_service_1.AuthService.instance));
+    registerStartMiddlewares = (configs) => {
+        this.app.use((0, webdav_auth_middleware_1.WebDAVAuthMiddleware)(configs));
+        this.app.use((0, auth_middleware_1.AuthMiddleware)());
         this.app.use((0, request_logger_middleware_1.RequestLoggerMiddleware)({
             enable: true,
         }));
@@ -80,72 +44,50 @@ class WebDavServer {
     registerEndMiddleWares = () => {
         this.app.use(errors_middleware_1.ErrorHandlingMiddleware);
     };
-    registerHandlers = async () => {
+    registerHandlers = () => {
         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));
-        this.app.get(serverListenPath, (0, express_async_handler_1.default)(new GET_handler_1.GETRequestHandler({
-            driveFileService: this.driveFileService,
-            downloadService: this.downloadService,
-            cryptoService: this.cryptoService,
-            authService: this.authService,
-            networkFacade: networkFacade,
-        }).handle));
+        this.app.head(serverListenPath, (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler().handle));
+        this.app.get(serverListenPath, (0, express_async_handler_1.default)(new GET_handler_1.GETRequestHandler().handle));
         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,
-        }).handle));
-        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,
-            driveFileService: this.driveFileService,
-            driveFolderService: this.driveFolderService,
-        }).handle));
+        this.app.propfind(serverListenPath, (0, express_async_handler_1.default)(new PROPFIND_handler_1.PROPFINDRequestHandler().handle));
+        this.app.put(serverListenPath, (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler().handle));
+        this.app.mkcol(serverListenPath, (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler().handle));
+        this.app.delete(serverListenPath, (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler().handle));
         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,
-            webDavFolderService,
-        }).handle));
+        this.app.move(serverListenPath, (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler().handle));
         this.app.copy(serverListenPath, (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
     };
+    static checkwebDAVCredentials = (configs) => {
+        if (configs.customAuth) {
+            if (!configs.username?.trim()) {
+                throw new Error('WebDAV CustomAuth is enabled but no username was provided.');
+            }
+            if (!configs.password?.trim()) {
+                throw new Error('WebDAV CustomAuth is enabled but no password was provided.');
+            }
+        }
+    };
     start = async () => {
-        const configs = await this.configService.readWebdavConfig();
+        const configs = await config_service_1.ConfigService.instance.readWebdavConfig();
+        WebDavServer.checkwebDAVCredentials(configs);
         this.app.disable('x-powered-by');
-        this.registerStartMiddlewares();
-        await this.registerHandlers();
+        this.registerStartMiddlewares(configs);
+        this.registerHandlers();
         this.registerEndMiddleWares();
         const plainHttp = configs.protocol === 'http';
         let server;
         if (plainHttp) {
-            server = http_1.default.createServer(this.app);
+            server = node_http_1.default.createServer(this.app);
         }
         else {
             const httpsCerts = await network_utils_1.NetworkUtils.getWebdavSSLCerts(configs);
-            server = https_1.default.createServer(httpsCerts, this.app);
+            server = node_https_1.default.createServer(httpsCerts, this.app);
         }
         server.requestTimeout = configs.timeoutMinutes * 60 * 1000;
         server.listen(Number(configs.port), configs.host, undefined, () => {
             logger_utils_1.webdavLogger.info(`Internxt ${sdk_manager_service_1.SdkManager.getAppDetails().clientVersion} WebDav server ` +
-                `listening at ${configs.protocol}://${configs.host}:${configs.port}`);
+                `listening at ${configs.protocol}://${configs.host}:${configs.port}` +
+                `${configs.customAuth ? ' (with custom authentication)' : ''}`);
         });
     };
 }