@internxt/cli 1.6.1 → 1.6.3

package/dist/utils/webdav.utils.d.ts

@@ -1,6 +1,4 @@
 import { WebDavRequestedResource } from '../types/webdav.types';
-import { DriveFolderService } from '../services/drive/drive-folder.service';
-import { DriveFileService } from '../services/drive/drive-file.service';
 import { DriveFileItem, DriveFolderItem, DriveItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
@@ -8,22 +6,8 @@ export declare class WebDavUtils {
     static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
     static normalizeFolderPath(path: string): string;
     static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }: {
-        url: string;
-        driveFolderService: DriveFolderService;
-        driveFileService: DriveFileService;
-    }): Promise<DriveItem | undefined>;
-    static getDriveFileFromResource({ url, driveFileService, }: {
-        url: string;
-        driveFileService: DriveFileService;
-    }): Promise<DriveFileItem | undefined>;
-    static getDriveFolderFromResource({ url, driveFolderService, }: {
-        url: string;
-        driveFolderService: DriveFolderService;
-    }): Promise<DriveFolderItem | undefined>;
-    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
-        resource: WebDavRequestedResource;
-        driveFolderService: DriveFolderService;
-        driveFileService: DriveFileService;
-    }): Promise<DriveItem | undefined>;
+    static tryGetFileOrFolderMetadata(url: string): Promise<DriveItem | undefined>;
+    static getDriveFileFromResource(url: string): Promise<DriveFileItem | undefined>;
+    static getDriveFolderFromResource(url: string): Promise<DriveFolderItem | undefined>;
+    static getDriveItemFromResource(resource: WebDavRequestedResource): Promise<DriveItem | undefined>;
 }

package/dist/utils/webdav.utils.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const drive_folder_service_1 = require("../services/drive/drive-folder.service");
+const drive_file_service_1 = require("../services/drive/drive-file.service");
 const logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
@@ -44,43 +46,39 @@ class WebDavUtils {
             parentPath,
         };
     }
