@internxt/cli 1.6.9 → 1.6.10

package/dist/services/drive/drive-item.service.js

@@ -8,6 +8,11 @@ const drive_file_service_1 = require("./drive-file.service");
 const drive_folder_service_1 = require("./drive-folder.service");
 class DriveItemService {
     static instance = new DriveItemService();
+    dropCacheIfGone = async (uuid, error) => {
+        if (!errors_utils_1.ErrorUtils.isNotFoundError(error))
+            return;
+        await drive_item_repository_1.DriveItemRepository.instance.delete([uuid]);
+    };
     tryGetFileByUuid = async (cached, path) => {
         try {
             const item = await drive_file_service_1.DriveFileService.instance.getFileMetadata(cached.uuid);
@@ -22,9 +27,12 @@ class DriveItemService {
             ]);
             return item;
         }
-        catch {
-            logger_utils_1.logger.warn('File metadata by uuid failed, falling back to path lookup', { path, uuid: cached.uuid });
-            await drive_item_repository_1.DriveItemRepository.instance.delete([cached.uuid]);
+        catch (error) {
+            logger_utils_1.webdavLogger.warn(errors_utils_1.ErrorUtils.withRequestId('File metadata by uuid failed, falling back to path lookup', error), {
+                path,
+                uuid: cached.uuid,
+            });
+            await this.dropCacheIfGone(cached.uuid, error);
         }
     };
     tryGetFolderByUuid = async (cached, path) => {
@@ -41,14 +49,14 @@ class DriveItemService {
             ]);
             return item;
         }
-        catch {
-            logger_utils_1.logger.warn('Folder metadata by uuid failed, falling back to path lookup', { path, uuid: cached.uuid });
-            await drive_item_repository_1.DriveItemRepository.instance.delete([cached.uuid]);
+        catch (error) {
+            logger_utils_1.webdavLogger.warn(errors_utils_1.ErrorUtils.withRequestId('Folder metadata by uuid failed, falling back to path lookup', error), { path, uuid: cached.uuid });
+            await this.dropCacheIfGone(cached.uuid, error);
         }
     };
     getFileByPath = async (path) => {
-        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path);
-        if (cached) {
+        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path, 'file');
+        if (cached?.type === 'file') {
             const item = await this.tryGetFileByUuid(cached, path);
             if (item)
                 return item;
@@ -66,13 +74,14 @@ class DriveItemService {
             ]);
             return item;
         }
-        catch {
-            throw new errors_utils_1.NotFoundError(`File not found at path: ${path}`);
+        catch (error) {
+            errors_utils_1.ErrorUtils.logIfUnexpected(logger_utils_1.webdavLogger, 'File lookup by path failed', error, { path });
+            throw errors_utils_1.ErrorUtils.toLookupError('file', path, error);
         }
     };
     getFolderByPath = async (path) => {
-        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path);
-        if (cached) {
+        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path, 'folder');
+        if (cached?.type === 'folder') {
             const item = await this.tryGetFolderByUuid(cached, path);
             if (item)
                 return item;
@@ -90,8 +99,9 @@ class DriveItemService {
             ]);
             return item;
         }
-        catch {
-            throw new errors_utils_1.NotFoundError(`Folder not found at path: ${path}`);
+        catch (error) {
+            errors_utils_1.ErrorUtils.logIfUnexpected(logger_utils_1.webdavLogger, 'Folder lookup by path failed', error, { path });
+            throw errors_utils_1.ErrorUtils.toLookupError('folder', path, error);
         }
     };
 }

package/dist/services/drive/trash.service.d.ts

