@internxt/cli 1.2.1 → 1.3.0

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

@@ -9,53 +9,38 @@ const format_utils_1 = require("../../utils/format.utils");
 const crypto_1 = require("crypto");
 const mime_types_1 = __importDefault(require("mime-types"));
 const webdav_utils_1 = require("../../utils/webdav.utils");
-const errors_utils_1 = require("../../utils/errors.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+const usage_service_1 = require("../../services/usage.service");
 class PROPFINDRequestHandler {
-    options;
     dependencies;
-    constructor(options = { debug: false }, dependencies) {
-        this.options = options;
+    constructor(dependencies) {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
-        const depth = req.header('depth') ?? '1';
+        const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        logger_utils_1.webdavLogger.info('[PROPFIND] Request received', { resource });
+        const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource,
+            driveDatabaseManager,
+            driveFolderService,
+            driveFileService,
+        });
         switch (resource.type) {
             case 'file': {
-                res.status(207).send(await this.getFileMetaXML(resource));
+                const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
+                res.status(207).send(fileMetaXML);
                 break;
             }
             case 'folder': {
-                if (resource.url === '/') {
-                    const rootFolder = await this.dependencies.driveFolderService.getFolderMetaById(req.user.rootFolderId);
-                    await this.dependencies.driveDatabaseManager.createFolder({
-                        name: '',
-                        status: 'EXISTS',
-                        encryptedName: rootFolder.name,
-                        bucket: rootFolder.bucket,
-                        id: rootFolder.id,
-                        parentId: rootFolder.parentId,
-                        uuid: rootFolder.uuid,
-                        createdAt: new Date(rootFolder.createdAt),
-                        updatedAt: new Date(rootFolder.updatedAt),
-                    });
-                    res.status(207).send(await this.getFolderContentXML('/', rootFolder.uuid, depth, true));
-                    break;
-                }
-                const driveParentFolder = await this.dependencies.driveDatabaseManager.findByRelativePath(resource.url);
-                if (!driveParentFolder) {
-                    res.status(404).send();
-                    return;
-                }
-                res.status(207).send(await this.getFolderContentXML(resource.url, driveParentFolder.uuid, depth));
+                const depth = req.header('depth') ?? '1';
+                const folderMetaXML = await this.getFolderContentXML(resource, driveItem, depth);
+                res.status(207).send(folderMetaXML);
                 break;
             }
         }
     };
-    async getFileMetaXML(resource) {
-        const driveFileItem = await this.dependencies.driveDatabaseManager.findByRelativePath(resource.url);
-        if (!driveFileItem || !('size' in driveFileItem))
-            throw new errors_utils_1.NotFoundError('File not found');
+    getFileMetaXML = async (resource, driveFileItem) => {
         const driveFile = this.driveFileItemToXMLNode({
             name: driveFileItem.name,
             type: driveFileItem.type,
@@ -69,32 +54,35 @@ class PROPFINDRequestHandler {
             updatedAt: driveFileItem.updatedAt,
             status: driveFileItem.status,
             folderId: driveFileItem.folderId,
-        }, encodeURI(resource.url));
+            folderUuid: driveFileItem.folderUuid,
+        }, resource.url);
         const xml = xml_utils_1.XMLUtils.toWebDavXML([driveFile], {
             arrayNodeName: xml_utils_1.XMLUtils.addDefaultNamespace('response'),
         });
         return xml;
-    }
-    async getFolderContentXML(relativePath, folderUuid, depth, isRootFolder = false) {
+    };
+    getFolderContentXML = async (resource, folderItem, depth) => {
+        const relativePath = resource.url;
+        const isRootFolder = resource.url === '/';
         let XMLNodes = [];
         switch (depth) {
             case '0':
                 if (isRootFolder) {
-                    XMLNodes.push(await this.getFolderRootXMLNode(relativePath, folderUuid));
+                    XMLNodes.push(await this.driveFolderRootStatsToXMLNode(folderItem, relativePath));
                 }
                 else {
-                    XMLNodes.push(await this.getFolderXMLNode(relativePath, folderUuid));
+                    XMLNodes.push(this.driveFolderItemToXMLNode(folderItem, relativePath));
                 }
                 break;
             case '1':
             default:
                 if (isRootFolder) {
-                    XMLNodes.push(await this.getFolderRootXMLNode(relativePath, folderUuid));
-                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderUuid));
+                    XMLNodes.push(await this.driveFolderRootStatsToXMLNode(folderItem, relativePath));
+                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderItem.uuid));
                 }
                 else {
-                    XMLNodes.push(await this.getFolderXMLNode(relativePath, folderUuid));
-                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderUuid));
+                    XMLNodes.push(this.driveFolderItemToXMLNode(folderItem, relativePath));
+                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderItem.uuid));
                 }
                 break;
         }
