jerkjs 2.0.0

package/examples/v2_no_auth/README.md

@@ -0,0 +1,75 @@
+# Ejemplo API Pública sin Autenticación
+
+Este ejemplo demuestra cómo crear una API pública sin autenticación utilizando el Framework API SDK.
+
+## Características
+
+- API completamente pública sin requerir tokens o autenticación
+- Rutas para diferentes tipos de datos
+- Documentación OpenAPI generada automáticamente
+- Endpoints de ejemplo para productos y datos públicos
+
+## Configuración
+
+No se requieren dependencias adicionales más allá del Framework API SDK.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8089`
+
+## Endpoints
+
+- `GET /` - Página de inicio
+- `GET /public` - Datos públicos de ejemplo
+- `GET /products` - Lista de productos
+- `GET /products/:id` - Producto específico por ID
+- `GET /health` - Estado del servicio
+- `GET /docs` - Documentación interactiva de la API
+- `GET /openapi.json` - Especificación OpenAPI
+
+## Ejemplo de uso
+
+1. Consultar productos:
+   ```bash
+   curl http://localhost:8089/products
+   ```
+
+2. Consultar producto específico:
+   ```bash
+   curl http://localhost:8089/products/1
+   ```
+
+3. Consultar datos públicos:
+   ```bash
+   curl http://localhost:8089/public
+   ```
+
+4. Ver estado del servicio:
+   ```bash
+   curl http://localhost:8089/health
+   ```
+
+## Estructura del proyecto
+
+```
+examples/v2_no_auth/
+├── app.js              # Punto de entrada de la aplicación
+├── routes.json         # Definición de rutas
+├── controllers/        # Controladores de las rutas
+│   ├── mainController.js
+│   ├── publicController.js
+│   ├── productController.js
+│   └── healthController.js
+└── README.md
+```
+
+## Notas
+
+- Esta API no requiere autenticación, por lo que todos los endpoints son públicos
+- Adecuada para servicios públicos, APIs de datos abiertos o prototipos
+- La documentación OpenAPI se genera automáticamente y está disponible en `/docs`

package/examples/v2_no_auth/app.js

@@ -0,0 +1,72 @@
+const {
+  APIServer,
+  RouteLoader,
+  Logger,
+  OpenApiGenerator
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8089,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // 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 Pública de Ejemplo',
+      description: 'Una API pública sin autenticación',
+      version: '1.0.0'
+    });
+
+    // Agregar rutas a la documentación OpenAPI
+    openApiGenerator.addRoute({
+      path: '/public',
+      method: 'GET',
+      config: {
+        summary: 'Endpoint público de ejemplo',
+        description: 'Devuelve datos públicos sin requerir autenticación',
+        responses: {
+          '200': {
+            description: 'Datos públicos',
+            content: {
+              'application/json': {
+                schema: {
+                  type: 'object',
+                  properties: {
+                    message: { type: 'string' },
+                    timestamp: { type: 'string' }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+
+    // Agregar ruta de documentación al servidor
+    openApiGenerator.addDocumentationRoute(server);
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor iniciado en http://localhost:8089');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2_no_auth/controllers/healthController.js

@@ -0,0 +1,14 @@
+const healthController = {
+  getStatus: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      status: 'healthy',
+      uptime: process.uptime(),
+      timestamp: new Date().toISOString(),
+      service: 'API Pública de Ejemplo',
+      version: '1.0.0'
+    }));
+  }
+};
+
+module.exports = healthController;

package/examples/v2_no_auth/controllers/mainController.js

@@ -0,0 +1,19 @@
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Bienvenido a la API pública de ejemplo',
+      endpoints: {
+        'GET /': 'Esta página de inicio',
+        'GET /public': 'Datos públicos de ejemplo',
+        'GET /products': 'Lista de productos',
+        'GET /products/:id': 'Producto por ID',
+        'GET /health': 'Estado del servicio',
+        'GET /docs': 'Documentación interactiva de la API',
+        'GET /openapi.json': 'Especificación OpenAPI'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;

package/examples/v2_no_auth/controllers/productController.js

@@ -0,0 +1,31 @@
+// 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 = {
+  getAllProducts: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(products));
+  },
+
+  getProductById: (req, res) => {
+    const productId = parseInt(req.params.id);
+    const product = products.find(p => p.id === productId);
+
+    if (!product) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Producto no encontrado' }));
+      return;
+    }
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(product));
+  }
+};
+
+module.exports = productController;

package/examples/v2_no_auth/controllers/publicController.js

@@ -0,0 +1,16 @@
+const publicController = {
+  getPublicData: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Este es un endpoint público sin autenticación',
+      timestamp: new Date().toISOString(),
+      data: {
+        randomValue: Math.floor(Math.random() * 100),
+        serverStatus: 'operational',
+        publicInfo: 'Esta información es accesible para todos'
+      }
+    }));
+  }
+};
+
+module.exports = publicController;

package/examples/v2_no_auth/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "api-sdk-public-example",
+  "version": "1.0.0",
+  "description": "Ejemplo de API pública sin autenticación usando el Framework API SDK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "public",
+    "no-authentication",
+    "framework"
+  ],
+  "author": "API SDK Framework",
+  "license": "MIT",
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2_no_auth/routes.json

@@ -0,0 +1,37 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/public",
+    "method": "GET",
+    "controller": "./controllers/publicController.js",
+    "handler": "getPublicData",
+    "auth": "none"
+  },
+  {
+    "path": "/products",
+    "method": "GET",
+    "controller": "./controllers/productController.js",
+    "handler": "getAllProducts",
+    "auth": "none"
+  },
+  {
+    "path": "/products/:id",
+    "method": "GET",
+    "controller": "./controllers/productController.js",
+    "handler": "getProductById",
+    "auth": "none"
+  },
+  {
+    "path": "/health",
+    "method": "GET",
+    "controller": "./controllers/healthController.js",
+    "handler": "getStatus",
+    "auth": "none"
+  }
+]

package/examples/v2_oauth/README.md

@@ -0,0 +1,70 @@
+# Ejemplo API con Funcionalidad OAuth 2.0
+
+Este ejemplo demuestra cómo implementar autenticación OAuth 2.0 usando el Framework API SDK.
+
+## Características
+
+- Implementación de flujo OAuth 2.0 (simulado para demostración)
+- Generación de tokens JWT tras autenticación OAuth
+- Rutas protegidas que requieren tokens JWT
+- Simulación del proceso de autorización y callback
+- Controladores organizados por funcionalidad
+
+## Configuración
+
+Este ejemplo simula el flujo OAuth para fines de demostración. En un entorno real, necesitarías:
+
+1. Registrar tu aplicación con un proveedor OAuth (Google, GitHub, etc.)
+2. Obtener Client ID y Client Secret
+3. Configurar la URL de callback en tu aplicación
+4. Ajustar las rutas y controladores según tus necesidades
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8093`
+
+## Endpoints
+
+- `GET /` - Página de inicio con instrucciones
+- `GET /auth/google` - Iniciar flujo OAuth con Google (simulado)
+- `GET /auth/callback` - Callback de OAuth (simulado)
+- `GET /profile` - Perfil de usuario (requiere token JWT)
+- `GET /protected` - Contenido protegido (requiere token JWT)
+
+## Flujo de OAuth simulado
+
+1. Visita `/auth/google` para iniciar el proceso OAuth
+2. El sistema simulará la redirección a Google y el callback
+3. Se generará un token JWT para el usuario autenticado
+4. Usa el token para acceder a endpoints protegidos
+
+## Estructura del proyecto
+
+```
+examples/v2_oauth/
+├── app.js              # Punto de entrada de la aplicación
+├── routes.json         # Definición de rutas
+├── controllers/        # Controladores de las rutas
+│   ├── mainController.js
+│   ├── oauthController.js
+│   ├── userController.js
+│   └── protectedController.js
+└── README.md
+```
+
+## Implementación real
+
+Para implementar OAuth en un entorno real:
+
+1. Registra tu aplicación con un proveedor OAuth
+2. Configura las credenciales en el código
+3. Implementa la lógica para intercambiar el código de autorización por tokens
+4. Almacena de forma segura los tokens de acceso y refresh
+5. Usa los tokens para acceder a las APIs del proveedor
+
+El framework proporciona la estrategia `oauth2Strategy` que puedes usar con tus credenciales reales.

