jerkjs 2.0.0

package/examples/public/controllers/userController.js

@@ -0,0 +1,139 @@
+// Simulación de base de datos en memoria
+let users = [
+  { id: 1, name: 'Juan Pérez', email: 'juan@example.com', age: 30 },
+  { id: 2, name: 'María García', email: 'maria@example.com', age: 25 },
+  { id: 3, name: 'Pedro Rodríguez', email: 'pedro@example.com', age: 35 }
+];
+
+let nextId = 4;
+
+const userController = {
+  getAllUsers: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      success: true,
+      data: users,
+      count: users.length
+    }));
+  },
+
+  getUserById: (req, res) => {
+    const userId = parseInt(req.params.id);
+    const user = users.find(u => u.id === userId);
+
+    if (!user) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: false,
+        error: 'Usuario no encontrado'
+      }));
+      return;
+    }
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      success: true,
+      data: user
+    }));
+  },
+
+  createUser: (req, res) => {
+    try {
+      const { name, email, age } = req.body;
+
+      // Validación simple
+      if (!name || !email) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: false,
+          error: 'Nombre y correo electrónico son obligatorios'
+        }));
+        return;
+      }
+
+      // Crear nuevo usuario
+      const newUser = {
+        id: nextId++,
+        name,
+        email,
+        age: age || null
+      };
+
+      users.push(newUser);
+
+      res.writeHead(201, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: true,
+        data: newUser,
+        message: 'Usuario creado exitosamente'
+      }));
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: false,
+        error: 'Error interno del servidor'
+      }));
+    }
+  },
+
+  updateUser: (req, res) => {
+    try {
+      const userId = parseInt(req.params.id);
+      const { name, email, age } = req.body;
+
+      const userIndex = users.findIndex(u => u.id === userId);
+
+      if (userIndex === -1) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          success: false,
+          error: 'Usuario no encontrado'
+        }));
+        return;
+      }
+
+      // Actualizar usuario
+      if (name) users[userIndex].name = name;
+      if (email) users[userIndex].email = email;
+      if (age !== undefined) users[userIndex].age = age;
+
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: true,
+        data: users[userIndex],
+        message: 'Usuario actualizado exitosamente'
+      }));
+    } catch (error) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: false,
+        error: 'Error interno del servidor'
+      }));
+    }
+  },
+
+  deleteUser: (req, res) => {
+    const userId = parseInt(req.params.id);
+    const userIndex = users.findIndex(u => u.id === userId);
+
+    if (userIndex === -1) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        success: false,
+        error: 'Usuario no encontrado'
+      }));
+      return;
+    }
+
+    const deletedUser = users.splice(userIndex, 1)[0];
+
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      success: true,
+      data: deletedUser,
+      message: 'Usuario eliminado exitosamente'
+    }));
+  }
+};
+
+module.exports = userController;

package/examples/public/routes.json

@@ -0,0 +1,51 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/users",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getAllUsers",
+    "auth": "none"
+  },
+  {
+    "path": "/users/:id",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getUserById",
+    "auth": "none"
+  },
+  {
+    "path": "/users",
+    "method": "POST",
+    "controller": "./controllers/userController.js",
+    "handler": "createUser",
+    "auth": "none"
+  },
+  {
+    "path": "/users/:id",
+    "method": "PUT",
+    "controller": "./controllers/userController.js",
+    "handler": "updateUser",
+    "auth": "none"
+  },
+  {
+    "path": "/users/:id",
+    "method": "DELETE",
+    "controller": "./controllers/userController.js",
+    "handler": "deleteUser",
+    "auth": "none"
+  },
+  {
+    "path": "/health",
+    "method": "GET",
+    "controller": "./controllers/healthController.js",
+    "handler": "checkHealth",
+    "auth": "none"
+  }
+]

package/examples/v2/README.md

