@internxt/cli 1.5.2 → 1.5.4

package/dist/services/drive/drive-file.service.d.ts

@@ -10,5 +10,5 @@ export declare class DriveFileService {
         type?: string | null;
     }) => Promise<void>;
     getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
-    createThumbnail: (payload: StorageTypes.ThumbnailEntry) => Promise<StorageTypes.Thumbnail>;
+    createThumbnail: (payload: StorageTypes.CreateThumbnailEntryPayload) => Promise<StorageTypes.Thumbnail>;
 }

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

@@ -6,7 +6,7 @@ const drive_utils_1 = require("../../utils/drive.utils");
 class DriveFileService {
     static instance = new DriveFileService();
     createFile = async (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const driveFile = await storageClient.createFileEntryByUuid(payload);
         return {
             name: payload.plain_name,
@@ -25,27 +25,27 @@ class DriveFileService {
         };
     };
     getFileMetadata = async (uuid) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const [getFileMetadata] = storageClient.getFile(uuid);
         const fileMetadata = await getFileMetadata;
         return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
     };
     moveFile = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.moveFileByUuid(payload);
     };
     renameFile = (fileUuid, payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.updateFileMetaByUUID(fileUuid, payload);
     };
     getFileMetadataByPath = async (path) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const fileMetadata = await storageClient.getFileByPath(encodeURIComponent(path));
         return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
     };
     createThumbnail = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(false);
-        return storageClient.createThumbnailEntry(payload);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return storageClient.createThumbnailEntryWithUUID(payload);
     };
 }
 exports.DriveFileService = DriveFileService;

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

@@ -6,17 +6,17 @@ const drive_utils_1 = require("../../utils/drive.utils");
 class DriveFolderService {
     static instance = new DriveFolderService();
     getFolderMetaByUuid = async (uuid) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderMeta(uuid);
         return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
     };
     getFolderMetaById = async (id) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderMetaById(id);
         return drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
     };
     getFolderContent = async (folderUuid) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folders = await this.getAllSubfolders(storageClient, folderUuid, 0);
         const files = await this.getAllSubfiles(storageClient, folderUuid, 0);
         return { folders, files };
@@ -42,19 +42,19 @@ class DriveFolderService {
         }
     };
     moveFolder = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.moveFolderByUuid(payload);
     };
     createFolder(payload) {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.createFolderByUuid(payload);
     }
     renameFolder = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.updateFolderNameWithUUID(payload);
     };
     getFolderMetadataByPath = async (path) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderByPath(encodeURIComponent(path));
         return drive_utils_1.DriveUtils.driveFolderMetaToItem({
             ...folderMeta,

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

@@ -2,13 +2,15 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 export declare class TrashService {
     static readonly instance: TrashService;
     trashItems: (payload: StorageTypes.AddItemsToTrashPayload) => Promise<void>;
-    deleteFile: (payload: StorageTypes.DeleteFilePayload) => Promise<unknown>;
-    deleteFolder: (folderId: number) => Promise<unknown>;
+    deleteFile: (fileId: string) => Promise<{
+        deleted: boolean;
+    }>;
+    deleteFolder: (folderId: string) => Promise<void>;
     clearTrash: () => Promise<void>;
     getTrashFolderContent: () => Promise<{
         folders: StorageTypes.FetchPaginatedFolder[];
         files: StorageTypes.FetchPaginatedFile[];
     }>;
-    private getAllTrashSubfolders;
-    private getAllTrashSubfiles;
+    private readonly getAllTrashSubfolders;
+    private readonly getAllTrashSubfiles;
 }

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

@@ -5,16 +5,16 @@ const sdk_manager_service_1 = require("../sdk-manager.service");
 class TrashService {
     static instance = new TrashService();
     trashItems = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(true);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.addItemsToTrash(payload);
     };
-    deleteFile = (payload) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(false);
-        return storageClient.deleteFile(payload);
+    deleteFile = (fileId) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return storageClient.deleteFileByUuid(fileId);
     };
     deleteFolder = (folderId) => {
-        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage(false);
-        return storageClient.deleteFolder(folderId);
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return storageClient.deleteFolderByUuid(folderId);
     };
     clearTrash = () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getTrash();

package/dist/services/sdk-manager.service.d.ts

@@ -12,11 +12,9 @@ export declare class SdkManager {
         throwErrorOnMissingCredentials: boolean;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
-    getAuth(useNewApi?: boolean): Auth;
-    getPayments(): Drive.Payments;
-    getUsers(useNewApi?: boolean): Drive.Users;
-    getReferrals(): Drive.Referrals;
-    getStorage(useNewApi?: boolean): Drive.Storage;
+    getAuth(): Auth;
+    getUsers(): Drive.Users;
+    getStorage(): Drive.Storage;
     getTrash(): Drive.Trash;
     getShare(): Drive.Share;
     getNetwork(credentials: {

package/dist/services/sdk-manager.service.js

@@ -25,68 +25,48 @@ class SdkManager {
     };
     static getAppDetails = () => {
         return {
-            clientName: package_json_1.default.name,
+            clientName: package_json_1.default.clientName,
             clientVersion: package_json_1.default.version,
         };
     };
-    getAuth(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getAuth() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Auth.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity?.newToken : apiSecurity?.token,
+            token: apiSecurity?.newToken,
         });
     }
-    getPayments() {
-        const PAYMENTS_API_URL = config_service_1.ConfigService.instance.get('PAYMENTS_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
-        const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Payments.client(PAYMENTS_API_URL, appDetails, {
-            token: newToken,
-        });
-    }
-    getUsers(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getUsers() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+            token: apiSecurity.newToken,
         });
     }
-    getReferrals() {
-        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
-        const apiSecurity = SdkManager.getApiSecurity();
-        const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Referrals.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getStorage(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getStorage() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+            token: apiSecurity.newToken,
         });
     }
     getTrash() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
