@internxt/cli 1.6.2 → 1.6.4

package/dist/utils/database.utils.d.ts

@@ -0,0 +1,11 @@
+export declare class DatabaseUtils {
+    static readonly CREATE_BATCH_SIZE = 100;
+    static readonly getFolderByPathGeneric: <T>({ path, parentUuid, onFound, getByParentAndName, }: {
+        path: string;
+        parentUuid: string;
+        onFound: (uuid: string) => Promise<T>;
+        getByParentAndName: (parentUuid: string, name: string) => Promise<{
+            uuid: string;
+        } | null | undefined>;
+    }) => Promise<T | undefined>;
+}

package/dist/utils/database.utils.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseUtils = void 0;
+class DatabaseUtils {
+    static CREATE_BATCH_SIZE = 100;
+    static getFolderByPathGeneric = async ({ path, parentUuid, onFound, getByParentAndName, }) => {
+        path = path.replace(/^\//, '').replace(/\/$/, '');
+        if (path.trim().length === 0) {
+            return onFound(parentUuid);
+        }
+        const slashIndex = path.indexOf('/');
+        const currentFolder = slashIndex === -1 ? path : path.substring(0, slashIndex);
+        const nextPath = slashIndex === -1 ? '' : path.substring(slashIndex + 1);
+        const folder = await getByParentAndName(parentUuid, currentFolder);
+        if (!folder) {
+            return;
+        }
+        return this.getFolderByPathGeneric({
+            path: nextPath,
+            parentUuid: folder.uuid,
+            onFound,
+            getByParentAndName,
+        });
+    };
+}
+exports.DatabaseUtils = DatabaseUtils;

package/dist/utils/drive.utils.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveUtils = void 0;
+const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
             itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
-            folderId: fileMeta.folderId,
             folderUuid: fileMeta.folderUuid,
             size: Number(fileMeta.size),
             name: fileMeta.plainName ?? fileMeta.name,
@@ -17,7 +17,6 @@ class DriveUtils {
             creationTime: new Date(fileMeta.creationTime ?? fileMeta.createdAt),
             modificationTime: new Date(fileMeta.modificationTime ?? fileMeta.updatedAt),
             fileId: fileMeta.fileId,
-            id: fileMeta.id,
             type: fileMeta.type,
         };
     }
@@ -25,30 +24,28 @@ class DriveUtils {
         return {
             itemType: 'folder',
             uuid: folderMeta.uuid,
-            id: folderMeta.id,
             bucket: folderMeta.bucket,
-            status: folderMeta.deleted || folderMeta.removed ? 'TRASHED' : 'EXISTS',
+            status: folderMeta.deleted || folderMeta.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.EXISTS,
             name: folderMeta.plainName ?? folderMeta.name,
-            encryptedName: folderMeta.name,
-            parentId: folderMeta.parentId,
             parentUuid: folderMeta.parentUuid,
             createdAt: new Date(folderMeta.createdAt),
             updatedAt: new Date(folderMeta.updatedAt),
+            creationTime: new Date(folderMeta.creation_time),
+            modificationTime: new Date(folderMeta.creation_time),
         };
     }
     static createFolderResponseToItem(folderResponse) {
         return {
             itemType: 'folder',
             uuid: folderResponse.uuid,
-            id: folderResponse.id,
             bucket: folderResponse.bucket,
-            status: folderResponse.deleted || folderResponse.removed ? 'TRASHED' : 'EXISTS',
+            status: folderResponse.deleted || folderResponse.removed ? types_1.FileStatus.TRASHED : types_1.FileStatus.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),
+            creationTime: new Date(folderResponse.creationTime),
+            modificationTime: new Date(folderResponse.modificationTime),
         };
     }
 }

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

