@drax/media-back 3.50.0 → 3.51.0

package/dist/controllers/FileController.js

@@ -1,7 +1,6 @@
 import FileServiceFactory from "../factory/services/FileServiceFactory.js";
 import { AbstractFastifyController } from "@drax/crud-back";
 import FilePermissions from "../permissions/FilePermissions.js";
-import { StoreManager } from "@drax/common-back";
 class FileController extends AbstractFastifyController {
     constructor() {
         super(FileServiceFactory.instance, FilePermissions);
@@ -24,15 +23,6 @@ class FileController extends AbstractFastifyController {
         };
         return payload;
     }
-    async postDelete(request, item) {
-        try {
-            await StoreManager.deleteFilepath(item.relativePath);
-        }
-        catch (error) {
-            console.error(error);
-        }
-        return item;
-    }
 }
 export default FileController;
 export { FileController };

package/dist/controllers/MediaController.js

@@ -51,6 +51,29 @@ class MediaController extends CommonController {
             this.handleError(e, reply);
         }
     }
+    async deleteFile(request, reply) {
+        try {
+            request.rbac.assertPermission(MediaPermissions.DeleteFile);
+            const dir = request.params.dir;
+            const year = request.params.year;
+            const month = request.params.month;
+            const filename = request.params.filename;
+            const deleteMetadata = request.query?.deleteMetadata === undefined
+                ? undefined
+                : !["false", "0", "no"].includes(String(request.query.deleteMetadata).toLowerCase());
+            const result = await this.mediaService.deleteFile({
+                dir,
+                year,
+                month,
+                filename,
+                deleteMetadata,
+            });
+            return reply.send(result);
+        }
+        catch (e) {
+            this.handleError(e, reply);
+        }
+    }
 }
 export default MediaController;
 export { MediaController };

package/dist/permissions/MediaPermissions.js

@@ -1,6 +1,7 @@
 var MediaPermissions;
 (function (MediaPermissions) {
     MediaPermissions["UploadFile"] = "file:upload";
+    MediaPermissions["DeleteFile"] = "file:delete";
 })(MediaPermissions || (MediaPermissions = {}));
 export default MediaPermissions;
 export { MediaPermissions };

package/dist/routes/MediaRoutes.js

@@ -11,6 +11,19 @@ async function MediaRoutes(fastify, options) {
             tags: ['Media'],
         }
     }, (req, rep) => controller.downloadFile(req, rep));
+    fastify.delete('/api/file/:dir/:year/:month/:filename', {
+        schema: {
+            tags: ['Media'],
+            querystring: {
+                type: 'object',
+                properties: {
+                    deleteMetadata: {
+                        type: 'boolean',
+                    },
+                },
+            },
+        }
+    }, (req, rep) => controller.deleteFile(req, rep));
 }
 export default MediaRoutes;
 export { MediaRoutes };

package/dist/services/FileService.js

@@ -1,8 +1,20 @@
 import { AbstractService } from "@drax/crud-back";
+import { StoreManager } from "@drax/common-back";
 class FileService extends AbstractService {
     constructor(FileRepository, baseSchema, fullSchema) {
         super(FileRepository, baseSchema, fullSchema);
         this._validateOutput = true;
+        this.onDeleted = async (id, item) => {
+            if (!item?.relativePath) {
+                return;
+            }
+            try {
+                await StoreManager.deleteFilepath(item.relativePath);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        };
     }
     async registerUploadedFile(data) {
         return await this.create(data);

package/dist/services/MediaService.js

@@ -118,6 +118,71 @@ class MediaService {
             absolutePath,
         };
     }
+    async deleteFile(params) {
+        const { dir, year, month, filename, deleteMetadata = true } = params;
+        this.assertDir(dir);
+        this.assertYear(year);
+        this.assertMonth(month);
+        const fileDir = join(this.getBaseFileDir(), dir, year, month);
+        const relativePath = join(fileDir, filename);
+        const absolutePath = resolve(process.cwd(), relativePath);
+        let metadataDeleted = false;
+        if (deleteMetadata && this.isMetadataEnabled()) {
+            const file = await FileServiceFactory.instance.findOneBy("relativePath", relativePath);
+            if (file) {
+                await FileServiceFactory.instance.delete(file._id);
+                metadataDeleted = true;
+                return {
+                    dir,
+                    year,
+                    month,
+                    filename,
+                    fileDir,
+                    relativePath,
+                    absolutePath,
+                    deleted: true,
+                    metadataDeleted,
+                };
+            }
+        }
+        await StoreManager.deleteFilepath(relativePath);
+        return {
+            dir,
+            year,
+            month,
+            filename,
+            fileDir,
+            relativePath,
+            absolutePath,
+            deleted: true,
+            metadataDeleted,
+        };
+    }
+    async deleteFileByRelativePath(params) {
+        const { relativePath, deleteMetadata = true } = params;
+        const absolutePath = resolve(process.cwd(), relativePath);
+        let metadataDeleted = false;
+        if (deleteMetadata && this.isMetadataEnabled()) {
+            const file = await FileServiceFactory.instance.findOneBy("relativePath", relativePath);
+            if (file) {
+                await FileServiceFactory.instance.delete(file._id);
+                metadataDeleted = true;
+                return {
+                    relativePath,
+                    absolutePath,
+                    deleted: true,
+                    metadataDeleted,
+                };
+            }
+        }
+        await StoreManager.deleteFilepath(relativePath);
+        return {
+            relativePath,
+            absolutePath,
+            deleted: true,
+            metadataDeleted,
+        };
+    }
 }
 export default MediaService;
 export { MediaService, };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.50.0",
+  "version": "3.51.0",
   "description": "Media files",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -21,7 +21,7 @@
   "license": "ISC",
   "dependencies": {
     "@drax/common-back": "^3.28.0",
-    "@drax/identity-back": "^3.50.0"
+    "@drax/identity-back": "^3.51.0"
   },
   "peerDependencies": {
     "@fastify/multipart": "^9.0.3",
@@ -39,5 +39,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.4.5"
   },
-  "gitHead": "1f7040e46eafd8ed45dcdec95d3c1ba41e567e75"
+  "gitHead": "62e011454676e3e1d5977be0fcfedba6bd568624"
 }

