@internxt/cli 1.6.7 → 1.6.8

package/dist/commands/rename-folder.js

@@ -60,7 +60,7 @@ class RenameFolder extends core_1.Command {
                 options: { type: 'input' },
             },
         }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            validate: validation_service_1.ValidationService.instance.validateUUID,
             error: new command_types_1.NotValidFolderUuidError(),
         }, this.log.bind(this));
         return folderUuid;

package/dist/commands/trash-file.js

@@ -54,7 +54,7 @@ class TrashFile extends core_1.Command {
                 options: { type: 'input' },
             },
         }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            validate: validation_service_1.ValidationService.instance.validateUUID,
             error: new command_types_1.NotValidFileUuidError(),
         }, this.log.bind(this));
         return fileUuid;

package/dist/commands/trash-folder.js

@@ -54,7 +54,7 @@ class TrashFolder extends core_1.Command {
                 options: { type: 'input' },
             },
         }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            validate: validation_service_1.ValidationService.instance.validateUUID,
             error: new command_types_1.NotValidFolderUuidError(),
         }, this.log.bind(this));
         return folderUuid;

package/dist/commands/trash-list.d.ts

@@ -33,6 +33,7 @@ export default class TrashList extends Command {
                 status: "EXISTS" | "TRASHED" | "DELETED";
                 removed: boolean;
                 deleted: boolean;
+                isFavorite?: boolean;
             }[];
             files: {
                 id: number;
@@ -52,6 +53,7 @@ export default class TrashList extends Command {
                 updatedAt: string;
                 plainName: string;
                 status: "EXISTS" | "TRASHED" | "DELETED";
+                isFavorite?: boolean;
             }[];
         };
     }>;

package/dist/commands/trash-restore-file.d.ts

@@ -32,6 +32,7 @@ export default class TrashRestoreFile extends Command {
             updatedAt: string;
             plainName: string;
             status: "EXISTS" | "TRASHED" | "DELETED";
+            isFavorite?: boolean;
         };
     }>;
     catch: (error: Error) => Promise<never>;

package/dist/commands/trash-restore-file.js

@@ -67,7 +67,7 @@ class TrashRestoreFile extends core_1.Command {
                 options: { type: 'input' },
             },
         }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            validate: validation_service_1.ValidationService.instance.validateUUID,
             error: new command_types_1.NotValidFileUuidError(),
         }, this.log.bind(this));
         return fileUuid;

package/dist/commands/trash-restore-folder.js

@@ -69,7 +69,7 @@ class TrashRestoreFolder extends core_1.Command {
                 options: { type: 'input' },
             },
         }, {
-            validate: validation_service_1.ValidationService.instance.validateUUIDv4,
+            validate: validation_service_1.ValidationService.instance.validateUUID,
             error: new command_types_1.NotValidFolderUuidError(),
         }, this.log.bind(this));
         return folderUuid;

package/dist/commands/upload-file.d.ts

@@ -7,6 +7,7 @@ export default class UploadFile extends Command {
     static readonly flags: {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         destination: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'non-interactive': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         debug: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };

package/dist/commands/upload-file.js

@@ -14,7 +14,6 @@ const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("../services/validation.service");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 const thumbnail_service_1 = require("../services/thumbnail.service");
-const auth_service_1 = require("../services/auth.service");
 const upload_utils_1 = require("../utils/upload.utils");
 class UploadFile extends core_1.Command {
     static args = {};
@@ -34,6 +33,12 @@ class UploadFile extends core_1.Command {
             required: false,
             parse: cli_utils_1.CLIUtils.parseEmpty,
         }),
+        overwrite: core_1.Flags.boolean({
+            char: 'o',
+            description: 'Overwrite the file if a file with the same name already exists in the cloud destination folder.',
+            required: false,
+            default: false,
+        }),
     };
     static enableJsonFlag = true;
     run = async () => {
@@ -54,6 +59,12 @@ class UploadFile extends core_1.Command {
             reporter,
         });
         const destinationFolderUuid = await cli_utils_1.CLIUtils.fallbackToRootFolderIdIfEmpty(destinationFolderUuidFromFlag);
