jerkjs 2.0.0

package/v2examplle/v2_json_auth/README.md

@@ -0,0 +1,83 @@
+# Ejemplo API con Autenticación JSON
+
+Este ejemplo demuestra cómo crear una API con autenticación basada en tokens estáticos almacenados en un archivo JSON utilizando el Framework API SDK.
+
+## Características
+
+- Autenticación JWT con tokens gestionados a través de almacenamiento JSON
+- Rutas protegidas y públicas
+- Sistema de login para obtener tokens
+- Controladores organizados por funcionalidad
+- Tokens almacenados en un archivo JSON local
+
+## Configuración
+
+1. Asegúrate de tener instaladas las dependencias del framework API SDK
+2. El archivo de tokens `tokens.json` se creará automáticamente al iniciar la aplicación
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8091`
+
+## 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)
+- `GET /tokens` - Ver tokens almacenados (requiere token)
+
+## Ejemplo de uso
+
+1. Iniciar sesión:
+   ```bash
+   curl -X POST http://localhost:8091/login \
+     -H "Content-Type: application/json" \
+     -d '{"username": "admin", "password": "password"}'
+   ```
+
+2. Acceder a contenido protegido:
+   ```bash
+   curl -X GET http://localhost:8091/protected \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+3. Ver perfil de usuario:
+   ```bash
+   curl -X GET http://localhost:8091/profile \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+4. Ver tokens almacenados:
+   ```bash
+   curl -X GET http://localhost:8091/tokens \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+## Estructura del proyecto
+
+```
+examples/v2_json_auth/
+├── 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
+│   └── tokenController.js
+├── tokens.json         # Archivo de almacenamiento de tokens (generado automáticamente)
+└── README.md
+```
+
+## Seguridad
+
+- Los tokens se gestionan a través del sistema de TokenManager del framework
+- Los tokens expiran después de 1 hora
+- Las rutas protegidas requieren un token válido en el header Authorization
+- El archivo de tokens se almacena localmente en formato JSON

package/v2examplle/v2_json_auth/app.js

@@ -0,0 +1,72 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  TokenManager
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8091,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del TokenManager con almacenamiento en JSON
+    const tokenManager = new TokenManager({
+      storage: 'json',
+      tokenFile: './tokens.json'
+    });
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT que utiliza el TokenManager con almacenamiento JSON
+    authenticator.use('jwt-json', 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 TokenManager
+      const secret = 'super-secret-key-for-json-example';
+      const decoded = tokenManager.validateToken(token, secret);
+      
+      if (decoded) {
+        // Verificar si el token está almacenado en el archivo JSON (opcional, dependiendo del enfoque)
+        // En este caso, simplemente verificamos que el token sea válido
+        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:8091');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/v2examplle/v2_json_auth/controllers/authController.js

@@ -0,0 +1,67 @@
+const jwt = require('jsonwebtoken');
+const { TokenManager } = require('../../../index.js');
+
+// TokenManager para este controlador
+const tokenManager = new TokenManager({
+  storage: 'json',
+  tokenFile: './tokens.json'
+});
+
+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-json-example';
+        const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+        // En este ejemplo con almacenamiento JSON, no almacenamos el token en sí
+        // pero podríamos registrar información sobre él si es necesario
+        // Alternativamente, podríamos usar el TokenManager para generar un par de tokens
+        const tokenPair = tokenManager.generateTokenPair(
+          { userId: 1, username: username, role: 'admin' },
+          {
+            jwtSecret: secret,
+            refreshSecret: 'refresh-' + secret,
+            accessExpiresIn: '15m',
+            refreshExpiresIn: '7d'
+          }
+        );
+        
+        // Usamos el token de acceso
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ 
+          message: 'Inicio de sesión exitoso',
+          token: tokenPair.accessToken,
+          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/v2examplle/v2_json_auth/controllers/mainController.js

@@ -0,0 +1,16 @@
+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 JSON',
+      endpoints: {
+        'POST /login': 'Iniciar sesión y obtener token',
+        'GET /protected': 'Contenido protegido (requiere token)',
+        'GET /profile': 'Perfil de usuario (requiere token)',
+        'GET /tokens': 'Ver tokens almacenados (requiere token)'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;

package/v2examplle/v2_json_auth/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/v2examplle/v2_json_auth/controllers/tokenController.js

@@ -0,0 +1,28 @@
+const { TokenManager } = require('../../../index.js');
+
+// TokenManager para este controlador
+const tokenManager = new TokenManager({
+  storage: 'json',
+  tokenFile: './tokens.json'
+});
+
+const tokenController = {
+  getTokens: (req, res) => {
+    try {
+      // Obtener todos los tokens almacenados
+      const tokens = tokenManager.getAllTokens ? tokenManager.getAllTokens() : 'Método no disponible en esta implementación';
+      
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ 
+        message: 'Tokens almacenados',
+        tokens: tokens || 'No se pudo obtener la lista de tokens'
+      }));
+    } catch (error) {
+      console.error('Error obteniendo tokens:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error obteniendo tokens' }));
+    }
+  }
+};
+
+module.exports = tokenController;

