electron-injector 1.0.2

package/README.md

@@ -0,0 +1,285 @@
+# Librería Electron Injector
+
+*electron-injector* es una librería diseñada para simplificar y robustecer el desarrollo de aplicaciones con Electron y TypeScript. Ofrece un sistema de Inyección de Dependencias (DI) e Inversión de Control (IoC) que promueve un código más mantenible, testeable y claro, mejorando tanto la experiencia del desarrollador como la calidad final del software.
+
+Nace de la necesidad de crear aplicaciones de escritorio multiplataforma donde no solo importa la experiencia de usuario (UX), sino también una experiencia de desarrollo (DX) ágil y bien estructurada.
+
+## ✨ Características
+✅ Sistema de Inyección de Dependencias completo con contenedor IoC
+
+✅ Decoradores para IPC (@OnSend, @OnInvoke) inspirados en NestJS
+
+✅ Gestión automática de handlers de Electron IPC
+
+✅ Soporte para Guards (autorización y validación)
+
+✅ Metadata reflection para parametrización avanzada
+
+✅ Soporte para RxJS (Observables) en guards y handlers
+
+✅ Control de ciclo de vida (singleton/transient)
+
+✅ Sistema de logging diferenciado (desarrollo/producción)
+
+✅ Detección de dependencias circulares
+
+✅ Tipado TypeScript completo
+
+## 📦 Instalación
+```bash
+npm install electron-injector rxjs
+```
+
+> **Nota:**  
+> Si estás usando Vite, también debes instalar `@swc/core` y configurar el plugin correspondiente en tu archivo de configuración de Vite:
+>
+> ```bash
+> npm install @swc/core --save-dev
+> ```
+>
+> Luego, agrega el plugin de SWC en tu `vite.config.js` o `vite.config.ts` según la documentación de Vite y el plugin que utilices.
+
+## 1. Configuración Principal
+```ts
+// main.ts
+import 'reflect-metadata';
+import { app, BrowserWindow } from 'electron';
+import { Application } from 'electron-injector';
+import { UserController } from './controllers/user.controller';
+import { AuthGuard } from './guards/auth.guard';
+import { UserService } from './services/user.service';
+
+async function bootstrap() {
+  const electronApp = new Application({
+    providers: [
+      UserService,
+      AuthGuard,
+    ],
+    controllers: [
+      UserController,
+    ],
+  });
+
+  await app.whenReady();
+  
+  const mainWindow = new BrowserWindow({
+    width: 800,
+    height: 600,
+    webPreferences: {
+      nodeIntegration: false,
+      contextIsolation: true,
+      preload: path.join(__dirname, 'preload.js'),
+    },
+  });
+
+  mainWindow.loadFile('index.html');
+}
+
+bootstrap().catch(console.error);
+```
+
+## 2. Creando un servicio
+```ts
+// services/user.service.ts
+import { Injectable } from 'electron-injector';
+
+export interface User {
+  id: string;
+  name: string;
+  email: string;
+}
+
+@Injectable() // Por defecto es singleton
+export class UserService {
+  private users: User[] = [];
+
+  async createUser(user: Omit<User, 'id'>): Promise<User> {
+    const newUser = {
+      ...user,
+      id: Date.now().toString(),
+    };
+    this.users.push(newUser);
+    return newUser;
+  }
+
+  async findAll(): Promise<User[]> {
+    return [...this.users];
+  }
+
+  async findById(id: string): Promise<User | undefined> {
+    return this.users.find(user => user.id === id);
+  }
+}
+```
+## 3. Creando un controlador IPC
+```ts
+// controllers/user.controller.ts
+import { Controller, OnInvoke, OnSend, Payload, Event } from 'electron-injector';
+import { UserService } from '../services/user.service';
+import { IpcMainEvent } from 'electron';
+
+@Controller('user') // Prefijo para todos los handlers
+export class UserController {
+  constructor(private userService: UserService) {}
+
+  // Handler para ipcMain.handle
+  @OnInvoke('create')
+  async createUser(@Payload() userData: any) {
+    return await this.userService.createUser(userData);
+  }
+
+  // Handler para ipcMain.on
+  @OnSend('updated')
+  onUserUpdated(@Payload() data: any, @Event() event: IpcMainEvent) {
+    console.log('User updated:', data);
+    // Puedes enviar respuestas o realizar otras acciones
+    return { success: true, timestamp: Date.now() };
+  }
+
+  // Handler con nombre del método como path
+  @OnInvoke()
+  async findAll() {
+    return await this.userService.findAll();
+  }
+}
+```
+
+## 4. Creando un Guard
+```ts
+// guards/auth.guard.ts
+import { Injectable, CanActivate, ExecutionContext } from 'electron-injector';
+import { Observable, of } from 'rxjs';
+import { delay } from 'rxjs/operators';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const payload = context.payload;
+    const event = context.event;
+    
+    // Lógica de autorización aquí
+    const token = payload?.token || event.sender.session.cookies.get({ name: 'auth_token' });
+    
+    return !!token; // Ejemplo simple
+  }
+}
+
+// Guard con RxJS
+@Injectable()
+export class AsyncGuard implements CanActivate {
+  canActivate(context: ExecutionContext): Observable<boolean> {
+    return of(true).pipe(delay(100)); // Ejemplo asíncrono
+  }
+}
+```
+
+# 📖 Decoradores disponibles
+## Decoradores de clase
+
+` @Controller(path?: string) `
+
+Marca una clase como controlador de IPC. Todos los handlers dentro de esta clase usarán el prefijo especificado.
+```ts
+@Controller('auth') // Todos los handlers empezarán con 'auth:'
+export class AuthController {}
+```
+
+` @Injectable(type?: 'singleton' | 'transient') `
+
+Marca una clase como disponible para inyección de dependencias.
+```ts
+@Injectable() // Por defecto singleton
+export class DatabaseService {}
+
+@Injectable('transient') // Nueva instancia cada vez que se inyecta en una clase
+export class RequestScopedService {}
+```
+
+## Decoradores de métodos
+
+` @OnInvoke(path?: string) `
+
+Crea un handler para `ipcMain.handle`. Responde a invocaciones del renderer.
+```ts
+@OnInvoke('get-data') // Responde a 'controller-prefix:get-data'
+async getData() {
+  return { data: 'value' };
+}
+````
+
+` @OnSend(path?: string) `
+
+Crea un handler para `ipcMain.on`. Escucha eventos del renderer.
+```ts
+@OnSend('message') // Escucha 'controller-prefix:message'
+onMessage(@Payload() data: any) {
+  console.log('Received:', data);
+}
+```
+
+## Decoradores de parámetros
+
+` @Payload() `
+
+Inyecta el payload recibido desde el renderer.
+```ts
+@OnInvoke('update')
+async update(@Payload() data: any) {
+  // 'data' contiene el payload enviado desde el renderer
+}
+```
+
+` @Event() `
+
+Inyecta el objeto `IpcMainEvent` o `IpcMainInvokeEvent`.
+```ts
+@OnSend('action')
+onAction(@Payload() data: any, @Event() event: IpcMainEvent) {
+  event.sender.send('response', { received: true });
+}
+```
+
+` @Ctx() `
+
+Inyecta el `ExecutionContext` completo.
+```ts
+@OnInvoke('process')
+async process(@Ctx() context: ExecutionContext) {
+  const { payload, event, getHandler, getClass } = context;
+  // Acceso completo al contexto
+}
+```
+
+## Decoradores de Metadata y Guards
+
+` @UseGuards(...guards) `
+
+Aplica guards a un controlador o método específico.
+```ts
+@Controller('admin')
+@UseGuards(AuthGuard, AdminGuard) // Aplica a todos los métodos
+export class AdminController {
+  
+  @OnInvoke('sensitive')
+  @UseGuards(ExtraSecurityGuard) // Guard adicional para este método
+  async sensitiveOperation() {
+    // Solo accesible si todos los guards retornan true
+  }
+}
+```
+
+` @SetMetadata(key, value) `
+
+Establece metadata personalizada en controladores o métodos.
+```ts
+@Controller('user')
+@SetMetadata('roles', ['admin', 'user'])
+export class UserController {
+  
+  @OnInvoke('delete')
+  @SetMetadata('requiresAdmin', true)
+  async deleteUser() {
+    // Método con metadata personalizada
+  }
+}
+```

package/dist/index.cjs

@@ -0,0 +1,446 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Application: () => Application,
+  Controller: () => Controller,
+  Ctx: () => Ctx,
+  Event: () => Event,
+  ExecutionContext: () => ExecutionContext,
+  Injectable: () => Injectable,
+  OnInvoke: () => OnInvoke,
+  OnSend: () => OnSend,
+  Payload: () => Payload,
+  Reflector: () => Reflector,
+  SetMetadata: () => SetMetadata,
+  UseGuards: () => UseGuards,
+  applyDecorators: () => applyDecorators
+});
+module.exports = __toCommonJS(index_exports);
+var import_reflect_metadata = require("reflect-metadata");
+
+// src/application.ts
+var import_rxjs = require("rxjs");
+
+// src/errors.ts
+var ElectronDiError = class extends Error {
+  static {
+    __name(this, "ElectronDiError");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+var ProviderNotFound = class extends ElectronDiError {
+  static {
+    __name(this, "ProviderNotFound");
+  }
+  constructor(providerName) {
+    super(`Provider '${providerName}' not found`);
+  }
+};
+var CircularDependency = class extends ElectronDiError {
+  static {
+    __name(this, "CircularDependency");
+  }
+  constructor(providerName) {
+    super(`Circular dependency detected for provider '${providerName}'`);
+  }
+};
+var ProviderIsNotInjectable = class extends ElectronDiError {
+  static {
+    __name(this, "ProviderIsNotInjectable");
+  }
+  constructor(providerName) {
+    super(`Provider '${providerName}' is not injectable. Please ensure it is decorated with @Injectable()`);
+  }
+};
+var ControllerIsNotValid = class extends ElectronDiError {
+  static {
+    __name(this, "ControllerIsNotValid");
+  }
+  constructor(controllerName) {
+    super(`Controller '${controllerName}' is not valid. Please ensure it is decorated with @Controller()`);
+  }
+};
+
+// src/keys.ts
+var CONTROLLER = Symbol("electron-di:controller");
+var INJECTABLE = Symbol("electron-di:injectable");
+var HANDLER = Symbol("electron-di:handler");
+var PARAM = Symbol("electron-di:param");
+var GUARD = Symbol("electron-di:guard");
+
+// src/utilities.ts
+var Reflector = class {
+  static {
+    __name(this, "Reflector");
+  }
+  get(key, target) {
+    return Reflect.getMetadata(key, target);
+  }
+  getAll(key, ...targets) {
+    return targets.map((t) => this.get(key, t));
+  }
+  getAllAndOverride(key, ...targets) {
+    return this.getAll(key, ...targets).reverse().find((value) => value !== void 0);
+  }
+  getAllAndMerge(key, ...targets) {
+    return this.getAll(key, ...targets).reduce((a, b) => {
+      if (Array.isArray(a)) return a.concat(b);
+      if (typeof a === "object" && typeof b === "object") return {
+        ...a,
+        ...b
+      };
+      return b;
+    }, []);
+  }
+};
+var ExecutionContext = class {
+  static {
+    __name(this, "ExecutionContext");
+  }
+  _classRef;
+  _handler;
+  _payload;
+  _event;
+  constructor(_classRef, _handler, _payload, _event) {
+    this._classRef = _classRef;
+    this._handler = _handler;
+    this._payload = _payload;
+    this._event = _event;
+  }
+  getHandler() {
+    return this._handler;
+  }
+  getClass() {
+    return this._classRef;
+  }
+  get payload() {
+    return this._payload;
+  }
+  get event() {
+    return this._event;
+  }
+  set payload(payload) {
+    this._payload = payload;
+  }
+};
+function applyDecorators(...decorators) {
+  return function(target, _propertyKey, descriptor) {
+    const targetKey = descriptor ? descriptor.value : target;
+    decorators.forEach((decorator) => decorator(targetKey));
+  };
+}
+__name(applyDecorators, "applyDecorators");
+
+// src/container.ts
+var Container = class {
+  static {
+    __name(this, "Container");
+  }
+  utilities = [
+    Reflector
+  ];
+  providers = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  addProvider(provider) {
+    const token = this.getProviderToken(provider);
+    this.providers.set(token, provider);
+  }
+  getDependencies(providerClass) {
+    return Reflect.getMetadata("design:paramtypes", providerClass) ?? [];
+  }
+  resolve(token, visited = []) {
+    const utilitie = this.utilities.find((u) => u === token);
+    if (utilitie) return new utilitie();
+    const singletonInstance = this.instances.get(token);
+    if (singletonInstance) return singletonInstance;
+    const provider = this.providers.get(token);
+    if (!provider) throw new ProviderNotFound(token.name);
+    if (visited.includes(token)) throw new CircularDependency(token.name);
+    const providerClass = this.getProviderClass(provider);
+    const providerDependencies = this.getDependencies(providerClass);
+    const providerMetadata = this.getProviderMetadata(providerClass);
+    const instanceDependencies = providerDependencies.map((dep) => this.resolve(dep, [
+      ...visited,
+      token
+    ]));
+    if (!providerMetadata) throw new ProviderIsNotInjectable(token.name);
+    const providerInstance = new providerClass(...instanceDependencies);
+    if (providerMetadata === "singleton") this.instances.set(token, providerInstance);
+    return providerInstance;
+  }
+  getProviderToken(provider) {
+    return typeof provider === "object" ? provider.provided : provider;
+  }
+  getProviderClass(provider) {
+    return typeof provider === "object" ? provider.useClass : provider;
+  }
+  getProviderMetadata(provider) {
+    return Reflect.getMetadata(INJECTABLE, provider);
+  }
+};
+
+// src/debugger.ts
+var import_debug = __toESM(require("debug"), 1);
+var prodLogger = (0, import_debug.default)("app:prod");
+var devLogger = (0, import_debug.default)("app:dev");
+if (!process.env.APP_LOGGER || process.env.APP_LOGGER === "false") {
+  import_debug.default.enable("app:prod");
+} else {
+  import_debug.default.enable("app:*");
+}
+var PROD_LOGGER = prodLogger;
+var DEV_LOGGER = devLogger;
+
+// src/application.ts
+var import_electron = require("electron");
+var Application = class {
+  static {
+    __name(this, "Application");
+  }
+  configOptions;
+  container = new Container();
+  constructor(configOptions) {
+    this.configOptions = configOptions;
+    this.loadProviders();
+    this.loadControllers();
+  }
+  loadProviders() {
+    for (const provider of this.configOptions.providers || []) {
+      this.container.addProvider(provider);
+      DEV_LOGGER(`Provider ${typeof provider == "object" ? provider.provided.name : provider.name} loaded`);
+    }
+  }
+  loadControllers() {
+    for (const controller of this.configOptions.controllers || []) {
+      const controllerPrefix = this.getControllerPrefix(controller);
+      const controllerDependencies = this.getControllerDependencies(controller);
+      const controllerGuards = this.getGuards(controller);
+      const controllerInstance = new controller(...controllerDependencies.map((dep) => this.container.resolve(dep)));
+      const controllerMethods = Object.getOwnPropertyNames(controllerInstance.constructor.prototype).filter((method) => method !== "constructor");
+      for (const controllerMethod of controllerMethods) {
+        const handlerMetadata = this.getHandlerMetadata(controllerInstance[controllerMethod]);
+        if (typeof handlerMetadata !== "object") continue;
+        const handlerGuards = this.getGuards(controllerInstance[controllerMethod]);
+        const guards = controllerGuards.filter((guard) => !handlerGuards.includes(guard)).concat(handlerGuards).map((guard) => this.container.resolve(guard));
+        const path = this.buildPath(controllerPrefix, controllerMethod);
+        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;
+          }
+          const params = this.getParams(controllerInstance, controllerMethod, executionContext);
+          const controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
+          return controllerResult;
+        }, "handlerCallback");
+        if (handlerMetadata.type === "invoke") {
+          import_electron.ipcMain.handle(path, handlerCallback);
+        } else {
+          import_electron.ipcMain.on(path, handlerCallback);
+        }
+      }
+    }
+  }
+  getParams(target, propertyKey, executionContext) {
+    const params = Reflect.getMetadata(PARAM, target, propertyKey);
+    if (!params) return [];
+    return params.map((param) => {
+      if (param === "ctx") return executionContext;
+      if (param === "event") return executionContext.event;
+      if (param === "payload") return executionContext.payload;
+      return void 0;
+    });
+  }
+  buildPath(controllerPrefix, methodPath) {
+    const prefix = controllerPrefix.trim();
+    const path = methodPath.trim();
+    if (prefix && path) return `${prefix}:${path}`;
+    if (prefix) return prefix;
+    if (path) return path;
+    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;
+    }
+  }
+  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;
+        }
+      }
+      return controllerResult;
+    } catch (error) {
+      PROD_LOGGER(error.message ?? error);
+      return void 0;
+    }
+  }
+  getHandlerMetadata(target) {
+    const handlerMetadata = Reflect.getMetadata(HANDLER, target);
+    return handlerMetadata ?? {};
+  }
+  getGuards(target) {
+    const guards = Reflect.getMetadata(GUARD, target);
+    return guards ?? [];
+  }
+  getControllerPrefix(target) {
+    const prefix = Reflect.getMetadata(CONTROLLER, target);
+    if (typeof prefix !== "string") throw new ControllerIsNotValid(target.name);
+    return prefix;
+  }
+  getControllerDependencies(target) {
+    const deps = Reflect.getMetadata("design:paramtypes", target);
+    return deps ?? [];
+  }
+};
+
+// src/decorators.ts
+function Controller(path = "") {
+  return function(target) {
+    Reflect.defineMetadata(CONTROLLER, path, target);
+  };
+}
+__name(Controller, "Controller");
+function Injectable(type = "singleton") {
+  return function(target) {
+    Reflect.defineMetadata(INJECTABLE, type, target);
+  };
+}
+__name(Injectable, "Injectable");
+function OnSend(path = "") {
+  return function(_target, _property, descriptor) {
+    Reflect.defineMetadata(HANDLER, {
+      path,
+      type: "send"
+    }, descriptor.value);
+  };
+}
+__name(OnSend, "OnSend");
+function OnInvoke(path = "") {
+  return function(_target, _property, descriptor) {
+    Reflect.defineMetadata(HANDLER, {
+      path,
+      type: "invoke"
+    }, descriptor.value);
+  };
+}
+__name(OnInvoke, "OnInvoke");
+function _getParams(target, property) {
+  const prevParams = Reflect.getMetadata(PARAM, target, property);
+  return prevParams ?? [];
+}
+__name(_getParams, "_getParams");
+function _getGuards(target) {
+  const prevGuards = Reflect.getMetadata(GUARD, target);
+  return prevGuards ?? [];
+}
+__name(_getGuards, "_getGuards");
+function Payload() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "payload";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Payload, "Payload");
+function Event() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "event";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Event, "Event");
+function Ctx() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "ctx";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Ctx, "Ctx");
+function UseGuards(...guards) {
+  return function(_target, _property, descriptor) {
+    const target = descriptor ? descriptor.value : _target;
+    const prevGuards = _getGuards(target).filter((prevGuard) => !guards.includes(prevGuard));
+    Reflect.defineMetadata(GUARD, [
+      ...guards,
+      ...prevGuards
+    ], target);
+  };
+}
+__name(UseGuards, "UseGuards");
+function SetMetadata(key, value) {
+  return function(target, propertyKey, descriptor) {
+    const targetKey = descriptor ? descriptor.value : target;
+    Reflect.defineMetadata(key, value, targetKey);
+  };
+}
+__name(SetMetadata, "SetMetadata");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Application,
+  Controller,
+  Ctx,
+  Event,
+  ExecutionContext,
+  Injectable,
+  OnInvoke,
+  OnSend,
+  Payload,
+  Reflector,
+  SetMetadata,
+  UseGuards,
+  applyDecorators
+});

package/dist/index.d.cts

@@ -0,0 +1,64 @@
+import { Observable } from 'rxjs';
+import { IpcMainEvent, IpcMainInvokeEvent } from 'electron';
+
+declare class Reflector {
+    get<T = any>(key: any, target: any): T;
+    getAll<T = any>(key: any, ...targets: any[]): T[];
+    getAllAndOverride<T = any>(key: any, ...targets: any[]): (T & ({} | null)) | undefined;
+    getAllAndMerge<T = any>(key: any, ...targets: any[]): T;
+}
+declare class ExecutionContext {
+    private readonly _classRef;
+    private readonly _handler;
+    private _payload;
+    private _event;
+    constructor(_classRef: any, _handler: CallableFunction, _payload: any, _event: IpcMainEvent | IpcMainInvokeEvent);
+    getHandler(): CallableFunction;
+    getClass<T = any>(): T;
+    get payload(): any;
+    get event(): Electron.IpcMainEvent | Electron.IpcMainInvokeEvent;
+    set payload(payload: any);
+}
+declare function applyDecorators(...decorators: CallableFunction[]): (target: Object, _propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+
+type Class<T = any> = new (...args: any[]) => T;
+type InjectableType = 'singleton' | 'transient';
+type Provider = Class | {
+    provided: Class;
+    useClass: Class;
+};
+interface CanActivate {
+    canActivate: (context: ExecutionContext) => boolean | Promise<boolean> | Observable<boolean>;
+}
+interface ConfigOptions {
+    providers?: Provider[];
+    controllers?: Class[];
+}
+
+declare class Application {
+    private configOptions;
+    private container;
+    constructor(configOptions: ConfigOptions);
+    private loadProviders;
+    private loadControllers;
+    private getParams;
+    private buildPath;
+    private guardExecute;
+    private controllerExecute;
+    private getHandlerMetadata;
+    private getGuards;
+    private getControllerPrefix;
+    private getControllerDependencies;
+}
+
+declare function Controller(path?: string): ClassDecorator;
+declare function Injectable(type?: InjectableType): ClassDecorator;
+declare function OnSend(path?: string): MethodDecorator;
+declare function OnInvoke(path?: string): MethodDecorator;
+declare function Payload(): ParameterDecorator;
+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;
+
+export { Application, type CanActivate, type ConfigOptions, Controller, Ctx, Event, ExecutionContext, Injectable, type InjectableType, OnInvoke, OnSend, Payload, Reflector, SetMetadata, UseGuards, applyDecorators };

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+import { Observable } from 'rxjs';
+import { IpcMainEvent, IpcMainInvokeEvent } from 'electron';
+
+declare class Reflector {
+    get<T = any>(key: any, target: any): T;
+    getAll<T = any>(key: any, ...targets: any[]): T[];
+    getAllAndOverride<T = any>(key: any, ...targets: any[]): (T & ({} | null)) | undefined;
+    getAllAndMerge<T = any>(key: any, ...targets: any[]): T;
+}
+declare class ExecutionContext {
+    private readonly _classRef;
+    private readonly _handler;
+    private _payload;
+    private _event;
+    constructor(_classRef: any, _handler: CallableFunction, _payload: any, _event: IpcMainEvent | IpcMainInvokeEvent);
+    getHandler(): CallableFunction;
+    getClass<T = any>(): T;
+    get payload(): any;
+    get event(): Electron.IpcMainEvent | Electron.IpcMainInvokeEvent;
+    set payload(payload: any);
+}
+declare function applyDecorators(...decorators: CallableFunction[]): (target: Object, _propertyKey?: string | symbol, descriptor?: PropertyDescriptor) => void;
+
+type Class<T = any> = new (...args: any[]) => T;
+type InjectableType = 'singleton' | 'transient';
+type Provider = Class | {
+    provided: Class;
+    useClass: Class;
+};
+interface CanActivate {
+    canActivate: (context: ExecutionContext) => boolean | Promise<boolean> | Observable<boolean>;
+}
+interface ConfigOptions {
+    providers?: Provider[];
+    controllers?: Class[];
+}
+
+declare class Application {
+    private configOptions;
+    private container;
+    constructor(configOptions: ConfigOptions);
+    private loadProviders;
+    private loadControllers;
+    private getParams;
+    private buildPath;
+    private guardExecute;
+    private controllerExecute;
+    private getHandlerMetadata;
+    private getGuards;
+    private getControllerPrefix;
+    private getControllerDependencies;
+}
+
+declare function Controller(path?: string): ClassDecorator;
+declare function Injectable(type?: InjectableType): ClassDecorator;
+declare function OnSend(path?: string): MethodDecorator;
+declare function OnInvoke(path?: string): MethodDecorator;
+declare function Payload(): ParameterDecorator;
+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;
+
+export { Application, type CanActivate, type ConfigOptions, Controller, Ctx, Event, ExecutionContext, Injectable, type InjectableType, OnInvoke, OnSend, Payload, Reflector, SetMetadata, UseGuards, applyDecorators };

package/dist/index.js

@@ -0,0 +1,401 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/index.ts
+import "reflect-metadata";
+
+// src/application.ts
+import { first, lastValueFrom, Observable } from "rxjs";
+
+// src/errors.ts
+var ElectronDiError = class extends Error {
+  static {
+    __name(this, "ElectronDiError");
+  }
+  constructor(message) {
+    super(message);
+  }
+};
+var ProviderNotFound = class extends ElectronDiError {
+  static {
+    __name(this, "ProviderNotFound");
+  }
+  constructor(providerName) {
+    super(`Provider '${providerName}' not found`);
+  }
+};
+var CircularDependency = class extends ElectronDiError {
+  static {
+    __name(this, "CircularDependency");
+  }
+  constructor(providerName) {
+    super(`Circular dependency detected for provider '${providerName}'`);
+  }
+};
+var ProviderIsNotInjectable = class extends ElectronDiError {
+  static {
+    __name(this, "ProviderIsNotInjectable");
+  }
+  constructor(providerName) {
+    super(`Provider '${providerName}' is not injectable. Please ensure it is decorated with @Injectable()`);
+  }
+};
+var ControllerIsNotValid = class extends ElectronDiError {
+  static {
+    __name(this, "ControllerIsNotValid");
+  }
+  constructor(controllerName) {
+    super(`Controller '${controllerName}' is not valid. Please ensure it is decorated with @Controller()`);
+  }
+};
+
+// src/keys.ts
+var CONTROLLER = Symbol("electron-di:controller");
+var INJECTABLE = Symbol("electron-di:injectable");
+var HANDLER = Symbol("electron-di:handler");
+var PARAM = Symbol("electron-di:param");
+var GUARD = Symbol("electron-di:guard");
+
+// src/utilities.ts
+var Reflector = class {
+  static {
+    __name(this, "Reflector");
+  }
+  get(key, target) {
+    return Reflect.getMetadata(key, target);
+  }
+  getAll(key, ...targets) {
+    return targets.map((t) => this.get(key, t));
+  }
+  getAllAndOverride(key, ...targets) {
+    return this.getAll(key, ...targets).reverse().find((value) => value !== void 0);
+  }
+  getAllAndMerge(key, ...targets) {
+    return this.getAll(key, ...targets).reduce((a, b) => {
+      if (Array.isArray(a)) return a.concat(b);
+      if (typeof a === "object" && typeof b === "object") return {
+        ...a,
+        ...b
+      };
+      return b;
+    }, []);
+  }
+};
+var ExecutionContext = class {
+  static {
+    __name(this, "ExecutionContext");
+  }
+  _classRef;
+  _handler;
+  _payload;
+  _event;
+  constructor(_classRef, _handler, _payload, _event) {
+    this._classRef = _classRef;
+    this._handler = _handler;
+    this._payload = _payload;
+    this._event = _event;
+  }
+  getHandler() {
+    return this._handler;
+  }
+  getClass() {
+    return this._classRef;
+  }
+  get payload() {
+    return this._payload;
+  }
+  get event() {
+    return this._event;
+  }
+  set payload(payload) {
+    this._payload = payload;
+  }
+};
+function applyDecorators(...decorators) {
+  return function(target, _propertyKey, descriptor) {
+    const targetKey = descriptor ? descriptor.value : target;
+    decorators.forEach((decorator) => decorator(targetKey));
+  };
+}
+__name(applyDecorators, "applyDecorators");
+
+// src/container.ts
+var Container = class {
+  static {
+    __name(this, "Container");
+  }
+  utilities = [
+    Reflector
+  ];
+  providers = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  addProvider(provider) {
+    const token = this.getProviderToken(provider);
+    this.providers.set(token, provider);
+  }
+  getDependencies(providerClass) {
+    return Reflect.getMetadata("design:paramtypes", providerClass) ?? [];
+  }
+  resolve(token, visited = []) {
+    const utilitie = this.utilities.find((u) => u === token);
+    if (utilitie) return new utilitie();
+    const singletonInstance = this.instances.get(token);
+    if (singletonInstance) return singletonInstance;
+    const provider = this.providers.get(token);
+    if (!provider) throw new ProviderNotFound(token.name);
+    if (visited.includes(token)) throw new CircularDependency(token.name);
+    const providerClass = this.getProviderClass(provider);
+    const providerDependencies = this.getDependencies(providerClass);
+    const providerMetadata = this.getProviderMetadata(providerClass);
+    const instanceDependencies = providerDependencies.map((dep) => this.resolve(dep, [
+      ...visited,
+      token
+    ]));
+    if (!providerMetadata) throw new ProviderIsNotInjectable(token.name);
+    const providerInstance = new providerClass(...instanceDependencies);
+    if (providerMetadata === "singleton") this.instances.set(token, providerInstance);
+    return providerInstance;
+  }
+  getProviderToken(provider) {
+    return typeof provider === "object" ? provider.provided : provider;
+  }
+  getProviderClass(provider) {
+    return typeof provider === "object" ? provider.useClass : provider;
+  }
+  getProviderMetadata(provider) {
+    return Reflect.getMetadata(INJECTABLE, provider);
+  }
+};
+
+// src/debugger.ts
+import debug from "debug";
+var prodLogger = debug("app:prod");
+var devLogger = debug("app:dev");
+if (!process.env.APP_LOGGER || process.env.APP_LOGGER === "false") {
+  debug.enable("app:prod");
+} else {
+  debug.enable("app:*");
+}
+var PROD_LOGGER = prodLogger;
+var DEV_LOGGER = devLogger;
+
+// src/application.ts
+import { ipcMain } from "electron";
+var Application = class {
+  static {
+    __name(this, "Application");
+  }
+  configOptions;
+  container = new Container();
+  constructor(configOptions) {
+    this.configOptions = configOptions;
+    this.loadProviders();
+    this.loadControllers();
+  }
+  loadProviders() {
+    for (const provider of this.configOptions.providers || []) {
+      this.container.addProvider(provider);
+      DEV_LOGGER(`Provider ${typeof provider == "object" ? provider.provided.name : provider.name} loaded`);
+    }
+  }
+  loadControllers() {
+    for (const controller of this.configOptions.controllers || []) {
+      const controllerPrefix = this.getControllerPrefix(controller);
+      const controllerDependencies = this.getControllerDependencies(controller);
+      const controllerGuards = this.getGuards(controller);
+      const controllerInstance = new controller(...controllerDependencies.map((dep) => this.container.resolve(dep)));
+      const controllerMethods = Object.getOwnPropertyNames(controllerInstance.constructor.prototype).filter((method) => method !== "constructor");
+      for (const controllerMethod of controllerMethods) {
+        const handlerMetadata = this.getHandlerMetadata(controllerInstance[controllerMethod]);
+        if (typeof handlerMetadata !== "object") continue;
+        const handlerGuards = this.getGuards(controllerInstance[controllerMethod]);
+        const guards = controllerGuards.filter((guard) => !handlerGuards.includes(guard)).concat(handlerGuards).map((guard) => this.container.resolve(guard));
+        const path = this.buildPath(controllerPrefix, controllerMethod);
+        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;
+          }
+          const params = this.getParams(controllerInstance, controllerMethod, executionContext);
+          const controllerResult = await this.controllerExecute(controllerInstance, controllerInstance[controllerMethod], params);
+          return controllerResult;
+        }, "handlerCallback");
+        if (handlerMetadata.type === "invoke") {
+          ipcMain.handle(path, handlerCallback);
+        } else {
+          ipcMain.on(path, handlerCallback);
+        }
+      }
+    }
+  }
+  getParams(target, propertyKey, executionContext) {
+    const params = Reflect.getMetadata(PARAM, target, propertyKey);
+    if (!params) return [];
+    return params.map((param) => {
+      if (param === "ctx") return executionContext;
+      if (param === "event") return executionContext.event;
+      if (param === "payload") return executionContext.payload;
+      return void 0;
+    });
+  }
+  buildPath(controllerPrefix, methodPath) {
+    const prefix = controllerPrefix.trim();
+    const path = methodPath.trim();
+    if (prefix && path) return `${prefix}:${path}`;
+    if (prefix) return prefix;
+    if (path) return path;
+    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;
+    }
+  }
+  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;
+        }
+      }
+      return controllerResult;
+    } catch (error) {
+      PROD_LOGGER(error.message ?? error);
+      return void 0;
+    }
+  }
+  getHandlerMetadata(target) {
+    const handlerMetadata = Reflect.getMetadata(HANDLER, target);
+    return handlerMetadata ?? {};
+  }
+  getGuards(target) {
+    const guards = Reflect.getMetadata(GUARD, target);
+    return guards ?? [];
+  }
+  getControllerPrefix(target) {
+    const prefix = Reflect.getMetadata(CONTROLLER, target);
+    if (typeof prefix !== "string") throw new ControllerIsNotValid(target.name);
+    return prefix;
+  }
+  getControllerDependencies(target) {
+    const deps = Reflect.getMetadata("design:paramtypes", target);
+    return deps ?? [];
+  }
+};
+
+// src/decorators.ts
+function Controller(path = "") {
+  return function(target) {
+    Reflect.defineMetadata(CONTROLLER, path, target);
+  };
+}
+__name(Controller, "Controller");
+function Injectable(type = "singleton") {
+  return function(target) {
+    Reflect.defineMetadata(INJECTABLE, type, target);
+  };
+}
+__name(Injectable, "Injectable");
+function OnSend(path = "") {
+  return function(_target, _property, descriptor) {
+    Reflect.defineMetadata(HANDLER, {
+      path,
+      type: "send"
+    }, descriptor.value);
+  };
+}
+__name(OnSend, "OnSend");
+function OnInvoke(path = "") {
+  return function(_target, _property, descriptor) {
+    Reflect.defineMetadata(HANDLER, {
+      path,
+      type: "invoke"
+    }, descriptor.value);
+  };
+}
+__name(OnInvoke, "OnInvoke");
+function _getParams(target, property) {
+  const prevParams = Reflect.getMetadata(PARAM, target, property);
+  return prevParams ?? [];
+}
+__name(_getParams, "_getParams");
+function _getGuards(target) {
+  const prevGuards = Reflect.getMetadata(GUARD, target);
+  return prevGuards ?? [];
+}
+__name(_getGuards, "_getGuards");
+function Payload() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "payload";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Payload, "Payload");
+function Event() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "event";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Event, "Event");
+function Ctx() {
+  return function(target, property, paramIndex) {
+    const params = _getParams(target, property);
+    params[paramIndex] = "ctx";
+    Reflect.defineMetadata(PARAM, params, target, property);
+  };
+}
+__name(Ctx, "Ctx");
+function UseGuards(...guards) {
+  return function(_target, _property, descriptor) {
+    const target = descriptor ? descriptor.value : _target;
+    const prevGuards = _getGuards(target).filter((prevGuard) => !guards.includes(prevGuard));
+    Reflect.defineMetadata(GUARD, [
+      ...guards,
+      ...prevGuards
+    ], target);
+  };
+}
+__name(UseGuards, "UseGuards");
+function SetMetadata(key, value) {
+  return function(target, propertyKey, descriptor) {
+    const targetKey = descriptor ? descriptor.value : target;
+    Reflect.defineMetadata(key, value, targetKey);
+  };
+}
+__name(SetMetadata, "SetMetadata");
+export {
+  Application,
+  Controller,
+  Ctx,
+  Event,
+  ExecutionContext,
+  Injectable,
+  OnInvoke,
+  OnSend,
+  Payload,
+  Reflector,
+  SetMetadata,
+  UseGuards,
+  applyDecorators
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "electron-injector",
+  "version": "1.0.2",
+  "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",
+  "scripts": {
+    "build": "tsup"
+  },
+  "author": {
+    "name": "Alejandro Jorgen",
+    "email": "ajorgenmarten35@gmail.com",
+    "url": "https://github.com/ajorgenmarten"
+  },
+  "keywords": [
+    "electron",
+    "dependency injection",
+    "dependency inversion",
+    "injection",
+    "inversion"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ajorgenmarten/electron-injector"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/ajorgenmarten/electron-injector#readme",
+  "bugs": {
+    "email": "ajorgenmarten35@gmail.com",
+    "url": "https://github.com/ajorgenmarten/electron-injector/issues"
+  },
+  "packageManager": "pnpm@10.24.0",
+  "type": "module",
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.3",
+    "@eslint/js": "^9.39.1",
+    "@swc/core": "^1.15.3",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^24.10.1",
+    "electron": "^39.2.4",
+    "eslint": "^9.39.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "globals": "^16.5.0",
+    "prettier": "^3.7.2",
+    "rxjs": "^7.8.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.0"
+  },
+  "peerDependencies": {
+    "electron": "^39.2.4",
+    "rxjs": "^7.8.2"
+  },
+  "files": [
+    "dist/",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "debug": "^4.4.3",
+    "reflect-metadata": "0.2.2"
+  }
+}