@drax/media-back 3.10.0 → 3.12.0

package/dist/controllers/MediaController.js

@@ -1,20 +1,10 @@
-import { CommonController, StoreManager, DraxConfig, CommonConfig, } from "@drax/common-back";
-import { join } from "path";
+import { CommonController, } from "@drax/common-back";
 import { MediaPermissions } from "../permissions/MediaPermissions.js";
-import { FileServiceFactory } from "../factory/services/FileServiceFactory.js";
-import path from 'node:path';
-const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
-const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : '';
+import { MediaService } from "../services/MediaService.js";
 class MediaController extends CommonController {
     constructor() {
         super();
-    }
-    validateDir(dir) {
-        let dirRegExp = /^[a-zA-Z0-9_-]+$/;
-        if (!dir || dirRegExp.test(dir) === false) {
-            return false;
-        }
-        return true;
+        this.mediaService = new MediaService();
     }
     async uploadFile(request, reply) {
         try {
@@ -24,56 +14,23 @@ class MediaController extends CommonController {
                 username: request.rbac.username,
             };
             const dir = request.params.dir;
-            if (!this.validateDir(dir)) {
-                reply.statusCode = 400;
-                reply.send({ error: 'Invalid directory name' });
-                return;
-            }
             const data = await request.file();
-            const file = {
-                filename: data.filename,
-                fileStream: data.file,
-                mimetype: data.mimetype
-            };
-            const year = (new Date().getFullYear()).toString();
-            const month = (new Date().getMonth() + 1).toString().padStart(2, '0');
-            const destinationPath = join(BASE_FILE_DIR, dir, year, month);
-            const storedFile = await StoreManager.saveFile(file, destinationPath);
-            const urlFile = `${BASE_URL}/api/file/${dir}/${year}/${month}/${storedFile.filename}`;
-            const relativePath = storedFile.path;
-            const absolutePath = path.resolve(process.cwd(), relativePath);
-            const extension = StoreManager.getExtension(storedFile.filename);
-            const fileService = FileServiceFactory.instance;
-            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true;
-            if (FILE_METADATA === true) {
-                try {
-                    await fileService.registerUploadedFile({
-                        filename: storedFile.filename,
-                        relativePath: relativePath,
-                        absolutePath: absolutePath,
-                        size: storedFile.size,
-                        mimetype: storedFile.mimetype || data.mimetype,
-                        encoding: storedFile.encoding || data.encoding || '',
-                        extension,
-                        type: storedFile.mimetype?.split('/')[0] || '',
-                        lastAccess: new Date(),
-                        ttlSeconds: 0,
-                        hits: 0,
-                        url: urlFile,
-                        createdBy,
-                    });
-                }
-                catch (e) {
-                    await StoreManager.deleteFile(destinationPath, storedFile.filename).catch(() => undefined);
-                    throw e;
-                }
-            }
+            const storedFile = await this.mediaService.saveFile({
+                dir,
+                file: {
+                    filename: data.filename,
+                    fileStream: data.file,
+                    mimetype: data.mimetype,
+                    encoding: data.encoding,
+                },
+                createdBy,
+            });
             let theFile = {
                 filename: storedFile.filename,
-                filepath: storedFile.path,
+                filepath: storedFile.relativePath,
                 size: storedFile.size,
                 mimetype: storedFile.mimetype,
-                url: urlFile,
+                url: storedFile.url,
             };
             return theFile;
         }
@@ -87,31 +44,8 @@ class MediaController extends CommonController {
             const year = request.params.year;
             const month = request.params.month;
             const filename = request.params.filename;
-            //console.log("dir: ", dir, " year: ", year, " month: ", month, " filename: ", filename)
-            if (this.validateDir(dir) == false) {
-                reply.statusCode = 400;
-                reply.send({ error: 'Invalid directory name' });
-                return;
-            }
-            if (/[0-9]{4}/.test(year) == false) {
-                reply.statusCode = 400;
-                reply.send({ error: 'Invalid year' });
-                return;
-            }
-            if (/[0-9]{2}/.test(month) == false) {
-                reply.statusCode = 400;
-                reply.send({ error: 'Invalid month' });
-                return;
-            }
-            const fileDir = join(BASE_FILE_DIR, dir, year, month);
-            //console.log("FILE_DIR: ", fileDir, " FILENAME:", filename)
-            //Agregar hit al archivo
-            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true;
-            if (FILE_METADATA === true) {
-                const fileService = FileServiceFactory.instance;
-                await fileService.registerDownloadHit(join(fileDir, filename));
-            }
-            return reply.sendFile(filename, fileDir);
+            const file = await this.mediaService.getFile({ dir, year, month, filename });
+            return reply.sendFile(file.filename, file.fileDir);
         }
         catch (e) {
             this.handleError(e, reply);

package/dist/index.js

@@ -7,6 +7,7 @@ import FileModel from "./models/FileModel.js";
 import FileMongoRepository from "./repository/mongo/FileMongoRepository.js";
 import FileSqliteRepository from "./repository/sqlite/FileSqliteRepository.js";
 import FileService from "./services/FileService.js";
+import MediaService from "./services/MediaService.js";
 import FileServiceFactory from "./factory/services/FileServiceFactory.js";
 import FileController from "./controllers/FileController.js";
 export { 
@@ -15,4 +16,4 @@ MediaRoutes, FileRoutes,
 //Permissions
 MediaPermissions, FilePermissions, 
 //File
-FileSchema, FileModel, FileMongoRepository, FileSqliteRepository, FileService, FileServiceFactory, FileController };
+FileSchema, FileModel, FileMongoRepository, FileSqliteRepository, FileService, MediaService, FileServiceFactory, FileController };

package/dist/services/MediaService.js

@@ -0,0 +1,123 @@
+import { BadRequestError, CommonConfig, DraxConfig, NotFoundError, StoreManager, } from "@drax/common-back";
+import { join, resolve } from "node:path";
+import { access } from "node:fs/promises";
+import { FileServiceFactory } from "../factory/services/FileServiceFactory.js";
+class MediaService {
+    getBaseFileDir() {
+        return DraxConfig.getOrLoad(CommonConfig.FileDir) || "files";
+    }
+    getBaseUrl() {
+        return DraxConfig.getOrLoad(CommonConfig.BaseUrl)
+            ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, "")
+            : "";
+    }
+    validateDir(dir) {
+        const dirRegExp = /^[a-zA-Z0-9_-]+$/;
+        return !!dir && dirRegExp.test(dir);
+    }
+    validateYear(year) {
+        return /^[0-9]{4}$/.test(year);
+    }
+    validateMonth(month) {
+        return /^[0-9]{2}$/.test(month);
+    }
+    assertDir(dir) {
+        if (!this.validateDir(dir)) {
+            throw new BadRequestError("Invalid directory name");
+        }
+    }
+    assertYear(year) {
+        if (!this.validateYear(year)) {
+            throw new BadRequestError("Invalid year");
+        }
+    }
+    assertMonth(month) {
+        if (!this.validateMonth(month)) {
+            throw new BadRequestError("Invalid month");
+        }
+    }
+    isMetadataEnabled() {
+        return process.env.DRAX_FILE_METADATA
+            ? /true|yes|enable/i.test(process.env.DRAX_FILE_METADATA)
+            : true;
+    }
+    buildDatePathParts(date) {
+        return {
+            year: date.getFullYear().toString(),
+            month: (date.getMonth() + 1).toString().padStart(2, "0"),
+        };
+    }
+    async saveFile(params) {
+        const { dir, file, createdBy, date = new Date() } = params;
+        this.assertDir(dir);
+        const { year, month } = this.buildDatePathParts(date);
+        const fileDir = join(this.getBaseFileDir(), dir, year, month);
+        const storedFile = await StoreManager.saveFile(file, fileDir);
+        const relativePath = storedFile.path;
+        const absolutePath = resolve(process.cwd(), relativePath);
+        const extension = StoreManager.getExtension(storedFile.filename);
+        const url = `${this.getBaseUrl()}/api/file/${dir}/${year}/${month}/${storedFile.filename}`;
+        const type = storedFile.mimetype?.split("/")[0] || "";
+        if (this.isMetadataEnabled()) {
+            try {
+                await FileServiceFactory.instance.registerUploadedFile({
+                    filename: storedFile.filename,
+                    relativePath,
+                    absolutePath,
+                    size: storedFile.size,
+                    mimetype: storedFile.mimetype || file.mimetype,
+                    encoding: storedFile.encoding || file.encoding || "",
+                    extension,
+                    type,
+                    lastAccess: new Date(),
+                    ttlSeconds: 0,
+                    hits: 0,
+                    url,
+                    createdBy,
+                });
+            }
+            catch (e) {
+                await StoreManager.deleteFile(fileDir, storedFile.filename).catch(() => undefined);
+                throw e;
+            }
+        }
+        return {
+            ...storedFile,
+            fileDir,
+            relativePath,
+            absolutePath,
+            extension,
+            type,
+            url,
+        };
+    }
+    async getFile(params) {
+        const { dir, year, month, filename, registerHit = 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);
+        try {
+            await access(absolutePath);
+        }
+        catch {
+            throw new NotFoundError("File not found");
+        }
+        if (registerHit && this.isMetadataEnabled()) {
+            await FileServiceFactory.instance.registerDownloadHit(relativePath);
+        }
+        return {
+            dir,
+            year,
+            month,
+            filename,
+            fileDir,
+            relativePath,
+            absolutePath,
+        };
+    }
+}
+export default MediaService;
+export { MediaService, };

package/env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_HTTP_TRANSPORT: string
+  // Add other env variables here
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "3.10.0",
+  "version": "3.12.0",
   "description": "Media files",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -21,7 +21,7 @@
   "license": "ISC",
   "dependencies": {
     "@drax/common-back": "^3.10.0",
-    "@drax/identity-back": "^3.10.0"
+    "@drax/identity-back": "^3.12.0"
   },
   "peerDependencies": {
     "@fastify/multipart": "^9.0.3",
@@ -39,5 +39,5 @@
     "tsc-alias": "^1.8.10",
     "typescript": "^5.4.5"
   },
-  "gitHead": "063b6aba11e891c5374c2d3de6546a3ff120b4c9"
+  "gitHead": "5395a022d01165f5c4cd11adbae6ed8b5d8b670a"
 }

