@internxt/cli 1.2.1 → 1.3.0

package/dist/utils/webdav.utils.js

@@ -5,36 +5,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const path_1 = __importDefault(require("path"));
-const drive_folder_domain_1 = require("../services/database/drive-folder/drive-folder.domain");
-const drive_file_domain_1 = require("../services/database/drive-file/drive-file.domain");
+const errors_utils_1 = require("./errors.utils");
+const logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return path_1.default.posix.join(...pathComponents);
     }
-    static getParentPath(fromPath) {
-        return path_1.default.dirname(fromPath);
+    static removeHostFromURL(completeURL) {
+        if (!completeURL.startsWith('/') && !/^https?:\/\//i.test(completeURL)) {
+            completeURL = 'https://' + completeURL;
+        }
+        const parsedUrl = new URL(completeURL);
+        let url = parsedUrl.href.replace(parsedUrl.origin + '/', '');
+        if (!url.startsWith('/'))
+            url = '/'.concat(url);
+        return url;
     }
-    static async getRequestedResource(req, driveDatabaseManager) {
-        const decodedUrl = decodeURI(req.url);
-        const parsedPath = path_1.default.parse(decodedUrl);
-        let isFolder = req.url.endsWith('/');
-        if (!isFolder) {
-            const findDatabaseItem = await driveDatabaseManager.findByRelativePath(decodedUrl);
-            if (findDatabaseItem) {
-                if (findDatabaseItem instanceof drive_file_domain_1.DriveFile) {
-                    isFolder = false;
-                }
-                else if (findDatabaseItem instanceof drive_folder_domain_1.DriveFolder) {
-                    isFolder = true;
-                }
-            }
+    static async getRequestedResource(urlObject) {
+        let requestUrl;
+        if (typeof urlObject === 'string') {
+            requestUrl = urlObject;
         }
+        else {
+            requestUrl = urlObject.url;
+        }
+        const decodedUrl = decodeURIComponent(requestUrl).replaceAll('/./', '/');
+        const parsedPath = path_1.default.parse(decodedUrl);
+        let parentPath = path_1.default.dirname(decodedUrl);
+        if (!parentPath.startsWith('/'))
+            parentPath = '/'.concat(parentPath);
+        if (!parentPath.endsWith('/'))
+            parentPath = parentPath.concat('/');
+        const isFolder = requestUrl.endsWith('/');
         if (isFolder) {
             return {
-                url: decodedUrl,
                 type: 'folder',
-                name: parsedPath.name,
+                url: decodedUrl,
+                name: parsedPath.base,
                 path: parsedPath,
+                parentPath,
             };
         }
         else {
@@ -43,8 +52,50 @@ class WebDavUtils {
                 url: decodedUrl,
                 name: parsedPath.name,
                 path: parsedPath,
+                parentPath,
             };
         }
     }
+    static async getDatabaseItemFromResource(resource, driveDatabaseManager) {
+        let databaseResource = null;
+        if (resource.type === 'folder') {
+            databaseResource = await driveDatabaseManager.findFolderByRelativePath(resource.url);
+        }
+        if (resource.type === 'file') {
+            databaseResource = await driveDatabaseManager.findFileByRelativePath(resource.url);
+        }
+        return databaseResource?.toItem() ?? null;
+    }
+    static async setDatabaseItem(type, driveItem, driveDatabaseManager, relativePath) {
+        if (type === 'folder') {
+            return await driveDatabaseManager.createFolder(driveItem, relativePath);
+        }
+        if (type === 'file') {
+            return await driveDatabaseManager.createFile(driveItem, relativePath);
+        }
+    }
+    static async getDriveItemFromResource(resource, driveFolderService, driveFileService) {
+        let item = undefined;
+        if (resource.type === 'folder') {
+            item = await driveFolderService?.getFolderMetadataByPath(resource.url);
+        }
+        if (resource.type === 'file') {
+            item = await driveFileService?.getFileMetadataByPath(resource.url);
+        }
+        return item;
+    }
+    static async getAndSearchItemFromResource({ resource, driveDatabaseManager, driveFolderService, driveFileService, }) {
+        let databaseItem = await this.getDatabaseItemFromResource(resource, driveDatabaseManager);
+        if (!databaseItem) {
+            logger_utils_1.webdavLogger.info('Resource not found on local database', { resource });
+            const driveItem = await this.getDriveItemFromResource(resource, driveFolderService, driveFileService);
+            if (!driveItem) {
+                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+            }
+            databaseItem = driveItem;
+            await this.setDatabaseItem(resource.type, driveItem, driveDatabaseManager, resource.url);
+        }
+        return databaseItem;
+    }
 }
 exports.WebDavUtils = WebDavUtils;

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

@@ -5,4 +5,5 @@ export declare class XMLUtils {
     static toXML(object: object, options?: XmlBuilderOptions): any;
     static toWebDavXML(object: object, options: XmlBuilderOptions): string;
     static addDefaultNamespace(key: string): string;
+    static encodeWebDavUri(uri: string): string;
 }

package/dist/utils/xml.utils.js

@@ -19,5 +19,8 @@ class XMLUtils {
     static addDefaultNamespace(key) {
         return `${XMLUtils.DEFAULT_NAMESPACE_LETTER}:${key}`;
     }
+    static encodeWebDavUri(uri) {
+        return encodeURIComponent(uri).replaceAll('%2F', '/');
+    }
 }
 exports.XMLUtils = XMLUtils;

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

@@ -2,11 +2,15 @@ import { Request, Response } from 'express';
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 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 dependencies;
+    private readonly dependencies;
     constructor(dependencies: {
         driveDatabaseManager: DriveDatabaseManager;
         trashService: TrashService;
+        driveFileService: DriveFileService;
+        driveFolderService: DriveFolderService;
     });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
-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 DELETERequestHandler {
@@ -10,21 +9,25 @@ class DELETERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
+        const { driveDatabaseManager, driveFileService, driveFolderService, trashService } = this.dependencies;
         logger_utils_1.webdavLogger.info('DELETE request received');
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
-        logger_utils_1.webdavLogger.info('Resource found for DELETE request', { resource });
-        const databaseItem = await this.dependencies.driveDatabaseManager.findByRelativePath(resource.url);
-        if (!databaseItem)
-            throw new errors_utils_1.NotFoundError('Resource not found');
-        logger_utils_1.webdavLogger.info(`Trashing ${resource.type} with UUID ${databaseItem.uuid}...`);
-        await this.dependencies.trashService.trashItems({
-            items: [{ type: resource.type, uuid: databaseItem.uuid }],
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        logger_utils_1.webdavLogger.info('Resource received for DELETE request', { resource });
+        const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource,
+            driveDatabaseManager,
+            driveFolderService,
+            driveFileService: driveFileService,
+        });
+        logger_utils_1.webdavLogger.info(`Trashing ${resource.type} with UUID ${driveItem.uuid}...`);
+        await trashService.trashItems({
+            items: [{ type: resource.type, uuid: driveItem.uuid }],
         });
         if (resource.type === 'folder') {
-            await this.dependencies.driveDatabaseManager.deleteFolder(databaseItem.id);
+            await driveDatabaseManager.deleteFolderById(driveItem.id);
         }
-        if (resource.type === 'file') {
-            await this.dependencies.driveDatabaseManager.deleteFile(databaseItem.id);
+        else if (resource.type === 'file') {
+            await driveDatabaseManager.deleteFileById(driveItem.id);
         }
         res.status(204).send();
     };

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

@@ -8,7 +8,7 @@ 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;
+    private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
         driveDatabaseManager: DriveDatabaseManager;
@@ -19,5 +19,4 @@ export declare class GETRequestHandler implements WebDavMethodHandler {
         networkFacade: NetworkFacade;
     });
     handle: (req: Request, res: Response) => Promise<void>;
-    private getDriveFileDatabaseObject;
 }

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

@@ -10,20 +10,22 @@ class GETRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
+        const { driveDatabaseManager, driveFileService, authService, networkFacade } = this.dependencies;
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         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');
-        }
+        const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource,
+            driveDatabaseManager,
+            driveFileService,
+        }));
         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();
