@internxt/cli 1.5.1 → 1.5.3

package/dist/utils/cli.utils.d.ts

@@ -2,14 +2,16 @@ import cliProgress from 'cli-progress';
 import { Header } from 'tty-table';
 import { PromptOptions } from '../types/command.types';
 export declare class CLIUtils {
-    static readonly clearPreviousLine: () => void;
+    static readonly clearPreviousLine: (jsonFlag?: boolean) => void;
     static readonly warning: (reporter: (message: string) => void, message: string) => void;
     static readonly error: (reporter: (message: string) => void, message: string) => void;
-    static readonly doing: (message: string) => void;
     static readonly success: (reporter: (message: string) => void, message: string) => void;
     static readonly log: (reporter: (message: string) => void, message: string) => void;
-    static readonly done: () => void;
-    static readonly progress: (opts: cliProgress.Options) => cliProgress.SingleBar;
+    static readonly consoleLog: (message: string) => void;
+    static readonly doing: (message: string, jsonFlag?: boolean) => void;
+    static readonly done: (jsonFlag?: boolean) => void;
+    static readonly failed: (jsonFlag?: boolean) => void;
+    static readonly progress: (opts: cliProgress.Options, jsonFlag?: boolean) => cliProgress.SingleBar | undefined;
     static readonly table: (reporter: (message: string) => void, header: Header[], rows: object[]) => void;
     static readonly generateTableHeaderFromType: <T extends object>() => Header[];
     static readonly CommonFlags: {
@@ -34,6 +36,13 @@ export declare class CLIUtils {
     static readonly timer: () => {
         stop: () => number;
     };
+    static readonly catchError: ({ error, logReporter, errorReporter, command, jsonFlag, }: {
+        error: Error;
+        command?: string;
+        logReporter: (message: string) => void;
+        errorReporter: (message: string) => void;
+        jsonFlag?: boolean;
+    }) => void;
     static readonly parseEmpty: (input: string) => Promise<string>;
 }
 export declare class NoFlagProvidedError extends Error {

package/dist/utils/cli.utils.js

@@ -8,10 +8,13 @@ const core_1 = require("@oclif/core");
 const cli_progress_1 = __importDefault(require("cli-progress"));
 const tty_table_1 = __importDefault(require("tty-table"));
 const inquirer_utils_1 = require("./inquirer.utils");
+const errors_utils_1 = require("./errors.utils");
 class CLIUtils {
-    static clearPreviousLine = () => {
-        process.stdout.write('\x1b[1A');
-        process.stdout.clearLine(0);
+    static clearPreviousLine = (jsonFlag) => {
+        if (!jsonFlag) {
+            process.stdout?.write?.('\x1b[1A');
+            process.stdout?.clearLine?.(0);
+        }
     };
     static warning = (reporter, message) => {
         reporter(core_1.ux.colorize('#a67805', `⚠ Warning: ${message}`));
@@ -19,20 +22,34 @@ class CLIUtils {
     static error = (reporter, message) => {
         reporter(core_1.ux.colorize('red', `⚠ Error: ${message}`));
     };
-    static doing = (message) => {
-        core_1.ux.action.start(message, undefined, {});
-    };
     static success = (reporter, message) => {
         reporter(core_1.ux.colorize('green', `✓ ${message}`));
     };
     static log = (reporter, message) => {
         reporter(`${message}`);
     };
-    static done = () => {
-        core_1.ux.action.stop(core_1.ux.colorize('green', 'done ✓'));
+    static consoleLog = (message) => {
+        console.log(message);
+    };
+    static doing = (message, jsonFlag) => {
+        if (!jsonFlag) {
+            core_1.ux.action.start(message, undefined, {});
+        }
+    };
+    static done = (jsonFlag) => {
+        if (!jsonFlag && core_1.ux.action.running) {
+            core_1.ux.action.stop(core_1.ux.colorize('green', 'done ✓'));
+        }
+    };
+    static failed = (jsonFlag) => {
+        if (!jsonFlag && core_1.ux.action.running) {
+            core_1.ux.action.stop(core_1.ux.colorize('red', 'failed ✕'));
+        }
     };
-    static progress = (opts) => {
-        return new cli_progress_1.default.SingleBar({ noTTYOutput: Boolean(!process.stdin.isTTY), ...opts }, cli_progress_1.default.Presets.shades_classic);
+    static progress = (opts, jsonFlag) => {
+        if (!jsonFlag) {
+            return new cli_progress_1.default.SingleBar({ noTTYOutput: Boolean(!process.stdin.isTTY), ...opts }, cli_progress_1.default.Presets.shades_classic);
+        }
     };
     static table = (reporter, header, rows) => {
         const table = (0, tty_table_1.default)(header, rows);
@@ -113,6 +130,23 @@ class CLIUtils {
             },
         };
     };
+    static catchError = ({ error, logReporter, errorReporter, command, jsonFlag, }) => {
+        let message;
+        if ('message' in error && error.message.trim().length > 0) {
+            message = error.message;
+        }
+        else {
+            message = JSON.stringify(error);
+        }
+        CLIUtils.failed(jsonFlag);
+        if (jsonFlag) {
+            CLIUtils.consoleLog(JSON.stringify({ success: false, message }));
+        }
+        else {
+            errors_utils_1.ErrorUtils.report(errorReporter, error, { command });
+            CLIUtils.error(logReporter, message);
+        }
+    };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
 }
 exports.CLIUtils = CLIUtils;

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

@@ -1,21 +1,15 @@
 import { Request } from 'express';
 import { WebDavRequestedResource } from '../types/webdav.types';
-import { DriveFile } from '../services/database/drive-file/drive-file.domain';
-import { DriveFolder } from '../services/database/drive-folder/drive-folder.domain';
-import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
 import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
     static removeHostFromURL(completeURL: string): string;
-    static getRequestedResource(urlObject: string | Request): Promise<WebDavRequestedResource>;
-    static getDatabaseItemFromResource(resource: WebDavRequestedResource, driveDatabaseManager: DriveDatabaseManager): Promise<DriveFileItem | DriveFolderItem | null>;
-    static setDatabaseItem(type: 'file' | 'folder', driveItem: DriveFileItem | DriveFolderItem, driveDatabaseManager: DriveDatabaseManager, relativePath: string): Promise<DriveFolder | DriveFile | undefined>;
+    static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
     static getDriveItemFromResource(resource: WebDavRequestedResource, driveFolderService?: DriveFolderService, driveFileService?: DriveFileService): Promise<DriveFileItem | DriveFolderItem | undefined>;
-    static getAndSearchItemFromResource({ resource, driveDatabaseManager, driveFolderService, driveFileService, }: {
+    static getAndSearchItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
-        driveDatabaseManager: DriveDatabaseManager;
         driveFolderService?: DriveFolderService;
         driveFileService?: DriveFileService;
     }): Promise<DriveFileItem | DriveFolderItem>;

package/dist/utils/webdav.utils.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const node_path_1 = __importDefault(require("node:path"));
 const errors_utils_1 = require("./errors.utils");
-const logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -21,7 +20,7 @@ class WebDavUtils {
             url = '/'.concat(url);
         return url;
     }
-    static async getRequestedResource(urlObject) {
+    static async getRequestedResource(urlObject, decodeUri = true) {
         let requestUrl;
         if (typeof urlObject === 'string') {
             requestUrl = urlObject;
@@ -29,7 +28,7 @@ class WebDavUtils {
         else {
             requestUrl = urlObject.url;
         }
-        const decodedUrl = decodeURIComponent(requestUrl).replaceAll('/./', '/');
+        const decodedUrl = (decodeUri ? decodeURIComponent(requestUrl) : requestUrl).replaceAll('/./', '/');
         const parsedPath = node_path_1.default.parse(decodedUrl);
         let parentPath = node_path_1.default.dirname(decodedUrl);
         if (!parentPath.startsWith('/'))
@@ -56,46 +55,30 @@ class WebDavUtils {
             };
         }
     }
-    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);
+            try {
+                item = await driveFolderService?.getFolderMetadataByPath(resource.url);
+            }
+            catch (error) {
+                if (error.status === 404) {
+                    throw new errors_utils_1.ConflictError(`Resource not found on Internxt Drive at ${resource.url}`);
+                }
+                throw error;
+            }
         }
         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);
+    static async getAndSearchItemFromResource({ resource, driveFolderService, driveFileService, }) {
+        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}`);
         }
-        return databaseItem;
+        return driveItem;
     }
 }
 exports.WebDavUtils = WebDavUtils;

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

@@ -2,8 +2,8 @@ import { X2jOptions, XmlBuilderOptions } from 'fast-xml-parser';
 export declare class XMLUtils {
     static readonly DEFAULT_NAMESPACE_LETTER = "D";
     static toJSON(xml: string, options?: X2jOptions): any;
-    static toXML(object: object, options?: XmlBuilderOptions): any;
-    static toWebDavXML(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

@@ -12,12 +12,12 @@ class XMLUtils {
         const builder = new fast_xml_parser_1.XMLBuilder(options);
         return builder.build(object);
     }
-    static toWebDavXML(object, options) {
+    static toWebDavXML(object, options, rootObject = 'multistatus') {
         const xmlContent = this.toXML(object, options);
         return ('<?xml version="1.0" encoding="utf-8" ?>' +
-            `<${XMLUtils.addDefaultNamespace('multistatus')} xmlns:${XMLUtils.DEFAULT_NAMESPACE_LETTER}="DAV:">` +
+            `<${XMLUtils.addDefaultNamespace(rootObject)} xmlns:${XMLUtils.DEFAULT_NAMESPACE_LETTER}="DAV:">` +
             `${xmlContent}` +
-            `</${XMLUtils.addDefaultNamespace('multistatus')}>`);
+            `</${XMLUtils.addDefaultNamespace(rootObject)}>`);
     }
     static addDefaultNamespace(key) {
         return `${XMLUtils.DEFAULT_NAMESPACE_LETTER}:${key}`;

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

@@ -1,13 +1,11 @@
 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 readonly dependencies;
     constructor(dependencies: {
-        driveDatabaseManager: DriveDatabaseManager;
         trashService: TrashService;
         driveFileService: DriveFileService;
         driveFolderService: DriveFolderService;

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

@@ -9,12 +9,11 @@ class DELETERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFileService, driveFolderService, trashService } = this.dependencies;
+        const { driveFileService, driveFolderService, trashService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[DELETE] Request received for ${resource.type} at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
-            driveDatabaseManager,
             driveFolderService,
             driveFileService: driveFileService,
         });
@@ -22,12 +21,6 @@ class DELETERequestHandler {
         await trashService.trashItems({
             items: [{ type: resource.type, uuid: driveItem.uuid }],
         });
-        if (resource.type === 'folder') {
-            await driveDatabaseManager.deleteFolderById(driveItem.id);
-        }
-        else if (resource.type === 'file') {
-            await driveDatabaseManager.deleteFileById(driveItem.id);
-        }
         res.status(204).send();
         const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);

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

@@ -1,7 +1,6 @@
 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 { DownloadService } from '../../services/network/download.service';
 import { CryptoService } from '../../services/crypto.service';
@@ -10,7 +9,6 @@ export declare class GETRequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
-        driveDatabaseManager: DriveDatabaseManager;
         downloadService: DownloadService;
         cryptoService: CryptoService;
         authService: AuthService;

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

@@ -11,7 +11,7 @@ class GETRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFileService, authService, networkFacade } = this.dependencies;
+        const { driveFileService, authService, networkFacade } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
@@ -20,7 +20,6 @@ class GETRequestHandler {
         logger_utils_1.webdavLogger.info(`[GET] Request received for ${resource.type} at ${resource.url}`);
         const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
-            driveDatabaseManager,
             driveFileService,
         }));
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);

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

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

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

@@ -10,32 +10,37 @@ class HEADRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFileService } = this.dependencies;
+        const { driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         if (resource.type === 'folder') {
             res.status(200).send();
             return;
         }
         logger_utils_1.webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
-        const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
-            resource,
-            driveDatabaseManager,
-            driveFileService,
-        }));
-        logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
-        const range = req.headers['range'];
-        const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
-            range,
-            totalFileSize: driveFile.size,
-        });
-        let contentLength = driveFile.size;
-        if (rangeOptions) {
-            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
-            contentLength = rangeOptions.rangeSize;
+        try {
+            const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+                resource,
+                driveFileService,
+            }));
+            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+            const range = req.headers['range'];
+            const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+                range,
+                totalFileSize: driveFile.size,
+            });
+            let contentLength = driveFile.size;
+            if (rangeOptions) {
+                logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.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.header('Content-Type', 'application/octet-stream');
-        res.header('Content-length', contentLength.toString());
-        res.status(200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

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

@@ -1,11 +1,9 @@
-import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 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 readonly dependencies;
     constructor(dependencies: {
-        driveDatabaseManager: DriveDatabaseManager;
         driveFolderService: DriveFolderService;
     });
     handle: (req: Request, res: Response) => Promise<void>;

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

@@ -5,39 +5,38 @@ 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 async_utils_1 = require("../../utils/async.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 class MKCOLRequestHandler {
     dependencies;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFolderService } = this.dependencies;
+        const { driveFolderService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[MKCOL] Request received for ${resource.type} at ${resource.url}`);
-        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath);
+        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
         const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource: parentResource,
-            driveDatabaseManager,
             driveFolderService,
         }));
+        let folderAlreadyExists = true;
+        try {
+            await driveFolderService.getFolderMetadataByPath(resource.url);
+        }
+        catch {
+            folderAlreadyExists = false;
+        }
+        if (folderAlreadyExists) {
+            logger_utils_1.webdavLogger.info(`[MKCOL] ❌ Folder '${resource.url}' already exists`);
+            throw new errors_utils_1.MethodNotAllowed('Folder already exists');
+        }
         const [createFolder] = driveFolderService.createFolder({
             plainName: resource.path.base,
             parentFolderUuid: parentFolderItem.uuid,
         });
         const newFolder = await createFolder;
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
-        await driveDatabaseManager.createFolder({
-            name: newFolder.plainName,
-            status: 'EXISTS',
-            encryptedName: newFolder.name,
-            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,12 +1,10 @@
 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 {
     private readonly dependencies;
     constructor(dependencies: {
-        driveDatabaseManager: DriveDatabaseManager;
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;
     });

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

@@ -10,7 +10,7 @@ class MOVERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
+        const { driveFolderService, driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[MOVE] Request received for ${resource.type} at ${resource.url}`);
         const destinationUrl = req.header('destination');
@@ -22,7 +22,6 @@ class MOVERequestHandler {
         logger_utils_1.webdavLogger.info('[MOVE] Destination resource found', { destinationResource });
         const originalDriveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
-            driveDatabaseManager,
             driveFolderService,
             driveFileService,
         });
@@ -35,7 +34,6 @@ class MOVERequestHandler {
                     folderUuid: folder.uuid,
                     name: newName,
                 });
-                await driveDatabaseManager.createFolder(folder, destinationResource.url);
             }
             else if (resource.type === 'file') {
                 const newType = destinationResource.path.ext.replace('.', '');
@@ -44,7 +42,6 @@ class MOVERequestHandler {
                     plainName: newName,
                     type: newType,
                 });
-                await driveDatabaseManager.createFile(file, destinationResource.url);
             }
         }
         else {
@@ -52,7 +49,6 @@ class MOVERequestHandler {
             const destinationFolderResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationResource.parentPath);
             const destinationFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
                 resource: destinationFolderResource,
-                driveDatabaseManager,
                 driveFolderService,
             }));
             if (resource.type === 'folder') {
@@ -61,7 +57,6 @@ class MOVERequestHandler {
                     folderUuid: folder.uuid,
                     destinationFolderUuid: destinationFolderItem.uuid,
                 });
-                await driveDatabaseManager.createFolder(folder, destinationPath);
             }
             else if (resource.type === 'file') {
                 const file = originalDriveItem;
@@ -69,7 +64,6 @@ class MOVERequestHandler {
                     fileUuid: file.uuid,
                     destinationFolderUuid: destinationFolderItem.uuid,
                 });
-                await driveDatabaseManager.createFile(file, destinationPath);
             }
         }
         res.status(204).send();

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

@@ -2,13 +2,11 @@ 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 readonly dependencies;
     constructor(dependencies: {
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;
-        driveDatabaseManager: DriveDatabaseManager;
     });
     handle: (req: Request, res: Response) => Promise<void>;
     private readonly getFileMetaXML;