jerkjs 2.0.0

package/examples/v2_openapi/controllers/authController.js

@@ -0,0 +1,52 @@
+const jwt = require('jsonwebtoken');
+const { TokenManager } = require('../../../index.js');
+
+// TokenManager para este controlador
+const tokenManager = new TokenManager({
+  storage: 'memory'
+});
+
+const authController = {
+  login: async (req, res) => {
+    try {
+      const { username, password } = req.body;
+
+      // Validación simple de credenciales (esto debería ser más robusto en producción)
+      if (!username || !password) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Nombre de usuario y contraseña requeridos' }));
+        return;
+      }
+
+      // Simulación de autenticación (en una aplicación real, esto verificaría contra una base de datos)
+      if (username === 'admin' && password === 'password') {
+        // Generar un token JWT
+        const payload = { 
+          userId: 1, 
+          username: username,
+          role: 'admin'
+        };
+        
+        // Secret para firmar el token (en producción, debería estar en variables de entorno)
+        const secret = 'super-secret-key-for-openapi-example';
+        const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          message: 'Inicio de sesión exitoso',
+          token: token,
+          user: payload
+        }));
+      } else {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Credenciales inválidas' }));
+      }
+    } catch (error) {
+      console.error('Error en login:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+};
+
+module.exports = authController;

package/examples/v2_openapi/controllers/mainController.js

@@ -0,0 +1,26 @@
+const jwt = require('jsonwebtoken');
+const { TokenManager } = require('../../../index.js');
+
+// TokenManager para este controlador
+const tokenManager = new TokenManager({
+  storage: 'memory'
+});
+
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Bienvenido a la API de ejemplo con funcionalidad OpenAPI',
+      endpoints: {
+        'POST /login': 'Iniciar sesión y obtener token',
+        'GET /users': 'Obtener lista de usuarios (requiere token)',
+        'GET /products': 'Obtener lista de productos (requiere token)',
+        'GET /profile': 'Obtener perfil de usuario (requiere token)',
+        'GET /docs': 'Documentación interactiva OpenAPI/Swagger',
+        'GET /openapi.json': 'Especificación OpenAPI'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;

package/examples/v2_openapi/controllers/productController.js

@@ -0,0 +1,17 @@
+// Datos de ejemplo de productos
+const products = [
+  { id: 1, name: 'Laptop', price: 999.99, category: 'Electronics' },
+  { id: 2, name: 'Mouse', price: 29.99, category: 'Electronics' },
+  { id: 3, name: 'Keyboard', price: 79.99, category: 'Electronics' },
+  { id: 4, name: 'Monitor', price: 299.99, category: 'Electronics' },
+  { id: 5, name: 'Webcam', price: 89.99, category: 'Electronics' }
+];
+
+const productController = {
+  getProducts: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(products));
+  }
+};
+
+module.exports = productController;

package/examples/v2_openapi/controllers/userController.js

@@ -0,0 +1,27 @@
+// Datos de ejemplo de usuarios
+const users = [
+  { id: 1, name: 'John Doe', email: 'john@example.com', role: 'admin' },
+  { id: 2, name: 'Jane Smith', email: 'jane@example.com', role: 'user' },
+  { id: 3, name: 'Robert Johnson', email: 'robert@example.com', role: 'user' }
+];
+
+const userController = {
+  getUsers: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(users));
+  },
+
+  getProfile: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      profile: {
+        id: req.user.userId,
+        username: req.user.username || 'Usuario',
+        role: req.user.role || 'guest'
+      },
+      message: 'Perfil de usuario obtenido exitosamente'
+    }));
+  }
+};
+
+module.exports = userController;

package/examples/v2_openapi/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "api-sdk-openapi-example",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con funcionalidad OpenAPI usando el Framework API SDK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "openapi",
+    "swagger",
+    "documentation",
+    "framework"
+  ],
+  "author": "API SDK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2_openapi/routes.json