@@ -104,8 +92,8 @@ class PROPFINDRequestHandler {
             suppressEmptyNode: true,
         });
         return xml;
-    }
-    async getFolderChildsXMLNode(relativePath, folderUuid) {
+    };
+    getFolderChildsXMLNode = async (relativePath, folderUuid) => {
         const { driveFolderService, driveDatabaseManager } = this.dependencies;
         const folderContent = await driveFolderService.getFolderContent(folderUuid);
         const foldersXML = folderContent.folders.map((folder) => {
@@ -120,14 +108,18 @@ class PROPFINDRequestHandler {
                 encryptedName: folder.name,
                 uuid: folder.uuid,
                 parentId: null,
-            }, encodeURI(folderRelativePath));
+                parentUuid: null,
+            }, folderRelativePath);
         });
-        await Promise.all(folderContent.folders.map((folder) => driveDatabaseManager.createFolder({
-            ...folder,
-            name: folder.plainName,
-            encryptedName: folder.name,
-            status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
-        })));
+        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({
@@ -142,35 +134,27 @@ class PROPFINDRequestHandler {
                 encryptedName: file.name,
                 status: file.status,
                 folderId: file.folderId,
+                folderUuid: file.folderUuid,
                 size: Number(file.size),
-            }, encodeURI(fileRelativePath));
+            }, fileRelativePath);
         });
         await Promise.all(folderContent.files.map((file) => {
-            driveDatabaseManager.createFile({
+            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);
-    }
-    async getFolderRootXMLNode(relativePath, folderUuid) {
-        const { driveFolderService } = this.dependencies;
-        const folderMeta = await driveFolderService.getFolderMetaByUuid(folderUuid);
-        const folderXML = this.driveFolderRootStatsToXMLNode(folderMeta, encodeURI(relativePath));
-        return folderXML;
-    }
-    async getFolderXMLNode(relativePath, folderUuid) {
-        const { driveFolderService } = this.dependencies;
-        const folderMeta = await driveFolderService.getFolderMetaByUuid(folderUuid);
-        const folderXML = this.driveFolderItemToXMLNode(folderMeta, encodeURI(relativePath));
-        return folderXML;
-    }
-    driveFolderRootStatsToXMLNode(driveFolderItem, relativePath) {
+    };
+    driveFolderRootStatsToXMLNode = async (driveFolderItem, relativePath) => {
+        const totalUsage = (await usage_service_1.UsageService.instance.fetchUsage()).total;
+        const spaceLimit = await usage_service_1.UsageService.instance.fetchSpaceLimit();
         const driveFolderXML = {
-            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: relativePath,
+            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(relativePath),
             [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
                 [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
                 [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
@@ -187,6 +171,8 @@ class PROPFINDRequestHandler {
                         '#text': '00000030',
                         '@_xmlns:x3': 'urn:schemas-microsoft-com:',
                     },
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('quota-available-bytes')]: spaceLimit - totalUsage,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('quota-used-bytes')]: totalUsage,
                     [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: {
                         [xml_utils_1.XMLUtils.addDefaultNamespace('collection')]: '',
                     },
@@ -194,11 +180,11 @@ class PROPFINDRequestHandler {
             },
         };
         return driveFolderXML;
-    }
-    driveFolderItemToXMLNode(driveFolderItem, relativePath) {
+    };
+    driveFolderItemToXMLNode = (driveFolderItem, relativePath) => {
         const displayName = `${driveFolderItem.name}`;
         const driveFolderXML = {
-            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: relativePath,
+            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(relativePath),
             [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
                 [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
                 [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
@@ -212,11 +198,11 @@ class PROPFINDRequestHandler {
             },
         };
         return driveFolderXML;
-    }
-    driveFileItemToXMLNode(driveFileItem, relativePath) {
+    };
+    driveFileItemToXMLNode = (driveFileItem, relativePath) => {
         const displayName = driveFileItem.type ? `${driveFileItem.name}.${driveFileItem.type}` : driveFileItem.name;
         const driveFileXML = {
-            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: relativePath,
+            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(relativePath),
             [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
                 [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
                 [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
@@ -230,6 +216,6 @@ class PROPFINDRequestHandler {
             },
         };
         return driveFileXML;
-    }
+    };
 }
 exports.PROPFINDRequestHandler = PROPFINDRequestHandler;

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

@@ -1,23 +1,20 @@
 import { Request, Response } from 'express';
 import { DriveFileService } from '../../services/drive/drive-file.service';
 import { NetworkFacade } from '../../services/network/network-facade.service';
-import { UploadService } from '../../services/network/upload.service';
-import { DownloadService } from '../../services/network/download.service';
-import { CryptoService } from '../../services/crypto.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 {
-    private dependencies;
+    private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
+        driveFolderService: DriveFolderService;
         driveDatabaseManager: DriveDatabaseManager;
-        uploadService: UploadService;
-        downloadService: DownloadService;
-        cryptoService: CryptoService;
+        trashService: TrashService;
         authService: AuthService;
         networkFacade: NetworkFacade;
     });
     handle: (req: Request, res: Response) => Promise<void>;
-    private getDriveFolderRealmObject;
 }

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

@@ -11,41 +11,57 @@ class PUTRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
+        const { driveDatabaseManager, authService, networkFacade, driveFileService, driveFolderService, trashService } = this.dependencies;
         const contentLength = Number(req.headers['content-length']);
         if (!contentLength || isNaN(contentLength) || contentLength <= 0) {
             throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
         }
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
-        const driveFolder = await this.getDriveFolderRealmObject(resource);
-        logger_utils_1.webdavLogger.info(`PUT request received for uploading file '${resource.name}' to '${resource.path.dir}'`);
-        if (!driveFolder) {
-            throw new errors_utils_1.ConflictError('Drive destination folder not found');
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        logger_utils_1.webdavLogger.info(`PUT request received for uploading file '${resource.name}' to '${resource.parentPath}'`);
+        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath);
+        const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource: parentResource,
+            driveDatabaseManager,
+            driveFolderService,
+        }));
+        if (!parentFolderItem) {
+            throw new errors_utils_1.ConflictError(`Parent resource not found for parent path ${resource.parentPath}`);
         }
-        const { user, mnemonic } = await this.dependencies.authService.getAuthDetails();
-        const [uploadPromise] = await this.dependencies.networkFacade.uploadFromStream(user.bucket, mnemonic, contentLength, req, {
+        try {
+            const driveFileItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+                resource: resource,
+                driveDatabaseManager,
+                driveFileService,
+            }));
+            if (driveFileItem && driveFileItem.status === 'EXISTS') {
+                logger_utils_1.webdavLogger.info(`File '${resource.name}' already exists in '${resource.path.dir}', trashing it before PUT`);
+                await driveDatabaseManager.deleteFileById(driveFileItem.id);
+                await trashService.trashItems({
+                    items: [{ type: resource.type, uuid: driveFileItem.uuid }],
+                });
+            }
+        }
+        catch {
+        }
+        const { user, mnemonic } = await authService.getAuthDetails();
+        const [uploadPromise] = await networkFacade.uploadFromStream(user.bucket, mnemonic, contentLength, req, {
             progressCallback: (progress) => {
-                logger_utils_1.webdavLogger.info(`Upload progress for file ${resource.name}: ${progress}%`);
+                logger_utils_1.webdavLogger.info(`Upload progress for file ${resource.name}: ${(100 * progress).toFixed(2)}%`);
             },
         });
         const uploadResult = await uploadPromise;
         logger_utils_1.webdavLogger.info('✅ File uploaded to network');
         const file = await drive_file_service_1.DriveFileService.instance.createFile({
             name: resource.path.name,
-            type: resource.path.ext.replaceAll('.', ''),
+            type: resource.path.ext.replace('.', ''),
             size: contentLength,
-            folderId: driveFolder.id,
+            folderId: parentFolderItem.id,
             fileId: uploadResult.fileId,
             bucket: user.bucket,
         });
         logger_utils_1.webdavLogger.info('✅ File uploaded to internxt drive');
-        this.dependencies.driveDatabaseManager.createFile(file);
-        res.status(200);
-        res.send();
+        await driveDatabaseManager.createFile(file, resource.path.dir + '/');
+        res.status(200).send();
     };
-    async getDriveFolderRealmObject(resource) {
-        const { driveDatabaseManager } = this.dependencies;
-        const result = await driveDatabaseManager.findByRelativePath(resource.path.dir);
-        return result;
-    }
 }
 exports.PUTRequestHandler = PUTRequestHandler;