package/v2examplle/v2_json_auth/controllers/userController.js

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

package/v2examplle/v2_json_auth/package.json

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

package/v2examplle/v2_json_auth/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": "/protected",
+    "method": "GET",
+    "controller": "./controllers/protectedController.js",
+    "handler": "getProtectedData",
+    "auth": "jwt-json"
+  },
+  {
+    "path": "/profile",
+    "method": "GET",
+    "controller": "./controllers/userController.js",
+    "handler": "getProfile",
+    "auth": "jwt-json"
+  },
+  {
+    "path": "/tokens",
+    "method": "GET",
+    "controller": "./controllers/tokenController.js",
+    "handler": "getTokens",
+    "auth": "jwt-json"
+  }
+]

package/v2examplle/v2_json_auth/tokens.json

@@ -0,0 +1,20 @@
+{
+  "example_token": {
+    "userId": 0,
+    "createdAt": "2026-01-14T00:00:00.000Z",
+    "expiresAt": "2026-01-15T00:00:00.000Z",
+    "revoked": false
+  },
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOjEsInVzZXJuYW1lIjoiYWRtaW4iLCJyb2xlIjoiYWRtaW4iLCJ0b2tlblR5cGUiOiJyZWZyZXNoIiwiaWF0IjoxNzY4NDMzODc2LCJleHAiOjE3NjkwMzg2NzZ9.50INL6kmOd9A2mQiBRBlHaXHk31Tw7SgQMH_uRh6NVo": {
+    "userId": 1,
+    "createdAt": "2026-01-14T23:37:56.407Z",
+    "expiresAt": "2026-01-21T23:37:56.407Z",
+    "revoked": false
+  },
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOjEsInVzZXJuYW1lIjoiYWRtaW4iLCJyb2xlIjoiYWRtaW4iLCJ0b2tlblR5cGUiOiJyZWZyZXNoIiwiaWF0IjoxNzY4NDM4NzU4LCJleHAiOjE3NjkwNDM1NTh9.WoMURKAizVPkMM0-lqtl1-mP0L8OMM6INeG5Bv79ixU": {
+    "userId": 1,
+    "createdAt": "2026-01-15T00:59:18.846Z",
+    "expiresAt": "2026-01-22T00:59:18.846Z",
+    "revoked": false
+  }
+}

package/v2examplle/v2_mariadb_auth/README.md

@@ -0,0 +1,94 @@
+# Ejemplo API con Autenticación MariaDB
+
+Este ejemplo demuestra cómo crear una API con autenticación basada en tokens almacenados en MariaDB utilizando el Framework API SDK.
+
+## Características
+
+- Autenticación JWT con tokens almacenados en MariaDB
+- Rutas protegidas y públicas
+- Sistema de login/logout para obtener y revocar tokens
+- Controladores organizados por funcionalidad
+- Revocación de tokens en la base de datos
+
+## Configuración
+
+1. Asegúrate de tener instaladas las dependencias del framework API SDK
+2. Instala mariadb si aún no está instalado: `npm install mariadb`
+3. Asegúrate de tener MariaDB instalado y en ejecución
+4. Crea la base de datos `token_db` en MariaDB
+
+## Preparación de la base de datos
+
+Antes de ejecutar la aplicación, asegúrate de tener MariaDB en ejecución y crea la base de datos:
+
+```sql
+CREATE DATABASE IF NOT EXISTS token_db;
+USE token_db;
+```
+
+La tabla de tokens se creará automáticamente al iniciar la aplicación.
+
+## Uso
+
+1. Inicia el servidor:
+   ```bash
+   node app.js
+   ```
+
+2. El servidor escuchará en `http://localhost:8090`
+
+## 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)
+- `POST /logout` - Cerrar sesión y revocar token (requiere token)
+
+## Ejemplo de uso
+
+1. Iniciar sesión:
+   ```bash
+   curl -X POST http://localhost:8090/login \
+     -H "Content-Type: application/json" \
+     -d '{"username": "admin", "password": "password"}'
+   ```
+
+2. Acceder a contenido protegido:
+   ```bash
+   curl -X GET http://localhost:8090/protected \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+3. Ver perfil de usuario:
+   ```bash
+   curl -X GET http://localhost:8090/profile \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+4. Cerrar sesión y revocar token:
+   ```bash
+   curl -X POST http://localhost:8090/logout \
+     -H "Authorization: Bearer TU_TOKEN_AQUI"
+   ```
+
+## Estructura del proyecto
+
+```
+examples/v2_mariadb_auth/
+├── 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
+└── README.md
+```
+
+## Seguridad
+
+- Los tokens se almacenan en una base de datos MariaDB
+- Los tokens expiran después de 1 hora
+- Las rutas protegidas requieren un token válido en el header Authorization
+- Los tokens pueden ser revocados mediante el endpoint de logout

