@internxt/cli 1.6.4 → 1.6.5

package/dist/services/database/{drive-folder/drive-folder.model.js → drive-item/drive-item.model.js}

@@ -9,43 +9,31 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DriveFolderModel = void 0;
+exports.DriveItemModel = void 0;
 const typeorm_1 = require("typeorm");
-let DriveFolderModel = class DriveFolderModel {
+let DriveItemModel = class DriveItemModel {
 };
-exports.DriveFolderModel = DriveFolderModel;
+exports.DriveItemModel = DriveItemModel;
 __decorate([
     (0, typeorm_1.PrimaryColumn)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", String)
-], DriveFolderModel.prototype, "uuid", void 0);
+], DriveItemModel.prototype, "uuid", void 0);
 __decorate([
     (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", String)
-], DriveFolderModel.prototype, "name", void 0);
+], DriveItemModel.prototype, "path", void 0);
 __decorate([
     (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", String)
-], DriveFolderModel.prototype, "status", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ nullable: true, type: 'varchar' }),
-    __metadata("design:type", Object)
-], DriveFolderModel.prototype, "parentUuid", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
-    __metadata("design:type", Date)
-], DriveFolderModel.prototype, "createdAt", void 0);
-__decorate([
-    (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
-    __metadata("design:type", Date)
-], DriveFolderModel.prototype, "updatedAt", void 0);
+], DriveItemModel.prototype, "type", void 0);
 __decorate([
     (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", Date)
-], DriveFolderModel.prototype, "creationTime", void 0);
+], DriveItemModel.prototype, "createdAt", void 0);
 __decorate([
     (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", Date)
-], DriveFolderModel.prototype, "modificationTime", void 0);
-exports.DriveFolderModel = DriveFolderModel = __decorate([
-    (0, typeorm_1.Entity)('drive_folder')
-], DriveFolderModel);
+], DriveItemModel.prototype, "updatedAt", void 0);
+exports.DriveItemModel = DriveItemModel = __decorate([
+    (0, typeorm_1.Entity)('drive_item')
+], DriveItemModel);

package/dist/services/database/drive-item/drive-item.repository.d.ts

@@ -0,0 +1,12 @@
+import { DriveItemBD } from './drive-item.domain';
+import { DriveItemModel } from './drive-item.model';
+export declare class DriveItemRepository {
+    static readonly instance: DriveItemRepository;
+    private readonly repository;
+    createOrUpdate: (items: DriveItemModel[]) => Promise<DriveItemBD[] | undefined>;
+    updateByUuid: (uuid: string, update: Partial<DriveItemModel>) => Promise<import("typeorm").UpdateResult | undefined>;
+    delete: (uuids: string[]) => Promise<import("typeorm").DeleteResult | undefined>;
+    getByUuid: (uuid: string) => Promise<DriveItemBD | undefined>;
+    getByPath: (path: string) => Promise<DriveItemBD | undefined>;
+    getAll: () => Promise<DriveItemBD[]>;
+}

package/dist/services/database/drive-item/drive-item.repository.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveItemRepository = void 0;
+const errors_utils_1 = require("../../../utils/errors.utils");
+const database_service_1 = require("../database.service");
+const drive_item_domain_1 = require("./drive-item.domain");
+const drive_item_model_1 = require("./drive-item.model");
+class DriveItemRepository {
+    static instance = new DriveItemRepository();
+    repository = database_service_1.DatabaseService.instance.dataSource.getRepository(drive_item_model_1.DriveItemModel);
+    createOrUpdate = async (items) => {
+        try {
+            const uuids = items.map((i) => i.uuid);
+            const paths = items.map((i) => i.path);
+            const existing = await this.repository
+                .createQueryBuilder('item')
+                .where('item.uuid IN (:...uuids)', { uuids })
+                .orWhere('item.path IN (:...paths)', { paths })
+                .getMany();
+            const existingByUuid = new Map(existing.map((e) => [e.uuid, e]));
+            const existingByPath = new Map(existing.map((e) => [e.path, e]));
+            for (const item of items) {
+                const match = existingByUuid.get(item.uuid) ?? existingByPath.get(item.path);
+                if (match) {
+                    await this.repository.update(match.uuid, item);
+                }
+                else {
+                    await this.repository.insert(item);
+                }
+            }
+            return items.map((item) => new drive_item_domain_1.DriveItemBD(item));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { createOrUpdate: items });
+        }
+    };
+    updateByUuid = async (uuid, update) => {
+        try {
+            return await this.repository.update({ uuid }, update);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { updateByUuid: uuid });
+        }
+    };
+    delete = async (uuids) => {
+        try {
+            return await this.repository.delete(uuids);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { delete: uuids });
+        }
+    };
+    getByUuid = async (uuid) => {
+        try {
+            const item = await this.repository.findOneBy({ uuid });
+            if (!item) {
+                return;
+            }
+            return new drive_item_domain_1.DriveItemBD(item);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByUuid: uuid });
+        }
+    };
+    getByPath = async (path) => {
+        try {
+            const item = await this.repository.findOneBy({ path });
+            if (!item) {
+                return;
+            }
+            return new drive_item_domain_1.DriveItemBD(item);
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getByPath: path });
+        }
+    };
+    getAll = async () => {
+        try {
+            const items = await this.repository.find();
+            return items.map((item) => new drive_item_domain_1.DriveItemBD(item));
+        }
+        catch (error) {
+            errors_utils_1.ErrorUtils.report(error, { getAll: true });
+            return [];
+        }
+    };
+}
+exports.DriveItemRepository = DriveItemRepository;

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