+        const { mnemonic } = await authService.getAuthDetails();
         logger_utils_1.webdavLogger.info('✅ Network ready for download');
         const writable = new WritableStream({
             write(chunk) {
@@ -33,9 +35,9 @@ class GETRequestHandler {
                 res.end();
             },
         });
-        const [executeDownload] = await this.dependencies.networkFacade.downloadToStream(driveFile.bucket, mnemonic, driveFile.fileId, writable, {
+        const [executeDownload] = await 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 progress for file ${resource.name}: ${(100 * progress).toFixed(2)}%`);
             },
         });
         logger_utils_1.webdavLogger.info('✅ Download prepared, executing...');
@@ -43,10 +45,5 @@ class GETRequestHandler {
         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

@@ -1,5 +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>;
+    handle: (_: Request, res: Response) => Promise<void>;
 }

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HEADRequestHandler = void 0;
 class HEADRequestHandler {
-    async handle(req, res) {
+    handle = async (_, res) => {
         res.status(405).send();
-    }
+    };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

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

@@ -3,7 +3,7 @@ import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
 import { DriveFolderService } from '../../services/drive/drive-folder.service';
 export declare class MKCOLRequestHandler implements WebDavMethodHandler {
-    private dependencies;
+    private readonly dependencies;
     constructor(dependencies: {
         driveDatabaseManager: DriveDatabaseManager;
         driveFolderService: DriveFolderService;

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

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MKCOLRequestHandler = 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");
-const path_1 = __importDefault(require("path"));
 const xml_utils_1 = require("../../utils/xml.utils");
 const async_utils_1 = require("../../utils/async.utils");
 class MKCOLRequestHandler {
@@ -17,18 +13,20 @@ class MKCOLRequestHandler {
     }
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFolderService } = this.dependencies;
-        const decodedUrl = decodeURI(req.url);
-        const resourceParsedPath = path_1.default.parse(decodedUrl);
-        const parentPath = webdav_utils_1.WebDavUtils.getParentPath(decodedUrl);
-        const parentResource = await driveDatabaseManager.findByRelativePath(parentPath);
-        if (!parentResource) {
-            throw new errors_utils_1.ConflictError(`Parent resource not found for parent path ${parentPath}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        logger_utils_1.webdavLogger.info('Resource received for MKCOL request', { resource });
+        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath);
+        const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource: parentResource,
+            driveDatabaseManager,
+            driveFolderService,
+        }));
+        if (!parentFolderItem) {
+            throw new errors_utils_1.ConflictError(`Parent resource not found for parent path ${resource.parentPath}`);
         }