package/examples/v2_oauth/app.js

@@ -0,0 +1,90 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  TokenManager
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8093,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del TokenManager
+    const tokenManager = new TokenManager({
+      storage: 'memory'
+    });
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación OAuth2 REAL del framework
+    // Esta es la verdadera implementación del framework
+    authenticator.use('oauth2', authenticator.oauth2Strategy({
+      clientId: process.env.OAUTH_CLIENT_ID || 'tu-client-id-aqui',
+      clientSecret: process.env.OAUTH_CLIENT_SECRET || 'tu-client-secret-aqui',
+      callbackURL: 'http://localhost:8093/auth/callback',
+      authorizationURL: 'https://accounts.google.com/o/oauth2/v2/auth',
+      tokenURL: 'https://oauth2.googleapis.com/token'
+    }));
+
+    // Registrar estrategia JWT para tokens generados internamente
+    authenticator.use('jwt-oauth', async (req, options = {}) => {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        return false;
+      }
+
+      // Validar el token usando el secreto de las variables de entorno
+      const secret = process.env.JWT_SECRET;
+
+      // Verificar que el secreto esté definido
+      if (!secret) {
+        logger.error('JWT_SECRET no está definido en las variables de entorno');
+        return false;
+      }
+
+      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');
+
+    // Iniciar el servidor
+    server.start();
+
+    logger.info('Servidor iniciado en http://localhost:8093');
+    logger.info('Configura tus credenciales OAuth para usar la autenticación real');
+    logger.info('Variables de entorno necesarias:');
+    logger.info('- OAUTH_CLIENT_ID: Tu Client ID de Google OAuth');
+    logger.info('- OAUTH_CLIENT_SECRET: Tu Client Secret de Google OAuth');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2_oauth/controllers/mainController.js

@@ -0,0 +1,45 @@
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'text/html' });
+    res.end(`
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <title>Ejemplo OAuth con API SDK Framework</title>
+        <style>
+          body { font-family: Arial, sans-serif; margin: 40px; }
+          .endpoint { margin: 10px 0; padding: 10px; background-color: #f0f0f0; border-radius: 5px; }
+          a { color: #007bff; text-decoration: none; }
+          a:hover { text-decoration: underline; }
+        </style>
+      </head>
+      <body>
+        <h1>Ejemplo OAuth con API SDK Framework</h1>
+        <p>Este ejemplo demuestra la funcionalidad OAuth 2.0 del framework.</p>
+        
+        <h2>Endpoints disponibles:</h2>
+        <div class="endpoint">
+          <strong><a href="/auth/google">GET /auth/google</a></strong> - Iniciar flujo OAuth con Google
+        </div>
+        <div class="endpoint">
+          <strong><a href="/profile">GET /profile</a></strong> - Perfil de usuario (requiere token JWT)
+        </div>
+        <div class="endpoint">
+          <strong><a href="/protected">GET /protected</a></strong> - Contenido protegido (requiere token JWT)
+        </div>
+        
+        <h2>Instrucciones:</h2>
+        <ol>
+          <li>Visita <a href="/auth/google">/auth/google</a> para iniciar el flujo OAuth</li>
+          <li>El callback OAuth manejará la autenticación y generará un token JWT</li>
+          <li>Usa el token generado para acceder a los endpoints protegidos</li>
+        </ol>
+        
+        <p><em>Nota: Este es un ejemplo funcional. En un entorno real, necesitarías configurar credenciales reales de OAuth con un proveedor como Google, GitHub, etc.</em></p>
+      </body>
+      </html>
+    `);
+  }
+};
+
+module.exports = mainController;