package/src/controllers/FileController.ts

@@ -2,7 +2,6 @@ import FileServiceFactory from "../factory/services/FileServiceFactory.js";
 import {AbstractFastifyController, CustomRequest} from "@drax/crud-back";
 import FilePermissions from "../permissions/FilePermissions.js";
 import type {IFile, IFileBase} from "../interfaces/IFile";
-import {StoreManager} from "@drax/common-back";
 
 class FileController extends AbstractFastifyController<IFile, IFileBase, IFileBase>   {
 
@@ -33,15 +32,6 @@ class FileController extends AbstractFastifyController<IFile, IFileBase, IFileBa
 
         return payload
     }
-
-    async postDelete(request: CustomRequest, item:IFile){
-        try {
-            await StoreManager.deleteFilepath(item.relativePath)
-        } catch (error) {
-            console.error(error)
-        }
-        return item
-    }
 }
 
 export default FileController;

package/src/controllers/MediaController.ts

@@ -64,6 +64,32 @@ class MediaController extends CommonController {
 
     }
 
+    async deleteFile(request: any, reply: any) {
+        try {
+            request.rbac.assertPermission(MediaPermissions.DeleteFile)
+
+            const dir = request.params.dir
+            const year = request.params.year
+            const month = request.params.month
+            const filename = request.params.filename
+            const deleteMetadata = request.query?.deleteMetadata === undefined
+                ? undefined
+                : !["false", "0", "no"].includes(String(request.query.deleteMetadata).toLowerCase())
+
+            const result = await this.mediaService.deleteFile({
+                dir,
+                year,
+                month,
+                filename,
+                deleteMetadata,
+            })
+
+            return reply.send(result)
+        } catch (e) {
+            this.handleError(e, reply)
+        }
+    }
+
 
 }
 

package/src/index.ts

@@ -18,6 +18,10 @@ import type {
     IMediaSaveFileResult,
     IMediaGetFileParams,
     IMediaGetFileResult,
+    IMediaDeleteFileParams,
+    IMediaDeleteFileResult,
+    IMediaDeleteFileByRelativePathParams,
+    IMediaDeleteFileByRelativePathResult,
 } from "./services/MediaService.js";
 
 export type {
@@ -29,6 +33,10 @@ export type {
     IMediaSaveFileResult,
     IMediaGetFileParams,
     IMediaGetFileResult,
+    IMediaDeleteFileParams,
+    IMediaDeleteFileResult,
+    IMediaDeleteFileByRelativePathParams,
+    IMediaDeleteFileByRelativePathResult,
 }
 
 export {

package/src/permissions/MediaPermissions.ts

@@ -1,6 +1,7 @@
 enum MediaPermissions {
 
     UploadFile = "file:upload",
+    DeleteFile = "file:delete",
 
 }
 

package/src/routes/MediaRoutes.ts

@@ -17,6 +17,20 @@ async function MediaRoutes(fastify, options) {
         }
     }, (req,rep) =>  controller.downloadFile(req,rep) )
 
+    fastify.delete('/api/file/:dir/:year/:month/:filename', {
+        schema: {
+            tags: ['Media'],
+            querystring: {
+                type: 'object',
+                properties: {
+                    deleteMetadata: {
+                        type: 'boolean',
+                    },
+                },
+            },
+        }
+    }, (req,rep) =>  controller.deleteFile(req,rep) )
+
 
 }
 