package/dist/webdav/middewares/request-logger.middleware.js

@@ -11,7 +11,7 @@ const RequestLoggerMiddleware = (config, analytics) => {
             return next();
         if (config.methods && !config.methods.includes(req.method))
             return next();
-        logger_utils_1.webdavLogger.info(`WebDav request received\nMethod: ${req.method}\nURL: ${req.url}\nBody: ${req.body}\nHeaders: ${JSON.stringify(req.headers)}`);
+        logger_utils_1.webdavLogger.info(`WebDav request received\nMethod: ${req.method}\nURL: ${req.url}\nBody: ${JSON.stringify(req.body)}\nHeaders: ${JSON.stringify(req.headers)}`);
         next();
     };
 };

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

@@ -9,19 +9,19 @@ import { AuthService } from '../services/auth.service';
 import { CryptoService } from '../services/crypto.service';
 import { TrashService } from '../services/drive/trash.service';
 export declare class WebDavServer {
-    private app;
-    private configService;
-    private driveFileService;
-    private driveFolderService;
-    private driveDatabaseManager;
-    private uploadService;
-    private downloadService;
-    private authService;
-    private cryptoService;
-    private trashService;
+    private readonly app;
+    private readonly configService;
+    private readonly driveFileService;
+    private readonly driveFolderService;
+    private readonly driveDatabaseManager;
+    private readonly uploadService;
+    private readonly downloadService;
+    private readonly authService;
+    private readonly cryptoService;
+    private readonly trashService;
     constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, driveDatabaseManager: DriveDatabaseManager, uploadService: UploadService, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
-    private getNetworkFacade;
-    private registerMiddlewares;
-    private registerHandlers;
-    start(): Promise<void>;
+    private readonly getNetworkFacade;
+    private readonly registerMiddlewares;
+    private readonly registerHandlers;
+    start: () => Promise<void>;
 }