-    static async tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }) {
+    static async tryGetFileOrFolderMetadata(url) {
         try {
-            return await driveFileService.getFileMetadataByPath(url);
+            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
         }
         catch {
-            return await driveFolderService.getFolderMetadataByPath(url);
+            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
         }
     }
-    static async getDriveFileFromResource({ url, driveFileService, }) {
+    static async getDriveFileFromResource(url) {
         try {
-            return await driveFileService.getFileMetadataByPath(url);
+            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
         }
         catch (err) {
             logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
         }
     }
-    static async getDriveFolderFromResource({ url, driveFolderService, }) {
+    static async getDriveFolderFromResource(url) {
         try {
-            return await driveFolderService.getFolderMetadataByPath(url);
+            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
         }
         catch (err) {
             logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
         }
     }
-    static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
+    static async getDriveItemFromResource(resource) {
         let item = undefined;
         const isFolder = resource.url.endsWith('/');
         try {
             if (isFolder) {
-                item = await driveFolderService.getFolderMetadataByPath(resource.url);
+                item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(resource.url);
             }
             else {
-                item = await this.tryGetFileOrFolderMetadata({
-                    url: resource.url,
-                    driveFileService,
-                    driveFolderService,
-                });
+                item = await this.tryGetFileOrFolderMetadata(resource.url);
             }
         }
         catch {

package/dist/utils/xml.utils.d.ts

@@ -2,7 +2,7 @@ import { X2jOptions, XmlBuilderOptions } from '../types/fast-xml-parser.types';
 export declare class XMLUtils {
     static readonly DEFAULT_NAMESPACE_LETTER = "D";
     static toJSON(xml: string, options?: X2jOptions): any;
-    static toXML(object: object, options?: XmlBuilderOptions): string;
+    static toXML(object: object, options: XmlBuilderOptions): string;
     static toWebDavXML(object: object, options: XmlBuilderOptions, rootObject?: string): string;
     static addDefaultNamespace(key: string): string;
     static encodeWebDavUri(uri: string): string;

package/dist/utils/xml.utils.js

@@ -8,7 +8,7 @@ class XMLUtils {
         const parser = new fast_xml_parser_1.XMLParser(options);
         return parser.parse(xml);
     }
-    static toXML(object, options = { format: true }) {
+    static toXML(object, options) {
         const builder = new fast_xml_parser_1.XMLBuilder(options);
         return builder.build(object);
     }

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

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

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

@@ -2,32 +2,34 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
+const trash_service_1 = require("../../services/drive/trash.service");
 const logger_utils_1 = require("../../utils/logger.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
+const config_service_1 = require("../../services/config.service");
+const format_utils_1 = require("../../utils/format.utils");
 class DELETERequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService, driveFolderService, trashService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[DELETE] Request received for item at ${resource.url}`);
-        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
-            driveFolderService,
-            driveFileService: driveFileService,
-        });
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
         if (!driveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
-        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
-        await trashService.trashItems({
-            items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
-        });
+        const type = format_utils_1.FormatUtils.capitalizeFirstLetter(driveItem.itemType);
+        const configs = await config_service_1.ConfigService.instance.readWebdavConfig();
+        if (configs.deleteFilesPermanently) {
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Deleting permanently ${driveItem.itemType}`);
+            await trash_service_1.TrashService.instance.deleteItemPermanently(driveItem.itemType, driveItem.uuid);
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} deleted permanently successfully`);
+        }
+        else {
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
+            await trash_service_1.TrashService.instance.trashItems({
+                items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
+            });
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
+        }
         res.status(204).send();
-        const type = driveItem.itemType.charAt(0).toUpperCase() + driveItem.itemType.substring(1);
-        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }
 exports.DELETERequestHandler = DELETERequestHandler;

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

@@ -1,18 +1,5 @@
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
-import { DriveFileService } from '../../services/drive/drive-file.service';
-import { NetworkFacade } from '../../services/network/network-facade.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 readonly dependencies;
-    constructor(dependencies: {
-        driveFileService: DriveFileService;
-        downloadService: DownloadService;
-        cryptoService: CryptoService;
-        authService: AuthService;
-        networkFacade: NetworkFacade;
-    });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -2,30 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GETRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
+const auth_service_1 = require("../../services/auth.service");
 const errors_utils_1 = require("../../utils/errors.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const network_utils_1 = require("../../utils/network.utils");
 const command_types_1 = require("../../types/command.types");
+const cli_utils_1 = require("../../utils/cli.utils");
 class GETRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService, authService, networkFacade } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
-        if (resource.name.startsWith('._'))
-            throw new errors_utils_1.NotFoundError('File not found');
         logger_utils_1.webdavLogger.info(`[GET] Request received item at ${resource.url}`);
-        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
-            url: resource.url,
-            driveFileService,
-        });
+        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource(resource.url);
         if (!driveFile) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}, if trying to access a folder use PROPFIND instead.`);
         }
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
-        const { user } = await authService.getAuthDetails();
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);
         res.header('Content-Type', 'application/octet-stream');
         const fileSize = driveFile.size ?? 0;
@@ -52,7 +44,8 @@ class GETRequestHandler {
             if (!driveFile.fileId) {
                 throw new command_types_1.NotValidFileIdError();
             }
-            const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
+            const { networkFacade, bucket, mnemonic } = await cli_utils_1.CLIUtils.prepareNetwork(user);
+            const [executeDownload] = await networkFacade.downloadToStream(bucket, mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
             logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
             res.status(200);
             await executeDownload;

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

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

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

@@ -6,41 +6,29 @@ const logger_utils_1 = require("../../utils/logger.utils");
 const network_utils_1 = require("../../utils/network.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
 class HEADRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
-        logger_utils_1.webdavLogger.info(`[HEAD] Request received for file at ${resource.url}`);
-        try {
-            const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
-                url: resource.url,
-                driveFileService,
-            });
-            if (!driveFile) {
-                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-            }
-            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+        logger_utils_1.webdavLogger.info(`[HEAD] Request received for item at ${resource.url}`);
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
+        logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Found Drive item`);
+        if (driveItem.itemType === 'file') {
             const range = req.headers['range'];
             const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
                 range,
-                totalFileSize: driveFile.size,
+                totalFileSize: driveItem.size,
             });
-            let contentLength = driveFile.size;
+            let contentLength = driveItem.size;
             if (rangeOptions) {
-                logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+                logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Range request received:`, { rangeOptions });
                 contentLength = rangeOptions.rangeSize;
             }
             res.header('Content-Type', 'application/octet-stream');
             res.header('Content-length', contentLength.toString());
-            res.status(200).send();
-        }
-        catch {
-            res.header('Content-Type', 'application/octet-stream');
-            res.status(200).send();
         }
+        res.status(200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

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>;
 }