@@ -1,8 +1,8 @@
-export declare function isError(error: unknown): error is Error;
-export declare function isAlreadyExistsError(error: unknown): error is Error;
-export declare function isFileNotFoundError(error: unknown): error is NodeJS.ErrnoException;
 export declare class ErrorUtils {
-    static report(error: unknown, props?: Record<string, unknown>): void;
+    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;
 }
 export declare class ConflictError extends Error {
     statusCode: number;

package/dist/utils/errors.utils.js

@@ -1,32 +1,29 @@
 "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;
-exports.isAlreadyExistsError = isAlreadyExistsError;
-exports.isFileNotFoundError = isFileNotFoundError;
 const logger_utils_1 = require("./logger.utils");
-function isError(error) {
-    return typeof Error.isError === 'function'
-        ? Error.isError(error)
-        : error instanceof Error ||
-            (typeof error === 'object' && error !== null && 'message' in error && ('stack' in error || 'name' in error));
-}
-function isAlreadyExistsError(error) {
-    return ((isError(error) && error.message.includes('already exists')) ||
-        (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
-}
-function isFileNotFoundError(error) {
-    return isError(error) && 'code' in error && error.code === 'ENOENT';
-}
 class ErrorUtils {
-    static report(error, props = {}) {
-        if (isError(error)) {
+    static isError = (error) => {
+        return typeof Error.isError === 'function'
+            ? Error.isError(error)
+            : error instanceof Error ||
+                (typeof error === 'object' && error !== null && 'message' in error && ('stack' in error || 'name' in error));
+    };
+    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}`);
         }
         else {
             logger_utils_1.logger.error(`[REPORTED_ERROR]: ${JSON.stringify(error)}\nProperties => ${JSON.stringify(props, null, 2)}\n`);
         }
-    }
+    };
+    static isAlreadyExistsError = (error) => {
+        return ((this.isError(error) && error.message.includes('already exists')) ||
+            (typeof error === 'object' && error !== null && 'status' in error && error.status === 409));
+    };
+    static isFileNotFoundError = (error) => {
+        return this.isError(error) && 'code' in error && error.code === 'ENOENT';
+    };
 }
 exports.ErrorUtils = ErrorUtils;
 class ConflictError extends Error {

package/dist/utils/format.utils.d.ts

@@ -3,4 +3,5 @@ export declare class FormatUtils {
     static readonly formatDate: (date: string | Date) => string;
     static readonly formatDateForWebDav: (date: string | Date) => string;
     static readonly formatLimit: (limit: number) => string;
+    static readonly capitalizeFirstLetter: (string: string) => string;
 }

package/dist/utils/format.utils.js

@@ -26,5 +26,8 @@ class FormatUtils {
         }
         return result;
     };
+    static capitalizeFirstLetter = (string) => {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    };
 }
 exports.FormatUtils = FormatUtils;

package/dist/utils/inquirer.utils.js

@@ -15,7 +15,16 @@ class InquirerUtils {
                 const confirmation = await (0, prompts_1.confirm)({ message, default: options.confirm?.default || false });
                 return confirmation ? 'y' : 'n';
             }
-            case 'input': {
+            case 'list':
+                if (!options.choices)
+                    throw new Error('Missing choices');
+                return (0, prompts_1.select)({
+                    message,
+                    choices: options.choices.values,
+                    default: options.choices.values[options.choices.default ?? 0],
+                });
+            case 'input':
+            default: {
                 return (0, prompts_1.input)({ message });
             }
         }

package/dist/utils/path.utils.d.ts

@@ -0,0 +1,7 @@
+export declare class PathUtils {
+    static getPathFileData(filePath: string): {
+        folderPath: string;
+        fileName: string;
+        fileType: string | null;
+    };
+}

package/dist/utils/path.utils.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathUtils = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+class PathUtils {
+    static getPathFileData(filePath) {
+        const folderPath = node_path_1.default.dirname(filePath);
+        const fileExt = node_path_1.default.extname(filePath);
+        const fileName = node_path_1.default.basename(filePath, fileExt);
+        const fileExtWithoutDot = fileExt.replace('.', '').trim();
+        const fileType = fileExtWithoutDot.length > 0 ? fileExtWithoutDot : null;
+        return { folderPath, fileName, fileType };
+    }
+}
+exports.PathUtils = PathUtils;

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

@@ -1,26 +1,12 @@
-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;
     readonly Quality: 100;
     readonly Type: "png";
 };
-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;
-};
+export declare class ThumbnailUtils {
+    static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB: number;
+    static readonly isFileThumbnailable: (fileType: string) => boolean;
+    static readonly isPDFThumbnailable: (fileType: string) => boolean;
+    static readonly isImageThumbnailable: (fileType: string, size: number) => boolean;
+}

package/dist/utils/thumbnail.utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.ThumbnailUtils = exports.ThumbnailConfig = void 0;
 exports.ThumbnailConfig = {
     MaxWidth: 300,
     MaxHeight: 300,
@@ -34,39 +30,18 @@ const thumbnailableImageExtension = new Set([
 ]);
 const thumbnailablePdfExtension = new Set(pdfExtensions['pdf']);
 const thumbnailableExtension = new Set(thumbnailableImageExtension);
-const isFileThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableExtension.has(fileType.trim().toLowerCase());
-};
-exports.isFileThumbnailable = isFileThumbnailable;
-const isPDFThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailablePdfExtension.has(fileType.trim().toLowerCase());
-};
-exports.isPDFThumbnailable = isPDFThumbnailable;
-const isImageThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableImageExtension.has(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;
+class ThumbnailUtils {
+    static MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB = 500 * 1024 * 1024;
+    static isFileThumbnailable = (fileType) => {
+        return fileType.trim().length > 0 && thumbnailableExtension.has(fileType.trim().toLowerCase());
+    };
+    static isPDFThumbnailable = (fileType) => {
+        return fileType.trim().length > 0 && thumbnailablePdfExtension.has(fileType.trim().toLowerCase());
+    };
+    static isImageThumbnailable = (fileType, size) => {
+        if (size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB)
+            return false;
+        return fileType.trim().length > 0 && thumbnailableImageExtension.has(fileType.trim().toLowerCase());
+    };
+}
+exports.ThumbnailUtils = ThumbnailUtils;

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

@@ -1,6 +1,4 @@
 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, DriveItem } from '../types/drive.types';
 export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
@@ -8,22 +6,9 @@ export declare class WebDavUtils {
     static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
     static normalizeFolderPath(path: string): string;
     static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }: {
-        url: string;
-        driveFolderService: DriveFolderService;
-        driveFileService: DriveFileService;
-    }): Promise<DriveItem | undefined>;
-    static getDriveFileFromResource({ url, driveFileService, }: {
-        url: string;
-        driveFileService: DriveFileService;
-    }): Promise<DriveFileItem | undefined>;
-    static getDriveFolderFromResource({ url, driveFolderService, }: {
-        url: string;
-        driveFolderService: DriveFolderService;
-    }): Promise<DriveFolderItem | undefined>;
-    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
-        resource: WebDavRequestedResource;
-        driveFolderService: DriveFolderService;
-        driveFileService: DriveFileService;
-    }): Promise<DriveItem | undefined>;
+    static tryGetFileOrFolderMetadata(url: string): Promise<DriveItem | undefined>;
+    static getDriveFileFromResource(url: string): Promise<DriveFileItem | undefined>;
+    static getDriveFolderFromResource(url: string): Promise<DriveFolderItem | undefined>;
+    static getDriveItemFromResource(resource: WebDavRequestedResource): Promise<DriveItem | undefined>;
+    static deleteOrTrashItem(driveItem: DriveItem): Promise<void>;
 }

package/dist/utils/webdav.utils.js

@@ -5,7 +5,12 @@ 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 drive_folder_service_1 = require("../services/drive/drive-folder.service");
+const drive_file_service_1 = require("../services/drive/drive-file.service");
 const logger_utils_1 = require("./logger.utils");
+const config_service_1 = require("../services/config.service");
+const trash_service_1 = require("../services/drive/trash.service");
+const format_utils_1 = require("./format.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -44,48 +49,60 @@ class WebDavUtils {
             parentPath,
         };
     }
-    static async tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }) {
+    static async tryGetFileOrFolderMetadata(url) {
         try {
-            return await driveFileService.getFileMetadataByPath(url);
+            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
         }
         catch {
-            return await driveFolderService.getFolderMetadataByPath(url);
+            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
         }
     }
-    static async getDriveFileFromResource({ url, driveFileService, }) {
+    static async getDriveFileFromResource(url) {
         try {
-            return await driveFileService.getFileMetadataByPath(url);
+            return await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(url);
         }
         catch (err) {
             logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
         }
     }
-    static async getDriveFolderFromResource({ url, driveFolderService, }) {
+    static async getDriveFolderFromResource(url) {
         try {
-            return await driveFolderService.getFolderMetadataByPath(url);
+            return await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(url);
         }
         catch (err) {
             logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
         }
     }
-    static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
+    static async getDriveItemFromResource(resource) {
         let item = undefined;
         const isFolder = resource.url.endsWith('/');
         try {
             if (isFolder) {
-                item = await driveFolderService.getFolderMetadataByPath(resource.url);
+                item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(resource.url);
             }
             else {
-                item = await this.tryGetFileOrFolderMetadata({
-                    url: resource.url,
-                    driveFileService,
-                    driveFolderService,
-                });
+                item = await this.tryGetFileOrFolderMetadata(resource.url);
             }
         }
         catch {
         }
         return item;
     }
+    static async deleteOrTrashItem(driveItem) {
+        const configs = await config_service_1.ConfigService.instance.readWebdavConfig();
+        const type = format_utils_1.FormatUtils.capitalizeFirstLetter(driveItem.itemType);
+        if (configs.deleteFilesPermanently) {
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Deleting permanently ${driveItem.itemType}`);
+            await trash_service_1.TrashService.instance.deleteItemPermanently(driveItem.itemType, driveItem.uuid);
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} deleted permanently successfully`);
+        }
+        else {
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
+            await trash_service_1.TrashService.instance.trashItems({
+                items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
+            });
+            logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
+        }
+    }
 }
 exports.WebDavUtils = WebDavUtils;

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

@@ -1,4 +1,4 @@
-import { X2jOptions, XmlBuilderOptions } from '../types/fast-xml-parser.types';
+import { X2jOptions, XmlBuilderOptions } from 'fast-xml-parser';
 export declare class XMLUtils {
     static readonly DEFAULT_NAMESPACE_LETTER = "D";
     static toJSON(xml: string, options?: X2jOptions): any;

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

@@ -1,14 +1,5 @@
 import { Request, Response } from 'express';
 import { WebDavMethodHandler } from '../../types/webdav.types';
-import { TrashService } from '../../services/drive/trash.service';
-import { DriveFileService } from '../../services/drive/drive-file.service';
-import { DriveFolderService } from '../../services/drive/drive-folder.service';
 export declare class DELETERequestHandler implements WebDavMethodHandler {
-    private readonly dependencies;
-    constructor(dependencies: {
-        trashService: TrashService;
-        driveFileService: DriveFileService;
-        driveFolderService: DriveFolderService;
-    });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -5,29 +5,15 @@ 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) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService, driveFolderService, trashService } = this.dependencies;
         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,
-            driveFileService: driveFileService,
-        });
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
         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 ${driveItem.itemType}`);
-        await trashService.trashItems({
-            items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
-        });
+        await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveItem);
         res.status(204).send();
-        const type = driveItem.itemType.charAt(0).toUpperCase() + driveItem.itemType.substring(1);
-        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }
 exports.DELETERequestHandler = DELETERequestHandler;

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