+        const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, {
-            token: newToken,
+            token: apiSecurity.newToken,
         });
     }
     getShare() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
+        const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, {
-            token: newToken,
+            token: apiSecurity.newToken,
         });
     }
     getNetwork(credentials) {

package/dist/services/thumbnail.service.d.ts

@@ -2,6 +2,6 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { NetworkFacade } from './network/network-facade.service';
 export declare class ThumbnailService {
     static readonly instance: ThumbnailService;
-    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: number, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
-    private getThumbnailFromImageBuffer;
+    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
+    private readonly getThumbnailFromImageBuffer;
 }

package/dist/services/thumbnail.service.js

@@ -27,14 +27,14 @@ class ThumbnailService {
                 }, () => { });
             });
             const createdThumbnailFile = await drive_file_service_1.DriveFileService.instance.createThumbnail({
-                file_id: file_id,
-                max_width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
-                max_height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
+                fileUuid: file_id,
+                maxWidth: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
+                maxHeight: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
                 type: thumbnail_utils_1.ThumbnailConfig.Type,
                 size: size,
-                bucket_id: userBucket,
-                bucket_file: fileId,
-                encrypt_version: drive_1.StorageTypes.EncryptionVersion.Aes03,
+                bucketId: userBucket,
+                bucketFile: fileId,
+                encryptVersion: drive_1.StorageTypes.EncryptionVersion.Aes03,
             });
             return createdThumbnailFile;
         }

package/dist/services/usage.service.d.ts

@@ -1,7 +1,7 @@
-import { UsageResponse } from '@internxt/sdk/dist/drive/storage/types';
+import { UsageResponseV2 } from '@internxt/sdk/dist/drive/storage/types';
 export declare class UsageService {
     static readonly instance: UsageService;
     static readonly INFINITE_LIMIT: number;
-    fetchUsage: () => Promise<UsageResponse>;
+    fetchUsage: () => Promise<UsageResponseV2>;
     fetchSpaceLimit: () => Promise<number>;
 }

package/dist/services/usage.service.js

@@ -7,12 +7,12 @@ class UsageService {
     static INFINITE_LIMIT = 99 * Math.pow(1024, 4);
     fetchUsage = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const driveUsage = await storageClient.spaceUsage();
+        const driveUsage = await storageClient.spaceUsageV2();
         return driveUsage;
     };
     fetchSpaceLimit = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const spaceLimit = await storageClient.spaceLimit();
