jerkjs 2.0.1 → 2.0.2

package/examples/v2_openapi/app.js

@@ -0,0 +1,222 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  OpenApiGenerator,
+  TokenManager
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8092,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del TokenManager con almacenamiento en memoria
+    const tokenManager = new TokenManager({
+      storage: 'memory'
+    });
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT
+    authenticator.use('jwt-openapi', async (req, options = {}) => {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        return false;
+      }
+
+      // Validar el token usando un secreto fijo para este ejemplo
+      const secret = 'super-secret-key-for-openapi-example';
+      const decoded = tokenManager.validateToken(token, secret);
+      
+      if (decoded) {
+        req.user = decoded;
+        return true;
+      }
+
+      return false;
+    });
+
+    // Agregar el autenticador al servidor para que pueda ser usado por el RouteLoader
+    server.authenticator = authenticator;
+
+    // Cargar rutas desde archivo JSON
+    const routeLoader = new RouteLoader();
+    await routeLoader.loadRoutes(server, './routes.json');
+
+    // Crear instancia del generador de OpenAPI
+    const openApiGenerator = new OpenApiGenerator({
+      title: 'API de Ejemplo con OpenAPI',
+      description: 'Una API de ejemplo que demuestra la funcionalidad OpenAPI del Framework JERK',
+      version: '1.0.0',
+      servers: [
+        { url: 'http://localhost:8092', description: 'Servidor de desarrollo' }
+      ]
+    });
+
+    // Agregar esquemas a la documentación
+    openApiGenerator.addSchema('User', {
+      type: 'object',
+      properties: {
+        id: { type: 'integer', example: 1 },
+        name: { type: 'string', example: 'John Doe' },
+        email: { type: 'string', example: 'john@example.com' },
+        role: { type: 'string', example: 'user' }
+      }
+    });
+
+    openApiGenerator.addSchema('Product', {
+      type: 'object',
+      properties: {
+        id: { type: 'integer', example: 1 },
+        name: { type: 'string', example: 'Laptop' },
+        price: { type: 'number', example: 999.99 },
+        category: { type: 'string', example: 'Electronics' }
+      }
+    });
+
+    openApiGenerator.addSchema('ApiResponse', {
+      type: 'object',
+      properties: {
+        success: { type: 'boolean', example: true },
+        message: { type: 'string', example: 'Operación exitosa' },
+        data: { type: 'object', description: 'Datos de la respuesta' }
+      }
+    });
+
+    // Agregar esquema de seguridad
+    openApiGenerator.addSecurityScheme('bearerAuth', {
+      type: 'http',
+      scheme: 'bearer',
+      bearerFormat: 'JWT',
+      description: 'Autenticación por token JWT'
+    });
+
+    // Agregar rutas a la documentación OpenAPI
+    openApiGenerator.addRoute({
+      path: '/users',
+      method: 'GET',
+      config: {
+        summary: 'Obtener todos los usuarios',
+        description: 'Devuelve una lista de todos los usuarios registrados',
+        security: [{ bearerAuth: [] }],
+        responses: {
+          '200': {
+            description: 'Lista de usuarios',
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/components/schemas/User'
+                  }
+                }
+              }
+            }
+          },
+          '401': {
+            description: 'No autorizado - Token inválido o ausente'
+          }
+        }
+      }
+    });
+
+    openApiGenerator.addRoute({
+      path: '/products',
+      method: 'GET',
+      config: {
+        summary: 'Obtener todos los productos',
+        description: 'Devuelve una lista de todos los productos disponibles',
+        security: [{ bearerAuth: [] }],
+        responses: {
+          '200': {
+            description: 'Lista de productos',
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/components/schemas/Product'
+                  }
+                }
+              }
+            }
+          },
+          '401': {
+            description: 'No autorizado - Token inválido o ausente'
+          }
+        }
+      }
+    });
+
+    openApiGenerator.addRoute({
+      path: '/login',
+      method: 'POST',
+      config: {
+        summary: 'Iniciar sesión',
+        description: 'Autenticación de usuario y obtención de token JWT',
+        requestBody: {
+          content: {
+            'application/json': {
+              schema: {
+                type: 'object',
+                properties: {
+                  username: { type: 'string', example: 'admin' },
+                  password: { type: 'string', example: 'password' }
+                },
+                required: ['username', 'password']
+              }
+            }
+          }
+        },
+        responses: {
+          '200': {
+            description: 'Inicio de sesión exitoso',
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    message: { type: 'string', example: 'Inicio de sesión exitoso' },
+                    token: { type: 'string', example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...' },
+                    user: { $ref: '#/components/schemas/User' }
+                  }
+                }
+              }
+            }
+          },
+          '401': {
+            description: 'Credenciales inválidas'
+          }
+        }
+      }
+    });
+
+    // Agregar ruta de documentación al servidor
+    openApiGenerator.addDocumentationRoute(server);
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor iniciado en http://localhost:8092');
+    logger.info('Documentación OpenAPI disponible en http://localhost:8092/docs');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

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": "jerk-openapi-example",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con funcionalidad OpenAPI usando el Framework JERK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "openapi",
+    "swagger",
+    "documentation",
+    "framework"
+  ],
+  "author": "JERK 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/index.js

