jerkjs 2.2.0 → 2.3.0

package/lib/query/queryBuilderMiddleware.js

@@ -0,0 +1,332 @@
+/**
+ * Middleware de QueryBuilder para el framework JERK
+ * Implementación del componente middleware/queryBuilderMiddleware.js
+ * Proporciona acceso al QueryBuilder a través del sistema de hooks y middlewares
+ */
+
+const QueryBuilder = require('./queryBuilder');
+
+class QueryBuilderMiddleware {
+  /**
+   * Constructor del middleware
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.queryBuilders = new Map(); // Almacenar instancias de QueryBuilder por contexto
+  }
+
+  /**
+   * Middleware para inyectar el QueryBuilder en la solicitud
+   * @param {Object} req - Objeto de solicitud HTTP
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @param {Function} next - Función para continuar con el siguiente middleware
+   */
+  injectQueryBuilder(req, res, next) {
+    // Si se ha almacenado un adaptador en la solicitud previamente, usarlo
+    if (req._dbAdapter) {
+      req.queryBuilder = (tableName = null) => {
+        const qb = new QueryBuilder(null, tableName);
+        qb.setAdapter(req._dbAdapter);
+        return qb;
+      };
+    } else {
+      // Si no hay adaptador en la solicitud, crear QueryBuilder sin adaptador
+      req.queryBuilder = (tableName = null) => new QueryBuilder(null, tableName);
+    }
+
+    // Agregar también un acceso directo al QueryBuilder en el objeto de solicitud
+    req.QueryBuilder = QueryBuilder;
+
+    next();
+  }
+
+  /**
+   * Middleware para registrar el QueryBuilder en el sistema de hooks
+   * @param {Object} req - Objeto de solicitud HTTP
+   * @param {Object} res - Objeto de respuesta HTTP
+   * @param {Function} next - Función para continuar con el siguiente middleware
+   */
+  registerWithHooks(req, res, next) {
+    // Disparar hook para permitir que otros componentes se registren con el QueryBuilder
+    const { hooks } = require('../../index.js');
+    if (hooks) {
+      hooks.doAction('query_builder_registered', {
+        request: req,
+        response: res,
+        queryBuilder: req.queryBuilder
+      });
+    }
+
+    next();
+  }
+
+  /**
+   * Middleware para configurar el QueryBuilder con un adaptador específico
+   * @param {Object} adapter - Adaptador de base de datos
+   * @returns {Function} - Middleware para configurar el QueryBuilder
+   */
+  configureWithAdapter(adapter) {
+    return (req, res, next) => {
+      // Guardar el adaptador en la solicitud para uso posterior
+      req._dbAdapter = adapter;
+
+      // Si queryBuilder ya existe, actualizarlo con el nuevo adaptador
+      if (req.queryBuilder) {
+        const originalQueryBuilder = req.queryBuilder;
+        req.queryBuilder = (tableName = null) => {
+          const qb = originalQueryBuilder(tableName);
+          qb.setAdapter(adapter);
+          return qb;
+        };
+      }
+
+      next();
+    };
+  }
+
+  /**
+   * Middleware para inicializar el QueryBuilder con opciones específicas
+   * @param {Object} options - Opciones de inicialización
+   * @returns {Function} - Middleware para inicializar el QueryBuilder
+   */
+  initializeWithOptions(options = {}) {
+    return (req, res, next) => {
+      // Guardar las opciones en la solicitud para uso posterior
+      req.queryBuilderOptions = { ...this.options, ...options };
+
+      next();
+    };
+  }
+
+  /**
+   * Middleware para registrar un QueryBuilder en el contexto de un modelo
+   * @param {Object} model - Instancia del modelo
+   * @returns {Function} - Middleware para registrar el QueryBuilder en el modelo
+   */
+  registerInModel(model) {
+    return (req, res, next) => {
+      // Asegurarse de que el modelo tenga acceso al QueryBuilder
+      if (model && typeof model.setAdapter === 'function' && model.adapter) {
+        // Crear una instancia de QueryBuilder con el adaptador del modelo
+        model.queryBuilder = (tableName = null) => new QueryBuilder(model.adapter, tableName);
+        
+        // Registrar el modelo con el QueryBuilder
+        if (typeof model.registerQueryBuilder === 'function') {
+          model.registerQueryBuilder(model.queryBuilder);
+        }
+      }
+
+      next();
+    };
+  }
+
+  /**
+   * Middleware para aplicar transformaciones a las consultas antes de ejecutarlas
+   * @param {Function} transformer - Función para transformar la consulta
+   * @returns {Function} - Middleware para transformar consultas
+   */
+  applyQueryTransformer(transformer) {
+    return (req, res, next) => {
+      if (typeof transformer !== 'function') {
+        next();
+        return;
+      }
+
+      // Guardar la función original de queryBuilder
+      const originalQueryBuilder = req.queryBuilder;
+
+      if (originalQueryBuilder) {
+        // Reemplazar la función queryBuilder con una versión que aplica el transformador
+        req.queryBuilder = (tableName = null) => {
+          const qb = originalQueryBuilder(tableName);
+          
+          // Guardar la función original toSQL
+          const originalToSQL = qb.toSQL;
+          
+          // Reemplazar toSQL para aplicar transformaciones
+          qb.toSQL = function() {
+            const result = originalToSQL.call(this);
+            
+            // Aplicar el transformador si existe
+            if (transformer) {
+              const transformed = transformer(result, this);
+              return transformed || result;
+            }
+            
+            return result;
+          };
+          
+          return qb;
+        };
+      }
+
+      next();
+    };
+  }
+
+  /**
+   * Middleware para habilitar el registro de consultas SQL
+   * @param {Object} logger - Instancia de logger
+   * @returns {Function} - Middleware para registrar consultas SQL
+   */
+  enableQueryLogging(logger = console) {
+    return (req, res, next) => {
+      // Guardar la función original de queryBuilder
+      const originalQueryBuilder = req.queryBuilder;
+
+      if (originalQueryBuilder) {
+        // Reemplazar la función queryBuilder con una versión que registra consultas
+        req.queryBuilder = (tableName = null) => {
+          const qb = originalQueryBuilder(tableName);
+          
+          // Guardar las funciones originales de ejecución
+          const originalGet = qb.get;
+          const originalFirst = qb.first;
+          const originalInsert = qb.insert;
+          const originalUpdate = qb.update;
+          const originalDelete = qb.delete;
+          
+          // Reemplazar get para registrar consultas
+          qb.get = async function() {
+            const { sql, params } = this.toSQL();
+            logger.info(`[QUERY_BUILDER] Ejecutando consulta: ${sql}`, { params });
+            
+            try {
+              const result = await originalGet.call(this);
+              logger.info(`[QUERY_BUILDER] Consulta completada, resultados: ${result.length}`);
+              return result;
+            } catch (error) {
+              logger.error(`[QUERY_BUILDER] Error en consulta: ${error.message}`, { sql, params });
+              throw error;
+            }
+          };
+          
+          // Reemplazar first para registrar consultas
+          qb.first = async function() {
+            const { sql, params } = this.toSQL();
+            logger.info(`[QUERY_BUILDER] Ejecutando consulta (first): ${sql}`, { params });
+            
+            try {
+              const result = await originalFirst.call(this);
+              logger.info(`[QUERY_BUILDER] Consulta (first) completada`, { result: result !== null });
+              return result;
+            } catch (error) {
+              logger.error(`[QUERY_BUILDER] Error en consulta (first): ${error.message}`, { sql, params });
+              throw error;
+            }
+          };
+          
+          // Reemplazar insert para registrar consultas
+          qb.insert = async function(data) {
+            const columns = Object.keys(data);
+            const placeholders = columns.map(() => '?').join(', ');
+            const sql = `INSERT INTO \`${this.tableName}\` (\`${columns.join('`, `')}\`) VALUES (${placeholders})`;
+            
+            logger.info(`[QUERY_BUILDER] Ejecutando inserción: ${sql}`, { data });
+            
+            try {
+              const result = await originalInsert.call(this, data);
+              logger.info(`[QUERY_BUILDER] Inserción completada`, { result });
+              return result;
+            } catch (error) {
+              logger.error(`[QUERY_BUILDER] Error en inserción: ${error.message}`, { sql, data });
+              throw error;
+            }
+          };
+          
+          // Reemplazar update para registrar consultas
+          qb.update = async function(data) {
+            const updates = Object.keys(data).map(key => `\`${key}\` = ?`).join(', ');
+            const sql = `UPDATE \`${this.tableName}\` SET ${updates}`;
+            
+            logger.info(`[QUERY_BUILDER] Ejecutando actualización: ${sql}`, { data });
+            
+            try {
+              const result = await originalUpdate.call(this, data);
+              logger.info(`[QUERY_BUILDER] Actualización completada`, { affectedRows: result });
+              return result;
+            } catch (error) {
+              logger.error(`[QUERY_BUILDER] Error en actualización: ${error.message}`, { sql, data });
+              throw error;
+            }
+          };
+          
+          // Reemplazar delete para registrar consultas
+          qb.delete = async function() {
+            const { sql, params } = this.toSQL();
+            logger.info(`[QUERY_BUILDER] Ejecutando eliminación: ${sql}`, { params });
+            
+            try {
+              const result = await originalDelete.call(this);
+              logger.info(`[QUERY_BUILDER] Eliminación completada`, { affectedRows: result });
+              return result;
+            } catch (error) {
+              logger.error(`[QUERY_BUILDER] Error en eliminación: ${error.message}`, { sql, params });
+              throw error;
+            }
+          };
+          
+          return qb;
+        };
+      }
+
+      next();
+    };
+  }
+
+  /**
+   * Middleware para aplicar reglas de seguridad a las consultas
+   * @param {Object} securityRules - Reglas de seguridad
+   * @returns {Function} - Middleware para aplicar reglas de seguridad
+   */
+  applySecurityRules(securityRules = {}) {
+    return (req, res, next) => {
+      // Guardar la función original de queryBuilder
+      const originalQueryBuilder = req.queryBuilder;
+
+      if (originalQueryBuilder) {
+        // Reemplazar la función queryBuilder con una versión que aplica reglas de seguridad
+        req.queryBuilder = (tableName = null) => {
+          const qb = originalQueryBuilder(tableName);
+          
+          // Guardar la función original toSQL
+          const originalToSQL = qb.toSQL;
+          
+          // Reemplazar toSQL para aplicar reglas de seguridad
+          qb.toSQL = function() {
+            // Aplicar reglas de seguridad antes de generar la consulta
+            if (securityRules.disallowSelectAll && this.selectFields.length === 0) {
+              throw new Error('SELECT * no está permitido por razones de seguridad');
+            }
+            
+            if (securityRules.requiredWheres && this.whereConditions.length === 0 && this.tableName) {
+              // Verificar si la tabla requiere condiciones WHERE
+              if (Array.isArray(securityRules.requiredWheres) && 
+                  securityRules.requiredWheres.includes(this.tableName)) {
+                throw new Error(`La tabla ${this.tableName} requiere condiciones WHERE por razones de seguridad`);
+              }
+            }
+            
+            // Aplicar límites de seguridad
+            if (securityRules.maxLimit && this.limitValue > securityRules.maxLimit) {
+              this.limitValue = securityRules.maxLimit;
+            }
+            
+            return originalToSQL.call(this);
+          };
+          
+          return qb;
+        };
+      }
+
+      next();
+    };
+  }
+}
+
+// Exportar el middleware y el QueryBuilder
+module.exports = {
+  QueryBuilderMiddleware,
+  QueryBuilder
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jerkjs",
-  "version": "2.2.0",
-  "description": "JERK Framework v2.2 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, and template engine with performance optimizations and complete MVC architecture with models",
+  "version": "2.3.0",
+  "description": "JERK Framework v2.3 - A comprehensive framework for building secure and scalable APIs with frontend support, sessions, template engine, QueryBuilder, and complete MVC architecture with models",
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",

package/utils/find_file_path.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+# Script to find a file's location using 'which' and show its real path with 'ls -ln'
+
+if [ $# -eq 0 ]; then
+    echo "Usage: $0 <filename>"
+    echo "Example: $0 python"
+    exit 1
+fi
+
+filename="$1"
+
+# Find the file using which
+echo "Finding location of '$filename' using 'which':"
+which_result=$(which "$filename")
+
+if [ $? -eq 0 ]; then
+    echo "Found: $which_result"
+    
+    # Get the directory containing the file
+    file_dir=$(dirname "$which_result")
+    file_basename=$(basename "$which_result")
+    
+    # Change to the directory and use ls -ln to show the real path
+    echo ""
+    echo "Using 'ls -ln' to show detailed info:"
+    (cd "$file_dir" && ls -ln "$file_basename")
+    
+    # If the file is a symlink, show the real path using readlink
+    echo ""
+    echo "Real path (using readlink -f):"
+    readlink -f "$which_result"
+else
+    echo "File '$filename' not found in PATH"
+    exit 1
+fi