@internxt/cli 1.5.6 → 1.5.8

package/dist/utils/drive.utils.js

@@ -34,5 +34,19 @@ class DriveUtils {
             updatedAt: new Date(folderMeta.updatedAt),
         };
     }
+    static createFolderResponseToItem(folderResponse) {
+        return {
+            uuid: folderResponse.uuid,
+            id: folderResponse.id,
+            bucket: folderResponse.bucket,
+            status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+            name: folderResponse.plainName ?? folderResponse.name,
+            encryptedName: folderResponse.name,
+            parentId: folderResponse.parentId,
+            parentUuid: folderResponse.parentUuid,
+            createdAt: new Date(folderResponse.createdAt),
+            updatedAt: new Date(folderResponse.updatedAt),
+        };
+    }
 }
 exports.DriveUtils = DriveUtils;

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

@@ -1,5 +1,6 @@
+export declare function isError(error: unknown): error is Error;
 export declare class ErrorUtils {
-    static report(reporter: (error: string) => void, error: unknown, props?: Record<string, unknown>): void;
+    static report(error: unknown, props?: Record<string, unknown>): void;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -1,13 +1,19 @@
 "use strict";
 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;
+const logger_utils_1 = require("./logger.utils");
+const node_util_1 = require("node:util");
+function isError(error) {
+    return node_util_1.types.isNativeError(error);
+}
 class ErrorUtils {
-    static report(reporter, error, props = {}) {
-        if (error instanceof Error) {
-            reporter(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
+    static report(error, props = {}) {
+        if (isError(error)) {
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
-            reporter(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
     }
 }

package/dist/utils/logger.utils.js

@@ -52,13 +52,3 @@ 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/webdav.utils.d.ts

@@ -2,14 +2,26 @@ 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';
-import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
+import { DriveFileItem, DriveFolderItem, DriveItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
     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({ resource, driveFolderService, driveFileService, }: {
+    static getDriveItemFromResource(params: {
         resource: WebDavRequestedResource;
-        driveFolderService?: DriveFolderService;
-        driveFileService?: DriveFileService;
-    }): Promise<DriveFileItem | DriveFolderItem | undefined>;
+        driveFolderService: DriveFolderService;
+        driveFileService?: never;
+    }): Promise<DriveFolderItem | undefined>;
+    static getDriveItemFromResource(params: {
+        resource: WebDavRequestedResource;
+        driveFolderService?: never;
+        driveFileService: DriveFileService;
+    }): Promise<DriveFileItem | undefined>;
+    static getDriveItemFromResource(params: {
+        resource: WebDavRequestedResource;
+        driveFolderService: DriveFolderService;
+        driveFileService: DriveFileService;
+    }): Promise<DriveItem | undefined>;
 }

package/dist/utils/webdav.utils.js

@@ -19,6 +19,19 @@ class WebDavUtils {
             url = '/'.concat(url);
         return url;
     }
+    static decodeUrl(requestUrl, decodeUri = true) {
+        return (decodeUri ? decodeURIComponent(requestUrl) : requestUrl).replaceAll('/./', '/');
+    }
+    static normalizeFolderPath(path) {
+        let normalizedPath = path;
+        if (!normalizedPath.startsWith('/')) {
+            normalizedPath = `/${normalizedPath}`;
+        }
+        if (!normalizedPath.endsWith('/')) {
+            normalizedPath = `${normalizedPath}/`;
+        }
+        return normalizedPath;
+    }
     static async getRequestedResource(urlObject, decodeUri = true) {
         let requestUrl;
         if (typeof urlObject === 'string') {
@@ -27,13 +40,9 @@ class WebDavUtils {
         else {
             requestUrl = urlObject.url;
         }
-        const decodedUrl = (decodeUri ? decodeURIComponent(requestUrl) : requestUrl).replaceAll('/./', '/');
+        const decodedUrl = this.decodeUrl(requestUrl, decodeUri);
         const parsedPath = node_path_1.default.parse(decodedUrl);
-        let parentPath = node_path_1.default.dirname(decodedUrl);
-        if (!parentPath.startsWith('/'))
-            parentPath = '/'.concat(parentPath);
-        if (!parentPath.endsWith('/'))
-            parentPath = parentPath.concat('/');
+        const parentPath = this.normalizeFolderPath(node_path_1.default.dirname(decodedUrl));
         const isFolder = requestUrl.endsWith('/');
         if (isFolder) {
             return {

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

@@ -1,10 +1,12 @@
 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,7 +4,6 @@ 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 async_utils_1 = require("../../utils/async.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
 class MKCOLRequestHandler {
     dependencies;
@@ -12,18 +11,11 @@ class MKCOLRequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveFolderService } = this.dependencies;
+        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 parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource: parentResource,
-            driveFolderService,
-        });
-        if (!parentDriveItem) {
-            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
-        }
-        const parentFolderItem = parentDriveItem;
+        const parentDriveFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
+            (await webDavFolderService.createParentPathOrThrow(resource.parentPath));
         const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
@@ -33,13 +25,11 @@ class MKCOLRequestHandler {
             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 webDavFolderService.createFolder({
+            folderName: resource.path.base,
+            parentFolderUuid: parentDriveFolderItem.uuid,
         });
-        const newFolder = await createFolder;
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
-        await async_utils_1.AsyncUtils.sleep(500);
         res.status(201).send(xml_utils_1.XMLUtils.toWebDavXML({}, {}));
     };
 }

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

@@ -2,11 +2,13 @@ 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

@@ -10,7 +10,7 @@ class MOVERequestHandler {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { driveFolderService, driveFileService } = this.dependencies;
+        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 destinationUrl = req.header('destination');
@@ -49,15 +49,8 @@ class MOVERequestHandler {
         }
         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 destinationDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource: destinationFolderResource,
-                driveFolderService,
-            });
-            if (!destinationDriveFolderItem) {
-                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-            }
-            const destinationFolderItem = destinationDriveFolderItem;
+            const destinationFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(destinationResource.parentPath)) ??
+                (await webDavFolderService.createParentPathOrThrow(destinationResource.parentPath));
             if (resource.type === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.moveFolder(folder.uuid, {

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

@@ -3,13 +3,13 @@ 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 { DriveFolderService } from '../../services/drive/drive-folder.service';
 import { TrashService } from '../../services/drive/trash.service';
+import { WebDavFolderService } from '../services/webdav-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;

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

@@ -10,13 +10,13 @@ const cli_utils_1 = require("../../utils/cli.utils");
 const stream_utils_1 = require("../../utils/stream.utils");
 const thumbnail_utils_1 = require("../../utils/thumbnail.utils");
 const thumbnail_service_1 = require("../../services/thumbnail.service");
+const async_utils_1 = require("../../utils/async.utils");
 class PUTRequestHandler {
     dependencies;
     constructor(dependencies) {
         this.dependencies = dependencies;
     }
     handle = async (req, res) => {
-        const { authService, networkFacade, driveFileService, driveFolderService, trashService } = this.dependencies;
         const contentLength = Number(req.headers['content-length']);
         if (!contentLength || isNaN(contentLength) || contentLength <= 0) {
             throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
@@ -26,30 +26,23 @@ class PUTRequestHandler {
             throw new errors_utils_1.NotFoundError('Folders cannot be created with PUT. Use MKCOL instead.');
         logger_utils_1.webdavLogger.info(`[PUT] Request received for ${resource.type} at ${resource.url}`);
         logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' to '${resource.parentPath}'`);
-        const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource: parentResource,
-            driveFolderService,
-        });
-        if (!parentDriveFolderItem) {
-            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
-        }
-        const parentFolderItem = parentDriveFolderItem;
+        const parentDriveFolderItem = (await this.dependencies.webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
+            (await this.dependencies.webDavFolderService.createParentPathOrThrow(resource.parentPath));
         try {
-            const driveFileItem = (await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
                 resource: resource,
-                driveFileService,
-            }));
+                driveFileService: this.dependencies.driveFileService,
+            });
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
                 logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
-                await trashService.trashItems({
+                await this.dependencies.trashService.trashItems({
                     items: [{ type: resource.type, uuid: driveFileItem.uuid, id: null }],
                 });
             }
         }
         catch {
         }
-        const { user } = await authService.getAuthDetails();
+        const { user } = await this.dependencies.authService.getAuthDetails();
         const fileType = resource.path.ext.replace('.', '');
         const timer = cli_utils_1.CLIUtils.timer();
         let bufferStream;
@@ -66,7 +59,7 @@ class PUTRequestHandler {
             }
         };
         const fileId = await new Promise((resolve, reject) => {
-            const state = networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
+            const state = this.dependencies.networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
                 if (err) {
                     aborted = true;
                     return reject(err);
@@ -87,7 +80,7 @@ class PUTRequestHandler {
             plainName: resource.path.name,
             type: fileType,
             size: contentLength,
-            folderUuid: parentFolderItem.uuid,
+            folderUuid: parentDriveFolderItem.uuid,
             fileId: fileId,
             bucket: user.bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
@@ -96,7 +89,7 @@ class PUTRequestHandler {
             if (isThumbnailable && bufferStream) {
                 const thumbnailBuffer = bufferStream.getBuffer();
                 if (thumbnailBuffer) {
-                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, networkFacade);
+                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, this.dependencies.networkFacade);
                 }
             }
         }
@@ -105,6 +98,8 @@ class PUTRequestHandler {
         }
         const uploadTime = timer.stop();
         logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${uploadTime}ms to Internxt Drive`);
+        await async_utils_1.AsyncUtils.sleep(500);
+        logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-201] ${resource.url} - Returning 201 Created after ${uploadTime}ms (+ 500ms propagation delay)`);
         res.status(201).send();
     };
 }

package/dist/webdav/middewares/auth.middleware.js

@@ -4,6 +4,7 @@ exports.AuthMiddleware = void 0;
 const sdk_manager_service_1 = require("../../services/sdk-manager.service");
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 const AuthMiddleware = (authService) => {
     return (_, res, next) => {
         (async () => {
@@ -14,10 +15,15 @@ const AuthMiddleware = (authService) => {
             }
             catch (error) {
                 let message = 'Authentication required to access this resource.';
-                if ('message' in error && error.message.trim().length > 0) {
+                if ((0, errors_utils_1.isError)(error)) {
                     message = error.message;
+                    if (error.stack) {
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}\nStack: ${error.stack}`);
+                    }
+                    else {
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}`);
+                    }
                 }
-                logger_utils_1.webdavLogger.error('Error from AuthMiddleware: ' + message);
                 const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({
                     [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
                 }, {}, 'error');

package/dist/webdav/middewares/errors.middleware.js

@@ -3,10 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ErrorHandlingMiddleware = void 0;
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 const ErrorHandlingMiddleware = (err, req, res, _) => {
-    logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}]`, err);
+    const message = (0, errors_utils_1.isError)(err) ? err.message : 'Something went wrong';
+    if ((0, errors_utils_1.isError)(err) && err.stack) {
+        logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}] ${message}\nStack: ${err.stack}`);
+    }
+    else {
+        logger_utils_1.webdavLogger.error(`[ERROR MIDDLEWARE] [${req.method.toUpperCase()} - ${req.url}] ${message}`);
+    }
     const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({
-        [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: 'message' in err ? err.message : 'Something went wrong',
+        [xml_utils_1.XMLUtils.addDefaultNamespace('responsedescription')]: message,
     }, {}, 'error');
     let statusCode = 500;
     if ('statusCode' in err && !isNaN(err.statusCode)) {

package/dist/webdav/services/webdav-folder.service.d.ts

@@ -0,0 +1,17 @@
+import { ConfigService } from '../../services/config.service';
+import { DriveFolderService } from '../../services/drive/drive-folder.service';
+import { DriveFolderItem } from '../../types/drive.types';
+export declare class WebDavFolderService {
+    private readonly dependencies;
+    constructor(dependencies: {
+        driveFolderService: DriveFolderService;
+        configService: ConfigService;
+    });
+    getDriveFolderItemFromPath: (path: string) => Promise<DriveFolderItem | undefined>;
+    createFolder: ({ folderName, parentFolderUuid, }: {
+        folderName: string;
+        parentFolderUuid: string;
+    }) => Promise<DriveFolderItem>;
+    createParentPathOrThrow: (parentPath: string) => Promise<DriveFolderItem>;
+    private createFolderRecursively;
+}

package/dist/webdav/services/webdav-folder.service.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebDavFolderService = void 0;
+const errors_utils_1 = require("../../utils/errors.utils");
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const async_utils_1 = require("../../utils/async.utils");
+const auth_service_1 = require("../../services/auth.service");
+const drive_utils_1 = require("../../utils/drive.utils");
+class WebDavFolderService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    getDriveFolderItemFromPath = async (path) => {
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
+        return await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            resource,
+            driveFolderService: this.dependencies.driveFolderService,
+        });
+    };
+    createFolder = async ({ folderName, parentFolderUuid, }) => {
+        const [createFolderPromise] = this.dependencies.driveFolderService.createFolder({
+            plainName: folderName,
+            parentFolderUuid: parentFolderUuid,
+        });
+        const newFolder = await createFolderPromise;
+        await async_utils_1.AsyncUtils.sleep(500);
+        return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
+    };
+    createParentPathOrThrow = async (parentPath) => {
+        const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
+        if (!createFullPath) {
+            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)}`);
+        }
+        const folders = parentPath.split('/').filter((f) => f.length > 0);
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
+        return await this.createFolderRecursively(folders, user.rootFolderId);
+    };
+    async createFolderRecursively(remainingFolders, parentFolderUuid, accumulatedPath = '') {
+        const [currentFolderName, ...rest] = remainingFolders;
+        const newPath = webdav_utils_1.WebDavUtils.joinURL(accumulatedPath, currentFolderName);
+        const folderPath = webdav_utils_1.WebDavUtils.normalizeFolderPath(newPath);
+        const folder = (await this.getDriveFolderItemFromPath(folderPath)) ??
+            (await this.createFolder({ folderName: currentFolderName, parentFolderUuid }));
+        if (rest.length === 0) {
+            return folder;
+        }
+        return await this.createFolderRecursively(rest, folder.uuid, newPath);
+    }
+}
+exports.WebDavFolderService = WebDavFolderService;

package/dist/webdav/webdav-server.js

@@ -31,6 +31,7 @@ const MOVE_handler_1 = require("./handlers/MOVE.handler");
 const COPY_handler_1 = require("./handlers/COPY.handler");
 const inxt_js_1 = require("@internxt/inxt-js");
 const mkcol_middleware_1 = require("./middewares/mkcol.middleware");
+const webdav_folder_service_1 = require("./services/webdav-folder.service");
 class WebDavServer {
     app;
     configService;
@@ -82,6 +83,10 @@ class WebDavServer {
     registerHandlers = async () => {
         const serverListenPath = /(.*)/;
         const networkFacade = await this.getNetworkFacade();
+        const webDavFolderService = new webdav_folder_service_1.WebDavFolderService({
+            driveFolderService: this.driveFolderService,
+            configService: this.configService,
+        });
         this.app.head(serverListenPath, (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler({
             driveFileService: this.driveFileService,
         }).handle));
@@ -99,13 +104,14 @@ class WebDavServer {
         }).handle));
         this.app.put(serverListenPath, (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler({
             driveFileService: this.driveFileService,
-            driveFolderService: this.driveFolderService,
+            webDavFolderService: webDavFolderService,
             authService: this.authService,
             trashService: this.trashService,
             networkFacade: networkFacade,
         }).handle));
         this.app.mkcol(serverListenPath, (0, express_async_handler_1.default)(new MKCOL_handler_1.MKCOLRequestHandler({
             driveFolderService: this.driveFolderService,
+            webDavFolderService: webDavFolderService,
         }).handle));
         this.app.delete(serverListenPath, (0, express_async_handler_1.default)(new DELETE_handler_1.DELETERequestHandler({
             trashService: this.trashService,
@@ -116,6 +122,7 @@ class WebDavServer {
         this.app.move(serverListenPath, (0, express_async_handler_1.default)(new MOVE_handler_1.MOVERequestHandler({
             driveFolderService: this.driveFolderService,
             driveFileService: this.driveFileService,
+            webDavFolderService,
         }).handle));
         this.app.copy(serverListenPath, (0, express_async_handler_1.default)(new COPY_handler_1.COPYRequestHandler().handle));
     };

package/oclif.manifest.json

@@ -1196,6 +1196,14 @@
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "createFullPath": {
+          "char": "c",
+          "description": "Auto-create missing parent directories during file uploads.",
+          "name": "createFullPath",
+          "required": false,
+          "allowNo": true,
+          "type": "boolean"
         }
       },
       "hasDynamicHelp": false,
@@ -1290,5 +1298,5 @@
       ]
     }
   },
-  "version": "1.5.6"
+  "version": "1.5.8"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "author": "Internxt <hello@internxt.com>",
-  "version": "1.5.6",
+  "version": "1.5.8",
   "description": "Internxt CLI to manage your encrypted storage",
   "scripts": {
     "build": "yarn clean && tsc",
@@ -40,8 +40,8 @@
     "@internxt/inxt-js": "2.2.9",
     "@internxt/lib": "1.3.1",
     "@internxt/sdk": "1.11.12",
-    "@oclif/core": "4.5.4",
-    "@oclif/plugin-autocomplete": "3.2.35",
+    "@oclif/core": "4.5.5",
+    "@oclif/plugin-autocomplete": "3.2.36",
     "axios": "1.12.2",
     "bip39": "3.1.0",
     "body-parser": "2.2.0",
@@ -50,7 +50,7 @@
     "dotenv": "17.2.3",
     "express": "5.1.0",
     "express-async-handler": "1.2.0",
-    "fast-xml-parser": "5.2.5",
+    "fast-xml-parser": "5.3.0",
     "mime-types": "3.0.1",
     "openpgp": "6.2.2",
     "otpauth": "9.4.1",
@@ -67,15 +67,15 @@
     "@types/cli-progress": "3.11.6",
     "@types/express": "5.0.3",
     "@types/mime-types": "3.0.1",
-    "@types/node": "22.18.6",
+    "@types/node": "22.18.9",
     "@types/range-parser": "1.2.7",
     "@vitest/coverage-istanbul": "3.2.4",
     "@vitest/spy": "3.2.4",
-    "eslint": "9.36.0",
+    "eslint": "9.37.0",
     "husky": "9.1.7",
-    "lint-staged": "16.2.3",
+    "lint-staged": "16.2.4",
     "nodemon": "3.1.10",
-    "oclif": "4.22.27",
+    "oclif": "4.22.32",
     "prettier": "3.6.2",
     "rimraf": "6.0.1",
     "ts-node": "10.9.2",