electron-injector 1.0.3 → 1.1.1

package/README.md

@@ -27,7 +27,7 @@ Nace de la necesidad de crear aplicaciones de escritorio multiplataforma donde n
 
 ## 📦 Instalación
 ```bash
-npm install electron-injector rxjs
+npm install electron-injector rxjs class-validator class-transformer
 ```
 
 > **Nota:**  
@@ -48,34 +48,39 @@ import { Application } from 'electron-injector';
 import { UserController } from './controllers/user.controller';
 import { AuthGuard } from './guards/auth.guard';
 import { UserService } from './services/user.service';
+import { DtoFilter } from './filters/dto.filter';
 
-async function bootstrap() {
-  const electronApp = new Application({
-    providers: [
-      UserService,
-      AuthGuard,
-    ],
-    controllers: [
-      UserController,
-    ],
-  });
-
-  await app.whenReady();
-  
+function createWindow() {
   const mainWindow = new BrowserWindow({
-    width: 800,
-    height: 600,
+    width: 900,
+    height: 670,
+    autoHideMenuBar: true,
+        ...(process.platform === 'linux' ? { icon } : {}),
     webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      preload: path.join(__dirname, 'preload.js'),
-    },
-  });
-
-  mainWindow.loadFile('index.html');
+      preload: join(__dirname, '../preload/index.js'),
+      sandbox: false
+    }
+  })
+  
+  if (is.dev && process.env['ELECTRON_RENDERER_URL']) {
+    mainWindow.loadURL(process.env['ELECTRON_RENDERER_URL'])
+  } else {
+    mainWindow.loadFile(join(__dirname, '../renderer/index.html'))
+  }
 }
 
-bootstrap().catch(console.error);
+app.whenReady().then(() {
+  const application = Application.create({
+    providers: [UserService, AuthGuard],
+    controllers: [UserController]
+  })
+
+  application.useGlobalFilters(DtoFilter)
+
+  application.bootstrap()
+
+  createWindow()
+})
 ```
 
 ## 2. Creando un servicio
@@ -221,7 +226,7 @@ onMessage(@Payload() data: any) {
 
 ` @Payload() `
 
-Inyecta el payload recibido desde el renderer.
+Inyecta el payload recibido desde el renderer. Si defines como tipo una clase decorada con class-validator, esto realiza la validación automática.
 ```ts
 @OnInvoke('update')
 async update(@Payload() data: any) {

package/dist/index.cjs

@@ -32,14 +32,23 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Application: () => Application,
+  Catch: () => Catch,
+  CircularDependency: () => CircularDependency,
   Controller: () => Controller,
+  ControllerIsNotValid: () => ControllerIsNotValid,
   Ctx: () => Ctx,
+  DataValidationError: () => DataValidationError,
+  ElectronInjectorError: () => ElectronInjectorError,
   Event: () => Event,
   ExecutionContext: () => ExecutionContext,
+  ForbiddenAccessError: () => ForbiddenAccessError,
   Injectable: () => Injectable,
+  IsNotExceptionFilter: () => IsNotExceptionFilter,
   OnInvoke: () => OnInvoke,
   OnSend: () => OnSend,
   Payload: () => Payload,
+  ProviderIsNotInjectable: () => ProviderIsNotInjectable,
+  ProviderNotFound: () => ProviderNotFound,
   Reflector: () => Reflector,
   SetMetadata: () => SetMetadata,
   UseGuards: () => UseGuards,
@@ -68,6 +77,14 @@ var ProviderNotFound = class extends ElectronInjectorError {
     super(`Provider '${providerName}' not found`);
   }
 };
