@internxt/cli 1.5.8 → 1.6.1

package/dist/utils/cli.utils.js

@@ -7,8 +7,16 @@ exports.NoFlagProvidedError = exports.CLIUtils = void 0;
 const core_1 = require("@oclif/core");
 const cli_progress_1 = __importDefault(require("cli-progress"));
 const tty_table_1 = __importDefault(require("tty-table"));
+const command_types_1 = require("../types/command.types");
 const inquirer_utils_1 = require("./inquirer.utils");
 const errors_utils_1 = require("./errors.utils");
+const validation_service_1 = require("../services/validation.service");
+const sdk_manager_service_1 = require("../services/sdk-manager.service");
+const inxt_js_1 = require("@internxt/inxt-js");
+const config_service_1 = require("../services/config.service");
+const network_facade_service_1 = require("../services/network/network-facade.service");
+const download_service_1 = require("../services/network/download.service");
+const crypto_service_1 = require("../services/crypto.service");
 class CLIUtils {
     static clearPreviousLine = (jsonFlag) => {
         if (!jsonFlag) {
@@ -94,6 +102,28 @@ class CLIUtils {
             return await CLIUtils.promptWithAttempts(command.prompt, maxAttempts, validation, reporter);
         }
     };
+    static getDestinationFolderUuid = async ({ destinationFolderUuidFlag, destinationFlagName, nonInteractive, reporter, }) => {
+        const destinationFolderUuid = await this.getValueFromFlag({
+            value: destinationFolderUuidFlag,
+            name: destinationFlagName,
+        }, {
+            nonInteractive,
+            prompt: {
+                message: 'What is the destination folder id? (leave empty for the root folder)',
+                options: { type: 'input' },
+            },
+        }, {
+            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            error: new command_types_1.NotValidFolderUuidError(),
+            canBeEmpty: true,
+        }, reporter);
+        if (destinationFolderUuid.trim().length === 0) {
+            return undefined;
+        }
+        else {
+            return destinationFolderUuid;
+        }
+    };
     static promptWithAttempts = async (prompt, maxAttempts, validation, reporter) => {
         let isValid = false;
         let currentAttempts = 0;
@@ -148,6 +178,23 @@ class CLIUtils {
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);
+    static prepareNetwork = ({ jsonFlag, loginUserDetails, }) => {
+        CLIUtils.doing('Preparing Network', jsonFlag);
+        const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
+            user: loginUserDetails.bridgeUser,
+            pass: loginUserDetails.userId,
+        });
+        const environment = new inxt_js_1.Environment({
+            bridgeUser: loginUserDetails.bridgeUser,
+            bridgePass: loginUserDetails.userId,
+            bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
+            encryptionKey: loginUserDetails.mnemonic,
+            appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
+        });
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
+        CLIUtils.done(jsonFlag);
+        return networkFacade;
+    };
 }
 exports.CLIUtils = CLIUtils;
 class NoFlagProvidedError extends Error {

package/dist/utils/drive.utils.js

@@ -4,6 +4,7 @@ exports.DriveUtils = void 0;
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
+            itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
             folderId: fileMeta.folderId,
@@ -22,6 +23,7 @@ class DriveUtils {
     }
     static driveFolderMetaToItem(folderMeta) {
         return {
+            itemType: 'folder',
             uuid: folderMeta.uuid,
             id: folderMeta.id,
             bucket: folderMeta.bucket,
@@ -36,6 +38,7 @@ class DriveUtils {
     }
     static createFolderResponseToItem(folderResponse) {
         return {
+            itemType: 'folder',
             uuid: folderResponse.uuid,
             id: folderResponse.id,
             bucket: folderResponse.bucket,

package/dist/utils/errors.utils.d.ts

@@ -1,4 +1,5 @@
 export declare function isError(error: unknown): error is Error;
+export declare function isAlreadyExistsError(error: unknown): error is Error;
 export declare class ErrorUtils {
     static report(error: unknown, props?: Record<string, unknown>): void;
 }

package/dist/utils/errors.utils.js

@@ -2,11 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
 exports.isError = isError;
+exports.isAlreadyExistsError = isAlreadyExistsError;
 const logger_utils_1 = require("./logger.utils");
 const node_util_1 = require("node:util");
 function isError(error) {
     return node_util_1.types.isNativeError(error);
 }
+function isAlreadyExistsError(error) {
+    return ((isError(error) && error.message.includes('already exists')) ||
+        (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
+}
 class ErrorUtils {
     static report(error, props = {}) {
         if (isError(error)) {

package/dist/utils/logger.utils.js

@@ -52,3 +52,13 @@ exports.webdavLogger = winston_1.default.createLogger({
         }),
     ],
 });
+if (process.env.NODE_ENV !== 'production') {
+    exports.webdavLogger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}
+if (process.env.NODE_ENV !== 'production') {
+    exports.logger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}

package/dist/utils/network.utils.d.ts

@@ -11,10 +11,10 @@ export declare class NetworkUtils {
         cert: string;
         privateKey: string;
     };
-    static generateNewSelfsignedCerts(configs: WebdavConfig): SelfsignedCert;
+    static generateNewSelfsignedCerts(configs: WebdavConfig): Promise<SelfsignedCert>;
     static getWebdavSSLCerts(configs: WebdavConfig): Promise<SelfsignedCert>;
     static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): Promise<void>;
-    static generateSelfSignedSSLCerts(configs: WebdavConfig): selfsigned.GenerateResult;
+    static generateSelfSignedSSLCerts(configs: WebdavConfig): Promise<selfsigned.GenerateResult>;
     static parseRangeHeader(rangeOptions: {
         range?: string;
         totalFileSize: number;

package/dist/utils/network.utils.js

@@ -21,8 +21,8 @@ class NetworkUtils {
         cert: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
         privateKey: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
     };
-    static generateNewSelfsignedCerts(configs) {
-        const newCerts = this.generateSelfSignedSSLCerts(configs);
+    static async generateNewSelfsignedCerts(configs) {
+        const newCerts = await this.generateSelfSignedSSLCerts(configs);
         this.saveWebdavSSLCerts(newCerts);
         return {
             cert: newCerts.cert,
@@ -44,7 +44,7 @@ class NetworkUtils {
             const dateToday = new Date();
             const dateValid = new Date(validTo);
             if (dateToday > dateValid) {
-                const newCerts = this.generateNewSelfsignedCerts(configs);
+                const newCerts = await this.generateNewSelfsignedCerts(configs);
                 selfsignedCert = {
                     cert: newCerts.cert,
                     key: newCerts.key,
@@ -57,7 +57,7 @@ class NetworkUtils {
         await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.cert, pems.cert, 'utf8');
         await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.privateKey, pems.private, 'utf8');
     }
-    static generateSelfSignedSSLCerts(configs) {
+    static async generateSelfSignedSSLCerts(configs) {
         const attrs = [{ name: 'commonName', value: configs.host }];
         const extensions = [
             {
@@ -70,7 +70,9 @@ class NetworkUtils {
                 ],
             },
         ];
-        const pems = selfsigned_1.default.generate(attrs, { days: 365, algorithm: 'sha256', keySize: 2048, extensions });
+        const notAfterDate = new Date();
+        notAfterDate.setDate(notAfterDate.getDate() + 365);
+        const pems = await selfsigned_1.default.generate(attrs, { notAfterDate, algorithm: 'sha256', keySize: 2048, extensions });
         return pems;
     }
     static parseRangeHeader(rangeOptions) {

package/dist/utils/thumbnail.utils.d.ts

@@ -1,3 +1,6 @@
+import { Readable } from 'node:stream';
+import { NetworkFacade } from '../services/network/network-facade.service';
+import { BufferStream } from './stream.utils';
 export declare const ThumbnailConfig: {
     readonly MaxWidth: 300;
     readonly MaxHeight: 300;
@@ -7,3 +10,17 @@ export declare const ThumbnailConfig: {
 export declare const isFileThumbnailable: (fileType: string) => boolean;
 export declare const isPDFThumbnailable: (fileType: string) => boolean;
 export declare const isImageThumbnailable: (fileType: string) => boolean;
+export declare const tryUploadThumbnail: ({ bufferStream, fileType, userBucket, fileUuid, networkFacade, }: {
+    bufferStream: BufferStream;
+    fileType: string;
+    userBucket: string;
+    fileUuid: string;
+    networkFacade: NetworkFacade;
+}) => Promise<void>;
+export declare const createFileStreamWithBuffer: ({ path, fileType, }: {
+    path: string;
+    fileType: string;
+}) => {
+    bufferStream?: BufferStream;
+    fileStream: Readable;
+};

package/dist/utils/thumbnail.utils.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImageThumbnailable = exports.isPDFThumbnailable = exports.isFileThumbnailable = exports.ThumbnailConfig = void 0;
+exports.createFileStreamWithBuffer = exports.tryUploadThumbnail = exports.isImageThumbnailable = exports.isPDFThumbnailable = exports.isFileThumbnailable = exports.ThumbnailConfig = void 0;
+const thumbnail_service_1 = require("../services/thumbnail.service");
+const errors_utils_1 = require("./errors.utils");
+const stream_utils_1 = require("./stream.utils");
+const node_fs_1 = require("node:fs");
 exports.ThumbnailConfig = {
     MaxWidth: 300,
     MaxHeight: 300,
@@ -42,3 +46,27 @@ const isImageThumbnailable = (fileType) => {
     return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isImageThumbnailable = isImageThumbnailable;
+const tryUploadThumbnail = async ({ bufferStream, fileType, userBucket, fileUuid, networkFacade, }) => {
+    try {
+        const thumbnailBuffer = bufferStream.getBuffer();
+        if (thumbnailBuffer) {
+            await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, userBucket, fileUuid, networkFacade);
+        }
+    }
+    catch (error) {
+        errors_utils_1.ErrorUtils.report(error);
+    }
+};
+exports.tryUploadThumbnail = tryUploadThumbnail;
+const createFileStreamWithBuffer = ({ path, fileType, }) => {
+    const readable = (0, node_fs_1.createReadStream)(path);
+    if ((0, exports.isFileThumbnailable)(fileType)) {
+        const bufferStream = new stream_utils_1.BufferStream();
+        return {
+            bufferStream,
+            fileStream: readable.pipe(bufferStream),
+        };
+    }
+    return { fileStream: readable };
+};
+exports.createFileStreamWithBuffer = createFileStreamWithBuffer;

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

@@ -1,4 +1,3 @@
-import { Request } from 'express';
 import { WebDavRequestedResource } from '../types/webdav.types';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
@@ -8,18 +7,21 @@ export declare class WebDavUtils {
     static removeHostFromURL(completeURL: string): string;
     static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
     static normalizeFolderPath(path: string): string;
-    static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static getDriveItemFromResource(params: {
-        resource: WebDavRequestedResource;
+    static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
+    static tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }: {
+        url: string;
         driveFolderService: DriveFolderService;
-        driveFileService?: never;
-    }): Promise<DriveFolderItem | undefined>;
-    static getDriveItemFromResource(params: {
-        resource: WebDavRequestedResource;
-        driveFolderService?: never;
+        driveFileService: DriveFileService;
+    }): Promise<DriveItem | undefined>;
+    static getDriveFileFromResource({ url, driveFileService, }: {
+        url: string;
         driveFileService: DriveFileService;
     }): Promise<DriveFileItem | undefined>;
-    static getDriveItemFromResource(params: {
+    static getDriveFolderFromResource({ url, driveFolderService, }: {
+        url: string;
+        driveFolderService: DriveFolderService;
+    }): Promise<DriveFolderItem | undefined>;
+    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;

package/dist/utils/webdav.utils.js

@@ -5,6 +5,7 @@ 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 logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -32,45 +33,54 @@ class WebDavUtils {
         }
         return normalizedPath;
     }
-    static async getRequestedResource(urlObject, decodeUri = true) {
-        let requestUrl;
-        if (typeof urlObject === 'string') {
-            requestUrl = urlObject;
-        }
-        else {
-            requestUrl = urlObject.url;
-        }
+    static async getRequestedResource(requestUrl, decodeUri = true) {
         const decodedUrl = this.decodeUrl(requestUrl, decodeUri);
         const parsedPath = node_path_1.default.parse(decodedUrl);
         const parentPath = this.normalizeFolderPath(node_path_1.default.dirname(decodedUrl));
-        const isFolder = requestUrl.endsWith('/');
-        if (isFolder) {
-            return {
-                type: 'folder',
-                url: decodedUrl,
-                name: parsedPath.base,
-                path: parsedPath,
-                parentPath,
-            };
+        return {
+            url: decodedUrl,
+            name: parsedPath.base,
+            path: parsedPath,
+            parentPath,
+        };
+    }
+    static async tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch {
+            return await driveFolderService.getFolderMetadataByPath(url);
+        }
+    }
+    static async getDriveFileFromResource({ url, driveFileService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
+        }
+    }
+    static async getDriveFolderFromResource({ url, driveFolderService, }) {
+        try {
+            return await driveFolderService.getFolderMetadataByPath(url);
         }
-        else {
-            return {
-                type: 'file',
-                url: decodedUrl,
-                name: parsedPath.name,
-                path: parsedPath,
-                parentPath,
-            };
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
         }
     }
     static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
         let item = undefined;
+        const isFolder = resource.url.endsWith('/');
         try {
-            if (resource.type === 'folder') {
-                item = await driveFolderService?.getFolderMetadataByPath(resource.url);
+            if (isFolder) {
+                item = await driveFolderService.getFolderMetadataByPath(resource.url);
             }
-            if (resource.type === 'file') {
-                item = await driveFileService?.getFileMetadataByPath(resource.url);
+            else {
+                item = await this.tryGetFileOrFolderMetadata({
+                    url: resource.url,
+                    driveFileService,
+                    driveFolderService,
+                });
             }
         }
         catch {

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

@@ -1,4 +1,4 @@
-import { X2jOptions, XmlBuilderOptions } from 'fast-xml-parser';
+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;

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

@@ -11,8 +11,8 @@ class DELETERequestHandler {
     }
     handle = async (req, res) => {
         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 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,
@@ -21,12 +21,12 @@ class DELETERequestHandler {
         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 ${resource.type}`);
+        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
         await trashService.trashItems({
-            items: [{ type: resource.type, uuid: driveItem.uuid, id: null }],
+            items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
         });
         res.status(204).send();
-        const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);
+        const type = driveItem.itemType.charAt(0).toUpperCase() + driveItem.itemType.substring(1);
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }

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

@@ -5,6 +5,7 @@ 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 network_utils_1 = require("../../utils/network.utils");
+const command_types_1 = require("../../types/command.types");
 class GETRequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -12,48 +13,57 @@ class GETRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService, authService, networkFacade } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
-        if (resource.type === 'folder')
-            throw new errors_utils_1.NotFoundError('Folders cannot be listed with GET. Use PROPFIND instead.');
-        logger_utils_1.webdavLogger.info(`[GET] Request received for ${resource.type} at ${resource.url}`);
-        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        logger_utils_1.webdavLogger.info(`[GET] Request received item at ${resource.url}`);
+        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+            url: resource.url,
             driveFileService,
         });
-        if (!driveItem) {
-            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${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.`);
         }
-        const driveFile = driveItem;
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
         const { user } = await authService.getAuthDetails();
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);
-        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(`[GET] [${driveFile.uuid}] Range request received:`, { rangeOptions });
-            contentLength = rangeOptions.rangeSize;
-        }
         res.header('Content-Type', 'application/octet-stream');
-        res.header('Content-length', contentLength.toString());
-        const writable = new WritableStream({
-            write(chunk) {
-                res.write(chunk);
-            },
-            close() {
-                res.end();
-            },
-        });
-        const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
-        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
-        res.status(200);
-        await executeDownload;
-        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] ✅ Download ready, replying to client`);
+        const fileSize = driveFile.size ?? 0;
+        if (fileSize > 0) {
+            const range = req.headers['range'];
+            const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+                range,
+                totalFileSize: fileSize,
+            });
+            let contentLength = fileSize;
+            if (rangeOptions) {
+                logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+                contentLength = rangeOptions.rangeSize;
+            }
+            res.header('Content-length', contentLength.toString());
+            const writable = new WritableStream({
+                write(chunk) {
+                    res.write(chunk);
+                },
+                close() {
+                    res.end();
+                },
+            });
+            if (!driveFile.fileId) {
+                throw new command_types_1.NotValidFileIdError();
+            }
+            const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
+            logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
+            res.status(200);
+            await executeDownload;
+            logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] ✅ Download ready, replying to client`);
+        }
+        else {
+            logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] File is empty, replying to client with no content`);
+            res.header('Content-length', '0');
+            res.status(200);
+            res.end();
+        }
     };
 }
 exports.GETRequestHandler = GETRequestHandler;

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

@@ -12,21 +12,16 @@ class HEADRequestHandler {
     }
     handle = async (req, res) => {
         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 resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[HEAD] Request received for file at ${resource.url}`);
         try {
-            const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource,
+            const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+                url: resource.url,
                 driveFileService,
             });
-            if (!driveItem) {
+            if (!driveFile) {
                 throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
             }
-            const driveFile = driveItem;
             logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
             const range = req.headers['range'];
             const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({

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

@@ -12,12 +12,12 @@ class MKCOLRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFolderService, webDavFolderService } = 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 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.getDriveItemFromResource({
-            resource,
+        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
+            url: resource.url,
             driveFolderService,
         });
         const folderAlreadyExists = !!driveFolderItem;

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

@@ -11,8 +11,8 @@ class MOVERequestHandler {
     }
     handle = async (req, res) => {
         const { driveFolderService, driveFileService, webDavFolderService } = 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 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');
         if (!destinationUrl) {
             throw new errors_utils_1.NotFoundError('[MOVE] Destination folder not received');
@@ -28,43 +28,45 @@ class MOVERequestHandler {
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
-        const newName = destinationResource.name;
         if (destinationResource.path.dir === resource.path.dir) {
-            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
-            if (resource.type === 'folder') {
+            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${originalDriveItem.itemType}
+        with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.renameFolder({
                     folderUuid: folder.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
-                const newType = destinationResource.path.ext.replace('.', '');
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.renameFile(file.uuid, {
-                    plainName: newName,
-                    type: newType,
+                    plainName: plainName,
+                    type: fileType,
                 });
             }
         }
         else {
-            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
+            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));
-            if (resource.type === 'folder') {
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.moveFolder(folder.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
-                const newType = destinationResource.path.ext.replace('.', '');
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.moveFile(file.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
-                    type: newType,
+                    name: plainName,
+                    type: fileType,
                 });
             }
         }