jerkjs 2.0.0

package/lib/middleware/session.js

@@ -0,0 +1,301 @@
+/**
+ * Middleware de sesión para el framework API SDK
+ * Implementación del componente middleware/session.js
+ */
+
+const crypto = require('crypto');
+
+class SessionManager {
+  constructor(options = {}) {
+    this.sessions = new Map(); // Almacenamiento en memoria de sesiones
+    this.cookieName = options.cookieName || 'sessionId';
+    this.secret = options.secret || 'default-session-secret-change-me';
+    this.timeout = options.timeout || 3600000; // 1 hora por defecto
+
+    // Obtener instancia de hooks del framework
+    try {
+      const framework = require('../../index.js');
+      this.hooks = framework.hooks;
+    } catch (error) {
+      // Si no está disponible, crear instancia local
+      const HookSystem = require('../core/hooks');
+      this.hooks = new HookSystem();
+    }
+  }
+
+  /**
+   * Genera un ID de sesión seguro
+   * @returns {string} - ID de sesión generado
+   */
+  generateSessionId() {
+    return crypto.randomBytes(32).toString('hex');
+  }
+
+  /**
+   * Crea una nueva sesión
+   * @param {Object} userData - Datos del usuario para almacenar en la sesión
+   * @returns {string} - ID de la sesión creada
+   */
+  createSession(userData) {
+    // Permitir que otros módulos modifiquen los datos de la sesión antes de crearla
+    const processedUserData = this.hooks.applyFilters('session_create_data', userData);
+
+    const sessionId = this.generateSessionId();
+    const sessionData = {
+      id: sessionId,
+      data: processedUserData,
+      createdAt: Date.now(),
+      lastAccessed: Date.now()
+    };
+
+    this.sessions.set(sessionId, sessionData);
+
+    // Disparar hook después de crear la sesión
+    this.hooks.doAction('session_created', sessionId, sessionData);
+
+    return sessionId;
+  }
+
+  /**
+   * Obtiene los datos de una sesión
+   * @param {string} sessionId - ID de la sesión
+   * @returns {Object|null} - Datos de la sesión o null si no existe
+   */
+  getSession(sessionId) {
+    if (!sessionId) {
+      // Disparar hook cuando se intenta obtener una sesión sin ID
+      this.hooks.doAction('session_get_no_id');
+      return null;
+    }
+
+    // Permitir que otros módulos modifiquen el ID de sesión antes de buscarla
+    const processedSessionId = this.hooks.applyFilters('session_get_id', sessionId);
+
+    const session = this.sessions.get(processedSessionId);
+    if (!session) {
+      // Disparar hook cuando no se encuentra la sesión
+      this.hooks.doAction('session_not_found', processedSessionId);
+      return null;
+    }
+
+    // Verificar si la sesión ha expirado
+    if (Date.now() - session.lastAccessed > this.timeout) {
+      this.destroySession(processedSessionId);
+      // Disparar hook cuando la sesión ha expirado
+      this.hooks.doAction('session_expired', processedSessionId);
+      return null;
+    }
+
+    // Actualizar último acceso
+    session.lastAccessed = Date.now();
+    this.sessions.set(processedSessionId, session);
+
+    // Disparar hook después de obtener la sesión
+    this.hooks.doAction('session_retrieved', processedSessionId, session.data);
+
+    return session.data;
+  }
+
+  /**
+   * Actualiza los datos de una sesión
+   * @param {string} sessionId - ID de la sesión
+   * @param {Object} newData - Nuevos datos para la sesión
+   * @returns {boolean} - True si la actualización fue exitosa
+   */
+  updateSession(sessionId, newData) {
+    // Permitir que otros módulos modifiquen los nuevos datos antes de actualizar
+    const processedNewData = this.hooks.applyFilters('session_update_data', newData, sessionId);
+
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      // Disparar hook cuando se intenta actualizar una sesión inexistente
+      this.hooks.doAction('session_update_failed', sessionId, processedNewData);
+      return false;
+    }
+
+    session.data = { ...session.data, ...processedNewData };
+    session.lastAccessed = Date.now();
+    this.sessions.set(sessionId, session);
+
+    // Disparar hook después de actualizar la sesión
+    this.hooks.doAction('session_updated', sessionId, session.data);
+
+    return true;
+  }
+
+  /**
+   * Destruye una sesión
+   * @param {string} sessionId - ID de la sesión a destruir
+   * @returns {boolean} - True si la destrucción fue exitosa
+   */
+  destroySession(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      // Disparar hook cuando se intenta destruir una sesión inexistente
+      this.hooks.doAction('session_destroy_failed', sessionId);
+      return false;
+    }
+
+    const result = this.sessions.delete(sessionId);
+
+    if (result) {
+      // Disparar hook después de destruir la sesión
+      this.hooks.doAction('session_destroyed', sessionId, session.data);
+    }
+
+    return result;
+  }
+
+  /**
+   * Middleware de sesión
+   * @returns {Function} - Middleware de sesión
+   */
+  middleware() {
+    return (req, res, next) => {
+      // Disparar hook antes de procesar la sesión
+      this.hooks.doAction('session_middleware_before', req, res);
+
+      // Obtener ID de sesión de la cookie
+      const cookies = this.parseCookies(req.headers.cookie || '');
+      const sessionId = cookies[this.cookieName];
+
+      // Agregar métodos de sesión a la solicitud
+      req.session = {
+        id: sessionId,
+        data: sessionId ? this.getSession(sessionId) : null,
+        create: (userData) => {
+          // Permitir que otros módulos modifiquen los datos antes de crear la sesión
+          const processedUserData = this.hooks.applyFilters('session_create_user_data', userData, req);
+
+          const newSessionId = this.createSession(processedUserData);
+          req.session.id = newSessionId;
+          req.session.data = processedUserData;
+
+          // Establecer cookie con el ID de sesión
+          res.setHeader('Set-Cookie', `${this.cookieName}=${newSessionId}; HttpOnly; Path=/; Max-Age=${this.timeout / 1000}`);
+
+          // Disparar hook después de crear la sesión
+          this.hooks.doAction('session_created_response', req, res, newSessionId);
+
+          return newSessionId;
+        },
+        update: (newData) => {
+          if (!req.session.id) return false;
+
+          // Permitir que otros módulos modifiquen los datos antes de actualizar
+          const processedNewData = this.hooks.applyFilters('session_update_user_data', newData, req, req.session.id);
+
+          const result = this.updateSession(req.session.id, processedNewData);
+
+          // Disparar hook después de actualizar la sesión
+          if (result) {
+            this.hooks.doAction('session_updated_response', req, res, req.session.id);
+          }
+
+          return result;
+        },
+        destroy: () => {
+          if (!req.session.id) return false;
+
+          // Disparar hook antes de destruir la sesión
+          this.hooks.doAction('session_destroy_before', req, res, req.session.id);
+
+          // Borrar cookie
+          res.setHeader('Set-Cookie', `${this.cookieName}=; HttpOnly; Path=/; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:01 GMT`);
+
+          const result = this.destroySession(req.session.id);
+          req.session.id = null;
+          req.session.data = null;
+
+          // Disparar hook después de destruir la sesión
+          if (result) {
+            this.hooks.doAction('session_destroyed_response', req, res);
+          }
+
+          return result;
+        },
+        regenerate: (userData) => {
+          if (req.session.id) {
+            this.destroySession(req.session.id);
+          }
+          return req.session.create(userData);
+        }
+      };
+
+      // Disparar hook después de procesar la sesión
+      this.hooks.doAction('session_middleware_after', req, res);
+
+      // Continuar con el siguiente middleware
+      if (next) {
+        next();
+      }
+    };
+  }
+
+  /**
+   * Parsea las cookies de la cabecera
+   * @param {string} cookieHeader - Cabecera de cookies
+   * @returns {Object} - Objeto con las cookies
+   */
+  parseCookies(cookieHeader) {
+    const cookies = {};
+    if (cookieHeader) {
+      cookieHeader.split(';').forEach(cookie => {
+        const parts = cookie.trim().split('=');
+        if (parts.length === 2) {
+          cookies[parts[0]] = parts[1];
+        }
+      });
+    }
+    return cookies;
+  }
+}
+
+/**
+ * Middleware de autenticación basado en sesión
+ * @param {SessionManager} sessionManager - Instancia del administrador de sesiones
+ * @param {Object} options - Opciones de autenticación
+ * @returns {Function} - Middleware de autenticación de sesión
+ */
+function sessionAuth(sessionManager, options = {}) {
+  const redirectTo = options.redirectTo || '/login';
+  const failureMessage = options.failureMessage || 'Acceso no autorizado. Por favor inicie sesión.';
+
+  return (req, res, next) => {
+    // Disparar hook antes de verificar la autenticación
+    sessionManager.hooks.doAction('session_auth_check_before', req, res);
+
+    // Verificar si hay una sesión activa
+    if (!req.session || !req.session.data || !req.session.data.authenticated) {
+      // Disparar hook cuando la autenticación falla
+      sessionManager.hooks.doAction('session_auth_failed', req, res, redirectTo);
+
+      // Si es una solicitud AJAX o API, devolver error JSON
+      if (req.headers['x-requested-with'] === 'XMLHttpRequest' ||
+          req.headers['content-type'] && req.headers['content-type'].includes('application/json')) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: false,
+          message: failureMessage,
+          redirect: redirectTo
+        }));
+        return;
+      } else {
+        // Para solicitudes normales, redirigir al login
+        res.writeHead(302, { 'Location': redirectTo });
+        res.end();
+        return;
+      }
+    }
+
+    // Disparar hook cuando la autenticación es exitosa
+    sessionManager.hooks.doAction('session_auth_success', req, res);
+
+    // Si hay sesión activa, continuar
+    if (next) {
+      next();
+    }
+  };
+}
+
+module.exports = { SessionManager, sessionAuth };

