@internxt/cli 1.6.2 → 1.6.3

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROPFINDRequestHandler = void 0;
 const xml_utils_1 = require("../../utils/xml.utils");
+const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const format_utils_1 = require("../../utils/format.utils");
 const node_crypto_1 = require("node:crypto");
 const mime_types_1 = __importDefault(require("mime-types"));
@@ -12,19 +13,10 @@ const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const usage_service_1 = require("../../services/usage.service");
 class PROPFINDRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFolderService, driveFileService } = this.dependencies;
         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,
-        });
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
         if (!driveItem) {
             res.status(404).send();
             return;
@@ -83,8 +75,7 @@ class PROPFINDRequestHandler {
         return xml;
     };
     getFolderChildsXMLNode = async (relativePath, folderUuid) => {
-        const { driveFolderService } = this.dependencies;
-        const folderContent = await driveFolderService.getFolderContent(folderUuid);
+        const folderContent = await drive_folder_service_1.DriveFolderService.instance.getFolderContent(folderUuid);
         const foldersXML = folderContent.folders.map((folder) => {
             const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
             return this.driveFolderItemToXMLNode({
@@ -94,11 +85,10 @@ class PROPFINDRequestHandler {
                 status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
                 createdAt: new Date(folder.createdAt),
                 updatedAt: new Date(folder.updatedAt),
-                id: folder.id,
-                encryptedName: folder.name,
+                creationTime: new Date(folder.creationTime),
+                modificationTime: new Date(folder.modificationTime),
                 uuid: folder.uuid,
-                parentId: null,
-                parentUuid: null,
+                parentUuid: folder.parentUuid,
             }, folderRelativePath);
         });
         const filesXML = folderContent.files.map((file) => {
@@ -107,12 +97,10 @@ class PROPFINDRequestHandler {
                 itemType: 'file',
                 name: file.plainName,
                 bucket: file.bucket,
-                id: file.id,
                 fileId: file.fileId,
                 uuid: file.uuid,
                 type: file.type,
                 status: file.status,
-                folderId: file.folderId,
                 folderUuid: file.folderUuid,
                 size: Number(file.size),
                 creationTime: new Date(file.creationTime),
@@ -124,7 +112,7 @@ class PROPFINDRequestHandler {
         return foldersXML.concat(filesXML);
     };
     driveFolderRootStatsToXMLNode = async (driveFolderItem, relativePath) => {
-        const totalUsage = (await usage_service_1.UsageService.instance.fetchUsage()).total;
+        const totalUsage = await usage_service_1.UsageService.instance.fetchUsage();
         const spaceLimit = await usage_service_1.UsageService.instance.fetchSpaceLimit();
         const driveFolderXML = {
             [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(relativePath),

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

@@ -1,20 +1,5 @@
 import { Request, Response } from 'express';
-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 { 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;
-    });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -2,30 +2,26 @@
 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 thumbnail_utils_1 = require("../../utils/thumbnail.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");
 class PUTRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
         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.');
         }
@@ -36,27 +32,28 @@ class PUTRequestHandler {
             driveUpload: 0,
             thumbnailUpload: 0,
         };
-        const parentDriveFolderItem = (await this.dependencies.webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
-            (await this.dependencies.webDavFolderService.createParentPathOrThrow(resource.parentPath));
+        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('.', '');
         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);
         }
+        const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(user);
         let fileId;
         if (contentLength > 0) {
             let uploaded = false, aborted = false;
@@ -67,7 +64,7 @@ class PUTRequestHandler {
             };
             const networkUploadTimer = cli_utils_1.CLIUtils.timer();
             fileId = await new Promise((resolve, reject) => {
-                const state = this.dependencies.networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
+                const state = networkFacade.uploadFile(fileStream, contentLength, bucket, (err, res) => {
                     if (err) {
                         aborted = true;
                         return reject(err);
@@ -92,29 +89,30 @@ class PUTRequestHandler {
             type: fileType,
             size: contentLength,
             folderUuid: parentDriveFolderItem.uuid,
-            fileId: fileId,
-            bucket: user.bucket,
+            fileId,
+            bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
         });
         timings.driveUpload = driveTimer.stop();
         const thumbnailTimer = cli_utils_1.CLIUtils.timer();
         if (contentLength > 0 && isThumbnailable && bufferStream) {
-            void (0, thumbnail_utils_1.tryUploadThumbnail)({
+            await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
+                fileUuid: file.uuid,
                 bufferStream,
                 fileType,
-                userBucket: user.bucket,
-                fileUuid: file.uuid,
-                networkFacade: this.dependencies.networkFacade,
+                bucket,
+                networkFacade,
+                size: contentLength,
             });
         }
         timings.thumbnailUpload = thumbnailTimer.stop();
         const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
         const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(contentLength, timings.networkUpload);
         logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${cli_utils_1.CLIUtils.formatDuration(totalTime)} to Internxt Drive`);
-        logger_utils_1.webdavLogger.info(`[PUT] Timing breakdown:\n
-      Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)} (${throughputMBps.toFixed(2)} MB/s)\n
-      Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n
-      Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n`);
+        logger_utils_1.webdavLogger.info('[PUT] Timing breakdown:\n' +
+            `Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)} (${throughputMBps.toFixed(2)} MB/s)\n` +
+            `Drive upload: ${cli_utils_1.CLIUtils.formatDuration(timings.driveUpload)}\n` +
+            `Thumbnail: ${cli_utils_1.CLIUtils.formatDuration(timings.thumbnailUpload)}\n`);
         await async_utils_1.AsyncUtils.sleep(500);
         logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-201] ${resource.url} - Returning 201 Created after ${cli_utils_1.CLIUtils.formatDuration(totalTime)}`);
         res.status(201).send();

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 {

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

@@ -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,58 +44,35 @@ 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;
@@ -145,7 +86,8 @@ class WebDavServer {
         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)' : ''}`);
         });
     };
 }