@internxt/cli 0.1.4

package/dist/utils/xml.utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XMLUtils = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+class XMLUtils {
+    static DEFAULT_NAMESPACE_LETTER = 'D';
+    static toJSON(xml, options = {}) {
+        const parser = new fast_xml_parser_1.XMLParser(options);
+        return parser.parse(xml);
+    }
+    static toXML(object, options = { format: true }) {
+        const builder = new fast_xml_parser_1.XMLBuilder(options);
+        return builder.build(object);
+    }
+    static toWebDavXML(object, options) {
+        const xmlContent = this.toXML(object, options);
+        return `<?xml version="1.0" encoding="utf-8" ?><${XMLUtils.addDefaultNamespace('multistatus')} xmlns:${XMLUtils.DEFAULT_NAMESPACE_LETTER}="DAV:">${xmlContent}</${XMLUtils.addDefaultNamespace('multistatus')}>`;
+    }
+    static addDefaultNamespace(key) {
+        return `${XMLUtils.DEFAULT_NAMESPACE_LETTER}:${key}`;
+    }
+}
+exports.XMLUtils = XMLUtils;

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

@@ -0,0 +1,23 @@
+import { WebDavMethodHandler } from '../../types/webdav.types';
+import { Request, Response } from 'express';
+import { DriveFileService } from '../../services/drive/drive-file.service';
+import { DriveDatabaseManager } from '../../services/database/drive-database-manager.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';
+export declare class GETRequestHandler implements WebDavMethodHandler {
+    private dependencies;
+    constructor(dependencies: {
+        driveFileService: DriveFileService;
+        driveDatabaseManager: DriveDatabaseManager;
+        uploadService: UploadService;
+        downloadService: DownloadService;
+        cryptoService: CryptoService;
+        authService: AuthService;
+        networkFacade: NetworkFacade;
+    });
+    handle: (req: Request, res: Response) => Promise<void>;
+    private getDriveFileDatabaseObject;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GETRequestHandler = void 0;
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+class GETRequestHandler {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    handle = async (req, res) => {
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
+        if (req.headers['content-range'] || req.headers['range'])
+            throw new errors_utils_1.NotImplementedError('Range requests not supported');
+        if (resource.name.startsWith('._'))
+            throw new errors_utils_1.NotFoundError('File not found');
+        logger_utils_1.webdavLogger.info(`GET request received for file at ${resource.url}`);
+        const driveFile = await this.getDriveFileDatabaseObject(resource);
+        if (!driveFile) {
+            throw new errors_utils_1.NotFoundError('Drive file not found');
+        }
+        logger_utils_1.webdavLogger.info(`✅ Found Drive File with uuid ${driveFile.uuid}`);
+        res.set('Content-Type', 'application/octet-stream');
+        res.set('Content-length', driveFile.size.toString());
+        const { mnemonic } = await this.dependencies.authService.getAuthDetails();
+        logger_utils_1.webdavLogger.info('✅ Network ready for download');
+        const writable = new WritableStream({
+            write(chunk) {
+                res.write(chunk);
+            },
+            close() {
+                res.end();
+            },
+        });
+        const [executeDownload] = await this.dependencies.networkFacade.downloadToStream(driveFile.bucket, mnemonic, driveFile.fileId, writable, {
+            progressCallback: (progress) => {
+                logger_utils_1.webdavLogger.info(`Download progress for file ${resource.name}: ${progress}%`);
+            },
+        });
+        logger_utils_1.webdavLogger.info('✅ Download prepared, executing...');
+        res.status(200);
+        await executeDownload;
+        logger_utils_1.webdavLogger.info('✅ Download ready, replying to client');
+    };
+    async getDriveFileDatabaseObject(resource) {
+        const { driveDatabaseManager } = this.dependencies;
+        const result = await driveDatabaseManager.findByRelativePath(resource.url);
+        return result;
+    }
+}
+exports.GETRequestHandler = GETRequestHandler;

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

@@ -0,0 +1,5 @@
+import { WebDavMethodHandler } from '../../types/webdav.types';
+import { Request, Response } from 'express';
+export declare class HEADRequestHandler implements WebDavMethodHandler {
+    handle(req: Request, res: Response): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEADRequestHandler = void 0;
+class HEADRequestHandler {
+    async handle(req, res) {
+        res.status(405).send();
+    }
+}
+exports.HEADRequestHandler = HEADRequestHandler;

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

@@ -0,0 +1,5 @@
+import { WebDavMethodHandler } from '../../types/webdav.types';
+import { Request, Response } from 'express';
+export declare class OPTIONSRequestHandler implements WebDavMethodHandler {
+    handle(_: Request, res: Response): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPTIONSRequestHandler = void 0;
+class OPTIONSRequestHandler {
+    async handle(_, res) {
+        res.header('Allow', 'OPTIONS, GET, HEAD, POST, PUT, DELETE, PROPFIND, PROPPATCH, MKCOL, COPY, MOVE, LOCK, UNLOCK');
+        res.header('DAV', '1, 2, ordered-collections');
+        res.status(200).send();
+    }
+}
+exports.OPTIONSRequestHandler = OPTIONSRequestHandler;

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

@@ -0,0 +1,21 @@
+import { WebDavMethodHandler, WebDavMethodHandlerOptions } from '../../types/webdav.types';
+import { DriveFolderService } from '../../services/drive/drive-folder.service';
+import { Request, Response } from 'express';
+import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
+export declare class PROPFINDRequestHandler implements WebDavMethodHandler {
+    private options;
+    private dependencies;
+    constructor(options: WebDavMethodHandlerOptions, dependencies: {
+        driveFolderService: DriveFolderService;
+        driveDatabaseManager: DriveDatabaseManager;
+    });
+    handle: (req: Request, res: Response) => Promise<void>;
+    private getFileMetaXML;
+    private getFolderContentXML;
+    private getFolderChildsXMLNode;
+    private getFolderRootXMLNode;
+    private getFolderXMLNode;
+    private driveFolderRootStatsToXMLNode;
+    private driveFolderItemToXMLNode;
+    private driveFileItemToXMLNode;
+}

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

@@ -0,0 +1,234 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPFINDRequestHandler = void 0;
+const xml_utils_1 = require("../../utils/xml.utils");
+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");
+class PROPFINDRequestHandler {
+    options;
+    dependencies;
+    constructor(options = { debug: false }, dependencies) {
+        this.options = options;
+        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';
+        switch (resource.type) {
+            case 'file': {
+                res.status(207).send(await this.getFileMetaXML(resource));
+                break;
+            }
+            case 'folder': {
+                if (resource.url === '/') {
+                    const rootFolder = await this.dependencies.driveFolderService.getFolderMetaById(req.user.rootFolderId);
+                    await this.dependencies.driveDatabaseManager.createFolder({
+                        name: '',
+                        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));
+                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');
+        const driveFile = this.driveFileItemToXMLNode({
+            name: driveFileItem.name,
+            type: driveFileItem.type,
+            bucket: driveFileItem.bucket,
+            id: driveFileItem.id,
+            uuid: driveFileItem.uuid,
+            fileId: driveFileItem.fileId,
+            encryptedName: driveFileItem.name,
+            size: driveFileItem.size,
+            createdAt: driveFileItem.createdAt,
+            updatedAt: driveFileItem.updatedAt,
+            status: driveFileItem.status,
+            folderId: driveFileItem.folderId,
+        }, encodeURI(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) {
+        let XMLNodes = [];
+        switch (depth) {
+            case '0':
+                if (isRootFolder) {
+                    XMLNodes.push(await this.getFolderRootXMLNode(relativePath, folderUuid));
+                }
+                else {
+                    XMLNodes.push(await this.getFolderXMLNode(relativePath, folderUuid));
+                }
+                break;
+            case '1':
+            default:
+                if (isRootFolder) {
+                    XMLNodes.push(await this.getFolderRootXMLNode(relativePath, folderUuid));
+                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderUuid));
+                }
+                else {
+                    XMLNodes.push(await this.getFolderXMLNode(relativePath, folderUuid));
+                    XMLNodes = XMLNodes.concat(await this.getFolderChildsXMLNode(relativePath, folderUuid));
+                }
+                break;
+        }
+        const xml = xml_utils_1.XMLUtils.toWebDavXML(XMLNodes, {
+            arrayNodeName: xml_utils_1.XMLUtils.addDefaultNamespace('response'),
+            ignoreAttributes: false,
+            suppressEmptyNode: true,
+        });
+        return xml;
+    }
+    async getFolderChildsXMLNode(relativePath, folderUuid) {
+        const { driveFolderService, driveDatabaseManager } = this.dependencies;
+        const folderContent = await driveFolderService.getFolderContent(folderUuid);
+        const foldersXML = folderContent.folders.map((folder) => {
+            const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
+            return this.driveFolderItemToXMLNode({
+                name: folder.plainName,
+                bucket: folder.bucket,
+                createdAt: new Date(folder.createdAt),
+                updatedAt: new Date(folder.updatedAt),
+                id: folder.id,
+                encryptedName: folder.name,
+                uuid: folder.uuid,
+                parentId: null,
+            }, encodeURI(folderRelativePath));
+        });
+        folderContent.folders.map(async (folder) => {
+            return await driveDatabaseManager.createFolder({
+                ...folder,
+                name: folder.plainName,
+                encryptedName: folder.name,
+            });
+        });
+        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({
+                name: file.plainName,
+                bucket: file.bucket,
+                id: file.id,
+                createdAt: new Date(file.createdAt),
+                updatedAt: new Date(file.updatedAt),
+                fileId: file.fileId,
+                uuid: file.uuid,
+                type: file.type,
+                encryptedName: file.name,
+                status: file.status,
+                folderId: file.folderId,
+                size: Number(file.size),
+            }, encodeURI(fileRelativePath));
+        });
+        folderContent.files.map(async (file) => {
+            return await driveDatabaseManager.createFile({
+                ...file,
+                name: file.plainName,
+                fileId: file.fileId,
+                size: Number(file.size),
+                encryptedName: file.name,
+            });
+        });
+        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) {
+        const driveFolderXML = {
+            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: relativePath,
+            [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
+                [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
+                [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: 'application/octet-stream',
+                    'x1:lastmodified': {
+                        '#text': format_utils_1.FormatUtils.formatDateForWebDav(driveFolderItem.updatedAt),
+                        '@_xmlns:x1': 'SAR:',
+                    },
+                    'x2:executable': {
+                        '#text': 'F',
+                        '@_xmlns:x2': 'http://apache.org/dav/props/',
+                    },
+                    'x3:Win32FileAttributes': {
+                        '#text': '00000030',
+                        '@_xmlns:x3': 'urn:schemas-microsoft-com:',
+                    },
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('collection')]: '',
+                    },
+                },
+            },
+        };
+        return driveFolderXML;
+    }
+    driveFolderItemToXMLNode(driveFolderItem, relativePath) {
+        const displayName = `${driveFolderItem.name}`;
+        const driveFolderXML = {
+            [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: relativePath,
+            [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
+                [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
+                [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('displayname')]: displayName,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: format_utils_1.FormatUtils.formatDateForWebDav(driveFolderItem.updatedAt),
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getcontentlength')]: 0,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: {
+                        [xml_utils_1.XMLUtils.addDefaultNamespace('collection')]: '',
+                    },
+                },
+            },
+        };
+        return driveFolderXML;
+    }
+    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('propstat')]: {
+                [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
+                [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: '',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: '"' + (0, crypto_1.randomUUID)().replaceAll('-', '') + '"',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('displayname')]: displayName,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: mime_types_1.default.lookup(displayName) || 'application/octet-stream',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: format_utils_1.FormatUtils.formatDateForWebDav(driveFileItem.updatedAt),
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getcontentlength')]: driveFileItem.size,
+                },
+            },
+        };
+        return driveFileXML;
+    }
+}
+exports.PROPFINDRequestHandler = PROPFINDRequestHandler;

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