package/lib/middleware/validator.js

@@ -0,0 +1,193 @@
+/**
+ * Middleware de validación para el framework API SDK
+ * Implementación del componente middleware/validator.js
+ */
+
+class Validator {
+  /**
+   * Constructor del validador
+   */
+  constructor() {
+    this.rules = new Map();
+  }
+
+  /**
+   * Método para crear un middleware de validación
+   * @param {Object} schema - Esquema de validación
+   * @returns {Function} - Middleware de validación
+   */
+  validate(schema) {
+    return (req, res, next) => {
+      const errors = this.validateSchema(req, schema);
+      
+      if (errors.length > 0) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          error: 'Validación fallida',
+          details: errors 
+        }));
+        return;
+      }
+      
+      if (next) {
+        next();
+      }
+    };
+  }
+
+  /**
+   * Método para validar un esquema contra una solicitud
+   * @param {Object} req - Objeto de solicitud HTTP
+   * @param {Object} schema - Esquema de validación
+   * @returns {Array} - Array de errores de validación
+   */
+  validateSchema(req, schema) {
+    const errors = [];
+    
+    // Validar campos en query
+    if (schema.query) {
+      for (const [field, rules] of Object.entries(schema.query)) {
+        const value = req.query[field];
+        const fieldErrors = this.validateField(value, rules, `query.${field}`);
+        errors.push(...fieldErrors);
+      }
+    }
+    
+    // Validar campos en params
+    if (schema.params) {
+      for (const [field, rules] of Object.entries(schema.params)) {
+        const value = req.params[field];
+        const fieldErrors = this.validateField(value, rules, `params.${field}`);
+        errors.push(...fieldErrors);
+      }
+    }
+    
+    // Validar campos en body
+    if (schema.body) {
+      for (const [field, rules] of Object.entries(schema.body)) {
+        const value = req.body[field];
+        const fieldErrors = this.validateField(value, rules, `body.${field}`);
+        errors.push(...fieldErrors);
+      }
+    }
+    
+    return errors;
+  }
+
+  /**
+   * Método para validar un campo individual
+   * @param {*} value - Valor a validar
+   * @param {Object|Array} rules - Reglas de validación
+   * @param {string} fieldName - Nombre del campo para mensajes de error
+   * @returns {Array} - Array de errores de validación para este campo
+   */
+  validateField(value, rules, fieldName) {
+    const errors = [];
+    
+    // Si las reglas son un array, procesar cada regla
+    const ruleList = Array.isArray(rules) ? rules : [rules];
+    
+    for (const rule of ruleList) {
+      // Si la regla es una cadena, interpretar como regla predefinida
+      if (typeof rule === 'string') {
+        const [ruleName, ...params] = rule.split(':');
+        const validationFn = this.getValidationRule(ruleName);
+        
+        if (validationFn) {
+          const isValid = validationFn(value, ...params);
+          if (!isValid) {
+            errors.push(`${fieldName} no cumple con la regla: ${ruleName}`);
+          }
+        } else {
+          errors.push(`Regla de validación desconocida: ${ruleName}`);
+        }
+      } 
+      // Si la regla es una función, ejecutarla directamente
+      else if (typeof rule === 'function') {
+        try {
+          const isValid = rule(value);
+          if (!isValid) {
+            errors.push(`${fieldName} no pasó la validación personalizada`);
+          }
+        } catch (error) {
+          errors.push(`${fieldName} causó un error en la validación: ${error.message}`);
+        }
+      }
+      // Si la regla es un objeto, asumir que es un esquema anidado
+      else if (typeof rule === 'object') {
+        if (typeof value === 'object' && value !== null) {
+          const nestedErrors = this.validateSchema({ body: value }, { body: rule });
+          errors.push(...nestedErrors.map(error => `${fieldName}.${error}`));
+        } else {
+          errors.push(`${fieldName} debe ser un objeto`);
+        }
+      }
+    }
+    
+    return errors;
+  }
+
+  /**
+   * Método para obtener una regla de validación por nombre
+   * @param {string} ruleName - Nombre de la regla de validación
+   * @returns {Function|null} - Función de validación o null si no existe
+   */
+  getValidationRule(ruleName) {
+    switch (ruleName) {
+      case 'required':
+        return (value) => value !== undefined && value !== null && value !== '';
+      case 'string':
+        return (value) => typeof value === 'string';
+      case 'number':
+        return (value) => typeof value === 'number' && !isNaN(value);
+      case 'boolean':
+        return (value) => typeof value === 'boolean';
+      case 'email':
+        return (value) => typeof value === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+      case 'minLength':
+        return (value, minLength) => typeof value === 'string' && value.length >= parseInt(minLength);
+      case 'maxLength':
+        return (value, maxLength) => typeof value === 'string' && value.length <= parseInt(maxLength);
+      case 'min':
+        return (value, min) => typeof value === 'number' && value >= parseFloat(min);
+      case 'max':
+        return (value, max) => typeof value === 'number' && value <= parseFloat(max);
+      case 'regex':
+        return (value, pattern) => {
+          try {
+            const regex = new RegExp(pattern);
+            return typeof value === 'string' && regex.test(value);
+          } catch (e) {
+            return false;
+          }
+        };
+      case 'array':
+        return (value) => Array.isArray(value);
+      case 'object':
+        return (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Método para registrar una regla de validación personalizada
+   * @param {string} name - Nombre de la regla
+   * @param {Function} validationFn - Función de validación
+   */
+  addRule(name, validationFn) {
+    this.rules.set(name, validationFn);
+  }
+
+  /**
+   * Método para validar un valor con reglas específicas
+   * @param {*} value - Valor a validar
+   * @param {Array} rules - Array de reglas de validación
+   * @returns {Array} - Array de errores de validación
+   */
+  validateValue(value, rules) {
+    return this.validateField(value, rules, 'value');
+  }
+}
+
+module.exports = Validator;

package/lib/mvc/controllerBase.js

@@ -0,0 +1,207 @@
+/**
+ * Controlador base para el framework API SDK
+ * Implementación del componente MVC controllerBase.js
+ * Similar al sistema de controladores de CodeIgniter
+ */
+
+const ViewEngine = require('./viewEngine');
+
+class ControllerBase {
+  constructor(options = {}) {
+    // Inicializar el motor de vistas
+    this.viewEngine = new ViewEngine({
+      viewsPath: options.viewsPath || './views',
+      defaultExtension: options.defaultExtension || '.html',
+      cacheEnabled: options.cacheEnabled
+    });
+    
+    // Inicializar variables de datos para la vista
+    this.viewData = {};
+    
+    // Referencia al objeto de solicitud y respuesta (cuando esté disponible)
+    this.req = null;
+    this.res = null;
+  }
+
+  /**
+   * Establece variables para pasar a la vista
+   * @param {string|Object} key - Nombre de la variable o objeto con múltiples variables
+   * @param {*} value - Valor de la variable (si key es string)
+   */
+  set(key, value) {
+    if (typeof key === 'object') {
+      // Si se pasa un objeto, fusionar con viewData
+      this.viewData = { ...this.viewData, ...key };
+    } else {
+      // Si se pasa una clave y valor, asignar individualmente
+      this.viewData[key] = value;
+    }
+  }
+
+  /**
+   * Renderiza una vista con las variables actuales
+   * @param {string} viewName - Nombre de la vista a renderizar
+   * @param {Object} additionalData - Datos adicionales para pasar a la vista
+   * @param {Object} options - Opciones adicionales
+   */
+  view(viewName, additionalData = {}, options = {}) {
+    // Fusionar datos de la vista con datos adicionales
+    const data = { ...this.viewData, ...additionalData };
+    
+    // Renderizar la vista
+    const renderedView = this.viewEngine.render(viewName, data, options);
+    
+    return renderedView;
+  }
+
+  /**
+   * Renderiza una vista y la envía como respuesta HTTP
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @param {string} viewName - Nombre de la vista a renderizar
+   * @param {Object} additionalData - Datos adicionales para pasar a la vista
+   * @param {Object} options - Opciones adicionales
+   */
+  render(res, viewName, additionalData = {}, options = {}) {
+    try {
+      // Renderizar la vista
+      const renderedView = this.view(viewName, additionalData, options);
+      
+      // Enviar la vista renderizada como respuesta
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(renderedView);
+    } catch (error) {
+      console.error('Error renderizando vista:', error);
+      res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+      res.end('Error interno del servidor');
+    }
+  }
+
+  /**
+   * Renderiza una vista parcial (sin layout)
+   * @param {string} viewName - Nombre de la vista parcial
+   * @param {Object} additionalData - Datos adicionales para pasar a la vista
+   * @returns {string} - Vista parcial renderizada
+   */
+  partial(viewName, additionalData = {}) {
+    // Fusionar datos de la vista con datos adicionales
+    const data = { ...this.viewData, ...additionalData };
+    
+    // Renderizar la vista parcial
+    return this.viewEngine.render(viewName, data);
+  }
+
+  /**
+   * Redirecciona a otra URL
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @param {string} url - URL a la que redireccionar
+   */
+  redirect(res, url) {
+    res.writeHead(302, { 'Location': url });
+    res.end();
+  }
+
+  /**
+   * Devuelve una respuesta JSON
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @param {Object} data - Datos a enviar como JSON
+   * @param {number} statusCode - Código de estado HTTP
+   */
+  json(res, data, statusCode = 200) {
+    res.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
+    res.end(JSON.stringify(data));
+  }
+
+  /**
+   * Obtiene un valor de la solicitud (query, body o params)
+   * @param {string} key - Clave del valor a obtener
+   * @param {*} defaultValue - Valor por defecto si no se encuentra
+   * @returns {*} - Valor obtenido o valor por defecto
+   */
+  input(key, defaultValue = null) {
+    if (!this.req) {
+      return defaultValue;
+    }
+
+    // Buscar en body, query y params
+    if (this.req.body && typeof this.req.body === 'object' && key in this.req.body) {
+      return this.req.body[key];
+    }
+
+    if (this.req.query && typeof this.req.query === 'object' && key in this.req.query) {
+      return this.req.query[key];
+    }
+
+    if (this.req.params && typeof this.req.params === 'object' && key in this.req.params) {
+      return this.req.params[key];
+    }
+
+    return defaultValue;
+  }
+
+  /**
+   * Obtiene todos los valores de entrada
+   * @returns {Object} - Todos los valores de entrada combinados
+   */
+  allInput() {
+    if (!this.req) {
+      return {};
+    }
+
+    return {
+      ...this.getBody(),
+      ...this.getQuery(),
+      ...this.getParams()
+    };
+  }
+
+  /**
+   * Obtiene los parámetros de consulta (query)
+   * @returns {Object} - Parámetros de consulta
+   */
+  getQuery() {
+    return this.req?.query || {};
+  }
+
+  /**
+   * Obtiene el cuerpo de la solicitud (body)
+   * @returns {Object} - Cuerpo de la solicitud
+   */
+  getBody() {
+    return this.req?.body || {};
+  }
+
+  /**
+   * Obtiene los parámetros de ruta (params)
+   * @returns {Object} - Parámetros de ruta
+   */
+  getParams() {
+    return this.req?.params || {};
+  }
+
+  /**
+   * Establece la solicitud y respuesta actuales
+   * @param {Object} req - Objeto de solicitud HTTP
+   * @param {Object} res - Objeto de respuesta HTTP
+   */
+  setRequestResponse(req, res) {
+    this.req = req;
+    this.res = res;
+  }
+
+  /**
+   * Obtiene la instancia del motor de vistas
+   * @returns {ViewEngine} - Instancia del motor de vistas
+   */
+  getViewEngine() {
+    return this.viewEngine;
+  }
+
+  /**
+   * Limpia las variables de vista
+   */
+  clearViewData() {
+    this.viewData = {};
+  }
+}
+
+module.exports = ControllerBase;