@@ -0,0 +1,37 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/login",
+    "method": "POST",
+    "controller": "./controllers/authController.js",
+    "handler": "login",
+    "auth": "none"
+  },
+  {
+    "path": "/users",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getUsers",
+    "auth": "jwt-openapi"
+  },
+  {
+    "path": "/products",
+    "method": "GET",
+    "controller": "./controllers/productController.js",
+    "handler": "getProducts",
+    "auth": "jwt-openapi"
+  },
+  {
+    "path": "/profile",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getProfile",
+    "auth": "jwt-openapi"
+  }
+]

package/generate_token.js

@@ -0,0 +1,10 @@
+const jwt = require('jsonwebtoken');
+
+// Generar un token JWT de prueba
+const payload = { userId: 1, username: 'testuser', role: 'user' };
+const secret = 'secret-jwt-key';
+
+const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+console.log('Token JWT generado:');
+console.log(token);

package/index.js

@@ -0,0 +1,85 @@
+/**
+ * Punto de entrada del framework API SDK
+ * API SDK Framework v2.0
+ */
+
+const APIServer = require('./lib/core/server');
+const Router = require('./lib/core/router');
+const HandlerManager = require('./lib/core/handler');
+const Authenticator = require('./lib/middleware/authenticator');
+const Validator = require('./lib/middleware/validator');
+const RouteLoader = require('./lib/loader/routeLoader');
+const ControllerLoader = require('./lib/loader/controllerLoader');
+const ConfigParser = require('./lib/utils/configParser');
+const { Logger } = require('./lib/utils/logger');
+
+// Componentes adicionales de la versión 2.0
+const Cors = require('./lib/middleware/cors');
+const RateLimiter = require('./lib/middleware/rateLimiter');
+const Compressor = require('./lib/middleware/compressor');
+const TokenManager = require('./lib/utils/tokenManager');
+const MariaDBTokenAdapter = require('./lib/utils/mariadbTokenAdapter');
+const SQLiteTokenAdapter = require('./lib/utils/sqliteTokenAdapter');
+const AuditLogger = require('./lib/middleware/auditLogger');
+const OpenApiGenerator = require('./lib/utils/openapiGenerator');
+
+const HookSystem = require('./lib/core/hooks');
+
+// Importar componentes adicionales
+const SecurityEnhancedServer = require('./lib/core/securityEnhancedServer');
+const Firewall = require('./lib/middleware/firewall');
+const { SessionManager, sessionAuth } = require('./lib/middleware/session');
+
+// Componentes MVC
+const ViewEngine = require('./lib/mvc/viewEngine');
+const ControllerBase = require('./lib/mvc/controllerBase');
+
+// Exportar todos los componentes del framework
+module.exports = {
+  // Componentes fundamentales (v1.0)
+  APIServer,
+  Router,
+  HandlerManager,
+  Authenticator,
+  Validator,
+  RouteLoader,
+  ControllerLoader,
+  ConfigParser,
+  Logger,
+
+  // Componentes de seguridad y rendimiento (v2.0)
+  Cors,
+  RateLimiter,
+  Compressor,
+
+  // Componentes de utilidad (v2.0)
+  TokenManager,
+  MariaDBTokenAdapter,
+  SQLiteTokenAdapter,
+  AuditLogger,
+  OpenApiGenerator,
+
+  // Sistema de hooks para extensibilidad
+  HookSystem,
+
+  // Componentes de seguridad avanzada (v2.1.0)
+  SecurityEnhancedServer,
+  Firewall,
+
+  // Componentes de sesión (v2.2.0)
+  SessionManager,
+  sessionAuth,
+
+  // Componentes MVC (v2.3.0)
+  ViewEngine,
+  ControllerBase
+};
+
+// También exportar clases individuales por conveniencia
+module.exports.APISDK = APIServer;
+
+// Crear instancia global del sistema de hooks
+module.exports.hooks = new HookSystem();
+
+// Disparar hooks de inicio del framework
+module.exports.hooks.doAction('framework_init');

package/lib/core/handler.js