package/src/controllers/MediaController.ts

@@ -1,28 +1,15 @@
 import {
     CommonController,
-    StoreManager,
-    DraxConfig,
-    CommonConfig,
 } from "@drax/common-back";
-import {join} from "path";
 import {MediaPermissions} from "../permissions/MediaPermissions.js";
-import {FileServiceFactory} from "../factory/services/FileServiceFactory.js";
-import path from 'node:path';
-const BASE_FILE_DIR = DraxConfig.getOrLoad(CommonConfig.FileDir) || 'files';
-const BASE_URL = DraxConfig.getOrLoad(CommonConfig.BaseUrl) ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, '') : ''
+import {MediaService} from "../services/MediaService.js";
 
 class MediaController extends CommonController {
+    protected mediaService: MediaService;
 
     constructor() {
         super()
-    }
-
-    validateDir(dir: string) {
-        let dirRegExp = /^[a-zA-Z0-9_-]+$/
-        if (!dir || dirRegExp.test(dir) === false) {
-            return false
-        }
-        return true
+        this.mediaService = new MediaService()
     }
 
     async uploadFile(request: any, reply: any) {
@@ -35,61 +22,24 @@ class MediaController extends CommonController {
             }
 
             const dir = request.params.dir
-            if (!this.validateDir(dir)) {
-                reply.statusCode = 400
-                reply.send({error: 'Invalid directory name'})
-                return
-            }
-
             const data = await request.file()
-            const file = {
-                filename: data.filename,
-                fileStream: data.file,
-                mimetype: data.mimetype
-            }
-
-            const year = (new Date().getFullYear()).toString()
-            const month = (new Date().getMonth() + 1).toString().padStart(2, '0')
-            const destinationPath = join(BASE_FILE_DIR, dir, year, month)
-
-            const storedFile = await StoreManager.saveFile(file, destinationPath)
-            const urlFile = `${BASE_URL}/api/file/${dir}/${year}/${month}/${storedFile.filename}`
-            const relativePath = storedFile.path
-            const absolutePath = path.resolve(process.cwd(), relativePath);
-            const extension = StoreManager.getExtension(storedFile.filename)
-            const fileService = FileServiceFactory.instance
-
-
-            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true
-            if (FILE_METADATA === true) {
-                try {
-                    await fileService.registerUploadedFile({
-                        filename: storedFile.filename,
-                        relativePath: relativePath,
-                        absolutePath: absolutePath,
-                        size: storedFile.size,
-                        mimetype: storedFile.mimetype || data.mimetype,
-                        encoding: storedFile.encoding || data.encoding || '',
-                        extension,
-                        type: storedFile.mimetype?.split('/')[0] || '',
-                        lastAccess: new Date(),
-                        ttlSeconds: 0,
-                        hits: 0,
-                        url: urlFile,
-                        createdBy,
-                    })
-                } catch (e) {
-                    await StoreManager.deleteFile(destinationPath, storedFile.filename).catch(() => undefined)
-                    throw e
-                }
-            }
+            const storedFile = await this.mediaService.saveFile({
+                dir,
+                file: {
+                    filename: data.filename,
+                    fileStream: data.file,
+                    mimetype: data.mimetype,
+                    encoding: data.encoding,
+                },
+                createdBy,
+            })
 
             let theFile = {
                 filename: storedFile.filename,
-                filepath: storedFile.path,
+                filepath: storedFile.relativePath,
                 size: storedFile.size,
                 mimetype: storedFile.mimetype,
-                url: urlFile,
+                url: storedFile.url,
             }
 
             return theFile
@@ -106,38 +56,8 @@ class MediaController extends CommonController {
             const year = request.params.year
             const month = request.params.month
             const filename = request.params.filename
-
-            //console.log("dir: ", dir, " year: ", year, " month: ", month, " filename: ", filename)
-
-            if (this.validateDir(dir) == false) {
-                reply.statusCode = 400
-                reply.send({error: 'Invalid directory name'})
-                return
-            }
-
-            if (/[0-9]{4}/.test(year) == false) {
-                reply.statusCode = 400
-                reply.send({error: 'Invalid year'})
-                return
-            }
-
-            if (/[0-9]{2}/.test(month) == false) {
-                reply.statusCode = 400
-                reply.send({error: 'Invalid month'})
-                return
-            }
-
-            const fileDir = join(BASE_FILE_DIR, dir, year, month)
-            //console.log("FILE_DIR: ", fileDir, " FILENAME:", filename)
-
-            //Agregar hit al archivo
-            const FILE_METADATA = process.env.DRAX_FILE_METADATA ? (/true|yes|enable/i).test(process.env.DRAX_FILE_METADATA) : true
-            if (FILE_METADATA === true) {
-                const fileService = FileServiceFactory.instance
-                await fileService.registerDownloadHit(join(fileDir, filename))
-            }
-
-            return reply.sendFile(filename, fileDir)
+            const file = await this.mediaService.getFile({dir, year, month, filename})
+            return reply.sendFile(file.filename, file.fileDir)
         } catch (e) {
             this.handleError(e, reply)
         }

package/src/index.ts

@@ -7,15 +7,28 @@ import FileModel from "./models/FileModel.js";
 import FileMongoRepository from "./repository/mongo/FileMongoRepository.js";
 import FileSqliteRepository from "./repository/sqlite/FileSqliteRepository.js";
 import FileService from "./services/FileService.js";
+import MediaService from "./services/MediaService.js";
 import FileServiceFactory from "./factory/services/FileServiceFactory.js";
 import FileController from "./controllers/FileController.js";
 import type { IFile, IFileBase } from "./interfaces/IFile";
 import type { IFileRepository } from "./interfaces/IFileRepository";
+import type {
+    IMediaCreatedBy,
+    IMediaSaveFileParams,
+    IMediaSaveFileResult,
+    IMediaGetFileParams,
+    IMediaGetFileResult,
+} from "./services/MediaService.js";
 
 export type {
     IFile,
     IFileBase,
-    IFileRepository
+    IFileRepository,
+    IMediaCreatedBy,
+    IMediaSaveFileParams,
+    IMediaSaveFileResult,
+    IMediaGetFileParams,
+    IMediaGetFileResult,
 }
 
 export {
@@ -33,6 +46,7 @@ export {
     FileMongoRepository,
     FileSqliteRepository,
     FileService,
+    MediaService,
     FileServiceFactory,
     FileController
 }

package/src/services/MediaService.ts

@@ -0,0 +1,198 @@
+import {
+    BadRequestError,
+    CommonConfig,
+    DraxConfig,
+    NotFoundError,
+    StoreManager,
+} from "@drax/common-back";
+import type {IUploadFile, IUploadFileResult} from "@drax/common-back";
+import {join, resolve} from "node:path";
+import {access} from "node:fs/promises";
+import {FileServiceFactory} from "../factory/services/FileServiceFactory.js";
+
+interface IMediaCreatedBy {
+    id: string;
+    username: string;
+}
+
+interface IMediaSaveFileParams {
+    dir: string;
+    file: IUploadFile;
+    createdBy?: IMediaCreatedBy;
+    date?: Date;
+}
+
+interface IMediaSaveFileResult extends IUploadFileResult {
+    fileDir: string;
+    relativePath: string;
+    absolutePath: string;
+    extension: string;
+    type: string;
+    url: string;
+}
+
+interface IMediaGetFileParams {
+    dir: string;
+    year: string;
+    month: string;
+    filename: string;
+    registerHit?: boolean;
+}
+
+interface IMediaGetFileResult {
+    dir: string;
+    year: string;
+    month: string;
+    filename: string;
+    fileDir: string;
+    relativePath: string;
+    absolutePath: string;
+}
+
+class MediaService {
+    protected getBaseFileDir(): string {
+        return DraxConfig.getOrLoad(CommonConfig.FileDir) || "files";
+    }
+
+    protected getBaseUrl(): string {
+        return DraxConfig.getOrLoad(CommonConfig.BaseUrl)
+            ? DraxConfig.get(CommonConfig.BaseUrl).replace(/\/$/, "")
+            : "";
+    }
+
+    validateDir(dir: string): boolean {
+        const dirRegExp = /^[a-zA-Z0-9_-]+$/;
+        return !!dir && dirRegExp.test(dir);
+    }
+
+    validateYear(year: string): boolean {
+        return /^[0-9]{4}$/.test(year);
+    }
+
+    validateMonth(month: string): boolean {
+        return /^[0-9]{2}$/.test(month);
+    }
+
+    protected assertDir(dir: string): void {
+        if (!this.validateDir(dir)) {
+            throw new BadRequestError("Invalid directory name");
+        }
+    }
+
+    protected assertYear(year: string): void {
+        if (!this.validateYear(year)) {
+            throw new BadRequestError("Invalid year");
+        }
+    }
+
+    protected assertMonth(month: string): void {
+        if (!this.validateMonth(month)) {
+            throw new BadRequestError("Invalid month");
+        }
+    }
+
+    protected isMetadataEnabled(): boolean {
+        return process.env.DRAX_FILE_METADATA
+            ? /true|yes|enable/i.test(process.env.DRAX_FILE_METADATA)
+            : true;
+    }
+
+    protected buildDatePathParts(date: Date): {year: string; month: string} {
+        return {
+            year: date.getFullYear().toString(),
+            month: (date.getMonth() + 1).toString().padStart(2, "0"),
+        };
+    }
+
+    async saveFile(params: IMediaSaveFileParams): Promise<IMediaSaveFileResult> {
+        const {dir, file, createdBy, date = new Date()} = params;
+
+        this.assertDir(dir);
+
+        const {year, month} = this.buildDatePathParts(date);
+        const fileDir = join(this.getBaseFileDir(), dir, year, month);
+        const storedFile = await StoreManager.saveFile(file, fileDir);
+        const relativePath = storedFile.path;
+        const absolutePath = resolve(process.cwd(), relativePath);
+        const extension = StoreManager.getExtension(storedFile.filename);
+        const url = `${this.getBaseUrl()}/api/file/${dir}/${year}/${month}/${storedFile.filename}`;
+        const type = storedFile.mimetype?.split("/")[0] || "";
+
+        if (this.isMetadataEnabled()) {
+            try {
+                await FileServiceFactory.instance.registerUploadedFile({
+                    filename: storedFile.filename,
+                    relativePath,
+                    absolutePath,
+                    size: storedFile.size,
+                    mimetype: storedFile.mimetype || file.mimetype,
+                    encoding: storedFile.encoding || file.encoding || "",
+                    extension,
+                    type,
+                    lastAccess: new Date(),
+                    ttlSeconds: 0,
+                    hits: 0,
+                    url,
+                    createdBy,
+                });
+            } catch (e) {
+                await StoreManager.deleteFile(fileDir, storedFile.filename).catch(() => undefined);
+                throw e;
+            }
+        }
+
+        return {
+            ...storedFile,
+            fileDir,
+            relativePath,
+            absolutePath,
+            extension,
+            type,
+            url,
+        };
+    }
+
+    async getFile(params: IMediaGetFileParams): Promise<IMediaGetFileResult> {
+        const {dir, year, month, filename, registerHit = 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);
+
+        try {
+            await access(absolutePath);
+        } catch {
+            throw new NotFoundError("File not found");
+        }
+
+        if (registerHit && this.isMetadataEnabled()) {
+            await FileServiceFactory.instance.registerDownloadHit(relativePath);
+        }
+
+        return {
+            dir,
+            year,
+            month,
+            filename,
+            fileDir,
+            relativePath,
+            absolutePath,
+        };
+    }
+}
+
+export default MediaService;
+export {
+    MediaService,
+};
+export type {
+    IMediaCreatedBy,
+    IMediaSaveFileParams,
+    IMediaSaveFileResult,
+    IMediaGetFileParams,
+    IMediaGetFileResult,
+};