package/dist/webdav/webdav-server.js

@@ -5,6 +5,7 @@ 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 config_service_1 = require("../services/config.service");
 const OPTIONS_handler_1 = require("./handlers/OPTIONS.handler");
 const PROPFIND_handler_1 = require("./handlers/PROPFIND.handler");
@@ -49,22 +50,22 @@ class WebDavServer {
         this.cryptoService = cryptoService;
         this.trashService = trashService;
     }
-    async getNetworkFacade() {
+    getNetworkFacade = async () => {
         const credentials = await this.configService.readUser();
         if (!credentials)
-            throw new Error('Credentials not found in Config service, cannot create network');
+            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,
         });
         return new network_facade_service_1.NetworkFacade(networkModule, this.uploadService, this.downloadService, this.cryptoService);
-    }
+    };
     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)(config_service_1.ConfigService.instance));
         this.app.use((0, request_logger_middleware_1.RequestLoggerMiddleware)({
-            enable: false,
+            enable: true,
         }, analytics_service_1.AnalyticsService.instance));
     };
     registerHandlers = async () => {
@@ -80,17 +81,17 @@ class WebDavServer {
             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({ debug: true }, {
+        this.app.propfind('*', (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({
             driveFileService: this.driveFileService,
+            driveFolderService: this.driveFolderService,
             driveDatabaseManager: this.driveDatabaseManager,
-            uploadService: this.uploadService,
-            downloadService: this.downloadService,
-            cryptoService: this.cryptoService,
             authService: this.authService,
+            trashService: this.trashService,
             networkFacade: networkFacade,
         }).handle));
         this.app.mkcol('*', (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler({
@@ -100,19 +101,35 @@ class WebDavServer {
         this.app.delete('*', (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler({
             driveDatabaseManager: this.driveDatabaseManager,
             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().handle));
+        this.app.move('*', (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler({
+            driveDatabaseManager: this.driveDatabaseManager,
+            driveFolderService: this.driveFolderService,
+            driveFileService: this.driveFileService,
+        }).handle));
         this.app.copy('*', (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
     };
-    async start() {
-        const port = this.configService.get('WEBDAV_SERVER_PORT');
+    start = async () => {
+        const configs = await this.configService.readWebdavConfig();
         this.app.disable('x-powered-by');
         await this.registerMiddlewares();
         await this.registerHandlers();
-        https_1.default.createServer(network_utils_1.NetworkUtils.getWebdavSSLCerts(), this.app).listen(port, () => {
-            logger_utils_1.webdavLogger.info(`Internxt WebDav server listening at https://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${port}`);
+        const plainHttp = configs.protocol === 'http';
+        let server;
+        if (plainHttp) {
+            server = http_1.default.createServer(this.app);
+        }
+        else {
+            const httpsCerts = network_utils_1.NetworkUtils.getWebdavSSLCerts();
+            server = https_1.default.createServer(httpsCerts, this.app);
+        }
+        server.requestTimeout = 15 * 60 * 1000;
+        server.listen(configs.port, () => {
+            logger_utils_1.webdavLogger.info(`Internxt WebDav server listening at ${configs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${configs.port}`);
         });
-    }
+    };
 }
 exports.WebDavServer = WebDavServer;