@@ -0,0 +1,86 @@
+/**
+ * Gestión de handlers para el framework API SDK
+ * Implementación del componente core/handler.js
+ */
+
+class HandlerManager {
+  /**
+   * Constructor del gestor de handlers
+   */
+  constructor() {
+    this.handlers = new Map();
+  }
+
+  /**
+   * Método para registrar un handler
+   * @param {string} name - Nombre del handler
+   * @param {Function} handler - Función handler
+   */
+  register(name, handler) {
+    this.handlers.set(name, handler);
+  }
+
+  /**
+   * Método para obtener un handler registrado
+   * @param {string} name - Nombre del handler
+   * @returns {Function|null} - Función handler o null si no existe
+   */
+  get(name) {
+    return this.handlers.get(name) || null;
+  }
+
+  /**
+   * Método para ejecutar un handler
+   * @param {string} name - Nombre del handler
+   * @param {Object} req - Objeto de solicitud HTTP
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @returns {*} - Resultado de la ejecución del handler
+   */
+  async execute(name, req, res) {
+    const handler = this.get(name);
+    if (!handler) {
+      throw new Error(`Handler '${name}' no encontrado`);
+    }
+    
+    // Verificar si el handler es una función asíncrona o no
+    if (handler.constructor.name === 'AsyncFunction') {
+      return await handler(req, res);
+    } else {
+      return handler(req, res);
+    }
+  }
+
+  /**
+   * Método para eliminar un handler
+   * @param {string} name - Nombre del handler
+   */
+  remove(name) {
+    this.handlers.delete(name);
+  }
+
+  /**
+   * Método para limpiar todos los handlers
+   */
+  clear() {
+    this.handlers.clear();
+  }
+
+  /**
+   * Método para verificar si un handler existe
+   * @param {string} name - Nombre del handler
+   * @returns {boolean} - True si existe, false en caso contrario
+   */
+  has(name) {
+    return this.handlers.has(name);
+  }
+
+  /**
+   * Método para obtener todos los nombres de handlers
+   * @returns {Array} - Array con los nombres de todos los handlers
+   */
+  getAllNames() {
+    return Array.from(this.handlers.keys());
+  }
+}
+
+module.exports = HandlerManager;

package/lib/core/hooks.js