@@ -3,14 +3,13 @@ import { DriveFileItem } from '../../types/drive.types';
 export declare class DriveFileService {
     static readonly instance: DriveFileService;
     createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
-    private createDriveFileEntry;
+    private readonly createDriveFileEntry;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
+    getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
     moveFile: (uuid: string, payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
     renameFile: (fileUuid: string, payload: {
         plainName?: string;
         type?: string | null;
     }) => Promise<void>;
-    getByParentUuidAndName: (parentUuid: string, name: string, type: string | null) => Promise<DriveFileItem>;
-    getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;
     createThumbnail: (payload: StorageTypes.CreateThumbnailEntryPayload) => Promise<StorageTypes.Thumbnail>;
 }

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

@@ -5,11 +5,7 @@ const drive_1 = require("@internxt/sdk/dist/drive");
 const sdk_manager_service_1 = require("../sdk-manager.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 const auth_service_1 = require("../auth.service");
-const drive_file_repository_1 = require("../database/drive-file/drive-file.repository");
-const drive_folder_service_1 = require("./drive-folder.service");
 const errors_utils_1 = require("../../utils/errors.utils");
-const path_utils_1 = require("../../utils/path.utils");
-const logger_utils_1 = require("../../utils/logger.utils");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveFileService {
     static instance = new DriveFileService();
@@ -30,7 +26,6 @@ class DriveFileService {
             creationTime: new Date(driveFile.creationTime ?? driveFile.createdAt),
             modificationTime: new Date(driveFile.modificationTime ?? driveFile.updatedAt),
         };
-        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
         return driveFileItem;
     };
     createDriveFileEntry = async (payload) => {
@@ -61,45 +56,25 @@ class DriveFileService {
             throw new errors_utils_1.NotFoundError(`File with uuid ${uuid} not found`);
         }
         const driveFileItem = drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
-        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
+        return driveFileItem;
+    };
+    getFileMetadataByPath = async (path) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const fileMetadata = await storageClient.getFileByPath(path);
+        if (fileMetadata?.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError(`File with path ${path} not found`);
+        }
+        const driveFileItem = drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
         return driveFileItem;
     };
     moveFile = async (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const fileMeta = await storageClient.moveFileByUuid(uuid, payload);
-        const driveFileItem = drive_utils_1.DriveUtils.driveFileMetaToItem(fileMeta);
-        await drive_file_repository_1.FileRepository.instance.createOrUpdate([driveFileItem]);
         return fileMeta;
     };
     renameFile = async (fileUuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         await storageClient.updateFileMetaByUUID(fileUuid, payload);
-        await drive_file_repository_1.FileRepository.instance.updateByUuid(fileUuid, { name: payload.plainName, type: payload.type });
-    };
-    getByParentUuidAndName = async (parentUuid, name, type) => {
-        const subFiles = await drive_folder_service_1.DriveFolderService.instance.getFolderSubfiles(parentUuid);
-        const fileMeta = subFiles.find((file) => (file.plainName === name || file.name === name) && (file.type ?? null) === type);
-        if (fileMeta?.status !== types_1.FileStatus.EXISTS) {
-            throw new errors_utils_1.NotFoundError('File not found');
-        }
-        return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMeta);
-    };
-    getFileMetadataByPath = async (path) => {
-        const { fileName, fileType, folderPath } = path_utils_1.PathUtils.getPathFileData(path);
-        const parentFolder = await drive_folder_service_1.DriveFolderService.instance.getFolderMetadataByPath(folderPath);
-        const localFileDB = await drive_file_repository_1.FileRepository.instance.getByParentUuidNameAndType(parentFolder.uuid, fileName, fileType);
-        if (localFileDB) {
-            try {
-                const file = await this.getFileMetadata(localFileDB.uuid);
-                if (file) {
-                    return file;
-                }
-            }
-            catch {
-                logger_utils_1.logger.error('File not found when getting file by path on local DB', { path });
-            }
-        }
-        return this.getByParentUuidAndName(parentFolder.uuid, fileName, fileType);
     };
     createThumbnail = (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

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

@@ -6,6 +6,7 @@ export declare class DriveFolderService {
     static readonly instance: DriveFolderService;
     getFolderMetaByUuid: (uuid: string) => Promise<DriveFolderItem>;
     getFolderMetaById: (id: number) => Promise<DriveFolderItem>;
+    getFolderMetaByPath: (path: string) => Promise<DriveFolderItem>;
     getFolderContent: (folderUuid: string) => Promise<{
         folders: {
             type: string;
@@ -58,7 +59,4 @@ export declare class DriveFolderService {
         folderUuid: string;
         name: string;
     }) => Promise<void>;
-    getByParentUuidAndName: (parentUuid: string, name: string) => Promise<DriveFolderItem>;
-    getByPath: (path: string, parentUuid: string) => Promise<DriveFolderItem>;
-    getFolderMetadataByPath: (path: string) => Promise<DriveFolderItem>;
 }

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

@@ -5,13 +5,7 @@ const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const sdk_manager_service_1 = require("../sdk-manager.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 const auth_service_1 = require("../auth.service");
-const drive_folder_repository_1 = require("../database/drive-folder/drive-folder.repository");
-const drive_folder_domain_1 = require("../database/drive-folder/drive-folder.domain");
-const drive_file_repository_1 = require("../database/drive-file/drive-file.repository");
-const drive_file_domain_1 = require("../database/drive-file/drive-file.domain");
 const errors_utils_1 = require("../../utils/errors.utils");
-const database_utils_1 = require("../../utils/database.utils");
-const logger_utils_1 = require("../../utils/logger.utils");
 class DriveFolderService {
     static instance = new DriveFolderService();
     getFolderMetaByUuid = async (uuid) => {
@@ -21,14 +15,21 @@ class DriveFolderService {
         if (folderItem?.status !== types_1.FileStatus.EXISTS) {
             throw new errors_utils_1.NotFoundError(`Folder with uuid ${uuid} not found`);
         }
-        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
         return folderItem;
     };
     getFolderMetaById = async (id) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.getFolderMetaById(id);
         const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
-        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
+        return folderItem;
+    };
+    getFolderMetaByPath = async (path) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const folderMeta = await storageClient.getFolderByPath(path);
+        const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
+        if (folderItem.status !== types_1.FileStatus.EXISTS) {
+            throw new errors_utils_1.NotFoundError(`Folder with uuid ${folderItem.uuid} not found at path: ${path}`);
+        }
         return folderItem;
     };
     getFolderContent = async (folderUuid) => {
@@ -61,16 +62,6 @@ class DriveFolderService {
             folders = (await personalFolderContentPromise).folders;
         }
         folders = folders.filter((folder) => folder.status === types_1.FileStatus.EXISTS);
-        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate(folders.map((folder) => new drive_folder_domain_1.DriveFolder({
-            uuid: folder.uuid,
-            name: folder.plainName,
-            parentUuid: folder.parentUuid,
-            status: types_1.FileStatus.EXISTS,
-            createdAt: new Date(folder.createdAt),
-            updatedAt: new Date(folder.updatedAt),
-            creationTime: new Date(folder.creationTime ?? folder.createdAt),
-            modificationTime: new Date(folder.modificationTime ?? folder.updatedAt),
-        })));
         if (folders.length > 0) {
             return folders.concat(await this.getAllSubfolders(currentWorkspace, folderUuid, offset + folders.length));
         }
@@ -92,21 +83,6 @@ class DriveFolderService {
         }
         files = files.filter((file) => file.status === types_1.FileStatus.EXISTS);
         if (files.length > 0) {
-            await drive_file_repository_1.FileRepository.instance.deleteByParentUuid(folderUuid);
-            await drive_file_repository_1.FileRepository.instance.createOrUpdate(files.map((file) => new drive_file_domain_1.DriveFile({
-                uuid: file.uuid,
-                name: file.plainName,
-                type: file.type,
-                folderUuid: file.folderUuid,
-                status: types_1.FileStatus.EXISTS,
-                bucket: file.bucket,
-                size: Number(file.size ?? 0),
-                fileId: file.fileId,
-                createdAt: new Date(file.createdAt),
-                updatedAt: new Date(file.updatedAt),
-                creationTime: new Date(file.creationTime ?? file.createdAt),
-                modificationTime: new Date(file.modificationTime ?? file.updatedAt),
-            })));
             return files.concat(await this.getAllSubfiles(currentWorkspace, folderUuid, offset + files.length));
         }
         else {
@@ -116,8 +92,6 @@ class DriveFolderService {
     moveFolder = async (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const folderMeta = await storageClient.moveFolderByUuid(uuid, payload);
-        const folderItem = drive_utils_1.DriveUtils.driveFolderMetaToItem(folderMeta);
-        await drive_folder_repository_1.FolderRepository.instance.createOrUpdate([folderItem]);
         return folderMeta;
     };
     createFolder = async (payload) => {
@@ -138,58 +112,6 @@ class DriveFolderService {
     renameFolder = async (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         await storageClient.updateFolderNameWithUUID(payload);
-        await drive_folder_repository_1.FolderRepository.instance.updateByUuid(payload.folderUuid, { name: payload.name });
-    };
-    getByParentUuidAndName = async (parentUuid, name) => {
-        const subFolders = await this.getFolderSubfolders(parentUuid);
-        const folderMeta = subFolders.find((folder) => folder.plainName === name || folder.name === name);
-        if (folderMeta?.status !== types_1.FileStatus.EXISTS) {
-            throw new errors_utils_1.NotFoundError('Folder not found');
-        }
-        return {
-            itemType: 'folder',
-            name: folderMeta.plainName,
-            uuid: folderMeta.uuid,
-            parentUuid: folderMeta.parentUuid,
-            status: types_1.FileStatus.EXISTS,
-            createdAt: new Date(folderMeta.createdAt),
-            updatedAt: new Date(folderMeta.updatedAt),
-            creationTime: new Date(folderMeta.creationTime),
-            modificationTime: new Date(folderMeta.modificationTime),
-            bucket: folderMeta.bucket,
-        };
-    };
-    getByPath = async (path, parentUuid) => {
-        const onFound = async (uuid) => {
-            const folder = await this.getFolderMetaByUuid(uuid);
-            return folder;
-        };
-        const folder = await database_utils_1.DatabaseUtils.getFolderByPathGeneric({
-            path,
-            parentUuid,
-            onFound,
-            getByParentAndName: this.getByParentUuidAndName.bind(this),
-        });
-        if (!folder) {
-            throw new errors_utils_1.NotFoundError('Folder not found');
-        }
-        return folder;
-    };
-    getFolderMetadataByPath = async (path) => {
-        const rootFolderUuid = await auth_service_1.AuthService.instance.getCurrentRootFolder();
-        const localFolderDB = await drive_folder_repository_1.FolderRepository.instance.getByPath(path, rootFolderUuid);
-        if (localFolderDB) {
-            try {
-                const folder = await this.getFolderMetaByUuid(localFolderDB.uuid);
-                if (folder) {
-                    return folder;
-                }
-            }
-            catch {
-                logger_utils_1.logger.error('Folder not found when getting folder by path on local DB', { path, rootFolderUuid });
-            }
-        }
-        return this.getByPath(path, rootFolderUuid);
     };
 }
 exports.DriveFolderService = DriveFolderService;

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

@@ -0,0 +1,8 @@
+import { DriveFileItem, DriveFolderItem } from '../../types/drive.types';
+export declare class DriveItemService {
+    static readonly instance: DriveItemService;
+    private readonly tryGetFileByUuid;
+    private readonly tryGetFolderByUuid;
+    getFileByPath: (path: string) => Promise<DriveFileItem>;
+    getFolderByPath: (path: string) => Promise<DriveFolderItem>;
+}

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

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DriveItemService = void 0;
+const drive_item_repository_1 = require("../database/drive-item/drive-item.repository");
+const errors_utils_1 = require("../../utils/errors.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+const drive_file_service_1 = require("./drive-file.service");
+const drive_folder_service_1 = require("./drive-folder.service");
+class DriveItemService {
+    static instance = new DriveItemService();
+    tryGetFileByUuid = async (cached, path) => {
+        try {
+            const item = await drive_file_service_1.DriveFileService.instance.getFileMetadata(cached.uuid);
+            await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+                {
+                    uuid: cached.uuid,
+                    path,
+                    type: 'file',
+                    createdAt: cached.createdAt,
+                    updatedAt: new Date(),
+                },
+            ]);
+            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]);
+        }
+    };
+    tryGetFolderByUuid = async (cached, path) => {
+        try {
+            const item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByUuid(cached.uuid);
+            await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+                {
+                    uuid: cached.uuid,
+                    path,
+                    type: 'folder',
+                    createdAt: cached.createdAt,
+                    updatedAt: new Date(),
+                },
+            ]);
+            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]);
+        }
+    };
+    getFileByPath = async (path) => {
+        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path);
+        if (cached) {
+            const item = await this.tryGetFileByUuid(cached, path);
+            if (item)
+                return item;
+        }
+        try {
+            const item = await drive_file_service_1.DriveFileService.instance.getFileMetadataByPath(path);
+            await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+                {
+                    uuid: item.uuid,
+                    path,
+                    type: 'file',
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                },
+            ]);
+            return item;
+        }
+        catch {
+            throw new errors_utils_1.NotFoundError(`File not found at path: ${path}`);
+        }
+    };
+    getFolderByPath = async (path) => {
+        const cached = await drive_item_repository_1.DriveItemRepository.instance.getByPath(path);
+        if (cached) {
+            const item = await this.tryGetFolderByUuid(cached, path);
+            if (item)
+                return item;
+        }
+        try {
+            const item = await drive_folder_service_1.DriveFolderService.instance.getFolderMetaByPath(path);
+            await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
+                {
+                    uuid: item.uuid,
+                    path,
+                    type: 'folder',
+                    createdAt: new Date(),
+                    updatedAt: new Date(),
+                },
+            ]);
+            return item;
+        }
+        catch {
+            throw new errors_utils_1.NotFoundError(`Folder not found at path: ${path}`);
+        }
+    };
+}
+exports.DriveItemService = DriveItemService;