package/src/services/FileService.ts

@@ -3,14 +3,25 @@ import type{IFileRepository} from "../interfaces/IFileRepository.js";
 import type {IFileBase, IFile} from "../interfaces/IFile.js";
 import {AbstractService} from "@drax/crud-back";
 import type {ZodObject, ZodRawShape} from "zod";
+import {StoreManager} from "@drax/common-back";
 
 class FileService extends AbstractService<IFile, IFileBase, IFileBase> {
 
-
     constructor(FileRepository: IFileRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
         super(FileRepository, baseSchema, fullSchema);
 
         this._validateOutput = true
+        this.onDeleted = async (id: string, item?: IFile | null): Promise<void> => {
+            if (!item?.relativePath) {
+                return;
+            }
+
+            try {
+                await StoreManager.deleteFilepath(item.relativePath);
+            } catch (error) {
+                console.error(error);
+            }
+        }
 
     }
 

package/src/services/MediaService.ts

@@ -49,6 +49,38 @@ interface IMediaGetFileResult {
     absolutePath: string;
 }
 
+interface IMediaDeleteFileParams {
+    dir: string;
+    year: string;
+    month: string;
+    filename: string;
+    deleteMetadata?: boolean;
+}
+
+interface IMediaDeleteFileResult {
+    dir: string;
+    year: string;
+    month: string;
+    filename: string;
+    fileDir: string;
+    relativePath: string;
+    absolutePath: string;
+    deleted: boolean;
+    metadataDeleted: boolean;
+}
+
+interface IMediaDeleteFileByRelativePathParams {
+    relativePath: string;
+    deleteMetadata?: boolean;
+}
+
+interface IMediaDeleteFileByRelativePathResult {
+    relativePath: string;
+    absolutePath: string;
+    deleted: boolean;
+    metadataDeleted: boolean;
+}
+
 class MediaService {
     protected getBaseFileDir(): string {
         return DraxConfig.getOrLoad(CommonConfig.FileDir) || "files";
@@ -183,6 +215,83 @@ class MediaService {
             absolutePath,
         };
     }
+
+    async deleteFile(params: IMediaDeleteFileParams): Promise<IMediaDeleteFileResult> {
+        const {dir, year, month, filename, deleteMetadata = true} = params;
+
+        this.assertDir(dir);
+        this.assertYear(year);
+        this.assertMonth(month);
+
+        const fileDir = join(this.getBaseFileDir(), dir, year, month);
+        const relativePath = join(fileDir, filename);
+        const absolutePath = resolve(process.cwd(), relativePath);
+        let metadataDeleted = false;
+
+        if (deleteMetadata && this.isMetadataEnabled()) {
+            const file = await FileServiceFactory.instance.findOneBy("relativePath", relativePath);
+            if (file) {
+                await FileServiceFactory.instance.delete(file._id);
+                metadataDeleted = true;
+
+                return {
+                    dir,
+                    year,
+                    month,
+                    filename,
+                    fileDir,
+                    relativePath,
+                    absolutePath,
+                    deleted: true,
+                    metadataDeleted,
+                };
+            }
+        }
+
+        await StoreManager.deleteFilepath(relativePath);
+
+        return {
+            dir,
+            year,
+            month,
+            filename,
+            fileDir,
+            relativePath,
+            absolutePath,
+            deleted: true,
+            metadataDeleted,
+        };
+    }
+
+    async deleteFileByRelativePath(params: IMediaDeleteFileByRelativePathParams): Promise<IMediaDeleteFileByRelativePathResult> {
+        const {relativePath, deleteMetadata = true} = params;
+        const absolutePath = resolve(process.cwd(), relativePath);
+        let metadataDeleted = false;
+
+        if (deleteMetadata && this.isMetadataEnabled()) {
+            const file = await FileServiceFactory.instance.findOneBy("relativePath", relativePath);
+            if (file) {
+                await FileServiceFactory.instance.delete(file._id);
+                metadataDeleted = true;
+
+                return {
+                    relativePath,
+                    absolutePath,
+                    deleted: true,
+                    metadataDeleted,
+                };
+            }
+        }
+
+        await StoreManager.deleteFilepath(relativePath);
+
+        return {
+            relativePath,
+            absolutePath,
+            deleted: true,
+            metadataDeleted,
+        };
+    }
 }
 
 export default MediaService;
@@ -195,4 +304,8 @@ export type {
     IMediaSaveFileResult,
     IMediaGetFileParams,
     IMediaGetFileResult,
+    IMediaDeleteFileParams,
+    IMediaDeleteFileResult,
+    IMediaDeleteFileByRelativePathParams,
+    IMediaDeleteFileByRelativePathResult,
 };