@hemia/core 0.0.3 → 0.0.5

package/dist/hemia-core.esm.js

@@ -1,10 +1,12 @@
 import 'reflect-metadata';
 import express, { Router } from 'express';
-import { METADATA_KEYS, ParamType, isRedirectResponse, ApiResponse } from '@hemia/common';
+import { METADATA_KEYS, ParamType, ApiResponse, isRedirectResponse } from '@hemia/common';
 import { TRACE_METADATA_KEY } from '@hemia/trace-manager';
 import { traceMiddleware } from '@hemia/app-context';
 import { plainToInstance } from 'class-transformer';
-import { injectable } from 'inversify';
+import multer from 'multer';
+import { injectable, inject } from 'inversify';
+import { AUTH_SERVICE_ID, AuthService } from '@hemia/auth-sdk';
 
 class GuardsConsumer {
     /**
@@ -79,7 +81,7 @@ class ResponseSerializer {
  * @param container Instancia del Container de Inversify
  * @param controllerIdentifiers Array de Symbols (o Clases si usas self-binding)
  */
-async function registerRoutes(app, container, controllerIdentifiers, onTraceFinishCallback) {
+async function registerRoutes(app, container, controllerIdentifiers, onTraceFinishCallback, multerOptions) {
     for (const identifier of controllerIdentifiers) {
         const instance = await container.getAsync(identifier);
         const prototype = Object.getPrototypeOf(instance);
@@ -101,6 +103,14 @@ async function registerRoutes(app, container, controllerIdentifiers, onTraceFini
             // Leer metadata de headers y redirect
             const headersMetadata = Reflect.getMetadata(METADATA_KEYS.HEADERS, ControllerClass, route.methodName) || [];
             const redirectMetadata = Reflect.getMetadata(METADATA_KEYS.REDIRECT, ControllerClass, route.methodName);
+            const needsFile = paramsMetadata.some(p => p.type === ParamType.FILE);
+            const needsFiles = paramsMetadata.some(p => p.type === ParamType.FILES);
+            if (needsFiles) {
+                handlers.push(multer(multerOptions).array('files'));
+            }
+            else if (needsFile) {
+                handlers.push(multer(multerOptions).single('file'));
+            }
             const mainHandler = async (req, res, next) => {
                 try {
                     const args = [];
@@ -137,11 +147,59 @@ async function registerRoutes(app, container, controllerIdentifiers, onTraceFini
                                 case ParamType.SESSION:
                                     args[param.index] = req.session;
                                     break;
+                                case ParamType.COOKIES:
+                                    args[param.index] = param.data ? req.cookies?.[param.data] : req.cookies;
+                                    break;
+                                case ParamType.FILE:
+                                    args[param.index] = req.file;
+                                    break;
+                                case ParamType.FILES:
+                                    args[param.index] = req.files;
+                                    break;
+                                case ParamType.USER:
+                                    args[param.index] = req.user;
+                                    break;
+                                case ParamType.IP:
+                                    args[param.index] = req.ip;
+                                    break;
+                                case ParamType.LOCALE:
+                                    args[param.index] = req.acceptsLanguages()[0];
+                                    break;
+                                case ParamType.HOST:
+                                    args[param.index] = req.hostname;
+                                    break;
+                                case ParamType.PERMISSIONS:
+                                    args[param.index] = req.permissions;
+                                    break;
+                                case ParamType.CONTEXT:
+                                    args[param.index] = req.context;
+                                    break;
                                 default: args[param.index] = undefined;
                             }
                         });
                     }
+                    // CUSTOM PARAMETERS
+                    const customs = Reflect.getMetadata(METADATA_KEYS.CUSTOMS, instance, route.methodName) || [];
+                    for (const { index, key } of customs) {
+                        args[index] = req.customData?.[key];
+                    }
+                    // TRANSFORMACIÓN DE PARÁMETROS
+                    const transformers = Reflect.getMetadata(METADATA_KEYS.TRANSFORMERS, instance, route.methodName) || [];
+                    for (const { index, transformer } of transformers) {
+                        args[index] = transformer(args[index]);
+                    }
+                    // VALIDACIÓN DE PARÁMETROS
+                    const validators = Reflect.getMetadata(METADATA_KEYS.VALIDATORS, instance, route.methodName) || [];
+                    for (const { index, validator } of validators) {
+                        const value = args[index];
+                        const result = validator(value);
+                        if (result === false) {
+                            return res.status(400).json(ApiResponse.error('Validation failed', undefined, 400));
+                        }
+                    }
+                    // EJECUCIÓN DEL CONTROLLER
                     const result = await instance[route.methodName](...args);
+                    // SERIALIZACIÓN DE RESULTADO
                     const serializeDto = Reflect.getMetadata(METADATA_KEYS.SERIALIZE, methodHandler) || Reflect.getMetadata(METADATA_KEYS.SERIALIZE, ControllerClass);
                     let finalResult = result;
                     if (serializeDto) {
@@ -206,6 +264,10 @@ function __decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
 function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
@@ -259,8 +321,8 @@ class HemiaFactory {
      */
     static async create(container, controllers, options = {}) {
         const app = express();
-        app.use(express.json());
-        app.use(express.urlencoded({ extended: true }));
+        app.use(express.json(options.jsonOptions));
+        app.use(express.urlencoded({ extended: true, ...options.urlencodedOptions }));
         if (options.middlewares && Array.isArray(options.middlewares)) {
             options.middlewares.forEach(middleware => {
                 app.use(middleware);
@@ -291,7 +353,14 @@ class HemiaFactory {
                 container.bind(controllerClass).toSelf();
             }
         });
-        await registerRoutes(app, container, controllers, options.onTraceFinish || (() => { }));
+        await registerRoutes(app, container, controllers, options.onTraceFinish || (() => { }), options.multerOptions);
+        app.use((err, req, res, next) => {
+            console.error('[Hemia] Unhandled error:', err);
+            res.status(err.status || 500).json({
+                error: err.message || 'Internal Server Error',
+                details: err.details || undefined,
+            });
+        });
         if (options.logger !== false) {
             console.log(`[Hemia] Application initialized with ${controllers.length} controllers.`);
         }
@@ -299,6 +368,10 @@ class HemiaFactory {
     }
 }
 
+/**
+ * Guardia de autorización que verifica roles y permisos definidos en los controladores y métodos.
+ * Utiliza los metadatos definidos con los decoradores @Roles y @Permissions.
+ */
 let AuthGuard = class AuthGuard {
     constructor(reflector) {
         this.reflector = reflector;
@@ -315,17 +388,19 @@ let AuthGuard = class AuthGuard {
         }
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        if (!user || !user.roles) {
+        const permissions = request.permissions;
+        const contextData = request.context;
+        if (!user) {
             return false;
         }
         if (requiredRoles) {
-            const userRoleNames = user.roles.map((r) => r.name);
+            const userRoleNames = Array.isArray(contextData.roles) ? contextData.roles : [];
             const hasRole = requiredRoles.some((role) => userRoleNames.includes(role));
             if (!hasRole)
                 return false;
         }
         if (requiredPermissions) {
-            const userPermissions = user.roles.flatMap((r) => r.permissions || []);
+            const userPermissions = Array.isArray(permissions) ? permissions : [];
             const hasPermission = requiredPermissions.some((perm) => userPermissions.includes(perm));
             if (!hasPermission)
                 return false;
@@ -338,4 +413,66 @@ AuthGuard = __decorate([
     __metadata("design:paramtypes", [Reflector])
 ], AuthGuard);
 
-export { AuthGuard, GuardsConsumer, HemiaExecutionContext, HemiaFactory, Reflector, ResponseSerializer, registerRoutes };
+/**
+ * Guardia para validar la presencia y validez de una API Key en las solicitudes entrantes.
+ * La API Key se espera en el encabezado 'x-api-key' o como parámetro de consulta 'api_key'.
+ * Las claves válidas se configuran mediante la variable de entorno 'API_KEY' y pueden ser múltiples, separadas por comas.
+ */
+let ApiKeyGuard = class ApiKeyGuard {
+    constructor() {
+        this.validApiKeys = (process.env.API_KEY || "")
+            .split(",")
+            .map(key => key.trim())
+            .filter(key => !!key);
+    }
+    canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const apiKey = request.headers['x-api-key'] || request.query['api_key'];
+        if (!apiKey)
+            return false;
+        return this.validApiKeys.includes(apiKey);
+    }
+};
+ApiKeyGuard = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [])
+], ApiKeyGuard);
+
+/**
+ * Guardia para validar y procesar tokens JWT en las solicitudes entrantes.
+ * Extrae el token de sesión del encabezado 'x-session' o de las cookies,
+ * y utiliza el AuthService para validar el token y obtener los datos del usuario.
+ * Si el token es válido, adjunta la información del usuario, permisos y contexto a la solicitud.
+ */
+let JWTGuard = class JWTGuard {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const sessionId = request.headers['x-session'] || request.cookies['x-session'];
+        if (!sessionId) {
+            return false;
+        }
+        try {
+            const accessTokenData = await this.authService.getSessionAccess(sessionId);
+            if (!accessTokenData) {
+                return false;
+            }
+            request.user = accessTokenData.user;
+            request.permissions = accessTokenData.permissions;
+            request.context = accessTokenData.context;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+};
+JWTGuard = __decorate([
+    injectable(),
+    __param(0, inject(AUTH_SERVICE_ID)),
+    __metadata("design:paramtypes", [AuthService])
+], JWTGuard);
+
+export { ApiKeyGuard, AuthGuard, GuardsConsumer, HemiaExecutionContext, HemiaFactory, JWTGuard, Reflector, ResponseSerializer, registerRoutes };

package/dist/hemia-core.js

@@ -6,7 +6,9 @@ var common = require('@hemia/common');
 var traceManager = require('@hemia/trace-manager');
 var appContext = require('@hemia/app-context');
 var classTransformer = require('class-transformer');
+var multer = require('multer');
 var inversify = require('inversify');
+var authSdk = require('@hemia/auth-sdk');
 
 class GuardsConsumer {
     /**
@@ -81,7 +83,7 @@ class ResponseSerializer {
  * @param container Instancia del Container de Inversify
  * @param controllerIdentifiers Array de Symbols (o Clases si usas self-binding)
  */
-async function registerRoutes(app, container, controllerIdentifiers, onTraceFinishCallback) {
+async function registerRoutes(app, container, controllerIdentifiers, onTraceFinishCallback, multerOptions) {
     for (const identifier of controllerIdentifiers) {
         const instance = await container.getAsync(identifier);
         const prototype = Object.getPrototypeOf(instance);
@@ -103,6 +105,14 @@ async function registerRoutes(app, container, controllerIdentifiers, onTraceFini
             // Leer metadata de headers y redirect
             const headersMetadata = Reflect.getMetadata(common.METADATA_KEYS.HEADERS, ControllerClass, route.methodName) || [];
             const redirectMetadata = Reflect.getMetadata(common.METADATA_KEYS.REDIRECT, ControllerClass, route.methodName);
+            const needsFile = paramsMetadata.some(p => p.type === common.ParamType.FILE);
+            const needsFiles = paramsMetadata.some(p => p.type === common.ParamType.FILES);
+            if (needsFiles) {
+                handlers.push(multer(multerOptions).array('files'));
+            }
+            else if (needsFile) {
+                handlers.push(multer(multerOptions).single('file'));
+            }
             const mainHandler = async (req, res, next) => {
                 try {
                     const args = [];
@@ -139,11 +149,59 @@ async function registerRoutes(app, container, controllerIdentifiers, onTraceFini
                                 case common.ParamType.SESSION:
                                     args[param.index] = req.session;
                                     break;
+                                case common.ParamType.COOKIES:
+                                    args[param.index] = param.data ? req.cookies?.[param.data] : req.cookies;
+                                    break;
+                                case common.ParamType.FILE:
+                                    args[param.index] = req.file;
+                                    break;
+                                case common.ParamType.FILES:
+                                    args[param.index] = req.files;
+                                    break;
+                                case common.ParamType.USER:
+                                    args[param.index] = req.user;
+                                    break;
+                                case common.ParamType.IP:
+                                    args[param.index] = req.ip;
+                                    break;
+                                case common.ParamType.LOCALE:
+                                    args[param.index] = req.acceptsLanguages()[0];
+                                    break;
+                                case common.ParamType.HOST:
+                                    args[param.index] = req.hostname;
+                                    break;
+                                case common.ParamType.PERMISSIONS:
+                                    args[param.index] = req.permissions;
+                                    break;
+                                case common.ParamType.CONTEXT:
+                                    args[param.index] = req.context;
+                                    break;
                                 default: args[param.index] = undefined;
                             }
                         });
                     }
+                    // CUSTOM PARAMETERS
+                    const customs = Reflect.getMetadata(common.METADATA_KEYS.CUSTOMS, instance, route.methodName) || [];
+                    for (const { index, key } of customs) {
+                        args[index] = req.customData?.[key];
+                    }
+                    // TRANSFORMACIÓN DE PARÁMETROS
+                    const transformers = Reflect.getMetadata(common.METADATA_KEYS.TRANSFORMERS, instance, route.methodName) || [];
+                    for (const { index, transformer } of transformers) {
+                        args[index] = transformer(args[index]);
+                    }
+                    // VALIDACIÓN DE PARÁMETROS
+                    const validators = Reflect.getMetadata(common.METADATA_KEYS.VALIDATORS, instance, route.methodName) || [];
+                    for (const { index, validator } of validators) {
+                        const value = args[index];
+                        const result = validator(value);
+                        if (result === false) {
+                            return res.status(400).json(common.ApiResponse.error('Validation failed', undefined, 400));
+                        }
+                    }
+                    // EJECUCIÓN DEL CONTROLLER
                     const result = await instance[route.methodName](...args);
+                    // SERIALIZACIÓN DE RESULTADO
                     const serializeDto = Reflect.getMetadata(common.METADATA_KEYS.SERIALIZE, methodHandler) || Reflect.getMetadata(common.METADATA_KEYS.SERIALIZE, ControllerClass);
                     let finalResult = result;
                     if (serializeDto) {
@@ -208,6 +266,10 @@ function __decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
 function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
@@ -261,8 +323,8 @@ class HemiaFactory {
      */
     static async create(container, controllers, options = {}) {
         const app = express();
-        app.use(express.json());
-        app.use(express.urlencoded({ extended: true }));
+        app.use(express.json(options.jsonOptions));
+        app.use(express.urlencoded({ extended: true, ...options.urlencodedOptions }));
         if (options.middlewares && Array.isArray(options.middlewares)) {
             options.middlewares.forEach(middleware => {
                 app.use(middleware);
@@ -293,7 +355,14 @@ class HemiaFactory {
                 container.bind(controllerClass).toSelf();
             }
         });
-        await registerRoutes(app, container, controllers, options.onTraceFinish || (() => { }));
+        await registerRoutes(app, container, controllers, options.onTraceFinish || (() => { }), options.multerOptions);
+        app.use((err, req, res, next) => {
+            console.error('[Hemia] Unhandled error:', err);
+            res.status(err.status || 500).json({
+                error: err.message || 'Internal Server Error',
+                details: err.details || undefined,
+            });
+        });
         if (options.logger !== false) {
             console.log(`[Hemia] Application initialized with ${controllers.length} controllers.`);
         }
@@ -301,6 +370,10 @@ class HemiaFactory {
     }
 }
 
+/**
+ * Guardia de autorización que verifica roles y permisos definidos en los controladores y métodos.
+ * Utiliza los metadatos definidos con los decoradores @Roles y @Permissions.
+ */
 exports.AuthGuard = class AuthGuard {
     constructor(reflector) {
         this.reflector = reflector;
@@ -317,17 +390,19 @@ exports.AuthGuard = class AuthGuard {
         }
         const request = context.switchToHttp().getRequest();
         const user = request.user;
-        if (!user || !user.roles) {
+        const permissions = request.permissions;
+        const contextData = request.context;
+        if (!user) {
             return false;
         }
         if (requiredRoles) {
-            const userRoleNames = user.roles.map((r) => r.name);
+            const userRoleNames = Array.isArray(contextData.roles) ? contextData.roles : [];
             const hasRole = requiredRoles.some((role) => userRoleNames.includes(role));
             if (!hasRole)
                 return false;
         }
         if (requiredPermissions) {
-            const userPermissions = user.roles.flatMap((r) => r.permissions || []);
+            const userPermissions = Array.isArray(permissions) ? permissions : [];
             const hasPermission = requiredPermissions.some((perm) => userPermissions.includes(perm));
             if (!hasPermission)
                 return false;
@@ -340,6 +415,68 @@ exports.AuthGuard = __decorate([
     __metadata("design:paramtypes", [exports.Reflector])
 ], exports.AuthGuard);
 
+/**
+ * Guardia para validar la presencia y validez de una API Key en las solicitudes entrantes.
+ * La API Key se espera en el encabezado 'x-api-key' o como parámetro de consulta 'api_key'.
+ * Las claves válidas se configuran mediante la variable de entorno 'API_KEY' y pueden ser múltiples, separadas por comas.
+ */
+exports.ApiKeyGuard = class ApiKeyGuard {
+    constructor() {
+        this.validApiKeys = (process.env.API_KEY || "")
+            .split(",")
+            .map(key => key.trim())
+            .filter(key => !!key);
+    }
+    canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const apiKey = request.headers['x-api-key'] || request.query['api_key'];
+        if (!apiKey)
+            return false;
+        return this.validApiKeys.includes(apiKey);
+    }
+};
+exports.ApiKeyGuard = __decorate([
+    inversify.injectable(),
+    __metadata("design:paramtypes", [])
+], exports.ApiKeyGuard);
+
+/**
+ * Guardia para validar y procesar tokens JWT en las solicitudes entrantes.
+ * Extrae el token de sesión del encabezado 'x-session' o de las cookies,
+ * y utiliza el AuthService para validar el token y obtener los datos del usuario.
+ * Si el token es válido, adjunta la información del usuario, permisos y contexto a la solicitud.
+ */
+exports.JWTGuard = class JWTGuard {
+    constructor(authService) {
+        this.authService = authService;
+    }
+    async canActivate(context) {
+        const request = context.switchToHttp().getRequest();
+        const sessionId = request.headers['x-session'] || request.cookies['x-session'];
+        if (!sessionId) {
+            return false;
+        }
+        try {
+            const accessTokenData = await this.authService.getSessionAccess(sessionId);
+            if (!accessTokenData) {
+                return false;
+            }
+            request.user = accessTokenData.user;
+            request.permissions = accessTokenData.permissions;
+            request.context = accessTokenData.context;
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+};
+exports.JWTGuard = __decorate([
+    inversify.injectable(),
+    __param(0, inversify.inject(authSdk.AUTH_SERVICE_ID)),
+    __metadata("design:paramtypes", [authSdk.AuthService])
+], exports.JWTGuard);
+
 exports.GuardsConsumer = GuardsConsumer;
 exports.HemiaExecutionContext = HemiaExecutionContext;
 exports.HemiaFactory = HemiaFactory;

package/dist/types/guards/api-key.guard.d.ts

@@ -0,0 +1,11 @@
+import { CanActivate, ExecutionContext } from "@hemia/common";
+/**
+ * Guardia para validar la presencia y validez de una API Key en las solicitudes entrantes.
+ * La API Key se espera en el encabezado 'x-api-key' o como parámetro de consulta 'api_key'.
+ * Las claves válidas se configuran mediante la variable de entorno 'API_KEY' y pueden ser múltiples, separadas por comas.
+ */
+export declare class ApiKeyGuard implements CanActivate {
+    private readonly validApiKeys;
+    constructor();
+    canActivate(context: ExecutionContext): boolean;
+}

package/dist/types/guards/auth.guard.d.ts

@@ -1,5 +1,9 @@
 import { CanActivate, ExecutionContext } from '@hemia/common';
 import { Reflector } from '../services';
+/**
+ * Guardia de autorización que verifica roles y permisos definidos en los controladores y métodos.
+ * Utiliza los metadatos definidos con los decoradores @Roles y @Permissions.
+ */
 export declare class AuthGuard implements CanActivate {
     private reflector;
     constructor(reflector: Reflector);

package/dist/types/guards/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./auth.guard";
 export * from "./guards-consumer";
+export * from "./api-key.guard";
+export * from "./jwt.guard";

package/dist/types/guards/jwt.guard.d.ts

@@ -0,0 +1,13 @@
+import { CanActivate, ExecutionContext } from "@hemia/common";
+import { AuthService } from "@hemia/auth-sdk";
+/**
+ * Guardia para validar y procesar tokens JWT en las solicitudes entrantes.
+ * Extrae el token de sesión del encabezado 'x-session' o de las cookies,
+ * y utiliza el AuthService para validar el token y obtener los datos del usuario.
+ * Si el token es válido, adjunta la información del usuario, permisos y contexto a la solicitud.
+ */
+export declare class JWTGuard implements CanActivate {
+    private readonly authService;
+    constructor(authService: AuthService);
+    canActivate(context: ExecutionContext): Promise<boolean>;
+}

package/dist/types/hemia-factory.d.ts

@@ -7,6 +7,9 @@ export interface HemiaFactoryOptions {
     logger?: boolean;
     corsHeaders?: Record<string, string>;
     middlewares?: any[];
+    multerOptions?: any;
+    jsonOptions?: any;
+    urlencodedOptions?: any;
 }
 export declare class HemiaFactory {
     /**

package/dist/types/router/routes-registry.d.ts

@@ -7,4 +7,4 @@ export type TraceFinishCallback = (payloads: any, context: any, res: Response) =
  * @param container Instancia del Container de Inversify
  * @param controllerIdentifiers Array de Symbols (o Clases si usas self-binding)
  */
-export declare function registerRoutes(app: Express, container: Container, controllerIdentifiers: any[], onTraceFinishCallback: TraceFinishCallback): Promise<void>;
+export declare function registerRoutes(app: Express, container: Container, controllerIdentifiers: any[], onTraceFinishCallback: TraceFinishCallback, multerOptions?: any): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hemia/core",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Core utilities for Hemia projects",
   "main": "dist/hemia-core.js",
   "module": "dist/hemia-core.esm.js",
@@ -17,15 +17,17 @@
     "@rollup/plugin-commonjs": "^26.0.1",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^15.2.3",
-    "@hemia/common": "^0.0.4",
+    "@hemia/common": "^0.0.7",
     "@hemia/app-context": "^0.0.6",
     "@hemia/trace-manager": "^0.0.9",
+    "@hemia/auth-sdk": "^0.0.9",
     "@types/express": "^5.0.5",
     "express": "^5.1.0",
     "inversify": "^7.10.4",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.3.0",
     "@typescript-eslint/eslint-plugin": "^8.5.0",
+    "@types/multer": "^2.0.0",
     "class-transformer": "^0.5.1",
     "events": "^3.3.0",
     "jest": "^29.7.0",
@@ -34,7 +36,8 @@
     "rollup-plugin-typescript2": "^0.36.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^8.9.0",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "multer": "^2.0.2"
   },
   "author": "",
   "license": "ISC",
@@ -45,6 +48,10 @@
     "class-transformer": "^0.5.1",
     "express": "^5.0.0",
     "inversify": "^7.0.0",
-    "reflect-metadata": "^0.1.13"
+    "reflect-metadata": "^0.2.2",
+    "multer": "^2.0.0"
+  },
+  "dependencies": {
+   
   }
 }