package/dist/services/network/network-facade.service.d.ts

@@ -3,19 +3,17 @@ import { Environment } from '@internxt/inxt-js';
 import { Readable } from 'node:stream';
 import { DownloadOptions } from '../../types/network.types';
 import { RangeOptions } from '../../utils/network.utils';
-import { EncryptProgressCallback } from '@internxt/inxt-js/build/lib/core';
 export declare class NetworkFacade {
     private readonly network;
     private readonly environment;
     private readonly cryptoLib;
     constructor(network: Network.Network, environment: Environment);
     downloadToStream: (bucketId: string, mnemonic: string, fileId: string, size: number, to: WritableStream, rangeOptions?: RangeOptions, options?: DownloadOptions) => Promise<[Promise<void>, AbortController]>;
-    uploadFile: ({ from, size, bucketId, progressCallback, abortSignal, encryptProgressCallback, }: {
+    uploadFile: ({ from, size, bucketId, progressCallback, abortSignal, }: {
         from: Readable;
         size: number;
         bucketId: string;
         progressCallback: (progress: number) => void;
         abortSignal?: AbortSignal;
-        encryptProgressCallback?: EncryptProgressCallback;
     }) => Promise<string>;
 }

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

@@ -36,12 +36,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NetworkFacade = void 0;
 const sdk_1 = require("@internxt/sdk");
 const NetworkDownload = __importStar(require("@internxt/sdk/dist/network/download"));
-const inxt_js_1 = require("@internxt/inxt-js");
+const crypto_1 = require("@internxt/inxt-js/build/lib/utils/crypto");
 const node_crypto_1 = require("node:crypto");
 const crypto_service_1 = require("../crypto.service");
 const download_service_1 = require("./download.service");
 const validation_service_1 = require("../validation.service");
-const FORTY_GIGABYTES = 40 * 1024 * 1024 * 1024;
+const upload_utils_1 = require("../../utils/upload.utils");
 class NetworkFacade {
     network;
     environment;
@@ -55,7 +55,7 @@ class NetworkFacade {
                 return validation_service_1.ValidationService.instance.validateMnemonic(mnemonic);
             },
             generateFileKey: (mnemonic, bucketId, index) => {
-                return inxt_js_1.Environment.utils.generateFileKey(mnemonic, bucketId, index);
+                return (0, crypto_1.GenerateFileKey)(mnemonic, bucketId, index);
             },
             randomBytes: node_crypto_1.randomBytes,
         };
@@ -99,16 +99,13 @@ class NetworkFacade {
         };
         return [downloadOperation(), abortable];
     };
-    uploadFile = ({ from, size, bucketId, progressCallback, abortSignal, encryptProgressCallback, }) => {
-        if (size > FORTY_GIGABYTES) {
-            throw new Error('File is too big (more than 40 GB)');
-        }
+    uploadFile = async ({ from, size, bucketId, progressCallback, abortSignal, }) => {
+        await upload_utils_1.UploadUtils.checkUploadSizeLimits(size);
         return this.environment.upload(bucketId, {
             source: from,
             fileSize: size,
             progressCallback,
             abortSignal,
-            encryptProgressCallback,
         });
     };
 }

package/dist/services/network/upload/upload-file.service.js

@@ -10,6 +10,7 @@ const promises_1 = require("node:fs/promises");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const cli_utils_1 = require("../../../utils/cli.utils");
 const thumbnail_service_1 = require("../../thumbnail.service");
+const format_utils_1 = require("../../../utils/format.utils");
 class UploadFileService {
     static instance = new UploadFileService();
     uploadFilesConcurrently = async ({ network, filesToUpload, folderMap, bucket, destinationFolderUuid, currentProgress, emitProgress, debugMode, reporter, }) => {
@@ -99,7 +100,7 @@ class UploadFileService {
                 if (debugMode) {
                     const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
                     const throughputMBps = cli_utils_1.CLIUtils.calculateThroughputMBps(stats.size, timings.networkUpload);
-                    cli_utils_1.CLIUtils.success(reporter, `Uploaded '${file.name}' (${cli_utils_1.CLIUtils.formatBytesToString(stats.size)})`);
+                    cli_utils_1.CLIUtils.success(reporter, `Uploaded '${file.name}' (${format_utils_1.FormatUtils.humanFileSize(stats.size)})`);
                     cli_utils_1.CLIUtils.log(reporter, 'Timing breakdown:\n' +
                         `Network upload: ${cli_utils_1.CLIUtils.formatDuration(timings.networkUpload)}` +
                         ` (${throughputMBps.toFixed(2)} MB/s)\n` +

package/dist/services/thumbnail.service.js

@@ -53,7 +53,7 @@ class ThumbnailService {
     getThumbnailFromImageBuffer = async (buffer) => {
         const sharp = await getSharp();
         if (sharp) {
-            return sharp(buffer, { failOnError: false })
+            return sharp(buffer, { failOn: 'none' })
                 .resize({
                 height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
                 width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
@@ -68,7 +68,7 @@ class ThumbnailService {
     tryUploadThumbnail = async ({ bufferStream, fileType, bucket, fileUuid, networkFacade, size, }) => {
         try {
             const thumbnailBuffer = bufferStream?.getBuffer();
-            if (thumbnailBuffer) {
+            if (thumbnailBuffer && size > 0) {
                 await async_utils_1.AsyncUtils.withTimeout(ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, bucket, fileUuid, networkFacade, size), ThumbnailService.MAX_THUMBNAIL_TIMEOUT, 'Thumbnail upload timeout');
             }
         }

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

@@ -1,6 +1,8 @@
+import { StorageTypes } from '@internxt/sdk/dist/drive/storage';
 export declare class UsageService {
     static readonly instance: UsageService;
     static readonly INFINITE_LIMIT: number;
     fetchUsage: () => Promise<number>;
     fetchSpaceLimit: () => Promise<number>;
+    fetchLimits: () => Promise<StorageTypes.FileLimitsResponse>;
 }