@internxt/cli 1.5.4 → 1.5.6

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

@@ -41,9 +41,9 @@ class DriveFolderService {
             return files;
         }
     };
-    moveFolder = (payload) => {
+    moveFolder = (uuid, payload) => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        return storageClient.moveFolderByUuid(payload);
+        return storageClient.moveFolderByUuid(uuid, payload);
     };
     createFolder(payload) {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();

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

@@ -8,8 +8,46 @@ export declare class TrashService {
     deleteFolder: (folderId: string) => Promise<void>;
     clearTrash: () => Promise<void>;
     getTrashFolderContent: () => Promise<{
-        folders: StorageTypes.FetchPaginatedFolder[];
-        files: StorageTypes.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 getAllTrashSubfolders;
     private readonly getAllTrashSubfiles;

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

@@ -1,10 +1,7 @@
 export declare class KeysService {
     static readonly instance: KeysService;
-    assertPrivateKeyIsValid: (privateKey: string, password: string) => Promise<void>;
     encryptPrivateKey: (privateKey: string, password: string) => string;
     decryptPrivateKey: (privateKey: string, password: string) => string;
-    assertValidateKeys: (privateKey: string, publicKey: string) => Promise<void>;
-    isValidKey: (key: string) => Promise<boolean>;
     generateNewKeysWithEncrypted: (password: string) => Promise<{
         privateKeyArmored: string;
         privateKeyArmoredEncrypted: string;

package/dist/services/keys.service.js

@@ -36,78 +36,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeysService = void 0;
 const lib_1 = require("@internxt/lib");
 const openpgp = __importStar(require("openpgp"));
-const keys_types_1 = require("../types/keys.types");
 const crypto_utils_1 = require("../utils/crypto.utils");
 class KeysService {
     static instance = new KeysService();
-    assertPrivateKeyIsValid = async (privateKey, password) => {
-        let privateKeyDecrypted;
-        let badIterations = true;
-        try {
-            lib_1.aes.decrypt(privateKey, password, 9999);
-        }
-        catch {
-            badIterations = false;
-        }
-        if (badIterations === true)
-            throw new keys_types_1.WrongIterationsToEncryptPrivateKeyError();
-        let badEncrypted = false;
-        try {
-            privateKeyDecrypted = this.decryptPrivateKey(privateKey, password);
-        }
-        catch {
-            badEncrypted = true;
-        }
-        let hasValidFormat = false;
-        try {
-            if (privateKeyDecrypted !== undefined) {
-                hasValidFormat = await this.isValidKey(privateKeyDecrypted);
-            }
-        }
-        catch {
-        }
-        if (badEncrypted === true)
-            throw new keys_types_1.CorruptedEncryptedPrivateKeyError();
-        if (hasValidFormat === false)
-            throw new keys_types_1.BadEncodedPrivateKeyError();
-    };
     encryptPrivateKey = (privateKey, password) => {
         return lib_1.aes.encrypt(privateKey, password, crypto_utils_1.CryptoUtils.getAesInit());
     };
     decryptPrivateKey = (privateKey, password) => {
         return lib_1.aes.decrypt(privateKey, password);
     };
-    assertValidateKeys = async (privateKey, publicKey) => {
-        const publicKeyArmored = await openpgp.readKey({ armoredKey: publicKey });
-        const privateKeyArmored = await openpgp.readPrivateKey({ armoredKey: privateKey });
-        const plainMessage = 'validate-keys';
-        const originalText = await openpgp.createMessage({ text: plainMessage });
-        const encryptedMessage = await openpgp.encrypt({
-            message: originalText,
-            encryptionKeys: publicKeyArmored,
-        });
-        const decryptedMessage = (await openpgp.decrypt({
-            message: await openpgp.readMessage({ armoredMessage: encryptedMessage }),
-            verificationKeys: publicKeyArmored,
-            decryptionKeys: privateKeyArmored,
-        })).data;
-        if (decryptedMessage !== plainMessage) {
-            throw new keys_types_1.KeysDoNotMatchError();
-        }
-    };
-    isValidKey = async (key) => {
-        try {
-            await openpgp.readKey({ armoredKey: key });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
     generateNewKeysWithEncrypted = async (password) => {
         const { privateKey, publicKey, revocationCertificate } = await openpgp.generateKey({
             userIDs: [{ email: 'inxt@inxt.com' }],
-            curve: 'ed25519',
+            curve: 'ed25519Legacy',
         });
         return {
             privateKeyArmored: privateKey,

package/dist/services/sdk-manager.service.d.ts

@@ -1,8 +1,6 @@
 import { Auth, Drive, Network as NetworkModule } from '@internxt/sdk';
 import { ApiSecurity, AppDetails } from '@internxt/sdk/dist/shared';
-export type SdkManagerApiSecurity = ApiSecurity & {
-    newToken: string;
-};
+export type SdkManagerApiSecurity = ApiSecurity;
 export declare class SdkManager {
     static readonly instance: SdkManager;
     private static apiSecurity?;

package/dist/services/sdk-manager.service.js

@@ -27,47 +27,38 @@ class SdkManager {
         return {
             clientName: package_json_1.default.clientName,
             clientVersion: package_json_1.default.version,
+            desktopHeader: config_service_1.ConfigService.instance.get('DESKTOP_HEADER'),
         };
     };
     getAuth() {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Auth.client(DRIVE_API_URL, appDetails, {
-            token: apiSecurity?.newToken,
-        });
+        return sdk_1.Auth.client(DRIVE_API_URL, appDetails, apiSecurity);
     }
     getUsers() {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, {
-            token: apiSecurity.newToken,
-        });
+        return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, apiSecurity);
     }
     getStorage() {
         const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, {
-            token: apiSecurity.newToken,
-        });
+        return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, apiSecurity);
     }
     getTrash() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
-        return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, {
-            token: apiSecurity.newToken,
-        });
+        return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
     }
     getShare() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, {
-            token: apiSecurity.newToken,
-        });
+        return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, apiSecurity);
     }
     getNetwork(credentials) {
         const appDetails = SdkManager.getAppDetails();

package/dist/services/thumbnail.service.js

@@ -1,14 +1,55 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ThumbnailService = void 0;
 const node_stream_1 = require("node:stream");
 const drive_file_service_1 = require("./drive/drive-file.service");
 const drive_1 = require("@internxt/sdk/dist/drive");
 const thumbnail_utils_1 = require("../utils/thumbnail.utils");
-const sharp_1 = __importDefault(require("sharp"));
+let sharpDependency = null;
+const getSharp = async () => {
+    if (!sharpDependency) {
+        try {
+            sharpDependency = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
+        }
+        catch {
+            return null;
+        }
+    }
+    return sharpDependency;
+};
 class ThumbnailService {
     static instance = new ThumbnailService();
     uploadThumbnail = async (fileContent, fileType, userBucket, file_id, networkFacade) => {
@@ -39,17 +80,20 @@ class ThumbnailService {
             return createdThumbnailFile;
         }
     };
-    getThumbnailFromImageBuffer = (buffer) => {
-        return (0, sharp_1.default)(buffer)
-            .resize({
-            height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
-            width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
-            fit: 'inside',
-        })
-            .png({
-            quality: thumbnail_utils_1.ThumbnailConfig.Quality,
-        })
-            .toBuffer();
+    getThumbnailFromImageBuffer = async (buffer) => {
+        const sharp = await getSharp();
+        if (sharp) {
+            return sharp(buffer, { failOnError: false })
+                .resize({
+                height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
+                width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
+                fit: 'inside',
+            })
+                .png({
+                quality: thumbnail_utils_1.ThumbnailConfig.Quality,
+            })
+                .toBuffer();
+        }
     };
 }
 exports.ThumbnailService = ThumbnailService;

package/dist/types/command.types.d.ts

@@ -1,12 +1,36 @@
-import { UserSettings } from '@internxt/sdk/dist/shared/types/userSettings';
+export interface LoginUserDetails {
+    userId: string;
+    uuid: string;
+    email: string;
+    name: string;
+    lastname: string;
+    username: string;
+    bridgeUser: string;
+    bucket: string;
+    rootFolderId: string;
+    mnemonic: string;
+    keys: {
+        ecc: {
+            publicKey: string;
+            privateKey: string;
+        };
+        kyber: {
+            publicKey: string;
+            privateKey: string;
+        };
+    };
+    createdAt: string;
+    avatar: string | null;
+    emailVerified: boolean;
+}
 export interface LoginCredentials {
-    user: UserSettings;
+    user: LoginUserDetails;
     token: string;
-    newToken: string;
     lastLoggedInAt: string;
     lastTokenRefreshAt: string;
 }
 export interface WebdavConfig {
+    host: string;
     port: string;
     protocol: 'http' | 'https';
     timeoutMinutes: number;

package/dist/types/config.types.d.ts

@@ -5,4 +5,5 @@ export interface ConfigKeys {
     readonly APP_MAGIC_IV: string;
     readonly APP_MAGIC_SALT: string;
     readonly NETWORK_URL: string;
+    readonly DESKTOP_HEADER: string;
 }

package/dist/types/drive.types.d.ts

@@ -1,10 +1,11 @@
-import { DriveFileData, DriveFolderData } from '@internxt/sdk/dist/drive/storage/types';
-export type DriveFileItem = Pick<DriveFileData, 'name' | 'bucket' | 'fileId' | 'id' | 'uuid' | 'folderId' | 'status' | 'folderUuid'> & {
-    encryptedName: string;
+import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
+export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
     size: number;
     createdAt: Date;
     updatedAt: Date;
-    type?: string;
+    creationTime: Date;
+    modificationTime: Date;
+    type?: string | null;
 };
 export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
     encryptedName: string;

package/dist/types/keys.types.d.ts

@@ -1,15 +1,3 @@
-export declare class BadEncodedPrivateKeyError extends Error {
-    constructor();
-}
-export declare class WrongIterationsToEncryptPrivateKeyError extends Error {
-    constructor();
-}
-export declare class CorruptedEncryptedPrivateKeyError extends Error {
-    constructor();
-}
-export declare class KeysDoNotMatchError extends Error {
-    constructor();
-}
 export interface AesInit {
     iv: string;
     salt: string;

package/dist/types/keys.types.js

@@ -1,31 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KeysDoNotMatchError = exports.CorruptedEncryptedPrivateKeyError = exports.WrongIterationsToEncryptPrivateKeyError = exports.BadEncodedPrivateKeyError = void 0;
-class BadEncodedPrivateKeyError extends Error {
-    constructor() {
-        super('Private key is bad encoded');
-        Object.setPrototypeOf(this, BadEncodedPrivateKeyError.prototype);
-    }
-}
-exports.BadEncodedPrivateKeyError = BadEncodedPrivateKeyError;
-class WrongIterationsToEncryptPrivateKeyError extends Error {
-    constructor() {
-        super('Private key was encrypted using the wrong iterations number');
-        Object.setPrototypeOf(this, WrongIterationsToEncryptPrivateKeyError.prototype);
-    }
-}
-exports.WrongIterationsToEncryptPrivateKeyError = WrongIterationsToEncryptPrivateKeyError;
-class CorruptedEncryptedPrivateKeyError extends Error {
-    constructor() {
-        super('Private key is corrupted');
-        Object.setPrototypeOf(this, CorruptedEncryptedPrivateKeyError.prototype);
-    }
-}
-exports.CorruptedEncryptedPrivateKeyError = CorruptedEncryptedPrivateKeyError;
-class KeysDoNotMatchError extends Error {
-    constructor() {
-        super('Keys do not match');
-        Object.setPrototypeOf(this, KeysDoNotMatchError.prototype);
-    }
-}
-exports.KeysDoNotMatchError = KeysDoNotMatchError;

package/dist/utils/drive.utils.js

@@ -6,14 +6,15 @@ class DriveUtils {
         return {
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
-            folderId: fileMeta.folderId ?? fileMeta.folder_id,
+            folderId: fileMeta.folderId,
             folderUuid: fileMeta.folderUuid,
-            size: fileMeta.size,
-            encryptedName: fileMeta.name,
+            size: Number(fileMeta.size),
             name: fileMeta.plainName ?? fileMeta.name,
             bucket: fileMeta.bucket,
             createdAt: new Date(fileMeta.createdAt),
             updatedAt: new Date(fileMeta.updatedAt),
+            creationTime: new Date(fileMeta.creationTime ?? fileMeta.createdAt),
+            modificationTime: new Date(fileMeta.modificationTime ?? fileMeta.updatedAt),
             fileId: fileMeta.fileId,
             id: fileMeta.id,
             type: fileMeta.type,

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

@@ -1,6 +1,7 @@
 import { NetworkCredentials, SelfsignedCert } from '../types/network.types';
 import selfsigned from 'selfsigned';
 import parseRange from 'range-parser';
+import { WebdavConfig } from '../types/command.types';
 export declare class NetworkUtils {
     static getAuthFromCredentials(creds: NetworkCredentials): {
         username: string;
@@ -10,10 +11,10 @@ export declare class NetworkUtils {
         cert: string;
         privateKey: string;
     };
-    static generateNewSelfsignedCerts(): SelfsignedCert;
-    static getWebdavSSLCerts(): Promise<SelfsignedCert>;
+    static generateNewSelfsignedCerts(configs: WebdavConfig): SelfsignedCert;
+    static getWebdavSSLCerts(configs: WebdavConfig): Promise<SelfsignedCert>;
     static saveWebdavSSLCerts(pems: selfsigned.GenerateResult): Promise<void>;
-    static generateSelfSignedSSLCerts(): selfsigned.GenerateResult;
+    static generateSelfSignedSSLCerts(configs: WebdavConfig): selfsigned.GenerateResult;
     static parseRangeHeader(rangeOptions: {
         range?: string;
         totalFileSize: number;

package/dist/utils/network.utils.js

@@ -21,19 +21,19 @@ class NetworkUtils {
         cert: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'cert.crt'),
         privateKey: node_path_1.default.join(config_service_1.ConfigService.WEBDAV_SSL_CERTS_DIR, 'priv.key'),
     };
-    static generateNewSelfsignedCerts() {
-        const newCerts = this.generateSelfSignedSSLCerts();
+    static generateNewSelfsignedCerts(configs) {
+        const newCerts = this.generateSelfSignedSSLCerts(configs);
         this.saveWebdavSSLCerts(newCerts);
         return {
             cert: newCerts.cert,
             key: newCerts.private,
         };
     }
-    static async getWebdavSSLCerts() {
+    static async getWebdavSSLCerts(configs) {
         const existCert = !!(await (0, promises_1.stat)(this.WEBDAV_SSL_CERTS_PATH.cert).catch(() => false));
         const existKey = !!(await (0, promises_1.stat)(this.WEBDAV_SSL_CERTS_PATH.privateKey).catch(() => false));
         if (!existCert || !existKey) {
-            return this.generateNewSelfsignedCerts();
+            return this.generateNewSelfsignedCerts(configs);
         }
         else {
             let selfsignedCert = {
@@ -44,7 +44,7 @@ class NetworkUtils {
             const dateToday = new Date();
             const dateValid = new Date(validTo);
             if (dateToday > dateValid) {
-                const newCerts = this.generateNewSelfsignedCerts();
+                const newCerts = this.generateNewSelfsignedCerts(configs);
                 selfsignedCert = {
                     cert: newCerts.cert,
                     key: newCerts.key,
@@ -57,15 +57,15 @@ class NetworkUtils {
         await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.cert, pems.cert, 'utf8');
         await (0, promises_1.writeFile)(this.WEBDAV_SSL_CERTS_PATH.privateKey, pems.private, 'utf8');
     }
-    static generateSelfSignedSSLCerts() {
-        const attrs = [{ name: 'commonName', value: config_service_1.ConfigService.WEBDAV_LOCAL_URL }];
+    static generateSelfSignedSSLCerts(configs) {
+        const attrs = [{ name: 'commonName', value: configs.host }];
         const extensions = [
             {
                 name: 'subjectAltName',
                 altNames: [
                     {
                         type: 2,
-                        value: config_service_1.ConfigService.WEBDAV_LOCAL_URL,
+                        value: configs.host,
                     },
                 ],
             },

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

@@ -23,7 +23,7 @@ class DELETERequestHandler {
         }
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${resource.type}`);
         await trashService.trashItems({
-            items: [{ type: resource.type, uuid: driveItem.uuid }],
+            items: [{ type: resource.type, uuid: driveItem.uuid, id: null }],
         });
         res.status(204).send();
         const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);

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

@@ -28,9 +28,9 @@ class MOVERequestHandler {
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
+        const newName = destinationResource.name;
         if (destinationResource.path.dir === resource.path.dir) {
             logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
-            const newName = destinationResource.name;
             if (resource.type === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.renameFolder({
@@ -60,16 +60,18 @@ class MOVERequestHandler {
             const destinationFolderItem = destinationDriveFolderItem;
             if (resource.type === 'folder') {
                 const folder = originalDriveItem;
-                await driveFolderService.moveFolder({
-                    folderUuid: folder.uuid,
-                    destinationFolderUuid: destinationFolderItem.uuid,
+                await driveFolderService.moveFolder(folder.uuid, {
+                    destinationFolder: destinationFolderItem.uuid,
+                    name: newName,
                 });
             }
             else if (resource.type === 'file') {
                 const file = originalDriveItem;
-                await driveFileService.moveFile({
-                    fileUuid: file.uuid,
-                    destinationFolderUuid: destinationFolderItem.uuid,
+                const newType = destinationResource.path.ext.replace('.', '');
+                await driveFileService.moveFile(file.uuid, {
+                    destinationFolder: destinationFolderItem.uuid,
+                    name: newName,
+                    type: newType,
                 });
             }
         }

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

@@ -62,13 +62,14 @@ class PROPFINDRequestHandler {
             id: driveFileItem.id,
             uuid: driveFileItem.uuid,
             fileId: driveFileItem.fileId,
-            encryptedName: driveFileItem.name,
             size: driveFileItem.size,
             createdAt: driveFileItem.createdAt,
             updatedAt: driveFileItem.updatedAt,
             status: driveFileItem.status,
             folderId: driveFileItem.folderId,
             folderUuid: driveFileItem.folderUuid,
+            creationTime: driveFileItem.creationTime,
+            modificationTime: driveFileItem.modificationTime,
         }, resource.url);
         const xml = xml_utils_1.XMLUtils.toWebDavXML([driveFile], {
             arrayNodeName: xml_utils_1.XMLUtils.addDefaultNamespace('response'),
@@ -131,16 +132,17 @@ class PROPFINDRequestHandler {
                 name: file.plainName,
                 bucket: file.bucket,
                 id: file.id,
-                createdAt: new Date(file.createdAt),
-                updatedAt: new Date(file.updatedAt),
                 fileId: file.fileId,
                 uuid: file.uuid,
                 type: file.type,
-                encryptedName: file.name,
                 status: file.status,
                 folderId: file.folderId,
                 folderUuid: file.folderUuid,
                 size: Number(file.size),
+                creationTime: new Date(file.creationTime),
+                modificationTime: new Date(file.modificationTime),
+                createdAt: new Date(file.createdAt),
+                updatedAt: new Date(file.updatedAt),
             }, fileRelativePath);
         });
         return foldersXML.concat(filesXML);
@@ -196,6 +198,7 @@ class PROPFINDRequestHandler {
     };
     driveFileItemToXMLNode = (driveFileItem, relativePath) => {
         const displayName = driveFileItem.type ? `${driveFileItem.name}.${driveFileItem.type}` : driveFileItem.name;
+        const lastModified = format_utils_1.FormatUtils.formatDateForWebDav(driveFileItem.modificationTime ?? driveFileItem.updatedAt);
         const driveFileXML = {
             [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(relativePath),
             [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
@@ -205,7 +208,7 @@ class PROPFINDRequestHandler {
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: '"' + (0, node_crypto_1.randomUUID)().replaceAll('-', '') + '"',
                     [xml_utils_1.XMLUtils.addDefaultNamespace('displayname')]: displayName,
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: mime_types_1.default.lookup(displayName) || 'application/octet-stream',
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: format_utils_1.FormatUtils.formatDateForWebDav(driveFileItem.updatedAt),
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: lastModified,
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontentlength')]: driveFileItem.size,
                 },
             },

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

@@ -43,7 +43,7 @@ class PUTRequestHandler {
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
                 logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
                 await trashService.trashItems({
-                    items: [{ type: resource.type, uuid: driveFileItem.uuid }],
+                    items: [{ type: resource.type, uuid: driveFileItem.uuid, id: null }],
                 });
             }
         }
@@ -84,14 +84,13 @@ class PUTRequestHandler {
         uploaded = true;
         logger_utils_1.webdavLogger.info('[PUT] ✅ File uploaded to network');
         const file = await drive_file_service_1.DriveFileService.instance.createFile({
-            plain_name: resource.path.name,
+            plainName: resource.path.name,
             type: fileType,
             size: contentLength,
-            folder_id: parentFolderItem.uuid,
-            id: fileId,
+            folderUuid: parentFolderItem.uuid,
+            fileId: fileId,
             bucket: user.bucket,
-            encrypt_version: types_1.EncryptionVersion.Aes03,
-            name: '',
+            encryptVersion: types_1.EncryptionVersion.Aes03,
         });
         try {
             if (isThumbnailable && bufferStream) {