@internxt/cli 1.5.4 → 1.5.6

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

@@ -11,8 +11,46 @@ export default class TrashList extends Command {
     run: () => Promise<{
         success: boolean;
         list: {
-            folders: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFolder[];
-            files: import("@internxt/sdk/dist/drive/storage/types").FetchPaginatedFile[];
+            folders: {
+                type: string;
+                id: number;
+                parentId: number;
+                parentUuid: string;
+                name: string;
+                parent: import("@internxt/sdk/dist/schema").components["schemas"]["Folder"];
+                bucket: string;
+                userId: number;
+                encryptVersion: string;
+                createdAt: string;
+                updatedAt: string;
+                uuid: string;
+                plainName: string;
+                size: number;
+                creationTime: string;
+                modificationTime: string;
+                status: "EXISTS" | "TRASHED" | "DELETED";
+                removed: boolean;
+                deleted: boolean;
+            }[];
+            files: {
+                id: number;
+                uuid: string;
+                fileId: string;
+                name: string;
+                type: string;
+                size: string;
+                bucket: string;
+                folderId: number;
+                folderUuid: string;
+                encryptVersion: string;
+                userId: number;
+                creationTime: string;
+                modificationTime: string;
+                createdAt: string;
+                updatedAt: string;
+                plainName: string;
+                status: "EXISTS" | "TRASHED" | "DELETED";
+            }[];
         };
     }>;
     catch: (error: Error) => Promise<never>;

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

@@ -13,7 +13,25 @@ export default class TrashRestoreFile extends Command {
     run: () => Promise<{
         success: boolean;
         message: string;
-        file: import("@internxt/sdk/dist/drive/storage/types").FileMeta;
+        file: {
+            id: number;
+            uuid: string;
+            fileId: string;
+            name: string;
+            type: string;
+            size: string;
+            bucket: string;
+            folderId: number;
+            folderUuid: string;
+            encryptVersion: string;
+            userId: number;
+            creationTime: string;
+            modificationTime: string;
+            createdAt: string;
+            updatedAt: string;
+            plainName: string;
+            status: "EXISTS" | "TRASHED" | "DELETED";
+        };
     }>;
     catch: (error: Error) => Promise<never>;
     private getFileUuid;

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

@@ -37,7 +37,7 @@ class TrashRestoreFile extends core_1.Command {
         if (destinationFolderUuid.trim().length === 0) {
             destinationFolderUuid = userCredentials.user.rootFolderId;
         }
-        const file = await drive_file_service_1.DriveFileService.instance.moveFile({ fileUuid, destinationFolderUuid });
+        const file = await drive_file_service_1.DriveFileService.instance.moveFile(fileUuid, { destinationFolder: destinationFolderUuid });
         const message = `File restored successfully to: ${destinationFolderUuid}`;
         cli_utils_1.CLIUtils.success(this.log.bind(this), message);
         return { success: true, message, file };

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

@@ -37,7 +37,9 @@ class TrashRestoreFolder extends core_1.Command {
         if (destinationFolderUuid.trim().length === 0) {
             destinationFolderUuid = userCredentials.user.rootFolderId;
         }
-        const folder = await drive_folder_service_1.DriveFolderService.instance.moveFolder({ folderUuid, destinationFolderUuid });
+        const folder = await drive_folder_service_1.DriveFolderService.instance.moveFolder(folderUuid, {
+            destinationFolder: destinationFolderUuid,
+        });
         const message = `Folder restored successfully to: ${destinationFolderUuid}`;
         cli_utils_1.CLIUtils.success(this.log.bind(this), message);
         return { success: true, message, folder };

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

@@ -13,7 +13,23 @@ export default class UploadFile extends Command {
     run: () => Promise<{
         success: boolean;
         message: string;
-        file: import("../types/drive.types").DriveFileItem;
+        file: {
+            plainName: string;
+            name: string;
+            id: number;
+            bucket: string;
+            uuid: string;
+            folderUuid: string;
+            folderId: number;
+            status: "EXISTS" | "TRASHED" | "DELETED";
+            fileId: string;
+            size: number;
+            createdAt: Date;
+            updatedAt: Date;
+            creationTime: Date;
+            modificationTime: Date;
+            type?: string | null;
+        };
     }>;
     catch: (error: Error) => Promise<never>;
     private getDestinationFolderUuid;

package/dist/commands/upload-file.js

@@ -46,9 +46,7 @@ class UploadFile extends core_1.Command {
     run = async () => {
         const { flags } = await this.parse(UploadFile);
         const nonInteractive = flags['non-interactive'];
-        const userCredentials = await config_service_1.ConfigService.instance.readUser();
-        if (!userCredentials)
-            throw new command_types_1.MissingCredentialsError();
+        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const filePath = await this.getFilePath(flags['file'], nonInteractive);
         const stats = await (0, promises_1.stat)(filePath);
         if (!stats.size) {
@@ -58,10 +56,9 @@ class UploadFile extends core_1.Command {
         const fileType = fileInfo.ext.replaceAll('.', '');
         let destinationFolderUuid = await this.getDestinationFolderUuid(flags['destination'], nonInteractive);
         if (destinationFolderUuid.trim().length === 0) {
-            destinationFolderUuid = userCredentials.user.rootFolderId;
+            destinationFolderUuid = user.rootFolderId;
         }
         cli_utils_1.CLIUtils.doing('Preparing Network', flags['json']);
-        const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const networkModule = sdk_manager_service_1.SdkManager.instance.getNetwork({
             user: user.bridgeUser,
             pass: user.userId,
@@ -71,6 +68,7 @@ class UploadFile extends core_1.Command {
             bridgePass: user.userId,
             bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
             encryptionKey: user.mnemonic,
+            appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
         });
         const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
         cli_utils_1.CLIUtils.done(flags['json']);
@@ -104,14 +102,15 @@ class UploadFile extends core_1.Command {
             });
         });
         const createdDriveFile = await drive_file_service_1.DriveFileService.instance.createFile({
-            plain_name: fileInfo.name,
+            plainName: fileInfo.name,
             type: fileType,
             size: stats.size,
-            folder_id: destinationFolderUuid,
-            id: fileId,
+            folderUuid: destinationFolderUuid,
+            fileId: fileId,
             bucket: user.bucket,
-            encrypt_version: types_1.EncryptionVersion.Aes03,
-            name: '',
+            encryptVersion: types_1.EncryptionVersion.Aes03,
+            creationTime: stats.birthtime?.toISOString(),
+            modificationTime: stats.mtime?.toISOString(),
         });
         try {
             if (isThumbnailable && bufferStream) {
@@ -130,7 +129,14 @@ class UploadFile extends core_1.Command {
         this.log('\n');
         const message = `File uploaded in ${uploadTime}ms, view it at ${config_service_1.ConfigService.instance.get('DRIVE_WEB_URL')}/file/${createdDriveFile.uuid}`;
         cli_utils_1.CLIUtils.success(this.log.bind(this), message);
-        return { success: true, message, file: createdDriveFile };
+        return {
+            success: true,
+            message,
+            file: {
+                ...createdDriveFile,
+                plainName: fileInfo.name,
+            },
+        };
     };
     catch = async (error) => {
         const { flags } = await this.parse(UploadFile);

package/dist/commands/webdav-config.d.ts

@@ -5,6 +5,7 @@ export default class WebDAVConfig extends Command {
     static readonly aliases: never[];
     static readonly examples: string[];
     static readonly flags: {
+        host: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         port: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         https: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         http: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;

package/dist/commands/webdav-config.js

@@ -11,6 +11,11 @@ class WebDAVConfig extends core_1.Command {
     static aliases = [];
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
+        host: core_1.Flags.string({
+            char: 'l',
+            description: 'The listening host for the WebDAV server.',
+            required: false,
+        }),
         port: core_1.Flags.string({
             char: 'p',
             description: 'The new port for the WebDAV server.',
@@ -39,6 +44,10 @@ class WebDAVConfig extends core_1.Command {
     run = async () => {
         const { flags } = await this.parse(WebDAVConfig);
         const webdavConfig = await config_service_1.ConfigService.instance.readWebdavConfig();
+        const host = flags['host'];
+        if (host) {
+            webdavConfig['host'] = host;
+        }
         const port = flags['port'];
         if (port) {
             if (validation_service_1.ValidationService.instance.validateTCPIntegerPort(port)) {

package/dist/commands/webdav.js

@@ -75,10 +75,10 @@ class Webdav extends core_1.Command {
         const { status } = await pm2_utils_1.PM2Utils.webdavServerStatus();
         const webdavConfigs = await config_service_1.ConfigService.instance.readWebdavConfig();
         if (status === 'online') {
-            const message = `Internxt WebDav server started successfully at ${webdavConfigs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${webdavConfigs.port}`;
+            const message = 'Internxt WebDav server started successfully at ' +
+                `${webdavConfigs.protocol}://${webdavConfigs.host}:${webdavConfigs.port}`;
             cli_utils_1.CLIUtils.log(this.log.bind(this), `\nWebDav server status: ${core_1.ux.colorize('green', 'online')}\n`);
             cli_utils_1.CLIUtils.success(this.log.bind(this), message);
-            cli_utils_1.CLIUtils.log(this.log.bind(this), `\n[If the above URL is not working, the WebDAV server can be accessed directly via your localhost IP at: ${webdavConfigs.protocol}://127.0.0.1:${webdavConfigs.port} ]\n`);
             return message;
         }
         else {

package/dist/commands/whoami.js

@@ -4,6 +4,7 @@ const core_1 = require("@oclif/core");
 const cli_utils_1 = require("../utils/cli.utils");
 const config_service_1 = require("../services/config.service");
 const validation_service_1 = require("../services/validation.service");
+const auth_service_1 = require("../services/auth.service");
 class Whoami extends core_1.Command {
     static args = {};
     static description = 'Display the current user logged into the Internxt CLI.';
@@ -20,13 +21,20 @@ class Whoami extends core_1.Command {
         }
         else {
             const validCreds = this.checkUserAndTokens(userCredentials);
-            if (!validCreds) {
+            if (!validCreds.valid) {
                 const message = 'Your session has expired. You have been logged out. Please log in again.';
                 await config_service_1.ConfigService.instance.clearUser();
                 cli_utils_1.CLIUtils.error(this.log.bind(this), message);
                 return { success: false, message };
             }
             else {
+                if (validCreds.refreshRequired) {
+                    try {
+                        await auth_service_1.AuthService.instance.refreshUserToken(userCredentials);
+                    }
+                    catch {
+                    }
+                }
                 const message = `You are logged in as: ${userCredentials.user.email}.`;
                 cli_utils_1.CLIUtils.success(this.log.bind(this), message);
                 return { success: true, message, login: userCredentials };
@@ -45,15 +53,13 @@ class Whoami extends core_1.Command {
         this.exit(1);
     };
     checkUserAndTokens = (loginCreds) => {
-        if (!(loginCreds?.newToken && loginCreds?.token && loginCreds?.user?.mnemonic)) {
-            return false;
+        if (!(loginCreds?.token && loginCreds?.user?.mnemonic)) {
+            return { valid: false, refreshRequired: false };
         }
-        const oldTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
-        const newTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.newToken);
+        const tokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
         const goodMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(loginCreds.user.mnemonic);
-        const goodToken = oldTokenDetails.isValid && !oldTokenDetails.expiration.expired;
-        const goodNewToken = newTokenDetails.isValid && !newTokenDetails.expiration.expired;
-        return goodToken && goodNewToken && goodMnemonic;
+        const goodToken = tokenDetails.isValid && !tokenDetails.expiration.expired;
+        return { valid: goodToken && goodMnemonic, refreshRequired: tokenDetails.expiration.refreshRequired };
     };
 }
 exports.default = Whoami;

package/dist/hooks/prerun/auth_check.js

@@ -19,11 +19,8 @@ const hook = async function (opts) {
     if (!CommandsToSkip.map((command) => command.name).includes(Command.name)) {
         cli_utils_1.CLIUtils.doing('Checking credentials', jsonFlag);
         try {
-            const { token, newToken } = await auth_service_1.AuthService.instance.getAuthDetails();
-            sdk_manager_service_1.SdkManager.init({
-                token,
-                newToken,
-            });
+            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);
         }

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

@@ -4,6 +4,7 @@ export declare class AuthService {
     doLogin: (email: string, password: string, twoFactorCode?: string) => Promise<LoginCredentials>;
     is2FANeeded: (email: string) => Promise<boolean>;
     getAuthDetails: () => Promise<LoginCredentials>;
-    refreshUserTokens: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
+    refreshUserDetails: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
+    refreshUserToken: (oldCreds: LoginCredentials) => Promise<LoginCredentials>;
     logout: () => Promise<void>;
 }

package/dist/services/auth.service.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthService = void 0;
 const sdk_manager_service_1 = require("./sdk-manager.service");
-const keys_service_1 = require("./keys.service");
 const crypto_service_1 = require("./crypto.service");
 const config_service_1 = require("./config.service");
 const command_types_1 = require("../types/command.types");
@@ -16,26 +15,16 @@ class AuthService {
             password: password,
             tfaCode: twoFactorCode,
         };
-        const data = await authClient.login(loginDetails, crypto_service_1.CryptoService.cryptoProvider);
-        const { user, token, newToken } = data;
-        const { privateKey, publicKey } = user;
-        const plainPrivateKeyInBase64 = privateKey
-            ? Buffer.from(keys_service_1.KeysService.instance.decryptPrivateKey(privateKey, password)).toString('base64')
-            : '';
-        if (privateKey) {
-            await keys_service_1.KeysService.instance.assertPrivateKeyIsValid(privateKey, password);
-            await keys_service_1.KeysService.instance.assertValidateKeys(Buffer.from(plainPrivateKeyInBase64, 'base64').toString(), Buffer.from(publicKey, 'base64').toString());
-        }
+        const data = await authClient.loginAccess(loginDetails, crypto_service_1.CryptoService.cryptoProvider);
+        const { user, newToken } = data;
         const clearMnemonic = crypto_service_1.CryptoService.instance.decryptTextWithKey(user.mnemonic, password);
         const clearUser = {
             ...user,
             mnemonic: clearMnemonic,
-            privateKey: plainPrivateKeyInBase64,
         };
         return {
             user: clearUser,
-            token: token,
-            newToken: newToken,
+            token: newToken,
             lastLoggedInAt: new Date().toISOString(),
             lastTokenRefreshAt: new Date().toISOString(),
         };
@@ -49,57 +38,63 @@ class AuthService {
     };
     getAuthDetails = async () => {
         let loginCreds = await config_service_1.ConfigService.instance.readUser();
-        if (!loginCreds?.newToken || !loginCreds?.token || !loginCreds?.user?.mnemonic) {
+        if (!loginCreds?.token || !loginCreds?.user?.mnemonic) {
             throw new command_types_1.MissingCredentialsError();
         }
-        const oldTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
-        const newTokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.newToken);
+        const tokenDetails = validation_service_1.ValidationService.instance.validateTokenAndCheckExpiration(loginCreds.token);
         const isValidMnemonic = validation_service_1.ValidationService.instance.validateMnemonic(loginCreds.user.mnemonic);
-        if (!oldTokenDetails.isValid || !newTokenDetails.isValid || !isValidMnemonic) {
+        if (!tokenDetails.isValid || !isValidMnemonic) {
             throw new command_types_1.InvalidCredentialsError();
         }
-        if (oldTokenDetails.expiration.expired || newTokenDetails.expiration.expired) {
+        if (tokenDetails.expiration.expired) {
             throw new command_types_1.ExpiredCredentialsError();
         }
-        const refreshOldToken = !oldTokenDetails.expiration.expired && oldTokenDetails.expiration.refreshRequired;
-        const refreshNewToken = !newTokenDetails.expiration.expired && newTokenDetails.expiration.refreshRequired;
-        if (refreshOldToken || refreshNewToken) {
-            loginCreds = await this.refreshUserTokens(loginCreds);
+        const refreshToken = tokenDetails.expiration.refreshRequired;
+        if (refreshToken) {
+            loginCreds = await this.refreshUserToken(loginCreds);
         }
         return loginCreds;
     };
-    refreshUserTokens = async (oldCreds) => {
-        sdk_manager_service_1.SdkManager.init({
-            token: oldCreds.token,
-            newToken: oldCreds.newToken,
-        });
+    refreshUserDetails = async (oldCreds) => {
+        sdk_manager_service_1.SdkManager.init({ token: oldCreds.token });
         const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
         const newCreds = await usersClient.getUserData({ userUuid: oldCreds.user.uuid });
         const loginCreds = {
             user: {
                 ...newCreds.user,
                 mnemonic: oldCreds.user.mnemonic,
-                privateKey: oldCreds.user.privateKey,
+                createdAt: new Date(newCreds.user.createdAt).toISOString(),
             },
-            token: newCreds.oldToken,
-            newToken: newCreds.newToken,
+            token: newCreds.newToken,
             lastLoggedInAt: oldCreds.lastLoggedInAt,
             lastTokenRefreshAt: new Date().toISOString(),
         };
-        sdk_manager_service_1.SdkManager.init({
-            token: newCreds.oldToken,
-            newToken: newCreds.newToken,
-        });
+        sdk_manager_service_1.SdkManager.init({ token: newCreds.newToken });
+        await config_service_1.ConfigService.instance.saveUser(loginCreds);
         return loginCreds;
     };
+    refreshUserToken = async (oldCreds) => {
+        sdk_manager_service_1.SdkManager.init({ token: oldCreds.token });
+        const usersClient = sdk_manager_service_1.SdkManager.instance.getUsers();
+        const newCreds = await usersClient.refreshUser();
+        sdk_manager_service_1.SdkManager.init({ token: newCreds.newToken });
+        const newLoginCreds = {
+            ...oldCreds,
+            token: newCreds.newToken,
+            lastLoggedInAt: oldCreds.lastLoggedInAt,
+            lastTokenRefreshAt: new Date().toISOString(),
+        };
+        await config_service_1.ConfigService.instance.saveUser(newLoginCreds);
+        return newLoginCreds;
+    };
     logout = async () => {
         try {
             const user = await config_service_1.ConfigService.instance.readUser();
-            if (!user || !user.newToken) {
+            if (!user || !user.token) {
                 return;
             }
             const authClient = sdk_manager_service_1.SdkManager.instance.getAuth();
-            return authClient.logout(user.newToken);
+            return authClient.logout(user.token);
         }
         catch {
         }

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

@@ -8,7 +8,7 @@ export declare class ConfigService {
     static readonly DRIVE_SQLITE_FILE: string;
     static readonly WEBDAV_SSL_CERTS_DIR: string;
     static readonly WEBDAV_CONFIGS_FILE: string;
-    static readonly WEBDAV_LOCAL_URL = "webdav.local.internxt.com";
+    static readonly WEBDAV_DEFAULT_HOST = "127.0.0.1";
     static readonly WEBDAV_DEFAULT_PORT = "3005";
     static readonly WEBDAV_DEFAULT_PROTOCOL = "https";
     static readonly WEBDAV_DEFAULT_TIMEOUT = 0;

package/dist/services/config.service.js

@@ -16,7 +16,7 @@ class ConfigService {
     static DRIVE_SQLITE_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'internxt-cli-drive.sqlite');
     static WEBDAV_SSL_CERTS_DIR = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'certs');
     static WEBDAV_CONFIGS_FILE = node_path_1.default.join(this.INTERNXT_CLI_DATA_DIR, 'config.webdav.inxt');
-    static WEBDAV_LOCAL_URL = 'webdav.local.internxt.com';
+    static WEBDAV_DEFAULT_HOST = '127.0.0.1';
     static WEBDAV_DEFAULT_PORT = '3005';
     static WEBDAV_DEFAULT_PROTOCOL = 'https';
     static WEBDAV_DEFAULT_TIMEOUT = 0;
@@ -43,12 +43,7 @@ class ConfigService {
         try {
             const encryptedCredentials = await promises_1.default.readFile(ConfigService.CREDENTIALS_FILE, 'utf8');
             const credentialsString = crypto_service_1.CryptoService.instance.decryptText(encryptedCredentials);
-            const loginCredentials = JSON.parse(credentialsString, (key, value) => {
-                if (typeof value === 'string' && key === 'createdAt') {
-                    return new Date(value);
-                }
-                return value;
-            });
+            const loginCredentials = JSON.parse(credentialsString);
             return loginCredentials;
         }
         catch {
@@ -65,6 +60,7 @@ class ConfigService {
             const configsData = await promises_1.default.readFile(ConfigService.WEBDAV_CONFIGS_FILE, 'utf8');
             const configs = JSON.parse(configsData);
             return {
+                host: configs?.host ?? ConfigService.WEBDAV_DEFAULT_HOST,
                 port: configs?.port ?? ConfigService.WEBDAV_DEFAULT_PORT,
                 protocol: configs?.protocol ?? ConfigService.WEBDAV_DEFAULT_PROTOCOL,
                 timeoutMinutes: configs?.timeoutMinutes ?? ConfigService.WEBDAV_DEFAULT_TIMEOUT,
@@ -72,6 +68,7 @@ class ConfigService {
         }
         catch {
             return {
+                host: ConfigService.WEBDAV_DEFAULT_HOST,
                 port: ConfigService.WEBDAV_DEFAULT_PORT,
                 protocol: ConfigService.WEBDAV_DEFAULT_PROTOCOL,
                 timeoutMinutes: ConfigService.WEBDAV_DEFAULT_TIMEOUT,

package/dist/services/database/drive-file/drive-file.attributes.d.ts

@@ -11,5 +11,7 @@ export interface DriveFileAttributes {
     createdAt: Date;
     updatedAt: Date;
     size: number;
-    status: string;
+    status: 'EXISTS' | 'TRASHED' | 'DELETED';
+    creationTime: Date;
+    modificationTime: Date;
 }

package/dist/services/database/drive-file/drive-file.domain.d.ts

@@ -13,8 +13,10 @@ export declare class DriveFile implements DriveFileAttributes {
     createdAt: Date;
     updatedAt: Date;
     size: number;
-    status: string;
-    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, }: DriveFileAttributes);
+    status: 'EXISTS' | 'TRASHED' | 'DELETED';
+    creationTime: Date;
+    modificationTime: Date;
+    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, creationTime, modificationTime, }: DriveFileAttributes);
     static build(file: DriveFileAttributes): DriveFile;
     toJSON(): DriveFileAttributes;
     toItem(): DriveFileItem;

package/dist/services/database/drive-file/drive-file.domain.js

@@ -15,7 +15,9 @@ class DriveFile {
     updatedAt;
     size;
     status;
-    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, }) {
+    creationTime;
+    modificationTime;
+    constructor({ id, name, type, uuid, fileId, folderId, folderUuid, bucket, relativePath, createdAt, updatedAt, size, status, creationTime, modificationTime, }) {
         this.id = id;
         this.name = name;
         this.type = type;
@@ -29,6 +31,8 @@ class DriveFile {
         this.updatedAt = updatedAt;
         this.size = size;
         this.status = status;
+        this.creationTime = creationTime;
+        this.modificationTime = modificationTime;
     }
     static build(file) {
         return new DriveFile(file);
@@ -48,6 +52,8 @@ class DriveFile {
             updatedAt: this.updatedAt,
             size: this.size,
             status: this.status,
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
         };
     }
     toItem() {
@@ -64,7 +70,8 @@ class DriveFile {
             updatedAt: this.updatedAt,
             size: this.size,
             status: this.status,
-            encryptedName: '',
+            creationTime: this.creationTime,
+            modificationTime: this.modificationTime,
         };
     }
 }

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

@@ -4,7 +4,7 @@ export declare class DriveFileService {
     static readonly instance: DriveFileService;
     createFile: (payload: StorageTypes.FileEntryByUuid) => Promise<DriveFileItem>;
     getFileMetadata: (uuid: string) => Promise<DriveFileItem>;
-    moveFile: (payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
+    moveFile: (uuid: string, payload: StorageTypes.MoveFileUuidPayload) => Promise<StorageTypes.FileMeta>;
     renameFile: (fileUuid: string, payload: {
         plainName?: string;
         type?: string | null;

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

@@ -9,8 +9,7 @@ class DriveFileService {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
         const driveFile = await storageClient.createFileEntryByUuid(payload);
         return {
-            name: payload.plain_name,
-            encryptedName: driveFile.name,
+            name: payload.plainName,
             id: driveFile.id,
             uuid: driveFile.uuid,
             size: driveFile.size,
@@ -22,6 +21,8 @@ class DriveFileService {
             status: driveFile.status,
             folderId: driveFile.folderId,
             folderUuid: driveFile.folderUuid,
+            creationTime: new Date(driveFile.creationTime ?? driveFile.createdAt),
+            modificationTime: new Date(driveFile.modificationTime ?? driveFile.updatedAt),
         };
     };
     getFileMetadata = async (uuid) => {
@@ -30,9 +31,9 @@ class DriveFileService {
         const fileMetadata = await getFileMetadata;
         return drive_utils_1.DriveUtils.driveFileMetaToItem(fileMetadata);
     };
-    moveFile = (payload) => {
+    moveFile = (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.moveFileByUuid(payload);
+        return storageClient.moveFileByUuid(uuid, payload);
     };
     renameFile = (fileUuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

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

@@ -1,4 +1,3 @@
-import { FetchPaginatedFile, FetchPaginatedFolder } from '@internxt/sdk/dist/drive/storage/types';
 import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { DriveFolderItem } from '../../types/drive.types';
 import { RequestCanceler } from '@internxt/sdk/dist/shared/http/types';
@@ -7,12 +6,50 @@ export declare class DriveFolderService {
     getFolderMetaByUuid: (uuid: string) => Promise<DriveFolderItem>;
     getFolderMetaById: (id: number) => Promise<DriveFolderItem>;
     getFolderContent: (folderUuid: string) => Promise<{
-        folders: FetchPaginatedFolder[];
-        files: FetchPaginatedFile[];
+        folders: {
+            type: string;
+            id: number;
+            parentId: number;
+            parentUuid: string;
+            name: string;
+            parent: import("@internxt/sdk/dist/schema").components["schemas"]["Folder"];
+            bucket: string;
+            userId: number;
+            encryptVersion: string;
+            createdAt: string;
+            updatedAt: string;
+            uuid: string;
+            plainName: string;
+            size: number;
+            creationTime: string;
+            modificationTime: string;
+            status: "EXISTS" | "TRASHED" | "DELETED";
+            removed: boolean;
+            deleted: boolean;
+        }[];
+        files: {
+            id: number;
+            uuid: string;
+            fileId: string;
+            name: string;
+            type: string;
+            size: string;
+            bucket: string;
+            folderId: number;
+            folderUuid: string;
+            encryptVersion: string;
+            userId: number;
+            creationTime: string;
+            modificationTime: string;
+            createdAt: string;
+            updatedAt: string;
+            plainName: string;
+            status: "EXISTS" | "TRASHED" | "DELETED";
+        }[];
     }>;
     private readonly getAllSubfolders;
     private readonly getAllSubfiles;
-    moveFolder: (payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
+    moveFolder: (uuid: string, payload: StorageTypes.MoveFolderUuidPayload) => Promise<StorageTypes.FolderMeta>;
     createFolder(payload: StorageTypes.CreateFolderByUuidPayload): [Promise<StorageTypes.CreateFolderResponse>, RequestCanceler];
     renameFolder: (payload: {
         folderUuid: string;