@@ -1,6 +1,7 @@
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 export declare class TrashService {
     static readonly instance: TrashService;
+    private static readonly SCAN_FROM;
     trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
     deleteItemPermanently: (itemType: "file" | "folder", id: string) => Promise<void> | Promise<{
         deleted: boolean;
@@ -31,7 +32,6 @@ export declare class TrashService {
             status: "EXISTS" | "TRASHED" | "DELETED";
             removed: boolean;
             deleted: boolean;
-            isFavorite?: boolean;
         }[];
         files: {
             id: number;
@@ -51,9 +51,10 @@ export declare class TrashService {
             updatedAt: string;
             plainName: string;
             status: "EXISTS" | "TRASHED" | "DELETED";
-            isFavorite?: boolean;
+            sharings?: import("@internxt/sdk/dist/schema").components["schemas"]["FileSharingDto"][];
         }[];
     }>;
-    private readonly getAllTrashSubfolders;
-    private readonly getAllTrashSubfiles;
+    private readonly getTrashedFolders;
+    private readonly getTrashedFiles;
+    private readonly syncQuery;
 }

package/dist/services/drive/trash.service.js

@@ -2,8 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TrashService = void 0;
 const sdk_manager_service_1 = require("../sdk-manager.service");
+const pagination_utils_1 = require("../../utils/pagination.utils");
 class TrashService {
     static instance = new TrashService();
+    static SCAN_FROM = new Date(0).toISOString();
     trashItems = (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.addItemsToTrash(payload);
@@ -29,31 +31,28 @@ class TrashService {
         return trashClient.clearTrash();
     };
     getTrashFolderContent = async () => {
-        const folders = await this.getAllTrashSubfolders(0);
-        const files = await this.getAllTrashSubfiles(0);
+        const [folders, files] = await Promise.all([this.getTrashedFolders(), this.getTrashedFiles()]);
         return { folders, files };
     };
-    getAllTrashSubfolders = async (offset) => {
-        const trashClient = sdk_manager_service_1.SdkManager.instance.getTrash();
-        const promise = trashClient.getTrashedFilesPaginated(50, offset, 'folders', true);
-        const folders = (await promise).result;
-        if (folders.length > 0) {
-            return folders.concat(await this.getAllTrashSubfolders(offset + folders.length));
-        }
-        else {
-            return folders;
-        }
+    getTrashedFolders = async () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return pagination_utils_1.PaginationUtils.fetchAllPages(async (cursor) => {
+            const [promise] = storageClient.getFoldersSync(this.syncQuery(cursor));
+            const { folders, nextCursor } = await promise;
+            return { items: folders, nextCursor };
+        });
     };
-    getAllTrashSubfiles = async (offset) => {
-        const trashClient = sdk_manager_service_1.SdkManager.instance.getTrash();
-        const promise = trashClient.getTrashedFilesPaginated(50, offset, 'files', true);
-        const files = (await promise).result;
-        if (files.length > 0) {
-            return files.concat(await this.getAllTrashSubfiles(offset + files.length));
-        }
-        else {
-            return files;
-        }
+    getTrashedFiles = async () => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return pagination_utils_1.PaginationUtils.fetchAllPages(async (cursor) => {
+            const [promise] = storageClient.getFilesSync(this.syncQuery(cursor));
+            const { files, nextCursor } = await promise;
+            return { items: files, nextCursor };
+        });
+    };
+    syncQuery = (cursor) => {
+        const position = cursor ? { cursor } : { updatedAt: TrashService.SCAN_FROM };
+        return { ...position, status: 'TRASHED', limit: pagination_utils_1.PaginationUtils.MAX_PAGE_SIZE };
     };
 }
 exports.TrashService = TrashService;

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

@@ -6,6 +6,10 @@ export declare class WebDavFolderService {
         folderName: string;
         parentFolderUuid: string;
     }) => Promise<DriveFolderItem>;
+    createOrReuseFolder: ({ folderName, parentFolderUuid, }: {
+        folderName: string;
+        parentFolderUuid: string;
+    }) => Promise<DriveFolderItem>;
     createParentPathOrThrow: (parentPath: string) => Promise<DriveFolderItem>;
     private createFolderRecursively;
 }

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

