@internxt/cli 1.6.2 → 1.6.4

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

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

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

@@ -4,28 +4,21 @@ exports.MKCOLRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const webdav_folder_service_1 = require("../../services/webdav/webdav-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 class MKCOLRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFolderService, webDavFolderService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[MKCOL] Request received for folder at ${resource.url}`);
-        const parentDriveFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
-            (await webDavFolderService.createParentPathOrThrow(resource.parentPath));
-        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
-            url: resource.url,
-            driveFolderService,
-        });
+        const parentDriveFolderItem = (await webdav_folder_service_1.WebDavFolderService.instance.getDriveFolderItemFromPath(resource.parentPath)) ??
+            (await webdav_folder_service_1.WebDavFolderService.instance.createParentPathOrThrow(resource.parentPath));
+        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource(resource.url);
         const folderAlreadyExists = !!driveFolderItem;
         if (folderAlreadyExists) {
             logger_utils_1.webdavLogger.info(`[MKCOL] ❌ Folder '${resource.url}' already exists`);
             throw new errors_utils_1.MethodNotAllowed('Folder already exists');
         }
-        const newFolder = await webDavFolderService.createFolder({
+        const newFolder = await webdav_folder_service_1.WebDavFolderService.instance.createFolder({
             folderName: resource.path.base,
             parentFolderUuid: parentDriveFolderItem.uuid,
         });

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

@@ -1,14 +1,5 @@
 import { Request, Response } from 'express';
-import { DriveFileService } from '../../services/drive/drive-file.service';
-import { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { WebDavMethodHandler } from '../../types/webdav.types';
-import { WebDavFolderService } from '../services/webdav-folder.service';
 export declare class MOVERequestHandler implements WebDavMethodHandler {
-    private readonly dependencies;
-    constructor(dependencies: {
-        driveFolderService: DriveFolderService;
-        driveFileService: DriveFileService;
-        webDavFolderService: WebDavFolderService;
-    });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -1,16 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOVERequestHandler = void 0;
+const drive_file_service_1 = require("../../services/drive/drive-file.service");
+const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
+const webdav_folder_service_1 = require("../../services/webdav/webdav-folder.service");
 class MOVERequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFolderService, driveFileService, webDavFolderService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[MOVE] Request received for item at ${resource.url}`);
         const destinationUrl = req.header('destination');
@@ -20,11 +18,7 @@ class MOVERequestHandler {
         const destinationPath = webdav_utils_1.WebDavUtils.removeHostFromURL(destinationUrl);
         const destinationResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationPath);
         logger_utils_1.webdavLogger.info('[MOVE] Destination resource found', { destinationResource });
-        const originalDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
-            driveFolderService,
-            driveFileService,
-        });
+        const originalDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
@@ -33,7 +27,7 @@ class MOVERequestHandler {
         with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
             if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
-                await driveFolderService.renameFolder({
+                await drive_folder_service_1.DriveFolderService.instance.renameFolder({
                     folderUuid: folder.uuid,
                     name: destinationResource.name,
                 });
@@ -42,7 +36,7 @@ class MOVERequestHandler {
                 const file = originalDriveItem;
                 const plainName = destinationResource.path.name;
                 const fileType = destinationResource.path.ext.replace('.', '');
-                await driveFileService.renameFile(file.uuid, {
+                await drive_file_service_1.DriveFileService.instance.renameFile(file.uuid, {
                     plainName: plainName,
                     type: fileType,
                 });
@@ -50,11 +44,11 @@ class MOVERequestHandler {
         }
         else {
             logger_utils_1.webdavLogger.info(`[MOVE] Moving ${originalDriveItem.itemType} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
-            const destinationFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(destinationResource.parentPath)) ??
-                (await webDavFolderService.createParentPathOrThrow(destinationResource.parentPath));
+            const destinationFolderItem = (await webdav_folder_service_1.WebDavFolderService.instance.getDriveFolderItemFromPath(destinationResource.parentPath)) ??
+                (await webdav_folder_service_1.WebDavFolderService.instance.createParentPathOrThrow(destinationResource.parentPath));
             if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
-                await driveFolderService.moveFolder(folder.uuid, {
+                await drive_folder_service_1.DriveFolderService.instance.moveFolder(folder.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
                     name: destinationResource.name,
                 });
@@ -63,7 +57,7 @@ class MOVERequestHandler {
                 const file = originalDriveItem;
                 const plainName = destinationResource.path.name;
                 const fileType = destinationResource.path.ext.replace('.', '');
-                await driveFileService.moveFile(file.uuid, {
+                await drive_file_service_1.DriveFileService.instance.moveFile(file.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
                     name: plainName,
                     type: fileType,

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

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

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,25 @@
 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 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 +31,26 @@ 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({
-                    items: [{ type: driveFileItem.itemType, uuid: driveFileItem.uuid }],
-                });
+                logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', it will be replaced...`);
+                await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveFileItem);
             }
         }
         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;
@@ -66,21 +60,20 @@ 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) => {
-                    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 abortable = new AbortController();
+            fileId = await networkFacade.uploadFile({
+                from: fileStream,
+                size: contentLength,
+                bucketId: bucket,
+                progressCallback,
+                abortSignal: abortable.signal,
+            });
+            res.on('close', async () => {
+                aborted = true;
+                if (!uploaded) {
+                    logger_utils_1.webdavLogger.info('[PUT] ❌ HTTP Client has been disconnected, res has been closed.');
+                    abortable.abort();
+                }
             });
             uploaded = true;
             timings.networkUpload = networkUploadTimer.stop();
@@ -92,29 +85,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>;
 }