@@ -1,18 +1,5 @@
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
-import { DriveFileService } from '../../services/drive/drive-file.service';
-import { NetworkFacade } from '../../services/network/network-facade.service';
-import { DownloadService } from '../../services/network/download.service';
-import { CryptoService } from '../../services/crypto.service';
-import { AuthService } from '../../services/auth.service';
 export declare class GETRequestHandler implements WebDavMethodHandler {
-    private readonly dependencies;
-    constructor(dependencies: {
-        driveFileService: DriveFileService;
-        downloadService: DownloadService;
-        cryptoService: CryptoService;
-        authService: AuthService;
-        networkFacade: NetworkFacade;
-    });
     handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -2,28 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GETRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
+const auth_service_1 = require("../../services/auth.service");
 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");
+const cli_utils_1 = require("../../utils/cli.utils");
 class GETRequestHandler {
-    dependencies;
-    constructor(dependencies) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService, authService, networkFacade } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[GET] Request received item at ${resource.url}`);
-        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
-            url: resource.url,
-            driveFileService,
-        });
+        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource(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.`);
         }
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
-        const { user } = await authService.getAuthDetails();
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);
         res.header('Content-Type', 'application/octet-stream');
         const fileSize = driveFile.size ?? 0;
@@ -50,7 +44,8 @@ class GETRequestHandler {
             if (!driveFile.fileId) {
                 throw new command_types_1.NotValidFileIdError();
             }
-            const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
+            const { networkFacade, bucket, mnemonic } = await cli_utils_1.CLIUtils.prepareNetwork(user);
+            const [executeDownload] = await networkFacade.downloadToStream(bucket, mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
             logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
             res.status(200);
             await executeDownload;

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

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

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

@@ -6,41 +6,29 @@ 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) {
-        this.dependencies = dependencies;
-    }
     handle = async (req, res) => {
-        const { driveFileService } = this.dependencies;
         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 driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
-                url: resource.url,
-                driveFileService,
-            });
-            if (!driveFile) {
-                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-            }
-            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+        logger_utils_1.webdavLogger.info(`[HEAD] Request received for item at ${resource.url}`);
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
+        logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Found Drive item`);
+        if (driveItem.itemType === 'file') {
             const range = req.headers['range'];
             const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
                 range,
-                totalFileSize: driveFile.size,
+                totalFileSize: driveItem.size,
             });
-            let contentLength = driveFile.size;
+            let contentLength = driveItem.size;
             if (rangeOptions) {
-                logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+                logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Range request received:`, { rangeOptions });
                 contentLength = rangeOptions.rangeSize;
             }
             res.header('Content-Type', 'application/octet-stream');
             res.header('Content-length', contentLength.toString());
-            res.status(200).send();
-        }
-        catch {
-            res.header('Content-Type', 'application/octet-stream');
-            res.status(200).send();
         }
+        res.status(200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;