@internxt/cli 1.4.1 → 1.5.0

package/dist/services/network/network-facade.service.js

@@ -35,22 +35,20 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkFacade = void 0;
 const sdk_1 = require("@internxt/sdk");
-const NetworkUpload = __importStar(require("@internxt/sdk/dist/network/upload"));
 const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
 const inxt_js_1 = require("@internxt/inxt-js");
 const node_crypto_1 = require("node:crypto");
 const validation_service_1 = require("../validation.service");
-const hash_utils_1 = require("../../utils/hash.utils");
-const stream_utils_1 = require("../../utils/stream.utils");
+const TWENTY_GIGABYTES = 20 * 1024 * 1024 * 1024;
 class NetworkFacade {
     network;
-    uploadService;
+    environment;
     downloadService;
     cryptoService;
     cryptoLib;
-    constructor(network, uploadService, downloadService, cryptoService) {
+    constructor(network, environment, downloadService, cryptoService) {
         this.network = network;
-        this.uploadService = uploadService;
+        this.environment = environment;
         this.downloadService = downloadService;
         this.cryptoService = cryptoService;
         this.cryptoLib = {
@@ -64,30 +62,36 @@ class NetworkFacade {
             randomBytes: node_crypto_1.randomBytes,
         };
     }
-    async downloadToStream(bucketId, mnemonic, fileId, to, options) {
+    async downloadToStream(bucketId, mnemonic, fileId, size, to, rangeOptions, options) {
         const encryptedContentStreams = [];
         let fileStream;
         const abortable = options?.abortController ?? new AbortController();
-        const onProgress = (progress) => {
+        const onProgress = (loadedBytes) => {
             if (!options?.progressCallback)
                 return;
-            options.progressCallback(progress);
-        };
-        const onDownloadProgress = (progress) => {
-            onProgress(progress);
+            const reportedProgress = Math.round((loadedBytes / size) * 100);
+            options.progressCallback(reportedProgress);
         };
         const decryptFile = async (_, key, iv) => {
-            fileStream = await this.cryptoService.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv));
+            let startOffsetByte;
+            if (rangeOptions) {
+                startOffsetByte = rangeOptions.parsed.start;
+            }
+            fileStream = this.cryptoService.decryptStream(encryptedContentStreams, Buffer.from(key), Buffer.from(iv), startOffsetByte);
             await fileStream.pipeTo(to);
         };
         const downloadFile = async (downloadables) => {
+            if (rangeOptions && downloadables.length > 1) {
+                throw new Error('Multi-Part Download with Range-Requests is not implemented');
+            }
             for (const downloadable of downloadables) {
                 if (abortable.signal.aborted) {
                     throw new Error('Download aborted');
                 }
                 const encryptedContentStream = await this.downloadService.downloadFile(downloadable.url, {
-                    progressCallback: onDownloadProgress,
+                    progressCallback: onProgress,
                     abortController: options?.abortController,
+                    rangeHeader: rangeOptions?.range,
                 });
                 encryptedContentStreams.push(encryptedContentStream);
             }
@@ -97,43 +101,28 @@ class NetworkFacade {
         };
         return [downloadOperation(), abortable];
     }
-    async uploadFromStream(bucketId, mnemonic, size, from, options) {
-        const hashStream = new hash_utils_1.HashStream();
-        const abortable = options?.abortController ?? new AbortController();
-        let encryptionTransform;
-        const progressTransform = new stream_utils_1.ProgressTransform({ totalBytes: size }, (progress) => {
-            if (options?.progressCallback) {
-                options.progressCallback(progress * 0.95);
-            }
-        });
-        const onProgress = (progress) => {
-            if (!options?.progressCallback)
-                return;
-            options.progressCallback(progress);
-        };
-        const encryptFile = async (_, key, iv) => {
-            encryptionTransform = from
-                .pipe(await this.cryptoService.getEncryptionTransform(Buffer.from(key), Buffer.from(iv)))
-                .pipe(hashStream);
-        };
-        const uploadFile = async (url) => {
-            await this.uploadService.uploadFile(url, encryptionTransform.pipe(progressTransform), {
-                abortController: abortable,
-                progressCallback: () => {
-                },
+    uploadFile(from, size, bucketId, finishedCallback, progressCallback) {
+        if (size > TWENTY_GIGABYTES) {
+            throw new Error('File is too big (more than 20 GB)');
+        }
+        const minimumMultipartThreshold = 100 * 1024 * 1024;
+        const useMultipart = size > minimumMultipartThreshold;
+        if (useMultipart) {
+            return this.environment.uploadMultipartFile(bucketId, {
+                source: from,
+                fileSize: size,
+                finishedCallback,
+                progressCallback,
             });
-            return hashStream.getHash().toString('hex');
-        };
-        const uploadOperation = async () => {
-            const uploadResult = await NetworkUpload.uploadFile(this.network, this.cryptoLib, bucketId, mnemonic, size, encryptFile, uploadFile);
-            const fileHash = Buffer.from('');
-            onProgress(1);
-            return {
-                fileId: uploadResult,
-                hash: fileHash,
-            };
-        };
-        return [uploadOperation(), abortable];
+        }
+        else {
+            return this.environment.upload(bucketId, {
+                source: from,
+                fileSize: size,
+                finishedCallback,
+                progressCallback,
+            });
+        }
     }
 }
 exports.NetworkFacade = NetworkFacade;

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

@@ -0,0 +1,7 @@
+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;
+}

package/dist/services/thumbnail.service.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThumbnailService = void 0;
+const node_stream_1 = require("node:stream");
+const drive_file_service_1 = require("./drive/drive-file.service");
+const drive_1 = require("@internxt/sdk/dist/drive");
+const thumbnail_utils_1 = require("../utils/thumbnail.utils");
+const sharp_1 = __importDefault(require("sharp"));
+class ThumbnailService {
+    static instance = new ThumbnailService();
+    uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade) => {
+        let thumbnailBuffer;
+        if ((0, thumbnail_utils_1.isImageThumbnailable)(fileType)) {
+            thumbnailBuffer = await this.getThumbnailFromImageBuffer(fileContent);
+        }
+        if (thumbnailBuffer) {
+            const size = thumbnailBuffer.length;
+            const fileId = await new Promise((resolve, reject) => {
+                networkFacade.uploadFile(node_stream_1.Readable.from(thumbnailBuffer), size, userBucket, (err, res) => {
+                    if (err) {
+                        return reject(err);
+                    }
+                    resolve(res);
+                }, () => { });
+            });
+            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,
+                type: thumbnail_utils_1.ThumbnailConfig.Type,
+                size: size,
+                bucket_id: userBucket,
+                bucket_file: fileId,
+                encrypt_version: drive_1.StorageTypes.EncryptionVersion.Aes03,
+            });
+            return createdThumbnailFile;
+        }
+    };
+    getThumbnailFromImageBuffer = (buffer) => {
+        return (0, sharp_1.default)(buffer)
+            .resize({
+            height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
+            width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
+            fit: 'inside',
+        })
+            .png({
+            quality: thumbnail_utils_1.ThumbnailConfig.Quality,
+        })
+            .toBuffer();
+    };
+}
+exports.ThumbnailService = ThumbnailService;

package/dist/types/network.types.d.ts

@@ -2,9 +2,10 @@ export interface NetworkCredentials {
     user: string;
     pass: string;
 }
-export type UploadProgressCallback = (progress: number) => void;
+export type DownloadProgressCallback = (downloadedBytes: number) => void;
+export type UploadProgressCallback = (uploadedBytes: number) => void;
 export interface NetworkOperationBaseOptions {
-    progressCallback: UploadProgressCallback;
+    progressCallback?: UploadProgressCallback;
     abortController?: AbortController;
 }
 export type UploadOptions = NetworkOperationBaseOptions;
@@ -13,3 +14,11 @@ export interface SelfsignedCert {
     cert: string | Buffer;
     key: string | Buffer;
 }
+export interface UploadTask {
+    contentToUpload: Buffer;
+    urlToUpload: string;
+    index: number;
+}
+export interface UploadMultipartOptions extends UploadOptions {
+    parts: number;
+}

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

@@ -17,6 +17,10 @@ export declare class UnsupportedMediaTypeError extends Error {
     statusCode: number;
     constructor(message: string);
 }
+export declare class MethodNotAllowed extends Error {
+    statusCode: number;
+    constructor(message: string);
+}
 export declare class NotImplementedError extends Error {
     statusCode: number;
     constructor(message: string);

package/dist/utils/errors.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotImplementedError = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
+exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
 class ErrorUtils {
     static report(reporter, error, props = {}) {
         if (error instanceof Error) {
@@ -48,6 +48,15 @@ class UnsupportedMediaTypeError extends Error {
     }
 }
 exports.UnsupportedMediaTypeError = UnsupportedMediaTypeError;
+class MethodNotAllowed extends Error {
+    statusCode = 405;
+    constructor(message) {
+        super(message);
+        this.name = 'MethodNotAllowed';
+        Object.setPrototypeOf(this, MethodNotAllowed.prototype);
+    }
+}
+exports.MethodNotAllowed = MethodNotAllowed;
 class NotImplementedError extends Error {
     statusCode = 501;
     constructor(message) {

package/dist/utils/logger.utils.js

@@ -6,35 +6,49 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.webdavLogger = exports.logger = void 0;
 const winston_1 = __importDefault(require("winston"));
 const config_service_1 = require("../services/config.service");
+const maxLogSize = 40 * 1024 * 1024;
+const maxLogsFiles = 5;
 exports.logger = winston_1.default.createLogger({
     level: 'info',
-    format: winston_1.default.format.json(),
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
     defaultMeta: { service: 'internxt-cli' },
     transports: [
         new winston_1.default.transports.File({
             filename: 'internxt-cli-error.log',
             level: 'error',
             dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            maxsize: maxLogSize,
+            maxFiles: maxLogsFiles,
+            tailable: true,
         }),
         new winston_1.default.transports.File({
             filename: 'internxt-cli-combined.log',
             dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            maxsize: maxLogSize,
+            maxFiles: maxLogsFiles,
+            tailable: true,
         }),
     ],
 });
 exports.webdavLogger = winston_1.default.createLogger({
     level: 'info',
-    format: winston_1.default.format.json(),
+    format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
     defaultMeta: { service: 'internxt-webdav' },
     transports: [
         new winston_1.default.transports.File({
             filename: 'internxt-webdav-error.log',
             level: 'error',
             dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            maxsize: maxLogSize,
+            maxFiles: maxLogsFiles,
+            tailable: true,
         }),
         new winston_1.default.transports.File({
             filename: 'internxt-webdav-combined.log',
             dirname: config_service_1.ConfigService.INTERNXT_CLI_LOGS_DIR,
+            maxsize: maxLogSize,
+            maxFiles: maxLogsFiles,
+            tailable: true,
         }),
     ],
 });

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

@@ -1,5 +1,6 @@
 import { NetworkCredentials, SelfsignedCert } from '../types/network.types';
 import selfsigned from 'selfsigned';
+import parseRange from 'range-parser';
 export declare class NetworkUtils {
     static getAuthFromCredentials(creds: NetworkCredentials): {
         username: string;
@@ -13,4 +14,14 @@ export declare class NetworkUtils {
     static getWebdavSSLCerts(): Promise<SelfsignedCert>;
     static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): Promise<void>;
     static generateSelfSignedSSLCerts(): selfsigned.GenerateResult;
+    static parseRangeHeader(rangeOptions: {
+        range?: string;
+        totalFileSize: number;
+    }): RangeOptions | undefined;
+}
+export interface RangeOptions {
+    range: string;
+    rangeSize: number;
+    totalFileSize: number;
+    parsed: parseRange.Range;
 }

package/dist/utils/network.utils.js

@@ -8,6 +8,7 @@ const node_crypto_1 = require("node:crypto");
 const promises_1 = require("node:fs/promises");
 const node_path_1 = __importDefault(require("node:path"));
 const selfsigned_1 = __importDefault(require("selfsigned"));
+const range_parser_1 = __importDefault(require("range-parser"));
 const config_service_1 = require("../services/config.service");
 class NetworkUtils {
     static getAuthFromCredentials(creds) {
@@ -72,5 +73,40 @@ class NetworkUtils {
         const pems = selfsigned_1.default.generate(attrs, { days: 365, algorithm: 'sha256', keySize: 2048, extensions });
         return pems;
     }
+    static parseRangeHeader(rangeOptions) {
+        if (!rangeOptions.range) {
+            return;
+        }
+        const parsed = (0, range_parser_1.default)(rangeOptions.totalFileSize, rangeOptions.range);
+        if (Array.isArray(parsed)) {
+            if (parsed.length > 1) {
+                throw new Error(`Multi Range-Requests functionality is not implemented. ${JSON.stringify(rangeOptions)}`);
+            }
+            else if (parsed.length <= 0) {
+                throw new Error(`Empty Range-Request. ${JSON.stringify(rangeOptions)}`);
+            }
+            else if (parsed.type !== 'bytes') {
+                throw new Error(`Unkwnown Range-Request type "${parsed.type}". ${JSON.stringify(rangeOptions)}`);
+            }
+            else {
+                const rangeSize = parsed[0].end - parsed[0].start + 1;
+                return {
+                    range: rangeOptions.range,
+                    rangeSize: rangeSize,
+                    totalFileSize: rangeOptions.totalFileSize,
+                    parsed: parsed[0],
+                };
+            }
+        }
+        else if (parsed === -1) {
+            throw new Error(`Malformed Range-Request. ${JSON.stringify(rangeOptions)}`);
+        }
+        else if (parsed === -2) {
+            throw new Error(`Unsatisfiable Range-Request. ${JSON.stringify(rangeOptions)}`);
+        }
+        else {
+            throw new Error(`Unknown error from Range-Request. ${JSON.stringify(rangeOptions)}`);
+        }
+    }
 }
 exports.NetworkUtils = NetworkUtils;

package/dist/utils/stream.utils.d.ts

@@ -1,17 +1,15 @@
 import { ReadStream, WriteStream } from 'node:fs';
-import { Transform, TransformCallback } from 'node:stream';
+import { Transform, TransformCallback, TransformOptions } from 'node:stream';
 export declare class StreamUtils {
     static readStreamToReadableStream(readStream: ReadStream): ReadableStream<Uint8Array>;
     static writeStreamToWritableStream(writeStream: WriteStream): WritableStream<Uint8Array>;
     static joinReadableBinaryStreams(streams: ReadableStream<Uint8Array>[]): ReadableStream<Uint8Array>;
 }
-export declare class ProgressTransform extends Transform {
-    private options;
-    private progressCallback;
-    private receivedBytes;
-    constructor(options: {
-        totalBytes: number;
-    }, progressCallback: (percentage: number) => void);
-    _transform(chunk: Buffer, encoding: BufferEncoding, callback: TransformCallback): void;
-    _flush(callback: (err: Error | null) => void): void;
+export declare class BufferStream extends Transform {
+    buffer: Buffer | null;
+    constructor(opts?: TransformOptions);
+    _transform(chunk: Buffer, _: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    reset(): void;
+    getBuffer(): Buffer | null;
 }

package/dist/utils/stream.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProgressTransform = exports.StreamUtils = void 0;
+exports.BufferStream = exports.StreamUtils = void 0;
 const node_stream_1 = require("node:stream");
 class StreamUtils {
     static readStreamToReadableStream(readStream) {
@@ -55,24 +55,25 @@ class StreamUtils {
     }
 }
 exports.StreamUtils = StreamUtils;
-class ProgressTransform extends node_stream_1.Transform {
-    options;
-    progressCallback;
-    receivedBytes = 0;
-    constructor(options, progressCallback) {
-        super();
-        this.options = options;
-        this.progressCallback = progressCallback;
+class BufferStream extends node_stream_1.Transform {
+    buffer;
+    constructor(opts) {
+        super(opts);
+        this.buffer = null;
     }
-    _transform(chunk, encoding, callback) {
-        this.receivedBytes += chunk.length;
-        const percentage = this.receivedBytes / this.options.totalBytes;
-        this.progressCallback(percentage);
-        this.push(chunk);
-        callback();
+    _transform(chunk, _, callback) {
+        const currentBuffer = this.buffer ?? Buffer.alloc(0);
+        this.buffer = Buffer.concat([currentBuffer, chunk]);
+        callback(null, chunk);
     }
     _flush(callback) {
-        callback(null);
+        callback();
+    }
+    reset() {
+        this.buffer = null;
+    }
+    getBuffer() {
+        return this.buffer;
     }
 }
-exports.ProgressTransform = ProgressTransform;
+exports.BufferStream = BufferStream;

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

@@ -0,0 +1,9 @@
+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;

package/dist/utils/thumbnail.utils.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageThumbnailable = exports.isPDFThumbnailable = exports.isFileThumbnailable = exports.ThumbnailConfig = void 0;
+exports.ThumbnailConfig = {
+    MaxWidth: 300,
+    MaxHeight: 300,
+    Quality: 100,
+    Type: 'png',
+};
+const imageExtensions = {
+    tiff: ['tif', 'tiff'],
+    bmp: ['bmp'],
+    heic: ['heic'],
+    jpg: ['jpg', 'jpeg'],
+    gif: ['gif'],
+    png: ['png'],
+    eps: ['eps'],
+    raw: ['raw', 'cr2', 'nef', 'orf', 'sr2'],
+    webp: ['webp'],
+};
+const pdfExtensions = {
+    pdf: ['pdf'],
+};
+const thumbnailableImageExtension = [
+    ...imageExtensions['jpg'],
+    ...imageExtensions['png'],
+    ...imageExtensions['webp'],
+    ...imageExtensions['gif'],
+    ...imageExtensions['tiff'],
+];
+const thumbnailablePdfExtension = pdfExtensions['pdf'];
+const thumbnailableExtension = [...thumbnailableImageExtension];
+const isFileThumbnailable = (fileType) => {
+    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType);
+};
+exports.isFileThumbnailable = isFileThumbnailable;
+const isPDFThumbnailable = (fileType) => {
+    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType);
+};
+exports.isPDFThumbnailable = isPDFThumbnailable;
+const isImageThumbnailable = (fileType) => {
+    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType);
+};
+exports.isImageThumbnailable = isImageThumbnailable;

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

@@ -10,16 +10,15 @@ class DELETERequestHandler {
     }
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFileService, driveFolderService, trashService } = this.dependencies;
-        logger_utils_1.webdavLogger.info('DELETE request received');
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info('Resource received for DELETE request', { resource });
+        logger_utils_1.webdavLogger.info(`[DELETE] Request received for ${resource.type} at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
             driveDatabaseManager,
             driveFolderService,
             driveFileService: driveFileService,
         });
-        logger_utils_1.webdavLogger.info(`Trashing ${resource.type} with UUID ${driveItem.uuid}...`);
+        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${resource.type}`);
         await trashService.trashItems({
             items: [{ type: resource.type, uuid: driveItem.uuid }],
         });
@@ -30,6 +29,8 @@ class DELETERequestHandler {
             await driveDatabaseManager.deleteFileById(driveItem.id);
         }
         res.status(204).send();
+        const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);
+        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }
 exports.DELETERequestHandler = DELETERequestHandler;

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

@@ -3,7 +3,6 @@ import { Request, Response } from 'express';
 import { DriveFileService } from '../../services/drive/drive-file.service';
 import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
 import { NetworkFacade } from '../../services/network/network-facade.service';
-import { UploadService } from '../../services/network/upload.service';
 import { DownloadService } from '../../services/network/download.service';
 import { CryptoService } from '../../services/crypto.service';
 import { AuthService } from '../../services/auth.service';
@@ -12,7 +11,6 @@ export declare class GETRequestHandler implements WebDavMethodHandler {
     constructor(dependencies: {
         driveFileService: DriveFileService;
         driveDatabaseManager: DriveDatabaseManager;
-        uploadService: UploadService;
         downloadService: DownloadService;
         cryptoService: CryptoService;
         authService: AuthService;

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

@@ -4,6 +4,7 @@ exports.GETRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
+const network_utils_1 = require("../../utils/network.utils");
 class GETRequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -12,21 +13,31 @@ class GETRequestHandler {
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFileService, authService, networkFacade } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        if (req.headers['content-range'] || req.headers['range'])
-            throw new errors_utils_1.NotImplementedError('Range requests not supported');
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
-        logger_utils_1.webdavLogger.info(`GET request received for file at ${resource.url}`);
+        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({
             resource,
             driveDatabaseManager,
             driveFileService,
         }));
-        logger_utils_1.webdavLogger.info(`✅ Found Drive File with uuid ${driveFile.uuid}`);
-        res.set('Content-Type', 'application/octet-stream');
-        res.set('Content-length', driveFile.size.toString());
+        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
         const { user } = await authService.getAuthDetails();
-        logger_utils_1.webdavLogger.info('✅ Network ready for download');
+        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);
+        const range = req.headers['range'];
+        const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+            range,
+            totalFileSize: driveFile.size,
+        });
+        let contentLength = driveFile.size;
+        if (rangeOptions) {
+            logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+            contentLength = rangeOptions.rangeSize;
+        }
+        res.header('Content-Type', 'application/octet-stream');
+        res.header('Content-length', contentLength.toString());
         const writable = new WritableStream({
             write(chunk) {
                 res.write(chunk);
@@ -35,20 +46,11 @@ class GETRequestHandler {
                 res.end();
             },
         });
-        let lastLoggedProgress = 0;
-        const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, writable, {
-            progressCallback: (progress) => {
-                const percentage = Math.floor(100 * progress);
-                if (percentage >= lastLoggedProgress + 1) {
-                    lastLoggedProgress = percentage;
-                    logger_utils_1.webdavLogger.info(`Download progress for file ${resource.name}: ${percentage}%`);
-                }
-            },
-        });
-        logger_utils_1.webdavLogger.info('✅ Download prepared, executing...');
+        const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, user.mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
+        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
         res.status(200);
         await executeDownload;
-        logger_utils_1.webdavLogger.info('✅ Download ready, replying to client');
+        logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] ✅ Download ready, replying to client`);
     };
 }
 exports.GETRequestHandler = GETRequestHandler;

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

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