jerkjs 2.1.7 → 2.3.0

package/lib/loader/routeLoader.js

@@ -83,12 +83,29 @@ class RouteLoader {
         throw new Error(`La ruta en la posición ${i} no tiene propiedad 'method'`);
       }
 
-      if (!route.controller) {
-        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
-      }
+      // Verificar si es una ruta estática
+      if (route.static) {
+        if (typeof route.static !== 'object' || route.static === null) {
+          throw new Error(`La ruta en la posición ${i} tiene una propiedad 'static' inválida`);
+        }
+
+        if (!route.static.dir) {
+          throw new Error(`La ruta en la posición ${i} tiene una configuración 'static' sin directorio 'dir'`);
+        }
+
+        // El método debe ser GET para rutas estáticas
+        if (route.method.toUpperCase() !== 'GET') {
+          throw new Error(`Las rutas estáticas deben usar el método GET, no ${route.method}`);
+        }
+      } else {
+        // Validación normal para rutas dinámicas
+        if (!route.controller) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'controller'`);
+        }
 
-      if (!route.handler) {
-        throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        if (!route.handler) {
+          throw new Error(`La ruta en la posición ${i} no tiene propiedad 'handler'`);
+        }
       }
 
       // Validar que el content-type sea un string si está presente
@@ -104,134 +121,148 @@ class RouteLoader {
    * @param {Object} route - Objeto de ruta a cargar
    */
   async loadSingleRoute(server, route) {
-    // Obtener el controlador
-    const controllerPath = path.resolve(process.cwd(), route.controller);
-    let controllerModule;
-
-    try {
-      controllerModule = require(controllerPath);
-    } catch (error) {
-      throw new Error(`No se pudo cargar el controlador: ${route.controller}. Error: ${error.message}`);
-    }
+    // Verificar si es una ruta estática
+    if (route.static) {
+      // Para rutas estáticas, simplemente llamar a addRoute con la configuración estática
+      server.addRoute({
+        method: route.method,
+        path: route.path,
+        static: route.static,
+        contentType: route.contentType,
+        auth: route.auth,
+        authOptions: route.authOptions
+      });
+    } else {
+      // Lógica existente para rutas dinámicas
+      // Obtener el controlador
+      const controllerPath = path.resolve(process.cwd(), route.controller);
+      let controllerModule;
+
+      try {
+        controllerModule = require(controllerPath);
+      } catch (error) {
+        throw new Error(`No se pudo cargar el controlador: ${route.controller}. Error: ${error.message}`);
+      }
 
-    // Obtener el handler del controlador
-    const handler = controllerModule[route.handler];
-    if (typeof handler !== 'function') {
-      throw new Error(`El handler '${route.handler}' no es una función en el controlador: ${route.controller}`);
-    }
+      // Obtener el handler del controlador
+      const handler = controllerModule[route.handler];
+      if (typeof handler !== 'function') {
+        throw new Error(`El handler '${route.handler}' no es una función en el controlador: ${route.controller}`);
+      }
 
-    // Crear un handler que establezca el content-type si está especificado
-    let finalHandler = handler;
+      // Crear un handler que establezca el content-type si está especificado
+      let finalHandler = handler;
 
-    if (route.contentType) {
-      finalHandler = async (req, res) => {
-        // Establecer el content-type antes de ejecutar el handler original
-        res.setHeader('Content-Type', route.contentType);
+      if (route.contentType) {
+        finalHandler = async (req, res) => {
+          // Establecer el content-type antes de ejecutar el handler original
+          res.setHeader('Content-Type', route.contentType);
 
-        // Si el handler es asíncrono, esperarlo
-        if (handler.constructor.name === 'AsyncFunction') {
-          await handler(req, res);
-        } else {
-          handler(req, res);
-        }
-      };
-    }
+          // Si el handler es asíncrono, esperarlo
+          if (handler.constructor.name === 'AsyncFunction') {
+            await handler(req, res);
+          } else {
+            handler(req, res);
+          }
+        };
+      }
 
-    // Aplicar autenticación si está especificada
-    if (route.auth && route.auth !== 'none') {
-      // Verificar si es autenticación de sesión
-      if (route.auth === 'session') {
-        // Verificar si el servidor tiene sessionManager
-        if (server.sessionManager) {
-          // Importar el middleware de autenticación de sesión
-          const { sessionAuth } = require('../middleware/session');
-          const authMiddleware = sessionAuth(server.sessionManager, route.authOptions || {});
-
-          // Crear un nuevo handler que ejecute la autenticación primero
-          const authenticatedHandler = async (req, res) => {
-            try {
-              // Ejecutar el middleware de autenticación y esperar a que se resuelva
-              await new Promise((resolve, reject) => {
-                const next = () => resolve();
-                const result = authMiddleware(req, res, next);
-
-                // Si authMiddleware devuelve una promesa, esperarla
-                if (result && typeof result.then === 'function') {
-                  result.then(resolve).catch(reject);
+      // Aplicar autenticación si está especificada
+      if (route.auth && route.auth !== 'none') {
+        // Verificar si es autenticación de sesión
+        if (route.auth === 'session') {
+          // Verificar si el servidor tiene sessionManager
+          if (server.sessionManager) {
+            // Importar el middleware de autenticación de sesión
+            const { sessionAuth } = require('../middleware/session');
+            const authMiddleware = sessionAuth(server.sessionManager, route.authOptions || {});
+
+            // Crear un nuevo handler que ejecute la autenticación primero
+            const authenticatedHandler = async (req, res) => {
+              try {
+                // Ejecutar el middleware de autenticación y esperar a que se resuelva
+                await new Promise((resolve, reject) => {
+                  const next = () => resolve();
+                  const result = authMiddleware(req, res, next);
+
+                  // Si authMiddleware devuelve una promesa, esperarla
+                  if (result && typeof result.then === 'function') {
+                    result.then(resolve).catch(reject);
+                  }
+                });
+
+                // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
+                if (!res.headersSent) {
+                  // Si el handler es asíncrono, esperarlo también
+                  if (finalHandler.constructor.name === 'AsyncFunction') {
+                    await finalHandler(req, res);
+                  } else {
+                    finalHandler(req, res);
+                  }
                 }
-              });
-
-              // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
-              if (!res.headersSent) {
-                // Si el handler es asíncrono, esperarlo también
-                if (finalHandler.constructor.name === 'AsyncFunction') {
-                  await finalHandler(req, res);
-                } else {
-                  finalHandler(req, res);
+              } catch (error) {
+                console.error('Error en el manejo de autenticación de sesión:', error);
+                if (!res.headersSent) {
+                  res.writeHead(500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
                 }
               }
-            } catch (error) {
-              console.error('Error en el manejo de autenticación de sesión:', error);
-              if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-              }
-            }
-          };
+            };
 
-          // Agregar la ruta con el handler autenticado
-          server.addRoute(route.method, route.path, authenticatedHandler);
+            // Agregar la ruta con el handler autenticado
+            server.addRoute(route.method, route.path, authenticatedHandler);
+          } else {
+            // Si no hay sessionManager en el servidor, agregar la ruta normalmente
+            server.addRoute(route.method, route.path, finalHandler);
+          }
         } else {
-          // Si no hay sessionManager en el servidor, agregar la ruta normalmente
-          server.addRoute(route.method, route.path, finalHandler);
-        }
-      } else {
-        // Usar el authenticator del servidor si está disponible para otros tipos de autenticación
-        if (server.authenticator) {
-          const authMiddleware = server.authenticator.authenticate(route.auth, route.authOptions || {});
-
-          // Crear un nuevo handler que ejecute la autenticación primero
-          const authenticatedHandler = async (req, res) => {
-            try {
-              // Ejecutar el middleware de autenticación y esperar a que se resuelva
-              await new Promise((resolve, reject) => {
-                const next = () => resolve();
-                const result = authMiddleware(req, res, next);
-
-                // Si authMiddleware devuelve una promesa, esperarla
-                if (result && typeof result.then === 'function') {
-                  result.then(resolve).catch(reject);
+          // Usar el authenticator del servidor si está disponible para otros tipos de autenticación
+          if (server.authenticator) {
+            const authMiddleware = server.authenticator.authenticate(route.auth, route.authOptions || {});
+
+            // Crear un nuevo handler que ejecute la autenticación primero
+            const authenticatedHandler = async (req, res) => {
+              try {
+                // Ejecutar el middleware de autenticación y esperar a que se resuelva
+                await new Promise((resolve, reject) => {
+                  const next = () => resolve();
+                  const result = authMiddleware(req, res, next);
+
+                  // Si authMiddleware devuelve una promesa, esperarla
+                  if (result && typeof result.then === 'function') {
+                    result.then(resolve).catch(reject);
+                  }
+                });
+
+                // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
+                if (!res.headersSent) {
+                  // Si el handler es asíncrono, esperarlo también
+                  if (finalHandler.constructor.name === 'AsyncFunction') {
+                    await finalHandler(req, res);
+                  } else {
+                    finalHandler(req, res);
+                  }
                 }
-              });
-
-              // Si la autenticación fue exitosa (no se envió respuesta aún), ejecutar el handler original
-              if (!res.headersSent) {
-                // Si el handler es asíncrono, esperarlo también
-                if (finalHandler.constructor.name === 'AsyncFunction') {
-                  await finalHandler(req, res);
-                } else {
-                  finalHandler(req, res);
+              } catch (error) {
+                console.error('Error en el manejo de autenticación:', error);
+                if (!res.headersSent) {
+                  res.writeHead(500, { 'Content-Type': 'application/json' });
+                  res.end(JSON.stringify({ error: 'Error interno del servidor' }));
                 }
               }
-            } catch (error) {
-              console.error('Error en el manejo de autenticación:', error);
-              if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Error interno del servidor' }));
-              }
-            }
-          };
+            };
 
-          // Agregar la ruta con el handler autenticado
-          server.addRoute(route.method, route.path, authenticatedHandler);
-        } else {
-          // Si no hay authenticator en el servidor, agregar la ruta normalmente
-          server.addRoute(route.method, route.path, finalHandler);
+            // Agregar la ruta con el handler autenticado
+            server.addRoute(route.method, route.path, authenticatedHandler);
+          } else {
+            // Si no hay authenticator en el servidor, agregar la ruta normalmente
+            server.addRoute(route.method, route.path, finalHandler);
+          }
         }
+      } else {
+        // Si no hay autenticación requerida, agregar la ruta normalmente
+        server.addRoute(route.method, route.path, finalHandler);
       }
-    } else {
-      // Si no hay autenticación requerida, agregar la ruta normalmente
-      server.addRoute(route.method, route.path, finalHandler);
     }
   }
 

package/lib/mvc/GenericAdapter.js

@@ -0,0 +1,136 @@
+/**
+ * Adaptador genérico para modelos en el framework JERK
+ * Implementación del componente MVC GenericAdapter.js
+ * Proporciona una interfaz común para diferentes tipos de almacenamiento
+ */
+
+class GenericAdapter {
+  /**
+   * Constructor del adaptador genérico
+   * @param {Object} options - Opciones de configuración
+   */
+  constructor(options = {}) {
+    this.options = options;
+    this.type = options.type || 'generic';
+    this.logger = options.logger || console;
+  }
+
+  /**
+   * Método para crear un registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} data - Datos a crear
+   * @returns {Promise<Object>} - Promesa con el resultado
+   */
+  async create(tableName, data) {
+    throw new Error('Método create no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para encontrar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales
+   * @returns {Promise<Array>} - Promesa con los resultados
+   */
+  async find(tableName, conditions, options) {
+    throw new Error('Método find no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para encontrar un solo registro
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de búsqueda
+   * @param {Object} options - Opciones adicionales
+   * @returns {Promise<Object|null>} - Promesa con el resultado o null
+   */
+  async findOne(tableName, conditions, options) {
+    throw new Error('Método findOne no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para actualizar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @param {Object} data - Datos a actualizar
+   * @returns {Promise<number>} - Promesa con el número de registros afectados
+   */
+  async update(tableName, conditions, data) {
+    throw new Error('Método update no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para eliminar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones para seleccionar registros
+   * @returns {Promise<number>} - Promesa con el número de registros eliminados
+   */
+  async delete(tableName, conditions) {
+    throw new Error('Método delete no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para contar registros
+   * @param {string} tableName - Nombre de la tabla
+   * @param {Object} conditions - Condiciones de conteo
+   * @returns {Promise<number>} - Promesa con el número de registros
+   */
+  async count(tableName, conditions) {
+    throw new Error('Método count no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para ejecutar consultas personalizadas
+   * @param {string} query - Consulta personalizada
+   * @param {Array} params - Parámetros de la consulta
+   * @returns {Promise<any>} - Promesa con el resultado
+   */
+  async query(query, params = []) {
+    throw new Error('Método query no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Método para inicializar el adaptador
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    // Implementación por defecto
+  }
+
+  /**
+   * Método para cerrar la conexión
+   * @returns {Promise<void>}
+   */
+  async close() {
+    // Implementación por defecto
+  }
+
+  /**
+   * Método para verificar si el adaptador está conectado
+   * @returns {boolean} - Verdadero si está conectado
+   */
+  isConnected() {
+    return true; // Por defecto, asumimos que está conectado
+  }
+
+  /**
+   * Método para migrar una tabla
+   * @param {string} tableName - Nombre de la tabla a migrar
+   * @returns {Promise<void>}
+   */
+  async migrate(tableName) {
+    throw new Error('Método migrate no implementado en el adaptador genérico');
+  }
+
+  /**
+   * Serializa el adaptador a JSON
+   * @returns {Object} - Representación JSON del adaptador
+   */
+  toJSON() {
+    return {
+      type: this.type,
+      initialized: true
+    };
+  }
+}
+
+module.exports = GenericAdapter;