+        const spaceLimit = await storageClient.spaceLimitV2();
         return spaceLimit.maxSpaceBytes;
     };
 }

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

@@ -1,10 +1,7 @@
 export interface ConfigKeys {
-    readonly DRIVE_URL: string;
-    readonly DRIVE_API_URL: string;
+    readonly DRIVE_WEB_URL: string;
     readonly DRIVE_NEW_API_URL: string;
-    readonly PAYMENTS_API_URL: string;
     readonly APP_CRYPTO_SECRET: string;
-    readonly APP_CRYPTO_SECRET2: string;
     readonly APP_MAGIC_IV: string;
     readonly APP_MAGIC_SALT: string;
     readonly NETWORK_URL: string;

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/pm2.utils.d.ts

@@ -1,7 +1,7 @@
 import pm2 from 'pm2';
 export type WebDavProcessStatus = 'online' | 'stopping' | 'stopped' | 'launching' | 'errored' | 'one-launch-status' | 'offline' | 'unknown';
 export declare class PM2Utils {
-    private static WEBDAV_APP_NAME;
+    private static readonly WEBDAV_APP_NAME;
     static connect(): Promise<void>;
     static disconnect(): void;
     static clean(): Promise<void>;

package/dist/utils/thumbnail.utils.js

@@ -31,14 +31,14 @@ const thumbnailableImageExtension = [
 const thumbnailablePdfExtension = pdfExtensions['pdf'];
 const thumbnailableExtension = [...thumbnailableImageExtension];
 const isFileThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isFileThumbnailable = isFileThumbnailable;
 const isPDFThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isPDFThumbnailable = isPDFThumbnailable;
 const isImageThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isImageThumbnailable = isImageThumbnailable;

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

@@ -7,10 +7,9 @@ export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
     static removeHostFromURL(completeURL: string): string;
     static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static getDriveItemFromResource(resource: WebDavRequestedResource, driveFolderService?: DriveFolderService, driveFileService?: DriveFileService): Promise<DriveFileItem | DriveFolderItem | undefined>;
-    static getAndSearchItemFromResource({ resource, driveFolderService, driveFileService, }: {
+    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
         driveFolderService?: DriveFolderService;
         driveFileService?: DriveFileService;
-    }): Promise<DriveFileItem | DriveFolderItem>;
+    }): Promise<DriveFileItem | DriveFolderItem | undefined>;
 }

package/dist/utils/webdav.utils.js

@@ -5,7 +5,6 @@ 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 errors_utils_1 = require("./errors.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -55,30 +54,19 @@ class WebDavUtils {
             };
         }
     }
-    static async getDriveItemFromResource(resource, driveFolderService, driveFileService) {
+    static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
         let item = undefined;
-        if (resource.type === 'folder') {
-            try {
+        try {
+            if (resource.type === 'folder') {
                 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);
             }
         }
-        if (resource.type === 'file') {
-            item = await driveFileService?.getFileMetadataByPath(resource.url);
+        catch {
         }
         return item;
     }
-    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 driveItem;
-    }
 }
 exports.WebDavUtils = WebDavUtils;

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

@@ -3,7 +3,7 @@ export declare class XMLUtils {
     static readonly DEFAULT_NAMESPACE_LETTER = "D";
     static toJSON(xml: string, options?: X2jOptions): any;
     static toXML(object: object, options?: XmlBuilderOptions): string;
-    static toWebDavXML(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.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 class DELETERequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -12,11 +13,14 @@ class DELETERequestHandler {
         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({
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
             driveFileService: driveFileService,
         });
+        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}`);
         await trashService.trashItems({
             items: [{ type: resource.type, uuid: driveItem.uuid }],

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

@@ -18,10 +18,14 @@ class GETRequestHandler {
         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 driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFileService,
-        }));
+        });
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
+        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`);

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

@@ -4,6 +4,7 @@ exports.HEADRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const network_utils_1 = require("../../utils/network.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 class HEADRequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -18,10 +19,14 @@ class HEADRequestHandler {
         }
         logger_utils_1.webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
         try {
-            const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
                 resource,
                 driveFileService,
-            }));
+            });
+            if (!driveItem) {
+                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({