+var IsNotExceptionFilter = class extends ElectronInjectorError {
+  static {
+    __name(this, "IsNotExceptionFilter");
+  }
+  constructor(filterName) {
+    super(`Class ${filterName} is not a filter. Please ensure it is decorated with @Catch(...filters)`);
+  }
+};
 var CircularDependency = class extends ElectronInjectorError {
   static {
     __name(this, "CircularDependency");
@@ -92,6 +109,26 @@ var ControllerIsNotValid = class extends ElectronInjectorError {
     super(`Controller '${controllerName}' is not valid. Please ensure it is decorated with @Controller()`);
   }
 };
+var DataValidationError = class {
+  static {
+    __name(this, "DataValidationError");
+  }
+  messages;
+  constructor(validationError) {
+    this.messages = validationError.constraints;
+  }
+  get Messages() {
+    return this.messages;
+  }
+};
+var ForbiddenAccessError = class extends ElectronInjectorError {
+  static {
+    __name(this, "ForbiddenAccessError");
+  }
+  constructor(path, guardName) {
+    super(`Can not access to "${path}" path, by the gaurd "${guardName}"`);
+  }
+};
 
 // src/keys.ts
 var CONTROLLER = Symbol("electron-di:controller");
@@ -99,6 +136,7 @@ var INJECTABLE = Symbol("electron-di:injectable");
 var HANDLER = Symbol("electron-di:handler");
 var PARAM = Symbol("electron-di:param");
 var GUARD = Symbol("electron-di:guard");
+var FILTER = Symbol("electron-di:filter");
 
 // src/utilities.ts
 var Reflector = class {
@@ -225,19 +263,33 @@ var DEV_LOGGER = devLogger;
 
 // src/application.ts
 var import_electron = require("electron");
+var import_class_validator = require("class-validator");
+var import_class_transformer = require("class-transformer");
 var Application = class _Application {
   static {
     __name(this, "Application");
   }
   configOptions;
+  validationOptions;
   container = new Container();
-  static create(configOptions) {
-    return new _Application(configOptions);
+  filters = /* @__PURE__ */ new Map();
+  static create(configOptions, validationOptions = {}) {
+    return new _Application(configOptions, validationOptions);
+  }
+  useGlobalFilters(...filters) {
+    for (const filter of filters) {
+      const exceptionsClasses = Reflect.getMetadata(FILTER, filter);
+      if (!exceptionsClasses) throw new IsNotExceptionFilter(filter.name);
+      exceptionsClasses.forEach((excls) => {
+        this.filters.set(excls, filter);
+        this.container.addProvider(filter);
+      });
+    }
   }
-  constructor(configOptions) {
+  constructor(configOptions, validationOptions) {
     this.configOptions = configOptions;
+    this.validationOptions = validationOptions;
     this.loadProviders();
-    this.loadControllers();
   }
   loadProviders() {
     for (const provider of this.configOptions.providers || []) {
@@ -245,7 +297,7 @@ var Application = class _Application {
       DEV_LOGGER(`Provider ${typeof provider == "object" ? provider.provided.name : provider.name} loaded`);
     }
   }
-  loadControllers() {
+  bootstrap() {
     for (const controller of this.configOptions.controllers || []) {
       const controllerPrefix = this.getControllerPrefix(controller);
       const controllerDependencies = this.getControllerDependencies(controller);
@@ -261,11 +313,28 @@ var Application = class _Application {
         const handlerCallback = /* @__PURE__ */ __name(async (event, data) => {
           const executionContext = new ExecutionContext(controller, controllerInstance[controllerMethod], data, event);
           for (const guard of guards) {
-            const response = await this.guardExecute(guard, executionContext);
-            if (!response) return false;
+            try {
+              const response = await this.guardExecute(guard, executionContext);
+              if (!response) return {
+                success: false,
+                error: new ForbiddenAccessError(path, guard.constructor.prototype.name)
+              };
+            } catch (e) {
+              return await this.useFilter(e, executionContext);
+            }
+          }
+          let params = [];
+          try {
+            params = await this.getParams(controllerInstance, controllerMethod, executionContext);
+          } catch (e) {
+            return await this.useFilter(e, executionContext);
+          }
+          let controllerResult = void 0;
+          try {
+            controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
+          } catch (e) {
+            return await this.useFilter(e, executionContext);
           }
-          const params = this.getParams(controllerInstance, controllerMethod, executionContext);
-          const controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
           return controllerResult;
         }, "handlerCallback");
         if (handlerMetadata.type === "invoke") {
@@ -273,18 +342,28 @@ var Application = class _Application {
         } else {
           import_electron.ipcMain.on(path, handlerCallback);
         }
+        DEV_LOGGER(`[Electron Injector] Route ${path} has initialized (${handlerMetadata.type === "invoke" ? "invoke" : "send"})`);
       }
     }
   }
-  getParams(target, propertyKey, executionContext) {
+  async getParams(target, propertyKey, executionContext) {
     const params = Reflect.getMetadata(PARAM, target, propertyKey);
     if (!params) return [];
-    return params.map((param) => {
+    return await Promise.all(params.map(async (param, index) => {
       if (param === "ctx") return executionContext;
       if (param === "event") return executionContext.event;
-      if (param === "payload") return executionContext.payload;
+      if (param === "payload") {
+        const validationClass = Reflect.getMetadata("design:paramtypes", target, propertyKey)[index];
+        const metadata = (0, import_class_validator.getMetadataStorage)().getTargetValidationMetadatas(validationClass, null, false, false);
+        if (typeof validationClass == "function" && metadata.length) {
+          const validatorObjectInstance = (0, import_class_transformer.plainToInstance)(validationClass, executionContext.payload);
+          const errors = await (0, import_class_validator.validate)(validatorObjectInstance, this.validationOptions);
+          if (errors.length) throw new DataValidationError(errors[0]);
+        }
+        return executionContext.payload;
+      }
       return void 0;
-    });
+    }));
   }
   buildPath(controllerPrefix, methodPath) {
     const prefix = controllerPrefix.trim();
@@ -295,39 +374,48 @@ var Application = class _Application {
     return "";
   }
   async guardExecute(guard, executionContext) {
-    try {
-      const guardResult = guard.canActivate(executionContext);
-      if (guardResult instanceof import_rxjs.Observable) {
-        const result = await (0, import_rxjs.lastValueFrom)(guardResult.pipe((0, import_rxjs.first)()));
-        if (!result) return false;
-      } else if (guardResult instanceof Promise) {
-        const result = await guardResult;
-        if (!result) return false;
-      } else {
-        if (!guardResult) return false;
-      }
-      return true;
-    } catch (error) {
-      PROD_LOGGER(error);
-      return false;
+    const guardResult = guard.canActivate(executionContext);
+    if (guardResult instanceof import_rxjs.Observable) {
+      const result = await (0, import_rxjs.lastValueFrom)(guardResult.pipe((0, import_rxjs.first)()));
+      if (!result) return false;
+    } else if (guardResult instanceof Promise) {
+      const result = await guardResult;
+      if (!result) return false;
+    } else {
+      if (!guardResult) return false;
     }
+    return true;
   }
   async controllerExecute(context, target, params) {
-    try {
-      const boundedTarget = target.bind(context);
-      let controllerResult = boundedTarget(...params);
-      while (controllerResult instanceof import_rxjs.Observable || controllerResult instanceof Promise) {
-        if (controllerResult instanceof import_rxjs.Observable) {
-          controllerResult = await (0, import_rxjs.lastValueFrom)(controllerResult);
-        } else if (controllerResult instanceof Promise) {
-          controllerResult = await controllerResult;
-        }
+    const boundedTarget = target.bind(context);
+    let controllerResult = boundedTarget(...params);
+    while (controllerResult instanceof import_rxjs.Observable || controllerResult instanceof Promise) {
+      if (controllerResult instanceof import_rxjs.Observable) {
+        controllerResult = await (0, import_rxjs.lastValueFrom)(controllerResult);
+      } else if (controllerResult instanceof Promise) {
+        controllerResult = await controllerResult;
       }
-      return controllerResult;
-    } catch (error) {
-      PROD_LOGGER(error.message ?? error);
-      return void 0;
     }
+    return controllerResult;
+  }
+  async useFilter(error, executionContext) {
+    PROD_LOGGER(error);
+    for (const [cls, fltr] of this.filters) {
+      if (!(error instanceof cls)) continue;
+      const filterInstance = this.container.resolve(fltr);
+      const response = filterInstance.catch(error, executionContext);
+      if (response instanceof Promise) {
+        return await response;
+      }
+      if (response instanceof import_rxjs.Observable) {
+        return await (0, import_rxjs.lastValueFrom)(response);
+      }
+      return response;
+    }
+    return {
+      success: false,
+      error
+    };
   }
   getHandlerMetadata(target) {
     const handlerMetadata = Reflect.getMetadata(HANDLER, target);
@@ -431,17 +519,37 @@ function SetMetadata(key, value) {
   };
 }
 __name(SetMetadata, "SetMetadata");
+function Catch(...filters) {
+  return function(target) {
+    const prevFilters = Reflect.getMetadata(FILTER, target) || [];
+    Reflect.defineMetadata(INJECTABLE, "singleton", target);
+    Reflect.defineMetadata(FILTER, [
+      ...prevFilters,
+      ...filters
+    ], target);
+  };
+}
+__name(Catch, "Catch");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Application,
+  Catch,
+  CircularDependency,
   Controller,
+  ControllerIsNotValid,
   Ctx,
+  DataValidationError,
+  ElectronInjectorError,
   Event,
   ExecutionContext,
+  ForbiddenAccessError,
   Injectable,
+  IsNotExceptionFilter,
   OnInvoke,
   OnSend,
   Payload,
+  ProviderIsNotInjectable,
+  ProviderNotFound,
   Reflector,
   SetMetadata,
   UseGuards,

package/dist/index.d.cts

@@ -1,5 +1,6 @@
 import { Observable } from 'rxjs';
 import { IpcMainEvent, IpcMainInvokeEvent } from 'electron';
+import { ValidatorOptions, ValidationError } from 'class-validator';
 
 declare class Reflector {
     get<T = any>(key: any, target: any): T;
@@ -30,6 +31,9 @@ type Provider = Class | {
 interface CanActivate {
     canActivate: (context: ExecutionContext) => boolean | Promise<boolean> | Observable<boolean>;
 }
+interface ExceptionFilter {
+    catch: (e: any, context: ExecutionContext) => any;
+}
 interface ConfigOptions {
     providers?: Provider[];
     controllers?: Class[];
@@ -37,15 +41,19 @@ interface ConfigOptions {
 
 declare class Application {
     private configOptions;
+    private validationOptions;
     private container;
-    static create(configOptions: ConfigOptions): Application;
-    constructor(configOptions: ConfigOptions);
+    private filters;
+    static create(configOptions: ConfigOptions, validationOptions?: ValidatorOptions): Application;
+    useGlobalFilters(...filters: Class<ExceptionFilter>[]): void;
+    constructor(configOptions: ConfigOptions, validationOptions: ValidatorOptions);
     private loadProviders;
-    private loadControllers;
+    bootstrap(): void;
     private getParams;
     private buildPath;
     private guardExecute;
     private controllerExecute;
+    private useFilter;
     private getHandlerMetadata;
     private getGuards;
     private getControllerPrefix;
@@ -61,5 +69,35 @@ declare function Event(): ParameterDecorator;
 declare function Ctx(): ParameterDecorator;
 declare function UseGuards(...guards: Class<CanActivate>[]): (_target: Object, _property?: string | symbol, descriptor?: PropertyDescriptor) => void;
 declare function SetMetadata(key: any, value: any): (target: Object, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+declare function Catch(...filters: Class[]): (target: Object) => void;
+
+declare class ElectronInjectorError extends Error {
+    constructor(message: string);
+}
+declare class ProviderNotFound extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class IsNotExceptionFilter extends ElectronInjectorError {
+    constructor(filterName: string);
+}
+declare class CircularDependency extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class ProviderIsNotInjectable extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class ControllerIsNotValid extends ElectronInjectorError {
+    constructor(controllerName: string);
+}
+declare class DataValidationError {
+    private messages;
+    constructor(validationError: ValidationError);
+    get Messages(): {
+        [type: string]: string;
+    } | undefined;
+}
+declare class ForbiddenAccessError extends ElectronInjectorError {
+    constructor(path: string, guardName: string);
+}
 
-export { Application, type CanActivate, type ConfigOptions, Controller, Ctx, Event, ExecutionContext, Injectable, type InjectableType, OnInvoke, OnSend, Payload, Reflector, SetMetadata, UseGuards, applyDecorators };
+export { Application, type CanActivate, Catch, CircularDependency, type ConfigOptions, Controller, ControllerIsNotValid, Ctx, DataValidationError, ElectronInjectorError, Event, type ExceptionFilter, ExecutionContext, ForbiddenAccessError, Injectable, type InjectableType, IsNotExceptionFilter, OnInvoke, OnSend, Payload, ProviderIsNotInjectable, ProviderNotFound, Reflector, SetMetadata, UseGuards, applyDecorators };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { Observable } from 'rxjs';
 import { IpcMainEvent, IpcMainInvokeEvent } from 'electron';
+import { ValidatorOptions, ValidationError } from 'class-validator';
 
 declare class Reflector {
     get<T = any>(key: any, target: any): T;
@@ -30,6 +31,9 @@ type Provider = Class | {
 interface CanActivate {
     canActivate: (context: ExecutionContext) => boolean | Promise<boolean> | Observable<boolean>;
 }
+interface ExceptionFilter {
+    catch: (e: any, context: ExecutionContext) => any;
+}
 interface ConfigOptions {
     providers?: Provider[];
     controllers?: Class[];
@@ -37,15 +41,19 @@ interface ConfigOptions {
 
 declare class Application {
     private configOptions;
+    private validationOptions;
     private container;
-    static create(configOptions: ConfigOptions): Application;
-    constructor(configOptions: ConfigOptions);
+    private filters;
+    static create(configOptions: ConfigOptions, validationOptions?: ValidatorOptions): Application;
+    useGlobalFilters(...filters: Class<ExceptionFilter>[]): void;
+    constructor(configOptions: ConfigOptions, validationOptions: ValidatorOptions);
     private loadProviders;
-    private loadControllers;
+    bootstrap(): void;
     private getParams;
     private buildPath;
     private guardExecute;
     private controllerExecute;
+    private useFilter;
     private getHandlerMetadata;
     private getGuards;
     private getControllerPrefix;
@@ -61,5 +69,35 @@ declare function Event(): ParameterDecorator;
 declare function Ctx(): ParameterDecorator;
 declare function UseGuards(...guards: Class<CanActivate>[]): (_target: Object, _property?: string | symbol, descriptor?: PropertyDescriptor) => void;
 declare function SetMetadata(key: any, value: any): (target: Object, propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+declare function Catch(...filters: Class[]): (target: Object) => void;
+
+declare class ElectronInjectorError extends Error {
+    constructor(message: string);
+}
+declare class ProviderNotFound extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class IsNotExceptionFilter extends ElectronInjectorError {
+    constructor(filterName: string);
+}
+declare class CircularDependency extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class ProviderIsNotInjectable extends ElectronInjectorError {
+    constructor(providerName: string);
+}
+declare class ControllerIsNotValid extends ElectronInjectorError {
+    constructor(controllerName: string);
+}
+declare class DataValidationError {
+    private messages;
+    constructor(validationError: ValidationError);
+    get Messages(): {
+        [type: string]: string;
+    } | undefined;
+}
+declare class ForbiddenAccessError extends ElectronInjectorError {
+    constructor(path: string, guardName: string);
+}
 
-export { Application, type CanActivate, type ConfigOptions, Controller, Ctx, Event, ExecutionContext, Injectable, type InjectableType, OnInvoke, OnSend, Payload, Reflector, SetMetadata, UseGuards, applyDecorators };
+export { Application, type CanActivate, Catch, CircularDependency, type ConfigOptions, Controller, ControllerIsNotValid, Ctx, DataValidationError, ElectronInjectorError, Event, type ExceptionFilter, ExecutionContext, ForbiddenAccessError, Injectable, type InjectableType, IsNotExceptionFilter, OnInvoke, OnSend, Payload, ProviderIsNotInjectable, ProviderNotFound, Reflector, SetMetadata, UseGuards, applyDecorators };

package/dist/index.js

@@ -24,6 +24,14 @@ var ProviderNotFound = class extends ElectronInjectorError {
     super(`Provider '${providerName}' not found`);
   }
 };
+var IsNotExceptionFilter = class extends ElectronInjectorError {
+  static {
+    __name(this, "IsNotExceptionFilter");
+  }
+  constructor(filterName) {
+    super(`Class ${filterName} is not a filter. Please ensure it is decorated with @Catch(...filters)`);
+  }
+};
 var CircularDependency = class extends ElectronInjectorError {
   static {
     __name(this, "CircularDependency");
@@ -48,6 +56,26 @@ var ControllerIsNotValid = class extends ElectronInjectorError {
     super(`Controller '${controllerName}' is not valid. Please ensure it is decorated with @Controller()`);
   }
 };
+var DataValidationError = class {
+  static {
+    __name(this, "DataValidationError");
+  }
+  messages;
+  constructor(validationError) {
+    this.messages = validationError.constraints;
+  }
+  get Messages() {
+    return this.messages;
+  }
+};
+var ForbiddenAccessError = class extends ElectronInjectorError {
+  static {
+    __name(this, "ForbiddenAccessError");
+  }
+  constructor(path, guardName) {
+    super(`Can not access to "${path}" path, by the gaurd "${guardName}"`);
+  }
+};
 
 // src/keys.ts
 var CONTROLLER = Symbol("electron-di:controller");
@@ -55,6 +83,7 @@ var INJECTABLE = Symbol("electron-di:injectable");
 var HANDLER = Symbol("electron-di:handler");
 var PARAM = Symbol("electron-di:param");
 var GUARD = Symbol("electron-di:guard");
+var FILTER = Symbol("electron-di:filter");
 
 // src/utilities.ts
 var Reflector = class {
@@ -181,19 +210,33 @@ var DEV_LOGGER = devLogger;
 
 // src/application.ts
 import { ipcMain } from "electron";
+import { getMetadataStorage, validate } from "class-validator";
+import { plainToInstance } from "class-transformer";
 var Application = class _Application {
   static {
     __name(this, "Application");
   }
   configOptions;
+  validationOptions;
   container = new Container();
-  static create(configOptions) {
-    return new _Application(configOptions);
+  filters = /* @__PURE__ */ new Map();
+  static create(configOptions, validationOptions = {}) {
+    return new _Application(configOptions, validationOptions);
+  }
+  useGlobalFilters(...filters) {
+    for (const filter of filters) {
+      const exceptionsClasses = Reflect.getMetadata(FILTER, filter);
+      if (!exceptionsClasses) throw new IsNotExceptionFilter(filter.name);
+      exceptionsClasses.forEach((excls) => {
+        this.filters.set(excls, filter);
+        this.container.addProvider(filter);
+      });
+    }
   }
-  constructor(configOptions) {
+  constructor(configOptions, validationOptions) {
     this.configOptions = configOptions;
+    this.validationOptions = validationOptions;
     this.loadProviders();
-    this.loadControllers();
   }
   loadProviders() {
     for (const provider of this.configOptions.providers || []) {
@@ -201,7 +244,7 @@ var Application = class _Application {
       DEV_LOGGER(`Provider ${typeof provider == "object" ? provider.provided.name : provider.name} loaded`);
     }
   }
-  loadControllers() {
+  bootstrap() {
     for (const controller of this.configOptions.controllers || []) {
       const controllerPrefix = this.getControllerPrefix(controller);
       const controllerDependencies = this.getControllerDependencies(controller);
@@ -217,11 +260,28 @@ var Application = class _Application {
         const handlerCallback = /* @__PURE__ */ __name(async (event, data) => {
           const executionContext = new ExecutionContext(controller, controllerInstance[controllerMethod], data, event);
           for (const guard of guards) {
-            const response = await this.guardExecute(guard, executionContext);
-            if (!response) return false;
+            try {
+              const response = await this.guardExecute(guard, executionContext);
+              if (!response) return {
+                success: false,
+                error: new ForbiddenAccessError(path, guard.constructor.prototype.name)
+              };
+            } catch (e) {
+              return await this.useFilter(e, executionContext);
+            }
+          }
+          let params = [];
+          try {
+            params = await this.getParams(controllerInstance, controllerMethod, executionContext);
+          } catch (e) {
+            return await this.useFilter(e, executionContext);
+          }
+          let controllerResult = void 0;
+          try {
+            controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
+          } catch (e) {
+            return await this.useFilter(e, executionContext);
           }
-          const params = this.getParams(controllerInstance, controllerMethod, executionContext);
-          const controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
           return controllerResult;
         }, "handlerCallback");
         if (handlerMetadata.type === "invoke") {
@@ -229,18 +289,28 @@ var Application = class _Application {
         } else {
           ipcMain.on(path, handlerCallback);
         }
+        DEV_LOGGER(`[Electron Injector] Route ${path} has initialized (${handlerMetadata.type === "invoke" ? "invoke" : "send"})`);
       }
     }
   }
-  getParams(target, propertyKey, executionContext) {
+  async getParams(target, propertyKey, executionContext) {
     const params = Reflect.getMetadata(PARAM, target, propertyKey);
     if (!params) return [];
-    return params.map((param) => {
+    return await Promise.all(params.map(async (param, index) => {
       if (param === "ctx") return executionContext;
       if (param === "event") return executionContext.event;
-      if (param === "payload") return executionContext.payload;
+      if (param === "payload") {
+        const validationClass = Reflect.getMetadata("design:paramtypes", target, propertyKey)[index];
+        const metadata = getMetadataStorage().getTargetValidationMetadatas(validationClass, null, false, false);
+        if (typeof validationClass == "function" && metadata.length) {
+          const validatorObjectInstance = plainToInstance(validationClass, executionContext.payload);
+          const errors = await validate(validatorObjectInstance, this.validationOptions);
+          if (errors.length) throw new DataValidationError(errors[0]);
+        }
+        return executionContext.payload;
+      }
       return void 0;
-    });
+    }));
   }
   buildPath(controllerPrefix, methodPath) {
     const prefix = controllerPrefix.trim();
@@ -251,39 +321,48 @@ var Application = class _Application {
     return "";
   }
   async guardExecute(guard, executionContext) {
-    try {
-      const guardResult = guard.canActivate(executionContext);
-      if (guardResult instanceof Observable) {
-        const result = await lastValueFrom(guardResult.pipe(first()));
-        if (!result) return false;
-      } else if (guardResult instanceof Promise) {
-        const result = await guardResult;
-        if (!result) return false;
-      } else {
-        if (!guardResult) return false;
-      }
-      return true;
-    } catch (error) {
-      PROD_LOGGER(error);
-      return false;
+    const guardResult = guard.canActivate(executionContext);
+    if (guardResult instanceof Observable) {
+      const result = await lastValueFrom(guardResult.pipe(first()));
+      if (!result) return false;
+    } else if (guardResult instanceof Promise) {
+      const result = await guardResult;
+      if (!result) return false;
+    } else {
+      if (!guardResult) return false;
     }
+    return true;
   }
   async controllerExecute(context, target, params) {
-    try {
-      const boundedTarget = target.bind(context);
-      let controllerResult = boundedTarget(...params);
-      while (controllerResult instanceof Observable || controllerResult instanceof Promise) {
-        if (controllerResult instanceof Observable) {
-          controllerResult = await lastValueFrom(controllerResult);
-        } else if (controllerResult instanceof Promise) {
-          controllerResult = await controllerResult;
-        }
+    const boundedTarget = target.bind(context);
+    let controllerResult = boundedTarget(...params);
+    while (controllerResult instanceof Observable || controllerResult instanceof Promise) {
+      if (controllerResult instanceof Observable) {
+        controllerResult = await lastValueFrom(controllerResult);
+      } else if (controllerResult instanceof Promise) {
+        controllerResult = await controllerResult;
       }
-      return controllerResult;
-    } catch (error) {
-      PROD_LOGGER(error.message ?? error);
-      return void 0;
     }
+    return controllerResult;
+  }
+  async useFilter(error, executionContext) {
+    PROD_LOGGER(error);
+    for (const [cls, fltr] of this.filters) {
+      if (!(error instanceof cls)) continue;
+      const filterInstance = this.container.resolve(fltr);
+      const response = filterInstance.catch(error, executionContext);
+      if (response instanceof Promise) {
+        return await response;
+      }
+      if (response instanceof Observable) {
+        return await lastValueFrom(response);
+      }
+      return response;
+    }
+    return {
+      success: false,
+      error
+    };
   }
   getHandlerMetadata(target) {
     const handlerMetadata = Reflect.getMetadata(HANDLER, target);
@@ -387,16 +466,36 @@ function SetMetadata(key, value) {
   };
 }
 __name(SetMetadata, "SetMetadata");
+function Catch(...filters) {
+  return function(target) {
+    const prevFilters = Reflect.getMetadata(FILTER, target) || [];
+    Reflect.defineMetadata(INJECTABLE, "singleton", target);
+    Reflect.defineMetadata(FILTER, [
+      ...prevFilters,
+      ...filters
+    ], target);
+  };
+}
+__name(Catch, "Catch");
 export {
   Application,
+  Catch,
+  CircularDependency,
   Controller,
+  ControllerIsNotValid,
   Ctx,
+  DataValidationError,
+  ElectronInjectorError,
   Event,
   ExecutionContext,
+  ForbiddenAccessError,
   Injectable,
+  IsNotExceptionFilter,
   OnInvoke,
   OnSend,
   Payload,
+  ProviderIsNotInjectable,
+  ProviderNotFound,
   Reflector,
   SetMetadata,
   UseGuards,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-injector",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "Biblioteca para el desarrollo de aplicaciones con electron que proporciona una arquitectura robusta con inyección e inversion de dependencias.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,6 +37,8 @@
     "@swc/core": "^1.15.3",
     "@types/debug": "^4.1.12",
     "@types/node": "^24.10.1",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
     "electron": "^39.2.4",
     "eslint": "^9.39.1",
     "eslint-config-prettier": "^10.1.8",
@@ -49,6 +51,8 @@
     "typescript-eslint": "^8.48.0"
   },
   "peerDependencies": {
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.3",
     "electron": "^39.2.4",
     "rxjs": "^7.8.2"
   },