[PB-2005]:(feature) Allow to trash a file and folder from WebDav

src/services/database/drive-database-manager.service.ts

@@ -8,6 +8,8 @@ import { DriveFile } from './drive-file/drive-file.domain';
 import { DriveFolder } from './drive-folder/drive-folder.domain';
 import DriveFileModel from './drive-file/drive-file.model';
 import DriveFolderModel from './drive-folder/drive-folder.model';
+import { DriveFileAttributes } from './drive-file/drive-file.attributes';
+import { DriveFolderAttributes } from './drive-folder/drive-folder.attributes';
 
 export class DriveDatabaseManager {
   private static readonly sequelize: Sequelize = new Sequelize({
@@ -89,4 +91,15 @@ export class DriveDatabaseManager {
 
     return WebDavUtils.joinURL(parentPath, folderName, '/');
   };
+
+  updateFile = async (id: number, payload: Partial<Pick<DriveFileAttributes, 'status' | 'relativePath' | 'name'>>) => {
+    return await this.driveFileRepository.updateFile(id, payload);
+  };
+
+  updateFolder = async (
+    id: number,
+    payload: Partial<Pick<DriveFolderAttributes, 'name' | 'relativePath' | 'status'>>,
+  ) => {
+    return await this.driveFolderRepository.updateFolder(id, payload);
+  };
 }

src/services/database/drive-file/drive-file.repository.ts

@@ -1,6 +1,7 @@
 import { DriveFileItem } from '../../../types/drive.types';
 import { DriveFileModel } from './drive-file.model';
 import { DriveFile } from './drive-file.domain';
+import { DriveFileAttributes } from './drive-file.attributes';
 
 export class DriveFileRepository {
   findByRelativePath = async (relativePath: DriveFile['relativePath']): Promise<DriveFile | null> => {
@@ -30,6 +31,21 @@ export class DriveFileRepository {
     return this.toDomain(newFile);
   };
 
+  updateFile = async (
+    id: number,
+    driveFileItemAttributes: Partial<Pick<DriveFileAttributes, 'status' | 'name' | 'relativePath'>>,
+  ): Promise<DriveFile | null> => {
+    const existingFile = await DriveFileModel.findByPk(id);
+    if (!existingFile) return null;
+
+    existingFile.updatedAt = new Date();
+    existingFile.status = driveFileItemAttributes.status ?? existingFile.status;
+    existingFile.name = driveFileItemAttributes.name ?? existingFile.name;
+    existingFile.relativePath = driveFileItemAttributes.relativePath ?? existingFile.relativePath;
+
+    return existingFile.save();
+  };
+
   toDomain = (model: DriveFileModel): DriveFile => {
     const driveFile = DriveFile.build({
       ...model.toJSON(),

src/services/database/drive-folder/drive-folder.attributes.ts

@@ -2,6 +2,7 @@ export interface DriveFolderAttributes {
   id: number;
   name: string;
   uuid: string;
+  status: 'EXISTS' | 'TRASHED';
   relativePath: string;
   parentId: number | null;
   createdAt: Date;

src/services/database/drive-folder/drive-folder.domain.ts

@@ -8,15 +8,17 @@ export class DriveFolder implements DriveFolderAttributes {
   parentId: number | null;
   createdAt: Date;
   updatedAt: Date;
+  status: DriveFolderAttributes['status'];
 
-  constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt }: DriveFolderAttributes) {
+  constructor({ id, name, uuid, relativePath, parentId, createdAt, updatedAt, status }: DriveFolderAttributes) {
     this.id = id;
     this.name = name;
     this.uuid = uuid;
     this.relativePath = relativePath;
     this.parentId = parentId;
     this.createdAt = createdAt;
     this.updatedAt = updatedAt;
+    this.status = status;
   }
 
   static build(folder: DriveFolderAttributes): DriveFolder {
@@ -28,6 +30,7 @@ export class DriveFolder implements DriveFolderAttributes {
       id: this.id,
       name: this.name,
       uuid: this.uuid,
+      status: this.status,
       relativePath: this.relativePath,
       parentId: this.parentId,
       createdAt: this.createdAt,

src/services/database/drive-folder/drive-folder.model.ts

@@ -25,6 +25,9 @@ export class DriveFolderModel extends Model implements DriveFolderAttributes {
   @Column(DataType.STRING)
   declare name: string;
 
+  @Column(DataType.STRING)
+  declare status: 'EXISTS' | 'TRASHED';
+
   @Unique
   @Column(DataType.UUIDV4)
   declare uuid: string;

src/services/database/drive-folder/drive-folder.repository.ts

@@ -1,4 +1,5 @@
 import { DriveFolderItem } from '../../../types/drive.types';
+import { DriveFolderAttributes } from './drive-folder.attributes';
 import { DriveFolder } from './drive-folder.domain';
 import { DriveFolderModel } from './drive-folder.model';
 
@@ -30,6 +31,21 @@ export class DriveFolderRepository {
     return this.toDomain(newFolder);
   };
 
+  updateFolder = async (
+    id: number,
+    driveFolderItemAttributes: Partial<Pick<DriveFolderAttributes, 'name' | 'relativePath' | 'status'>>,
+  ): Promise<DriveFolder | null> => {
+    const existingFolder = await DriveFolderModel.findByPk(id);
+    if (!existingFolder) return null;
+
+    existingFolder.updatedAt = new Date();
+    existingFolder.status = driveFolderItemAttributes.status ?? existingFolder.status;
+    existingFolder.name = driveFolderItemAttributes.name ?? existingFolder.name;
+    existingFolder.relativePath = driveFolderItemAttributes.relativePath ?? existingFolder.relativePath;
+
+    return existingFolder.save();
+  };
+
   toDomain = (model: DriveFolderModel): DriveFolder => {
     const driveFolder = DriveFolder.build({
       ...model.toJSON(),

src/types/drive.types.ts

@@ -16,4 +16,5 @@ export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | '
   uuid: string;
   createdAt: Date;
   updatedAt: Date;
+  status: 'EXISTS' | 'TRASHED';
 };

src/utils/drive.utils.ts

@@ -24,6 +24,7 @@ export class DriveUtils {
       uuid: folderMeta.uuid,
       id: folderMeta.id,
       bucket: folderMeta.bucket,
+      status: folderMeta.deleted || folderMeta.removed ? 'TRASHED' : 'EXISTS',
       name: folderMeta.plainName ?? folderMeta.name,
       encryptedName: folderMeta.name,
       parentId: folderMeta.parentId,

src/webdav/handlers/DELETE.handler.ts

@@ -1,8 +1,34 @@
+import { Request, Response } from 'express';
 import { WebDavMethodHandler } from '../../types/webdav.types';
-import { NotImplementedError } from '../../utils/errors.utils';
+import { NotFoundError } from '../../utils/errors.utils';
+import { WebDavUtils } from '../../utils/webdav.utils';
+import { DriveDatabaseManager } from '../../services/database/drive-database-manager.service';
+import { TrashService } from '../../services/drive/trash.service';
 
 export class DELETERequestHandler implements WebDavMethodHandler {
-  async handle() {
-    throw new NotImplementedError('DELETE is not implemented yet.');
-  }
+  constructor(private dependencies: { driveDatabaseManager: DriveDatabaseManager; trashService: TrashService }) {}
+  handle = async (req: Request, res: Response) => {
+    const resource = await WebDavUtils.getRequestedResource(req, this.dependencies.driveDatabaseManager);
+    const databaseItem = await this.dependencies.driveDatabaseManager.findByRelativePath(resource.url);
+
+    if (!databaseItem) throw new NotFoundError('Resource not found');
+
+    await this.dependencies.trashService.trashItems({
+      items: [{ type: resource.type, uuid: databaseItem.uuid }],
+    });
+
+    if (resource.type === 'folder') {
+      await this.dependencies.driveDatabaseManager.updateFolder(databaseItem.id, {
+        status: 'TRASHED',
+      });
+    }
+
+    if (resource.type === 'file') {
+      await this.dependencies.driveDatabaseManager.updateFile(databaseItem.id, {
+        status: 'TRASHED',
+      });
+    }
+
+    res.status(204).send();
+  };
 }

src/webdav/handlers/PROPFIND.handler.ts

@@ -31,6 +31,7 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
           const rootFolder = await this.dependencies.driveFolderService.getFolderMetaById(req.user.rootFolderId);
           await this.dependencies.driveDatabaseManager.createFolder({
             name: '',
+            status: 'EXISTS',
             encryptedName: rootFolder.name,
             bucket: rootFolder.bucket,
             id: rootFolder.id,
@@ -127,6 +128,7 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
         {
           name: folder.plainName,
           bucket: folder.bucket,
+          status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
           createdAt: new Date(folder.createdAt),
           updatedAt: new Date(folder.updatedAt),
           id: folder.id,
@@ -143,10 +145,12 @@ export class PROPFINDRequestHandler implements WebDavMethodHandler {
         ...folder,
         name: folder.plainName,
         encryptedName: folder.name,
+        status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
       });
     });
 
     const filesXML = folderContent.files.map((file) => {
+      console.log('FILE', file.status);
       const fileRelativePath = WebDavUtils.joinURL(
         relativePath,
         file.type ? `${file.plainName}.${file.type}` : file.plainName,

src/webdav/index.ts

@@ -11,6 +11,7 @@ import { UploadService } from '../services/network/upload.service';
 import { DownloadService } from '../services/network/download.service';
 import { AuthService } from '../services/auth.service';
 import { CryptoService } from '../services/crypto.service';
+import { TrashService } from '../services/drive/trash.service';
 
 dotenv.config();
 
@@ -31,6 +32,7 @@ const init = async () => {
     DownloadService.instance,
     AuthService.instance,
     CryptoService.instance,
+    TrashService.instance,
   )
     .start()
     .then()

src/webdav/webdav-server.ts

@@ -27,6 +27,7 @@ import { DELETERequestHandler } from './handlers/DELETE.handler';
 import { PROPPATCHRequestHandler } from './handlers/PROPPATCH.handler';
 import { MOVERequestHandler } from './handlers/MOVE.handler';
 import { COPYRequestHandler } from './handlers/COPY.handler';
+import { TrashService } from '../services/drive/trash.service';
 
 export class WebDavServer {
   constructor(
@@ -39,6 +40,7 @@ export class WebDavServer {
     private downloadService: DownloadService,
     private authService: AuthService,
     private cryptoService: CryptoService,
+    private trashService: TrashService,
   ) {}
 
   private async getNetwork() {
@@ -107,7 +109,15 @@ export class WebDavServer {
     );
 
     this.app.mkcol('*', asyncHandler(new MKCOLRequestHandler().handle));
-    this.app.delete('*', asyncHandler(new DELETERequestHandler().handle));
+    this.app.delete(
+      '*',
+      asyncHandler(
+        new DELETERequestHandler({
+          driveDatabaseManager: this.driveDatabaseManager,
+          trashService: this.trashService,
+        }).handle,
+      ),
+    );
     this.app.proppatch('*', asyncHandler(new PROPPATCHRequestHandler().handle));
     this.app.move('*', asyncHandler(new MOVERequestHandler().handle));
     this.app.copy('*', asyncHandler(new COPYRequestHandler().handle));

test/fixtures/drive.fixture.ts

@@ -23,6 +23,7 @@ export const newFolderItem = (attributes?: Partial<DriveFolderItem>): DriveFolde
     encryptedName: crypto.randomBytes(16).toString('hex'),
     createdAt: new Date(),
     updatedAt: new Date(),
+    status: 'EXISTS',
   };
   return { ...folder, ...attributes };
 };

test/webdav/webdav-server.test.ts

@@ -14,6 +14,7 @@ import { AuthService } from '../../src/services/auth.service';
 import { CryptoService } from '../../src/services/crypto.service';
 import { ConfigKeys } from '../../src/types/config.types';
 import { NetworkUtils } from '../../src/utils/network.utils';
+import { TrashService } from '../../src/services/drive/trash.service';
 
 describe('WebDav server', () => {
   const sandbox = sinon.createSandbox();
@@ -52,6 +53,7 @@ describe('WebDav server', () => {
       DownloadService.instance,
       AuthService.instance,
       CryptoService.instance,
+      TrashService.instance,
     );
     server.start();