@@ -0,0 +1,72 @@
+# Ejemplo API con Autenticación SQLite
+
+Este ejemplo demuestra cómo crear una API con autenticación basada en tokens almacenados en SQLite utilizando el Framework API SDK.
+
+## Características
+
+- Autenticación JWT con tokens almacenados en SQLite
+- Rutas protegidas y públicas
+- Sistema de login para obtener tokens
+- Controladores organizados por funcionalidad
+
+## Configuración
+
+1. Asegúrate de tener instaladas las dependencias del framework API SDK
+2. Instala sqlite3 si aún no está instalado: `npm install sqlite3`
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8088`
+
+## Endpoints
+
+- `GET /` - Página de inicio (público)
+- `POST /login` - Iniciar sesión y obtener token (público)
+- `GET /protected` - Contenido protegido (requiere token)
+- `GET /profile` - Perfil de usuario (requiere token)
+
+## Ejemplo de uso
+
+1. Iniciar sesión:
+   ```bash
+   curl -X POST http://localhost:8088/login \
+     -H "Content-Type: application/json" \
+     -d '{"username": "admin", "password": "password"}'
+   ```
+
+2. Acceder a contenido protegido:
+   ```bash
+   curl -X GET http://localhost:8088/protected \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+3. Ver perfil de usuario:
+   ```bash
+   curl -X GET http://localhost:8088/profile \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+## Estructura del proyecto
+
+```
+examples/v2/
+├── app.js              # Punto de entrada de la aplicación
+├── routes.json         # Definición de rutas
+├── controllers/        # Controladores de las rutas
+│   ├── mainController.js
+│   ├── authController.js
+│   ├── protectedController.js
+│   └── userController.js
+└── tokens_example.sqlite  # Base de datos SQLite para tokens (generada automáticamente)
+```
+
+## Seguridad
+
+- Los tokens se almacenan en una base de datos SQLite
+- Los tokens expiran después de 1 hora
+- Las rutas protegidas requieren un token válido en el header Authorization

package/examples/v2/app.js

@@ -0,0 +1,74 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  SQLiteTokenAdapter
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8088,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del adaptador de tokens SQLite
+    const tokenAdapter = new SQLiteTokenAdapter({
+      dbPath: './tokens_example.sqlite',
+      tableName: 'example_tokens'
+    });
+
+    // Inicializar el adaptador de tokens
+    await tokenAdapter.initialize();
+    logger.info('SQLite Token Adapter inicializado correctamente');
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT que utiliza el adaptador SQLite
+    authenticator.use('jwt-sqlite', async (req, options = {}) => {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        return false;
+      }
+
+      // Validar el token contra la base de datos SQLite
+      const tokenRecord = await tokenAdapter.validateToken(token);
+      
+      if (tokenRecord) {
+        // Agregar información del usuario a la solicitud
+        req.user = { userId: tokenRecord.user_id, tokenType: tokenRecord.token_type };
+        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:8088');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2/app_fixed.js

@@ -0,0 +1,74 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  SQLiteTokenAdapter
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8088,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del adaptador de tokens SQLite
+    const tokenAdapter = new SQLiteTokenAdapter({
+      dbPath: './tokens_example.sqlite',
+      tableName: 'example_tokens'
+    });
+
+    // Inicializar el adaptador de tokens
+    await tokenAdapter.initialize();
+    logger.info('SQLite Token Adapter inicializado correctamente');
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT que utiliza el adaptador SQLite
+    authenticator.use('jwt-sqlite', async (req, options = {}) => {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        return false;
+      }
+
+      // Validar el token contra la base de datos SQLite
+      const tokenRecord = await tokenAdapter.validateToken(token);
+
+      if (tokenRecord) {
+        // Agregar información del usuario a la solicitud
+        req.user = { userId: tokenRecord.user_id, tokenType: tokenRecord.token_type };
+        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:8088');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/examples/v2/controllers/authController.js

@@ -0,0 +1,64 @@
+const jwt = require('jsonwebtoken');
+const { SQLiteTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new SQLiteTokenAdapter({
+  dbPath: './tokens_example.sqlite',
+  tableName: 'example_tokens'
+});
+
+// Asegurarse de que el adaptador esté inicializado
+tokenAdapter.initialize().catch(console.error);
+
+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-example';
+        const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+        // Guardar el token en la base de datos SQLite
+        await tokenAdapter.saveToken(
+          token,
+          { userId: 1 },
+          'access',
+          new Date(Date.now() + 60 * 60 * 1000) // 1 hora
+        );
+
+        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/controllers/mainController.js

@@ -0,0 +1,24 @@
+const jwt = require('jsonwebtoken');
+const { SQLiteTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new SQLiteTokenAdapter({
+  dbPath: './tokens_example.sqlite',
+  tableName: 'example_tokens'
+});
+
+const mainController = {
+  home: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Bienvenido a la API de ejemplo con autenticación SQLite',
+      endpoints: {
+        'POST /login': 'Iniciar sesión y obtener token',
+        'GET /protected': 'Contenido protegido (requiere token)',
+        'GET /profile': 'Perfil de usuario (requiere token)'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;

package/examples/v2/controllers/protectedController.js

@@ -0,0 +1,12 @@
+const protectedController = {
+  getProtectedData: (req, res) => {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ 
+      message: 'Datos protegidos accesados exitosamente',
+      user: req.user,
+      timestamp: new Date().toISOString()
+    }));
+  }
+};
+
+module.exports = protectedController;

package/examples/v2/controllers/userController.js

@@ -0,0 +1,16 @@
+const userController = {
+  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',
+        tokenType: req.user.tokenType
+      },
+      message: 'Perfil de usuario obtenido exitosamente'
+    }));
+  }
+};
+
+module.exports = userController;

package/examples/v2/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "api-sdk-example-v2",
+  "version": "1.0.0",
+  "description": "Ejemplo de API con autenticación SQLite usando el Framework API SDK",
+  "main": "app.js",
+  "scripts": {
+    "start": "node app.js",
+    "dev": "nodemon app.js"
+  },
+  "keywords": [
+    "api",
+    "sdk",
+    "authentication",
+    "sqlite",
+    "jwt",
+    "framework"
+  ],
+  "author": "API SDK Framework",
+  "license": "MIT",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.0",
+    "sqlite3": "^5.1.6"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.0"
+  }
+}

package/examples/v2/routes.json

@@ -0,0 +1,30 @@
+[
+  {
+    "path": "/",
+    "method": "GET",
+    "controller": "./controllers/mainController.js",
+    "handler": "home",
+    "auth": "none"
+  },
+  {
+    "path": "/login",
+    "method": "POST",
+    "controller": "./controllers/authController.js",
+    "handler": "login",
+    "auth": "none"
+  },
+  {
+    "path": "/protected",
+    "method": "GET",
+    "controller": "./controllers/protectedController.js",
+    "handler": "getProtectedData",
+    "auth": "jwt-sqlite"
+  },
+  {
+    "path": "/profile",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getProfile",
+    "auth": "jwt-sqlite"
+  }
+]

package/examples/v2/test_api.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+
+echo "Iniciando prueba de la API con autenticación SQLite..."
+
+# Iniciar el servidor en segundo plano
+node app.js &
+SERVER_PID=$!
+
+# Esperar a que el servidor inicie
+sleep 3
+
+echo "Probando endpoints..."
+
+# Probar endpoint público
+echo "1. Probando endpoint público (/)"
+curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/
+
+# Probar login
+echo -e "\n2. Probando login..."
+TOKEN=$(curl -s -X POST http://localhost:8088/login \
+  -H "Content-Type: application/json" \
+  -d '{"username": "admin", "password": "password"}' | jq -r '.token')
+
+if [ "$TOKEN" != "null" ] && [ -n "$TOKEN" ]; then
+  echo "Login exitoso, token obtenido: ${TOKEN:0:20}..."
+  
+  # Probar endpoint protegido con token
+  echo -e "\n3. Probando endpoint protegido (/protected) con token..."
+  curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/protected \
+    -H "Authorization: Bearer $TOKEN"
+  
+  # Probar endpoint de perfil con token
+  echo -e "\n4. Probando endpoint de perfil (/profile) con token..."
+  curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/profile \
+    -H "Authorization: Bearer $TOKEN"
+else
+  echo "Error: No se pudo obtener el token de login"
+fi
+
+# Probar endpoint protegido sin token (debería fallar)
+echo -e "\n5. Probando endpoint protegido (/protected) sin token (debería fallar)..."
+curl -s -w "\n%{http_code}\n" -X GET http://localhost:8088/protected
+
+echo -e "\nPrueba completada."
+
+# Detener el servidor
+kill $SERVER_PID