@@ -0,0 +1,23 @@
+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';
+export declare class PUTRequestHandler implements WebDavMethodHandler {
+    private dependencies;
+    constructor(dependencies: {
+        driveFileService: DriveFileService;
+        driveDatabaseManager: DriveDatabaseManager;
+        uploadService: UploadService;
+        downloadService: DownloadService;
+        cryptoService: CryptoService;
+        authService: AuthService;
+        networkFacade: NetworkFacade;
+    });
+    handle: (req: Request, res: Response) => Promise<void>;
+    private getDriveFolderRealmObject;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUTRequestHandler = void 0;
+const drive_file_service_1 = require("../../services/drive/drive-file.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");
+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');
+        }
+        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.NotFoundError('Drive destination folder not found');
+        }
+        const { user, mnemonic } = await this.dependencies.authService.getAuthDetails();
+        const [uploadPromise] = await this.dependencies.networkFacade.uploadFromStream(user.bucket, mnemonic, contentLength, req, {
+            progressCallback: (progress) => {
+                logger_utils_1.webdavLogger.info(`Upload progress for file ${resource.name}: ${progress}%`);
+            },
+        });
+        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('.', ''),
+            size: contentLength,
+            folderId: driveFolder.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();
+    };
+    async getDriveFolderRealmObject(resource) {
+        const { driveDatabaseManager } = this.dependencies;
+        const result = await driveDatabaseManager.findByRelativePath(resource.path.dir);
+        return result;
+    }
+}
+exports.PUTRequestHandler = PUTRequestHandler;