@@ -1,6 +1,6 @@
 /**
- * Punto de entrada del framework API SDK
- * API SDK Framework v2.0
+ * Punto de entrada del framework JERK
+ * JERK Framework v2.0
  */
 
 const APIServer = require('./lib/core/server');
@@ -30,6 +30,10 @@ 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)
@@ -64,7 +68,11 @@ module.exports = {
 
   // Componentes de sesión (v2.2.0)
   SessionManager,
-  sessionAuth
+  sessionAuth,
+
+  // Componentes MVC (v2.3.0)
+  ViewEngine,
+  ControllerBase
 };
 
 // También exportar clases individuales por conveniencia

package/lib/core/handler.js

@@ -1,5 +1,5 @@
 /**
- * Gestión de handlers para el framework API SDK
+ * Gestión de handlers para el framework JERK
  * Implementación del componente core/handler.js
  */
 

package/lib/core/hooks.js

@@ -1,6 +1,6 @@
 /**
  * Sistema de Hooks y Filters como el core de WordPress
- * Implementación para el Framework API SDK
+ * Implementación para el Framework JERK
  */
 
 class HookSystem {

package/lib/core/router.js

@@ -1,5 +1,5 @@
 /**
- * Sistema de enrutamiento avanzado para el framework API SDK
+ * Sistema de enrutamiento avanzado para el framework JERK
  * Implementación extendida del componente core/router.js
  * Incluye soporte para rutas anidadas y otras mejoras
  */

package/lib/core/server.js

@@ -1,5 +1,5 @@
 /**
- * Servidor HTTP básico para el framework API SDK
+ * Servidor HTTP básico para el framework JERK
  * Implementación del componente core/server.js
  */
 

package/lib/loader/controllerLoader.js

@@ -1,5 +1,5 @@
 /**
- * Carga de controladores para el framework API SDK
+ * Carga de controladores para el framework JERK
  * Implementación del componente loader/controllerLoader.js
  */
 

package/lib/loader/routeLoader.js

@@ -1,5 +1,5 @@
 /**
- * Carga de rutas desde archivos JSON para el framework API SDK
+ * Carga de rutas desde archivos JSON para el framework JERK
  * Implementación del componente loader/routeLoader.js
  */
 

package/lib/middleware/auditLogger.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de auditoría para el API SDK Framework
+ * Middleware de auditoría para el JERK Framework
  * Componente: lib/middleware/auditLogger.js
  */
 

package/lib/middleware/authenticator.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de autenticación para el framework API SDK
+ * Middleware de autenticación para el framework JERK
  * Implementación extendida del componente middleware/authenticator.js
  * Incluye soporte para OAuth2 y OpenID Connect
  */

package/lib/middleware/compressor.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de compresión para el framework API SDK
+ * Middleware de compresión para el framework JERK
  * Implementación del componente middleware/compressor.js
  */
 

package/lib/middleware/cors.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de CORS para el framework API SDK
+ * Middleware de CORS para el framework JERK
  * Implementación del componente middleware/cors.js
  */
 

package/lib/middleware/firewall.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de Firewall para el framework API SDK
+ * Middleware de Firewall para el framework JERK
  * Implementación del componente middleware/firewall.js
  */
 

package/lib/middleware/rateLimiter.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de Rate Limiting para el framework API SDK
+ * Middleware de Rate Limiting para el framework JERK
  * Implementación del componente middleware/rateLimiter.js
  */
 

package/lib/middleware/session.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de sesión para el framework API SDK
+ * Middleware de sesión para el framework JERK
  * Implementación del componente middleware/session.js
  */
 

package/lib/middleware/validator.js

@@ -1,5 +1,5 @@
 /**
- * Middleware de validación para el framework API SDK
+ * Middleware de validación para el framework JERK
  * Implementación del componente middleware/validator.js
  */