package/v2examplle/v2_mariadb_auth/app.js

@@ -0,0 +1,81 @@
+const {
+  APIServer,
+  Authenticator,
+  RouteLoader,
+  Logger,
+  MariaDBTokenAdapter
+} = require('../../index.js');
+
+async function startServer() {
+  // Crear instancia del servidor
+  const server = new APIServer({
+    port: 8090,
+    host: 'localhost'
+  });
+
+  // Crear instancia del logger
+  const logger = new Logger({ level: 'info' });
+
+  try {
+    // Crear instancia del adaptador de tokens MariaDB
+    const tokenAdapter = new MariaDBTokenAdapter({
+      host: 'localhost',
+      user: 'root',
+      password: '', // Dejar vacío si no hay contraseña para root
+      database: 'token_db',
+      tableName: 'mariadb_tokens'
+    });
+
+    // Inicializar el adaptador de tokens
+    await tokenAdapter.initialize();
+    logger.info('MariaDB Token Adapter inicializado correctamente');
+
+    // Crear instancia del autenticador
+    const authenticator = new Authenticator({ logger });
+
+    // Registrar estrategia de autenticación JWT que utiliza el adaptador MariaDB
+    authenticator.use('jwt-mariadb', 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 MariaDB
+      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,
+          expiresAt: tokenRecord.expires_at
+        };
+        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:8090');
+  } catch (error) {
+    logger.error('Error iniciando el servidor:', error.message);
+    process.exit(1);
+  }
+}
+
+// Iniciar el servidor
+startServer();
+
+module.exports = { startServer };

package/v2examplle/v2_mariadb_auth/controllers/authController.js

@@ -0,0 +1,95 @@
+const jwt = require('jsonwebtoken');
+const { MariaDBTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new MariaDBTokenAdapter({
+  host: 'localhost',
+  user: 'root',
+  password: '',
+  database: 'token_db',
+  tableName: 'mariadb_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-mariadb-example';
+        const token = jwt.sign(payload, secret, { expiresIn: '1h' });
+
+        // Guardar el token en la base de datos MariaDB
+        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' }));
+    }
+  },
+
+  logout: async (req, res) => {
+    try {
+      const authHeader = req.headers.authorization;
+      const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN
+
+      if (!token) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Token no proporcionado' }));
+        return;
+      }
+
+      // Revocar el token en la base de datos MariaDB
+      const revoked = await tokenAdapter.revokeToken(token);
+
+      if (revoked) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ message: 'Sesión cerrada exitosamente' }));
+      } else {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'No se pudo revocar el token' }));
+      }
+    } catch (error) {
+      console.error('Error en logout:', error);
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Error interno del servidor' }));
+    }
+  }
+};
+
+module.exports = authController;

package/v2examplle/v2_mariadb_auth/controllers/mainController.js

@@ -0,0 +1,31 @@
+const jwt = require('jsonwebtoken');
+const { MariaDBTokenAdapter } = require('../../../index.js');
+
+// Adaptador de tokens para este controlador
+const tokenAdapter = new MariaDBTokenAdapter({
+  host: 'localhost',
+  user: 'root',
+  password: '',
+  database: 'token_db',
+  tableName: 'mariadb_tokens'
+});
+
+// Asegurarse de que el adaptador esté inicializado
+tokenAdapter.initialize().catch(console.error);
+
+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 MariaDB',
+      endpoints: {
+        'POST /login': 'Iniciar sesión y obtener token',
+        'GET /protected': 'Contenido protegido (requiere token)',
+        'GET /profile': 'Perfil de usuario (requiere token)',
+        'POST /logout': 'Cerrar sesión y revocar token (requiere token)'
+      }
+    }));
+  }
+};
+
+module.exports = mainController;