package/dist/webdav/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/webdav/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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_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 upload_service_1 = require("../services/network/upload.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");
+dotenv_1.default.config();
+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();
+    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()), upload_service_1.UploadService.instance, download_service_1.DownloadService.instance, auth_service_1.AuthService.instance, crypto_service_1.CryptoService.instance)
+        .start()
+        .then()
+        .catch(console.error);
+};
+init();

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

@@ -0,0 +1,3 @@
+import { RequestHandler } from 'express';
+import { ConfigService } from '../../services/config.service';
+export declare const AuthMiddleware: (configService: ConfigService) => RequestHandler;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthMiddleware = void 0;
+const sdk_manager_service_1 = require("../../services/sdk-manager.service");
+const AuthMiddleware = (configService) => {
+    return (req, res, next) => {
+        (async () => {
+            try {
+                const credentials = await configService.readUser();
+                if (!credentials)
+                    throw new Error('Unauthorized');
+                sdk_manager_service_1.SdkManager.init({
+                    token: credentials.token,
+                    newToken: credentials.newToken,
+                });
+                req.user = {
+                    rootFolderId: credentials.user.root_folder_id,
+                };
+                next();
+            }
+            catch (error) {
+                res.status(401).send({ error: error.message });
+            }
+        })();
+    };
+};
+exports.AuthMiddleware = AuthMiddleware;

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorHandlingMiddleware = void 0;
+const ErrorHandlingMiddleware = (err, _, res, __) => {
+    if ('statusCode' in err) {
+        res.status(err.statusCode).send({
+            error: {
+                message: err.message,
+            },
+        });
+    }
+    else {
+        res.status(500).send({
+            error: {
+                message: 'message' in err ? err.message : 'Something went wrong',
+            },
+        });
+    }
+};
+exports.ErrorHandlingMiddleware = ErrorHandlingMiddleware;