+        const existingFile = flags['overwrite']
+            ? await drive_file_service_1.DriveFileService.instance.findExistentFile(destinationFolderUuid, {
+                plainName: fileInfo.name,
+                type: fileType,
+            })
+            : undefined;
         const timings = {
             networkUpload: 0,
             driveUpload: 0,
@@ -69,18 +80,15 @@ class UploadFile extends core_1.Command {
         }, flags['json']);
         progressBar?.start(100, 0);
         let fileId;
-        let thumbnailStream;
         const fileSize = stats.size ?? 0;
         if (fileSize > 0) {
             const readStream = (0, node_fs_1.createReadStream)(filePath);
-            const preparedStreams = upload_utils_1.UploadUtils.prepareUploadStreams(readStream, fileType);
-            thumbnailStream = preparedStreams.thumbnailStream;
             const progressCallback = (progress) => {
                 progressBar?.update(progress * 100 * 0.99);
             };
             const abortable = new AbortController();
             fileId = await networkFacade.uploadFile({
-                from: preparedStreams.fileStream,
+                from: readStream,
                 size: fileSize,
                 bucketId: bucket,
                 progressCallback,
@@ -93,7 +101,7 @@ class UploadFile extends core_1.Command {
         }
         timings.networkUpload = networkUploadTimer.stop();
         const driveUploadTimer = cli_utils_1.CLIUtils.timer();
-        const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
+        const filePayload = {
             plainName: fileInfo.name,
             type: fileType,
             size: fileSize,
@@ -103,11 +111,14 @@ class UploadFile extends core_1.Command {
             encryptVersion: types_1.EncryptionVersion.Aes03,
             creationTime: stats.birthtime?.toISOString(),
             modificationTime: stats.mtime?.toISOString(),
-        });
+        };
+        const createdDriveFile = existingFile
+            ? await drive_file_service_1.DriveFileService.instance.replaceFile(existingFile.uuid, filePayload)
+            : await drive_file_service_1.DriveFileService.instance.createFile(filePayload);
         timings.driveUpload = driveUploadTimer.stop();
         const thumbnailTimer = cli_utils_1.CLIUtils.timer();
         await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
-            bufferStream: thumbnailStream,
+            input: filePath,
             fileType,
             bucket,
             fileUuid: createdDriveFile.uuid,
@@ -121,11 +132,9 @@ class UploadFile extends core_1.Command {
         if (flags['debug']) {
             cli_utils_1.CLIUtils.log(reporter, timingBreakdown);
         }
-        const workspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
-        const workspaceId = workspace?.workspaceData.workspace.id;
-        const message = `File uploaded successfully in ${cli_utils_1.CLIUtils.formatDuration(totalTime)}, view it at ` +
-            `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/file/${createdDriveFile.uuid}` +
-            `${workspaceId ? `?workspaceid=${workspaceId}` : ''}`;
+        const uploadVerb = existingFile ? 'overwritten' : 'uploaded';
+        const message = `File ${uploadVerb} successfully in ${cli_utils_1.CLIUtils.formatDuration(totalTime)}, view it at ` +
+            `${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/file/${createdDriveFile.uuid}`;
         cli_utils_1.CLIUtils.success(reporter, message);
         return {
             success: true,

package/dist/hooks/prerun/auth_check.js

@@ -29,8 +29,8 @@ const hook = async function (opts) {
         !commandsToSkipIds.includes(Command.id?.toLowerCase())) {
         cli_utils_1.CLIUtils.doing('Checking credentials', jsonFlag);
         try {
-            const { token, workspace } = await auth_service_1.AuthService.instance.getAuthDetails();
-            sdk_manager_service_1.SdkManager.init({ token, workspaceToken: workspace?.workspaceCredentials.token });
+            const { token } = await auth_service_1.AuthService.instance.getAuthDetails();
+            sdk_manager_service_1.SdkManager.init({ token });
             cli_utils_1.CLIUtils.done(jsonFlag);
             cli_utils_1.CLIUtils.clearPreviousLine(jsonFlag);
             await database_service_1.DatabaseService.instance.initialize();

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

@@ -1,12 +1,12 @@
-import { LoginCredentials, Workspace } from '../types/command.types';
+import { LoginCredentials } from '../types/command.types';
 export declare class AuthService {
     static readonly instance: AuthService;
     doLogin: (email: string, password: string, twoFactorCode?: string) => Promise<LoginCredentials>;
     is2FANeeded: (email: string) => Promise<boolean>;
     getAuthDetails: () => Promise<LoginCredentials>;
+    private readonly shouldClearUserAfterRefreshError;
+    private readonly getHttpStatusFromError;
     refreshUserToken: (oldToken: string, mnemonic: string, privateKey: string) => Promise<LoginCredentials>;
-    refreshWorkspaceCredentials: (loginCreds: LoginCredentials) => Promise<Workspace | undefined>;
-    getCurrentWorkspace: () => Promise<Workspace | undefined>;
     getCurrentRootFolder: () => Promise<string>;
     logout: () => Promise<void>;
 }

package/dist/services/auth.service.js

@@ -7,7 +7,6 @@ const crypto_service_1 = require("./crypto.service");
 const config_service_1 = require("./config.service");
 const command_types_1 = require("../types/command.types");
 const validation_service_1 = require("./validation.service");
-const workspace_service_1 = require("./drive/workspace.service");
 const lib_1 = require("@internxt/lib");
 class AuthService {
     static instance = new AuthService();
@@ -62,21 +61,43 @@ class AuthService {
                 credentialsChanged = true;
             }
             catch (error) {
-                await config_service_1.ConfigService.instance.clearUser();
+                if (this.shouldClearUserAfterRefreshError(error)) {
+                    await config_service_1.ConfigService.instance.clearUser();
+                }
                 throw error;
             }
         }
-        const workspaceCreds = await this.refreshWorkspaceCredentials(loginCreds);
-        if (workspaceCreds !== loginCreds.workspace) {
-            credentialsChanged = true;
-        }
-        loginCreds.workspace = workspaceCreds;
-        sdk_manager_service_1.SdkManager.init({ token: loginCreds.token, workspaceToken: workspaceCreds?.workspaceCredentials.token });
+        sdk_manager_service_1.SdkManager.init({ token: loginCreds.token });
         if (credentialsChanged) {
             await config_service_1.ConfigService.instance.saveUser(loginCreds);
         }
         return loginCreds;
     };
+    shouldClearUserAfterRefreshError = (error) => {
+        if (error instanceof command_types_1.InvalidCredentialsError || error instanceof command_types_1.ExpiredCredentialsError) {
+            return true;
+        }
+        const status = this.getHttpStatusFromError(error);
+        if (status === undefined) {
+            return false;
+        }
+        return status >= 400 && status < 500 && status !== 408 && status !== 429;
+    };
+    getHttpStatusFromError = (error) => {
+        if (typeof error !== 'object' || error === null) {
+            return undefined;
+        }
+        const response = 'response' in error ? error.response : undefined;
+        if (typeof response?.status === 'number') {
+            return response.status;
+        }
+        const status = 'status' in error ? error.status : undefined;
+        if (typeof status === 'number') {
+            return status;
+        }
+        const statusCode = 'statusCode' in error ? error.statusCode : undefined;
+        return typeof statusCode === 'number' ? statusCode : undefined;
+    };
     refreshUserToken = async (oldToken, mnemonic, privateKey) => {
         sdk_manager_service_1.SdkManager.init({ token: oldToken });
         const isValidMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(mnemonic);
@@ -105,43 +126,12 @@ class AuthService {
         };
         return newLoginCreds;
     };
-    refreshWorkspaceCredentials = async (loginCreds) => {
-        if (loginCreds.workspace?.workspaceCredentials && loginCreds.workspace?.workspaceData) {
-            const workspaceToken = loginCreds.workspace.workspaceCredentials.token;
-            const workspaceUuid = loginCreds.workspace.workspaceCredentials.id;
-            const workspaceTokenStatus = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(workspaceToken);
-            if (workspaceTokenStatus === lib_1.TokenStatus.VALID) {
-                return loginCreds.workspace;
-            }
-            else if (workspaceTokenStatus === lib_1.TokenStatus.INVALID) {
-                throw new command_types_1.InvalidCredentialsError();
-            }
-            else if (workspaceTokenStatus === lib_1.TokenStatus.EXPIRED) {
-                throw new command_types_1.ExpiredCredentialsError();
-            }
-            else if (workspaceTokenStatus === lib_1.TokenStatus.REFRESH_REQUIRED) {
-                sdk_manager_service_1.SdkManager.init({ token: loginCreds.token, workspaceToken: loginCreds.workspace.workspaceCredentials.token });
-                const workspaceCredentials = await workspace_service_1.WorkspaceService.instance.getWorkspaceCredentials(workspaceUuid);
-                return {
-                    workspaceCredentials,
-                    workspaceData: loginCreds.workspace.workspaceData,
-                };
-            }
-        }
-    };
-    getCurrentWorkspace = async () => {
-        const loginCreds = await config_service_1.ConfigService.instance.readUser();
-        if (!loginCreds?.token || !loginCreds?.user?.mnemonic) {
-            throw new command_types_1.MissingCredentialsError();
-        }
-        return loginCreds.workspace;
-    };
     getCurrentRootFolder = async () => {
         const loginCreds = await config_service_1.ConfigService.instance.readUser();
         if (!loginCreds?.token || !loginCreds?.user?.mnemonic) {
             throw new command_types_1.MissingCredentialsError();
         }
-        return loginCreds.workspace?.workspaceData?.workspaceUser?.rootFolderId ?? loginCreds.user.rootFolderId;
+        return loginCreds.user.rootFolderId;
     };
     logout = async () => {
         cache_service_1.CacheService.instance.clearCaches();

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

@@ -1,6 +1,4 @@
 import { CryptoProvider } from '@internxt/sdk';
-import { LoginCredentials } from '../types/command.types';
-import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
 export declare class CryptoService {
     static readonly instance: CryptoService;
     static readonly cryptoProvider: CryptoProvider;
@@ -17,7 +15,5 @@ export declare class CryptoService {
     decryptTextWithKey: (encryptedText: string, secret: string) => string;
     decryptStream: (inputSlices: ReadableStream<Uint8Array>[], key: Buffer, iv: Buffer, startOffsetByte?: number) => ReadableStream<any>;
     private readonly getKeyAndIvFrom;
-    private readonly decryptWorkspaceMnemonic;
-    decryptWorkspacesMnemonic: (workspaces: WorkspaceData[], user: LoginCredentials["user"]) => Promise<WorkspaceData[]>;
     decryptPrivateKey: (privateKey: string, password: string) => string;
 }

package/dist/services/crypto.service.js

@@ -15,11 +15,8 @@ class CryptoService {
             return CryptoService.instance.encryptText(hashObj.hash);
         },
         async generateKeys(password) {
-            const { privateKeyArmoredEncrypted, publicKeyArmored, revocationCertificate } = await keys_service_1.KeysService.instance.generateNewKeysWithEncrypted(password);
+            const { privateKeyArmoredEncrypted, publicKeyArmored } = await keys_service_1.KeysService.instance.generateNewKeysWithEncrypted(password);
             const keys = {
-                privateKeyEncrypted: privateKeyArmoredEncrypted,
-                publicKey: publicKeyArmored,
-                revocationCertificate: revocationCertificate,
                 ecc: {
                     privateKeyEncrypted: privateKeyArmoredEncrypted,
                     publicKey: publicKeyArmored,
@@ -116,34 +113,6 @@ class CryptoService {
         const iv = md5Hashes[2];
         return { key, iv };
     };
-    decryptWorkspaceMnemonic = async (encryptionKey, user) => {
-        const privateKeyInBase64 = user.keys?.ecc?.privateKey;
-        const privateKyberKeyInBase64 = user.keys?.kyber?.privateKey;
-        if (!privateKeyInBase64) {
-            throw new Error('Missing privateKey in user keys');
-        }
-        try {
-            return await keys_service_1.KeysService.instance.hybridDecryptMessageWithPrivateKey({
-                encryptedMessageInBase64: encryptionKey,
-                privateKeyInBase64,
-                privateKyberKeyInBase64,
-            });
-        }
-        catch {
-            throw new Error('Failed to decrypt workspace mnemonic');
-        }
-    };
-    decryptWorkspacesMnemonic = async (workspaces, user) => {
-        return await Promise.all(workspaces.map(async (workspace) => {
-            return {
-                ...workspace,
-                workspaceUser: {
-                    ...workspace.workspaceUser,
-                    key: await this.decryptWorkspaceMnemonic(workspace.workspaceUser.key, user),
-                },
-            };
-        }));
-    };
     decryptPrivateKey = (privateKey, password) => {
         const MINIMAL_ENCRYPTED_KEY_LEN = 129;
         if (!privateKey || privateKey.length <= MINIMAL_ENCRYPTED_KEY_LEN)

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

@@ -19,6 +19,7 @@ __decorate([
     __metadata("design:type", String)
 ], DriveItemModel.prototype, "uuid", void 0);
 __decorate([
+    (0, typeorm_1.Index)(),
     (0, typeorm_1.Column)({ nullable: false, type: 'varchar' }),
     __metadata("design:type", String)
 ], DriveItemModel.prototype, "path", void 0);

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

@@ -19,15 +19,25 @@ class DriveItemRepository {
                 .getMany();
             const existingByUuid = new Map(existing.map((e) => [e.uuid, e]));
             const existingByPath = new Map(existing.map((e) => [e.path, e]));
+            const itemsToInsert = [];
+            const itemsToUpdate = [];
             for (const item of items) {
                 const match = existingByUuid.get(item.uuid) ?? existingByPath.get(item.path);
                 if (match) {
-                    await this.repository.update(match.uuid, item);
+                    itemsToUpdate.push({ targetUuid: match.uuid, item });
                 }
                 else {
-                    await this.repository.insert(item);
+                    itemsToInsert.push(item);
                 }
             }
+            await this.repository.manager.transaction(async (transactionalEntityManager) => {
+                if (itemsToInsert.length > 0) {
+                    await transactionalEntityManager.insert(drive_item_model_1.DriveItemModel, itemsToInsert);
+                }
+                for (const { targetUuid, item } of itemsToUpdate) {
+                    await transactionalEntityManager.update(drive_item_model_1.DriveItemModel, targetUuid, item);
+                }
+            });
             return items.map((item) => new drive_item_domain_1.DriveItemBD(item));
         }
         catch (error) {

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

@@ -3,6 +3,8 @@ import { DriveFileItem } from '../../types/drive.types';
 export declare class DriveFileService {
     static readonly instance: DriveFileService;
     createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
+    replaceFile: (uuid: string, payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
+    findExistentFile: (folderUuid: string, file: StorageTypes.FileStructure) => Promise<DriveFileItem | undefined>;
     private readonly createDriveFileEntry;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
     getFileMetadataByPath: (path: string) => Promise<DriveFileItem>;

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

@@ -1,10 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DriveFileService = void 0;
-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 errors_utils_1 = require("../../utils/errors.utils");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
 class DriveFileService {
@@ -28,23 +26,55 @@ class DriveFileService {
         };
         return driveFileItem;
     };
+    replaceFile = async (uuid, payload) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const driveFile = await storageClient.replaceFile(uuid, {
+            fileId: payload.fileId ?? '',
+            size: payload.size,
+        });
+        const driveFileItem = {
+            itemType: 'file',
+            name: driveFile.plainName ?? driveFile.name,
+            uuid: driveFile.uuid,
+            size: driveFile.size,
+            bucket: driveFile.bucket,
+            createdAt: new Date(driveFile.createdAt),
+            updatedAt: new Date(driveFile.updatedAt),
+            fileId: driveFile.fileId ?? null,
+            type: driveFile.type ?? null,
+            status: driveFile.status,
+            folderUuid: driveFile.folderUuid,
+            creationTime: new Date(driveFile.creationTime ?? driveFile.createdAt),
+            modificationTime: new Date(driveFile.modificationTime ?? driveFile.updatedAt),
+        };
+        return driveFileItem;
+    };
+    findExistentFile = async (folderUuid, file) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const { existentFiles } = await storageClient.checkDuplicatedFiles({
+            folderUuid,
+            filesList: [file],
+        });
+        const existentFile = existentFiles[0];
+        if (!existentFile)
+            return undefined;
+        return {
+            itemType: 'file',
+            name: existentFile.plainName ?? existentFile.name,
+            uuid: existentFile.uuid,
+            size: existentFile.size,
+            bucket: existentFile.bucket,
+            createdAt: new Date(existentFile.createdAt),
+            updatedAt: new Date(existentFile.updatedAt),
+            fileId: existentFile.fileId ?? null,
+            type: existentFile.type ?? null,
+            status: existentFile.status,
+            folderUuid: existentFile.folderUuid,
+            creationTime: new Date(existentFile.creationTime ?? existentFile.createdAt),
+            modificationTime: new Date(existentFile.modificationTime ?? existentFile.updatedAt),
+        };
+    };
     createDriveFileEntry = async (payload) => {
-        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
-        if (currentWorkspace) {
-            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
-            return workspaceClient.createFileEntry({
-                name: payload.plainName,
-                plainName: payload.plainName,
-                bucket: payload.bucket,
-                fileId: payload.fileId ?? '',
-                encryptVersion: drive_1.StorageTypes.EncryptionVersion.Aes03,
-                folderUuid: payload.folderUuid,
-                size: payload.size,
-                type: payload.type ?? '',
-                modificationTime: payload.modificationTime ?? new Date().toISOString(),
-                date: payload.date ?? new Date().toISOString(),
-            }, currentWorkspace.workspaceCredentials.id);
-        }
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         return storageClient.createFileEntryByUuid(payload);
     };

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

@@ -28,6 +28,7 @@ export declare class DriveFolderService {
             status: "EXISTS" | "TRASHED" | "DELETED";
             removed: boolean;
             deleted: boolean;
+            isFavorite?: boolean;
         }[];
         files: {
             id: number;
@@ -47,6 +48,7 @@ export declare class DriveFolderService {
             updatedAt: string;
             plainName: string;
             status: "EXISTS" | "TRASHED" | "DELETED";
+            isFavorite?: boolean;
         }[];
     }>;
     getFolderSubfolders: (folderUuid: string) => Promise<FetchPaginatedFolder[]>;

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

@@ -4,7 +4,6 @@ exports.DriveFolderService = void 0;
 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 errors_utils_1 = require("../../utils/errors.utils");
 class DriveFolderService {
     static instance = new DriveFolderService();
@@ -38,52 +37,32 @@ class DriveFolderService {
         return { folders, files };
     };
     getFolderSubfolders = async (folderUuid) => {
-        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
-        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
-        const folders = await this.getAllSubfolders(currentWorkspaceCreds, folderUuid, 0);
+        const folders = await this.getAllSubfolders(folderUuid, 0);
         return folders;
     };
     getFolderSubfiles = async (folderUuid) => {
-        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
-        const currentWorkspaceCreds = currentWorkspace?.workspaceCredentials;
-        const files = await this.getAllSubfiles(currentWorkspaceCreds, folderUuid, 0);
+        const files = await this.getAllSubfiles(folderUuid, 0);
         return files;
     };
-    getAllSubfolders = async (currentWorkspace, folderUuid, offset) => {
-        let folders;
-        if (currentWorkspace) {
-            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
-            const [workspaceContentPromise] = workspaceClient.getFolders(currentWorkspace.id, folderUuid, offset, 50, 'plainName', 'ASC');
-            folders = (await workspaceContentPromise).result;
-        }
-        else {
-            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-            const [personalFolderContentPromise] = storageClient.getFolderFoldersByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
-            folders = (await personalFolderContentPromise).folders;
-        }
+    getAllSubfolders = async (folderUuid, offset) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const [personalFolderContentPromise] = storageClient.getFolderFoldersByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+        let folders = (await personalFolderContentPromise).folders;
         folders = folders.filter((folder) => folder.status === types_1.FileStatus.EXISTS);
         if (folders.length > 0) {
-            return folders.concat(await this.getAllSubfolders(currentWorkspace, folderUuid, offset + folders.length));
+            return folders.concat(await this.getAllSubfolders(folderUuid, offset + folders.length));
         }
         else {
             return folders;
         }
     };
-    getAllSubfiles = async (currentWorkspace, folderUuid, offset) => {
-        let files;
-        if (currentWorkspace) {
-            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
-            const [workspaceContentPromise] = workspaceClient.getFiles(currentWorkspace.id, folderUuid, offset, 50, 'plainName', 'ASC');
-            files = (await workspaceContentPromise).result;
-        }
-        else {
-            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-            const [folderContentPromise] = storageClient.getFolderFilesByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
-            files = (await folderContentPromise).files;
-        }
+    getAllSubfiles = async (folderUuid, offset) => {
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        const [folderContentPromise] = storageClient.getFolderFilesByUuid(folderUuid, offset, 50, 'plainName', 'ASC');
+        let files = (await folderContentPromise).files;
         files = files.filter((file) => file.status === types_1.FileStatus.EXISTS);
         if (files.length > 0) {
-            return files.concat(await this.getAllSubfiles(currentWorkspace, folderUuid, offset + files.length));
+            return files.concat(await this.getAllSubfiles(folderUuid, offset + files.length));
         }
         else {
             return files;
@@ -95,19 +74,8 @@ class DriveFolderService {
         return folderMeta;
     };
     createFolder = async (payload) => {
-        const currentWorkspace = await auth_service_1.AuthService.instance.getCurrentWorkspace();
-        if (currentWorkspace) {
-            const workspaceClient = sdk_manager_service_1.SdkManager.instance.getWorkspaces();
-            return workspaceClient.createFolder({
-                workspaceId: currentWorkspace.workspaceCredentials.id,
-                parentFolderUuid: payload.parentFolderUuid,
-                plainName: payload.plainName,
-            });
-        }
-        else {
-            const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-            return storageClient.createFolderByUuid(payload);
-        }
+        const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
+        return storageClient.createFolderByUuid(payload);
     };
     renameFolder = async (payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

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

@@ -31,6 +31,7 @@ export declare class TrashService {
             status: "EXISTS" | "TRASHED" | "DELETED";
             removed: boolean;
             deleted: boolean;
+            isFavorite?: boolean;
         }[];
         files: {
             id: number;
@@ -50,6 +51,7 @@ export declare class TrashService {
             updatedAt: string;
             plainName: string;
             status: "EXISTS" | "TRASHED" | "DELETED";
+            isFavorite?: boolean;
         }[];
     }>;
     private readonly getAllTrashSubfolders;