@@ -23,6 +23,19 @@ class WebDavFolderService {
         await async_utils_1.AsyncUtils.sleep(500);
         return drive_utils_1.DriveUtils.createFolderResponseToItem(newFolder);
     };
+    createOrReuseFolder = async ({ folderName, parentFolderUuid, }) => {
+        try {
+            return await this.createFolder({ folderName, parentFolderUuid });
+        }
+        catch (error) {
+            if (!errors_utils_1.ErrorUtils.isAlreadyExistsError(error))
+                throw error;
+            const existingFolder = await drive_folder_service_1.DriveFolderService.instance.findExistentFolder(parentFolderUuid, folderName);
+            if (!existingFolder)
+                throw error;
+            return existingFolder;
+        }
+    };
     createParentPathOrThrow = async (parentPath) => {
         const { createFullPath } = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (!createFullPath) {
@@ -38,7 +51,7 @@ class WebDavFolderService {
         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 }));
+            (await this.createOrReuseFolder({ folderName: currentFolderName, parentFolderUuid }));
         if (rest.length === 0) {
             return folder;
         }

package/dist/types/config.types.d.ts

@@ -7,4 +7,5 @@ export interface ConfigKeys {
     readonly APP_MAGIC_SALT: string;
     readonly NETWORK_URL: string;
     readonly DESKTOP_HEADER: string;
+    readonly INXT_SQLITE_JOURNAL_MODE: string;
 }

package/dist/types/drive.types.d.ts