-        logger_utils_1.webdavLogger.info(`MKCOL request received for folder at ${req.url}`);
-        logger_utils_1.webdavLogger.info(`Parent path: ${parentResource.id}`);
         const [createFolder] = driveFolderService.createFolder({
-            folderName: resourceParsedPath.name,
-            parentFolderId: parentResource.id,
+            folderName: resource.name,
+            parentFolderId: parentFolderItem.id,
         });
         const newFolder = await createFolder;
         logger_utils_1.webdavLogger.info(`✅ Folder created with UUID ${newFolder.uuid}`);
@@ -39,10 +37,11 @@ class MKCOLRequestHandler {
             bucket: newFolder.bucket,
             id: newFolder.id,
             parentId: newFolder.parentId,
+            parentUuid: newFolder.parentUuid,
             uuid: newFolder.uuid,
             createdAt: new Date(newFolder.createdAt),
             updatedAt: new Date(newFolder.updatedAt),
-        });
+        }, resource.url);
         await async_utils_1.AsyncUtils.sleep(500);
         res.status(201).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
     };

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

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

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

@@ -2,9 +2,80 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOVERequestHandler = void 0;
 const errors_utils_1 = require("../../utils/errors.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+const webdav_utils_1 = require("../../utils/webdav.utils");
 class MOVERequestHandler {
-    async handle() {
-        throw new errors_utils_1.NotImplementedError('MOVE is not implemented yet.');
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
     }
+    handle = async (req, res) => {
+        const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        logger_utils_1.webdavLogger.info('[MOVE] Resource found', { resource });
+        const destinationUrl = req.header('destination');
+        if (!destinationUrl) {
+            throw new errors_utils_1.NotFoundError('Destination folder not received');
+        }
+        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.getAndSearchItemFromResource({
+            resource,
+            driveDatabaseManager,
+            driveFolderService,
+            driveFileService,
+        });
+        if (destinationResource.path.dir === resource.path.dir) {
+            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
+            const newName = destinationResource.name;
+            if (resource.type === 'folder') {
+                const folder = originalDriveItem;
+                await driveFolderService.renameFolder({
+                    folderUuid: folder.uuid,
+                    name: newName,
+                });
+                await driveDatabaseManager.createFolder(folder, destinationResource.url);
+            }
+            else if (resource.type === 'file') {
+                const newType = destinationResource.path.ext.replace('.', '');
+                const file = originalDriveItem;
+                await driveFileService.renameFile(file.uuid, {
+                    plainName: newName,
+                    type: newType,
+                });
+                await driveDatabaseManager.createFile(file, destinationResource.url);
+            }
+        }
+        else {
+            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
+            const destinationFolderResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationResource.parentPath);
+            const destinationFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+                resource: destinationFolderResource,
+                driveDatabaseManager,
+                driveFolderService,
+            }));
+            if (!destinationFolderItem) {
+                throw new errors_utils_1.ConflictError(`Destination folder resource not found for path ${destinationResource.parentPath}`);
+            }
+            if (resource.type === 'folder') {
+                const folder = originalDriveItem;
+                await driveFolderService.moveFolder({
+                    folderUuid: folder.uuid,
+                    destinationFolderUuid: destinationFolderItem.uuid,
+                });
+                await driveDatabaseManager.createFolder(folder, destinationPath);
+            }
+            else if (resource.type === 'file') {
+                const file = originalDriveItem;
+                await driveFileService.moveFile({
+                    fileUuid: file.uuid,
+                    destinationFolderUuid: destinationFolderItem.uuid,
+                });
+                await driveDatabaseManager.createFile(file, destinationPath);
+            }
+        }
+        res.status(204).send();
+    };
 }
 exports.MOVERequestHandler = MOVERequestHandler;

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

@@ -1,5 +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>;
+    handle: (_: Request, res: Response) => Promise<void>;
 }

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

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPTIONSRequestHandler = void 0;
 class OPTIONSRequestHandler {
-    async handle(_, res) {
+    handle = async (_, 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

@@ -1,21 +1,20 @@
-import { WebDavMethodHandler, WebDavMethodHandlerOptions } from '../../types/webdav.types';
+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';
 import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 export declare class PROPFINDRequestHandler implements WebDavMethodHandler {
-    private options;
-    private dependencies;
-    constructor(options: WebDavMethodHandlerOptions, dependencies: {
+    private readonly dependencies;
+    constructor(dependencies: {
         driveFolderService: DriveFolderService;
+        driveFileService: DriveFileService;
         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;
+    private readonly getFileMetaXML;
+    private readonly getFolderContentXML;
+    private readonly getFolderChildsXMLNode;
+    private readonly driveFolderRootStatsToXMLNode;
+    private readonly driveFolderItemToXMLNode;
+    private readonly driveFileItemToXMLNode;
 }