package/dist/webdav/middewares/request-logger.middleware.d.ts

@@ -0,0 +1,7 @@
+import { RequestHandler } from 'express';
+type RequestLoggerConfig = {
+    enable: boolean;
+    methods?: string[];
+};
+export declare const RequestLoggerMiddleware: (config: RequestLoggerConfig) => RequestHandler;
+export {};

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLoggerMiddleware = void 0;
+const logger_utils_1 = require("../../utils/logger.utils");
+const RequestLoggerMiddleware = (config) => {
+    return (req, _, next) => {
+        if (!config.enable)
+            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)}`);
+        next();
+    };
+};
+exports.RequestLoggerMiddleware = RequestLoggerMiddleware;

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

@@ -0,0 +1,25 @@
+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 { UploadService } from '../services/network/upload.service';
+import { DownloadService } from '../services/network/download.service';
+import { AuthService } from '../services/auth.service';
+import { CryptoService } from '../services/crypto.service';
+export declare class WebDavServer {
+    private app;
+    private configService;
+    private driveFileService;
+    private driveFolderService;
+    private driveDatabaseManager;
+    private uploadService;
+    private downloadService;
+    private authService;
+    private cryptoService;
+    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, driveDatabaseManager: DriveDatabaseManager, uploadService: UploadService, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService);
+    private getNetwork;
+    private registerMiddlewares;
+    private registerHandlers;
+    start(): Promise<void>;
+}