@@ -1,4 +1,5 @@
 import { FileMeta, FolderMeta } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveItemType = 'file' | 'folder';
 export type DriveFileItem = Pick<FileMeta, 'uuid' | 'name' | 'bucket' | 'folderUuid' | 'status'> & {
     itemType: 'file';
     size: number;

package/dist/utils/cli.utils.js

@@ -185,13 +185,7 @@ class CLIUtils {
     };
     static catchError = ({ error, logReporter, command, jsonFlag, debugMode, }) => {
         let message = '';
-        let requestId;
-        if ('requestId' in error) {
-            requestId = error.requestId;
-        }
-        else if ('xRequestId' in error) {
-            requestId = error.xRequestId;
-        }
+        const requestId = errors_utils_1.ErrorUtils.getRequestId(error);
         if ('message' in error && typeof error.message === 'string' && error.message?.trim?.().length > 0) {
             message = error.message;
         }
@@ -226,7 +220,7 @@ class CLIUtils {
             if (debugMode) {
                 errors_utils_1.ErrorUtils.report(error);
             }
-            CLIUtils.error(logReporter, message + (requestId ? ` (requestId: ${requestId})` : ''));
+            CLIUtils.error(logReporter, errors_utils_1.ErrorUtils.withRequestId(message, error));
         }
     };
     static parseEmpty = async (input) => (input.trim().length === 0 ? ' ' : input);

package/dist/utils/drive.utils.d.ts

@@ -1,6 +1,7 @@
 import { FileMeta, FolderMeta, CreateFolderResponse } from '@internxt/sdk/dist/drive/storage/types';
 import { DriveFileItem, DriveFolderItem } from '../types/drive.types';
 export declare class DriveUtils {
+    private static assertUsableMeta;
     static parseFileSize(size: string | number): number;
     static driveFileMetaToItem(fileMeta: FileMeta): DriveFileItem;
     static driveFolderMetaToItem(folderMeta: FolderMeta): DriveFolderItem;

package/dist/utils/drive.utils.js

@@ -2,15 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveUtils = void 0;
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+const errors_utils_1 = require("./errors.utils");
 class DriveUtils {
+    static assertUsableMeta(meta, kind) {
+        if (!meta?.uuid) {
+            throw new errors_utils_1.ServiceUnavailableError(`Unusable ${kind} metadata received from the API`);
+        }
+    }
     static parseFileSize(size) {
         const parsed = Number(size);
         return Number.isFinite(parsed) ? parsed : 0;
     }
     static driveFileMetaToItem(fileMeta) {
+        DriveUtils.assertUsableMeta(fileMeta, 'file');
         return {
             itemType: 'file',
-            uuid: fileMeta.uuid ?? '',
+            uuid: fileMeta.uuid,
             status: fileMeta.status,
             folderUuid: fileMeta.folderUuid,
             size: DriveUtils.parseFileSize(fileMeta.size),
@@ -25,6 +32,7 @@ class DriveUtils {
         };
     }
     static driveFolderMetaToItem(folderMeta) {
+        DriveUtils.assertUsableMeta(folderMeta, 'folder');
         return {
             itemType: 'folder',
             uuid: folderMeta.uuid,

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

@@ -1,8 +1,26 @@
+import { Logger } from 'winston';
+import { DriveItemType } from '../types/drive.types';
+export type LookupErrorKind = 'not-found' | 'auth' | 'inconclusive';
+export declare const DEFAULT_RETRY_AFTER_SECONDS = 5;
 export declare class ErrorUtils {
     static readonly isError: (error: unknown) => error is Error;
     static readonly report: (error: unknown, props?: Record<string, unknown>) => void;
     static readonly isAlreadyExistsError: (error: unknown) => error is Error;
     static readonly isFileNotFoundError: (error: unknown) => error is NodeJS.ErrnoException;
+    static readonly getRequestId: (error: unknown) => string | undefined;
+    static readonly withRequestId: (message: string, error: unknown) => string;
+    static readonly getStatusCode: (error: unknown, key?: "statusCode" | "status") => number | undefined;
+    static readonly isNotFoundError: (error: unknown) => boolean;
+    private static readonly hasResponseBody;
+    static readonly classifyLookupError: (error: unknown) => LookupErrorKind;
+    static readonly toLookupError: (itemType: DriveItemType, path: string, error: unknown) => Error;
+    private static readonly isAuthStatus;
+    private static readonly isRetryableStatus;
+    static readonly toWebDavStatus: (error: unknown) => {
+        statusCode: number;
+        retryAfter?: number;
+    };
+    static readonly logIfUnexpected: (log: Logger, message: string, error: unknown, meta?: Record<string, unknown>) => void;
 }
 export declare class ConflictError extends Error {
     statusCode: number;
@@ -12,6 +30,15 @@ export declare class NotFoundError extends Error {
     statusCode: number;
     constructor(message: string);
 }
+export declare class ServiceUnavailableError extends Error {
+    statusCode: number;
+    retryAfter: number;
+    constructor(message: string, retryAfter?: number);
+}
+export declare class BadGatewayError extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
 export declare class BadRequestError extends Error {
     statusCode: number;
     constructor(message: string);

package/dist/utils/errors.utils.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RangeNotSatisfiableError = exports.PreconditionFailedError = exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
+exports.RangeNotSatisfiableError = exports.PreconditionFailedError = exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.BadGatewayError = exports.ServiceUnavailableError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = exports.DEFAULT_RETRY_AFTER_SECONDS = void 0;
 const logger_utils_1 = require("./logger.utils");
+exports.DEFAULT_RETRY_AFTER_SECONDS = 5;
 class ErrorUtils {
     static isError = (error) => {
         return typeof Error.isError === 'function'
@@ -11,10 +12,12 @@ class ErrorUtils {
     };
     static report = (error, props = {}) => {
         if (this.isError(error)) {
-            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${error.message}\nProperties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${this.withRequestId(error.message, error)}\n` +
+                `Properties => ${JSON.stringify(props, null, 2)}\nStack => ${error.stack}`);
         }
         else {
-            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
+            logger_utils_1.logger.error(`[REPORTED_ERROR]: ${this.withRequestId(JSON.stringify(error), error)}\n` +
+                `Properties => ${JSON.stringify(props, null, 2)}\n`);
         }
     };
     static isAlreadyExistsError = (error) => {
@@ -24,6 +27,78 @@ class ErrorUtils {
     static isFileNotFoundError = (error) => {
         return this.isError(error) && 'code' in error && error.code === 'ENOENT';
     };
+    static getRequestId = (error) => {
+        if (typeof error !== 'object' || error === null)
+            return undefined;
+        const { requestId, xRequestId, data } = error;
+        const bodyRequestId = typeof data === 'object' && data !== null ? data.requestId : undefined;
+        return [requestId, xRequestId, bodyRequestId].find((candidate) => typeof candidate === 'string' && candidate.length > 0);
+    };
+    static withRequestId = (message, error) => {
+        const requestId = this.getRequestId(error);
+        return requestId ? `${message} (requestId: ${requestId})` : message;
+    };
+    static getStatusCode = (error, key) => {
+        if (typeof error !== 'object' || error === null)
+            return undefined;
+        const source = error;
+        const value = key ? source[key] : (source.statusCode ?? source.status);
+        return typeof value === 'number' && !Number.isNaN(value) ? value : undefined;
+    };
+    static isNotFoundError = (error) => {
+        return this.getStatusCode(error) === 404;
+    };
+    static hasResponseBody = (error) => {
+        return typeof error === 'object' && error !== null && 'data' in error;
+    };
+    static classifyLookupError = (error) => {
+        const status = this.getStatusCode(error);
+        if (status === 404)
+            return 'not-found';
+        if (status === undefined || !this.hasResponseBody(error))
+            return 'inconclusive';
+        if (status === 400 || status === 414 || status === 422)
+            return 'not-found';
+        if (this.isAuthStatus(status))
+            return 'auth';
+        return 'inconclusive';
+    };
+    static toLookupError = (itemType, path, error) => {
+        const label = itemType === 'file' ? 'File' : 'Folder';
+        switch (this.classifyLookupError(error)) {
+            case 'auth':
+                return new BadGatewayError(this.withRequestId(`The Internxt API rejected this session while looking up ${path}, log in again with 'internxt login'`, error));
+            case 'inconclusive':
+                return new ServiceUnavailableError(this.withRequestId(`${label} lookup at path ${path} could not be completed, retry later`, error));
+            case 'not-found':
+                return new NotFoundError(`${label} not found at path: ${path}`);
+        }
+    };
+    static isAuthStatus = (status) => status === 401 || status === 403;
+    static isRetryableStatus = (status) => status === 408 || status === 425 || status === 429 || status >= 500;
+    static toWebDavStatus = (error) => {
+        const ownStatus = this.getStatusCode(error, 'statusCode');
+        if (ownStatus !== undefined) {
+            return error instanceof ServiceUnavailableError
+                ? { statusCode: ownStatus, retryAfter: error.retryAfter }
+                : { statusCode: ownStatus };
+        }
+        const apiStatus = this.getStatusCode(error, 'status');
+        if (apiStatus === undefined)
+            return { statusCode: 500 };
+        if (!this.hasResponseBody(error) || this.isRetryableStatus(apiStatus)) {
+            return { statusCode: 503, retryAfter: exports.DEFAULT_RETRY_AFTER_SECONDS };
+        }
+        if (this.isAuthStatus(apiStatus))
+            return { statusCode: 502 };
+        return { statusCode: apiStatus };
+    };
+    static logIfUnexpected = (log, message, error, meta) => {
+        if (this.isNotFoundError(error))
+            return;
+        const errorMessage = this.isError(error) ? error.message : String(error);
+        log.warn(this.withRequestId(`${message}: ${errorMessage}`, error), meta);
+    };
 }
 exports.ErrorUtils = ErrorUtils;
 class ConflictError extends Error {
@@ -44,6 +119,26 @@ class NotFoundError extends Error {
     }
 }
 exports.NotFoundError = NotFoundError;
+class ServiceUnavailableError extends Error {
+    statusCode = 503;
+    retryAfter;
+    constructor(message, retryAfter = exports.DEFAULT_RETRY_AFTER_SECONDS) {
+        super(message);
+        this.name = 'ServiceUnavailableError';
+        this.retryAfter = retryAfter;
+        Object.setPrototypeOf(this, ServiceUnavailableError.prototype);
+    }
+}
+exports.ServiceUnavailableError = ServiceUnavailableError;
+class BadGatewayError extends Error {
+    statusCode = 502;
+    constructor(message) {
+        super(message);
+        this.name = 'BadGatewayError';
+        Object.setPrototypeOf(this, BadGatewayError.prototype);
+    }
+}
+exports.BadGatewayError = BadGatewayError;
 class BadRequestError extends Error {
     statusCode = 400;
     constructor(message) {

package/dist/utils/pagination.utils.d.ts

@@ -0,0 +1,7 @@
+export declare class PaginationUtils {
+    static readonly MAX_PAGE_SIZE = 1000;
+    static readonly fetchAllPages: <T>(fetchPage: (cursor?: string) => Promise<{
+        items: T[];
+        nextCursor: string | null;
+    }>) => Promise<T[]>;
+}

package/dist/utils/pagination.utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginationUtils = void 0;
+class PaginationUtils {
+    static MAX_PAGE_SIZE = 1000;
+    static fetchAllPages = async (fetchPage) => {
+        const items = [];
+        let cursor;
+        do {
+            const page = await fetchPage(cursor);
+            if (!Array.isArray(page.items)) {
+                throw new Error('Unusable page received from the API');
+            }
+            items.push(...page.items);
+            cursor = page.nextCursor ?? undefined;
+        } while (cursor);
+        return items;
+    };
+}
+exports.PaginationUtils = PaginationUtils;

package/dist/utils/webdav.utils.js

@@ -12,6 +12,7 @@ const config_service_1 = require("../services/config.service");
 const trash_service_1 = require("../services/drive/trash.service");
 const format_utils_1 = require("./format.utils");
 const drive_item_repository_1 = require("../services/database/drive-item/drive-item.repository");
+const errors_utils_1 = require("./errors.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -54,35 +55,47 @@ class WebDavUtils {
         try {
             return await drive_item_service_1.DriveItemService.instance.getFileByPath(url);
         }
-        catch {
+        catch (error) {
+            if (errors_utils_1.ErrorUtils.isNotFoundError(error))
+                return undefined;
+            throw error;
         }
     }
     static async getDriveFolderFromResource(url) {
         try {
             return await drive_item_service_1.DriveItemService.instance.getFolderByPath(url);
         }
-        catch {
+        catch (error) {
+            if (errors_utils_1.ErrorUtils.isNotFoundError(error))
+                return undefined;
+            throw error;
         }
     }
     static async getDriveItemFromResource(resource) {
-        let item = undefined;
-        const isFolder = resource.url.endsWith('/');
+        if (resource.url.endsWith('/')) {
+            return await this.getDriveFolderFromResource(resource.url);
+        }
+        const lookupFile = () => this.getDriveFileFromResource(resource.url);
+        const lookupFolder = () => this.getDriveFolderFromResource(resource.url);
+        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(resource.url);
+        const [first, second] = cached?.type === 'folder' ? [lookupFolder, lookupFile] : [lookupFile, lookupFolder];
+        let inconclusive;
         try {
-            if (isFolder) {
-                item = await drive_item_service_1.DriveItemService.instance.getFolderByPath(resource.url);
-            }
-            else {
-                try {
-                    item = await drive_item_service_1.DriveItemService.instance.getFileByPath(resource.url);
-                }
-                catch {
-                    item = await drive_item_service_1.DriveItemService.instance.getFolderByPath(resource.url);
-                }
-            }
+            const item = await first();
+            if (item)
+                return item;
         }
-        catch {
+        catch (error) {
+            if (!(error instanceof errors_utils_1.ServiceUnavailableError))
+                throw error;
+            inconclusive = error;
         }
-        return item;
+        const item = await second();
+        if (item)
+            return item;
+        if (inconclusive)
+            throw inconclusive;
+        return undefined;
     }
     static async deleteOrTrashItem(driveItem) {
         const configs = await config_service_1.ConfigService.instance.readWebdavConfig();

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

@@ -20,9 +20,15 @@ class MKCOLRequestHandler {
             logger_utils_1.webdavLogger.info(`[MKCOL] Folder '${resource.url}' already exists, throwing 405 error`);
             throw new errors_utils_1.MethodNotAllowed('Folder already exists');
         }
-        const newFolder = await webdav_folder_service_1.WebDavFolderService.instance.createFolder({
+        const newFolder = await webdav_folder_service_1.WebDavFolderService.instance
+            .createFolder({
             folderName: resource.path.base,
             parentFolderUuid: parentDriveFolderItem.uuid,
+        })
+            .catch((error) => {
+            if (errors_utils_1.ErrorUtils.isAlreadyExistsError(error))
+                throw new errors_utils_1.MethodNotAllowed('Folder already exists');
+            throw error;
         });
         logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
         await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([

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

@@ -88,7 +88,7 @@ class PUTRequestHandler {
                 file = await drive_file_service_1.DriveFileService.instance.replaceFile(driveFileItem.uuid, filePayload);
             }
             catch (error) {
-                logger_utils_1.webdavLogger.warn(`[PUT] File replace failed for '${resource.url}', falling back to delete and create: ${error instanceof Error ? error.message : String(error)}`);
+                logger_utils_1.webdavLogger.warn(errors_utils_1.ErrorUtils.withRequestId(`[PUT] File replace failed for '${resource.url}', falling back to delete and create: ${error instanceof Error ? error.message : String(error)}`, error));
                 await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveFileItem);
                 file = await drive_file_service_1.DriveFileService.instance.createFile(filePayload);
             }

package/dist/webdav/index.js

@@ -11,6 +11,7 @@ const auth_service_1 = require("../services/auth.service");
 const logger_utils_1 = require("../utils/logger.utils");
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
 const database_service_1 = require("../services/database/database.service");
+const errors_utils_1 = require("../utils/errors.utils");
 dotenv_1.default.config({ quiet: true });
 const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtCliDataDirExists();
@@ -23,9 +24,9 @@ const init = async () => {
     new webdav_server_1.WebDavServer((0, express_1.default)())
         .start()
         .then()
-        .catch((err) => logger_utils_1.webdavLogger.error('Failed to start WebDAV server', err));
+        .catch((err) => logger_utils_1.webdavLogger.error(errors_utils_1.ErrorUtils.withRequestId('Failed to start WebDAV server', err), err));
 };
 process.on('uncaughtException', (err) => {
-    logger_utils_1.webdavLogger.error('Unhandled exception:', err);
+    logger_utils_1.webdavLogger.error(errors_utils_1.ErrorUtils.withRequestId('Unhandled exception:', err), err);
 });
 init();

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

@@ -25,11 +25,12 @@ const AuthMiddleware = () => {
                 let message = 'Authentication required to access this resource.';
                 if (errors_utils_1.ErrorUtils.isError(error)) {
                     message = error.message;
+                    const logMessage = errors_utils_1.ErrorUtils.withRequestId(message, error);
                     if (error.stack) {
-                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}\nStack: ${error.stack}`);
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${logMessage}\nStack: ${error.stack}`);
                     }
                     else {
-                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${message}`);
+                        logger_utils_1.webdavLogger.error(`Error from AuthMiddleware: ${logMessage}`);
                     }
                 }
                 const errorBodyXML = xml_utils_1.XMLUtils.toWebDavXML({