@@ -0,0 +1,224 @@
+/**
+ * Sistema de Hooks y Filters como el core de WordPress
+ * Implementación para el Framework API SDK
+ */
+
+class HookSystem {
+  constructor() {
+    // Almacenar acciones registradas
+    this.actions = new Map();
+    // Almacenar filtros registrados
+    this.filters = new Map();
+  }
+
+  /**
+   * Registra una acción
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Función a ejecutar
+   * @param {number} priority - Prioridad (más bajo se ejecuta primero)
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   */
+  addAction(hookName, callback, priority = 10, acceptedArgs = 1) {
+    if (!this.actions.has(hookName)) {
+      this.actions.set(hookName, []);
+    }
+
+    const hookList = this.actions.get(hookName);
+    hookList.push({
+      callback,
+      priority,
+      acceptedArgs,
+      id: Date.now() + Math.random() // ID único para identificar el hook
+    });
+
+    // Ordenar por prioridad
+    hookList.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Registra un filtro
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Función a ejecutar
+   * @param {number} priority - Prioridad (más bajo se ejecuta primero)
+   * @param {number} acceptedArgs - Número de argumentos aceptados
+   */
+  addFilter(hookName, callback, priority = 10, acceptedArgs = 1) {
+    if (!this.filters.has(hookName)) {
+      this.filters.set(hookName, []);
+    }
+
+    const hookList = this.filters.get(hookName);
+    hookList.push({
+      callback,
+      priority,
+      acceptedArgs,
+      id: Date.now() + Math.random() // ID único para identificar el hook
+    });
+
+    // Ordenar por prioridad
+    hookList.sort((a, b) => a.priority - b.priority);
+  }
+
+  /**
+   * Ejecuta una acción
+   * @param {string} hookName - Nombre del hook
+   * @param {...any} args - Argumentos a pasar a los callbacks
+   */
+  doAction(hookName, ...args) {
+    const hooks = this.actions.get(hookName);
+    if (!hooks || hooks.length === 0) {
+      return;
+    }
+
+    for (const hook of hooks) {
+      // Limitar argumentos según acceptedArgs
+      const callArgs = args.slice(0, hook.acceptedArgs);
+      hook.callback(...callArgs);
+    }
+  }
+
+  /**
+   * Aplica un filtro
+   * @param {string} hookName - Nombre del hook
+   * @param {any} value - Valor a filtrar
+   * @param {...any} additionalArgs - Argumentos adicionales
+   * @returns {any} - Valor filtrado
+   */
+  applyFilters(hookName, value, ...additionalArgs) {
+    const hooks = this.filters.get(hookName);
+    if (!hooks || hooks.length === 0) {
+      return value;
+    }
+
+    let filteredValue = value;
+    for (const hook of hooks) {
+      // El primer argumento es el valor a filtrar, luego los adicionales
+      const callArgs = [filteredValue, ...additionalArgs.slice(0, hook.acceptedArgs - 1)];
+      filteredValue = hook.callback(...callArgs);
+    }
+
+    return filteredValue;
+  }
+
+  /**
+   * Verifica si una acción tiene callbacks registrados
+   * @param {string} hookName - Nombre del hook
+   * @returns {boolean} - True si tiene callbacks registrados
+   */
+  hasAction(hookName) {
+    const hooks = this.actions.get(hookName);
+    return !!hooks && hooks.length > 0;
+  }
+
+  /**
+   * Verifica si un filtro tiene callbacks registrados
+   * @param {string} hookName - Nombre del hook
+   * @returns {boolean} - True si tiene callbacks registrados
+   */
+  hasFilter(hookName) {
+    const hooks = this.filters.get(hookName);
+    return !!hooks && hooks.length > 0;
+  }
+
+  /**
+   * Elimina una acción específica
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Callback a eliminar
+   * @param {number} priority - Prioridad del callback
+   * @returns {boolean} - True si se eliminó correctamente
+   */
+  removeAction(hookName, callback, priority = 10) {
+    const hooks = this.actions.get(hookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+    const filteredHooks = hooks.filter(hook => 
+      !(hook.callback === callback && hook.priority === priority)
+    );
+
+    if (filteredHooks.length !== initialLength) {
+      this.actions.set(hookName, filteredHooks);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina un filtro específico
+   * @param {string} hookName - Nombre del hook
+   * @param {Function} callback - Callback a eliminar
+   * @param {number} priority - Prioridad del callback
+   * @returns {boolean} - True si se eliminó correctamente
+   */
+  removeFilter(hookName, callback, priority = 10) {
+    const hooks = this.filters.get(hookName);
+    if (!hooks) {
+      return false;
+    }
+
+    const initialLength = hooks.length;
+    const filteredHooks = hooks.filter(hook => 
+      !(hook.callback === callback && hook.priority === priority)
+    );
+
+    if (filteredHooks.length !== initialLength) {
+      this.filters.set(hookName, filteredHooks);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Elimina todas las acciones de un hook
+   * @param {string} hookName - Nombre del hook
+   * @returns {boolean} - True si se eliminaron correctamente
+   */
+  removeAllActions(hookName) {
+    if (!hookName) {
+      this.actions.clear();
+      return true;
+    }
+    
+    return this.actions.delete(hookName);
+  }
+
+  /**
+   * Elimina todos los filtros de un hook
+   * @param {string} hookName - Nombre del hook
+   * @returns {boolean} - True si se eliminaron correctamente
+   */
+  removeAllFilters(hookName) {
+    if (!hookName) {
+      this.filters.clear();
+      return true;
+    }
+    
+    return this.filters.delete(hookName);
+  }
+
+  /**
+   * Obtiene el número de callbacks registrados para una acción
+   * @param {string} hookName - Nombre del hook
+   * @returns {number} - Número de callbacks
+   */
+  actionsCount(hookName) {
+    const hooks = this.actions.get(hookName);
+    return hooks ? hooks.length : 0;
+  }
+
+  /**
+   * Obtiene el número de callbacks registrados para un filtro
+   * @param {string} hookName - Nombre del hook
+   * @returns {number} - Número de callbacks
+   */
+  filtersCount(hookName) {
+    const hooks = this.filters.get(hookName);
+    return hooks ? hooks.length : 0;
+  }
+}
+
+module.exports = HookSystem;